// Zaznaczyć "breakpoint" w pokazanym miejscu
//---------------------------------------------------------------------------

#include <vcl.h>
#include <stdio.h>
#include <math.h>
#pragma hdrstop
#include "UnitMain.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//--- Definicje ---------------------------------
#include <time.h>
//========================================
//=== Rozdziały 2, 3 ============================
//========================================
//Definicja klasy
class Counter //początek deklaracji klasy
{
  int number; //opis pola klasy
public:
  Counter(); //opis konstruktora klasy
  int Plus(); //opis metody klasy
};
Counter::Counter() //konstruktor klasy
{
  number=0; //inicjalizacja pola klasy
}
int Counter::Plus() //metoda klasy
{
  number++; if (number>=100) number=0;
  return (int)number;
}
//Definicja klasy z uprawnieniami dostępu
class Counter2 //początek opisania klasy
{
public:
        Counter2(); //opis konstruktora klasy
protected:
        int Plus(); // podprogram
private:
        int number; //opisanie pola klasy
};
Counter2::Counter2() //konstruktor klasy
{
        number=0; //inicjalizacja pola klasy
}
int Counter2::Plus() //funkcja składowa klasy
{
        number++; if (number>=100) number=0;
        return number;
}
//========================================
//=== Rozdział 4 ============================
//========================================
/*Realizacją w języku C++ stosu dla wskaźników na pewne obiekty*/
#define RS2 64 /*rozmiar stosu*/
class klStos
{
  void* stos[RS2]; // definicja tablicy - stosu
  int ind; // indeks stosu
public:
  klStos(){ind=-1;} //konstruktor
  void ZeroStos() { ind=-1; }
  bool CzyStosPusty()
  {// podprogram sprawdzający czy stos jest pusty
    return(ind==-1);
  }
  bool CzyStosNiePrzep()
  {//sprawdzanie, czy stos nie jest przepełniony
    return(ind<RS2);
  }
  bool StosZapis(void* pNowy)
  {// podprogram do zapisywania na stos
    if (CzyStosNiePrzep())
    {
      ind++; //indeks stosu zwiększa się o jeden
      stos[ind]=pNowy;/*zapisuje się nowy element*/
      return true; //zapisywanie udało się
    }
    else
      return false; //zapisywanie nie udało się
  }
  bool StosCzyt(void** ppEl)
  {// podprogram do zdejmowania ze stosu
    if (CzyStosPusty())
      return false; //odczyt jest nieudany
    else
    {
      (*ppEl)=stos[ind]; //odczyt z tablicy
      ind--; //indeks stosu zmniejsza się o jeden
      return true; //odczyt jest udany
    }
  }
  bool StosFront(void** ppEl)
  {// podprogram do zdejmowania ze stosu
    if (CzyStosPusty())
      return false; //odczyt jest nieudany
    else
    {
      (*ppEl)=stos[ind]; //odczyt z tablicy
      return true; //odczyt jest udany
    }
  }
};
/* Procedura rekurencyjna do obliczenia współczynnika
dwumianowego (symbolu Newtona) */
int WspDwum(int n,int m)
{
  int wd=0;
  if (n==m || m==0) wd=1;
  else
    wd = WspDwum(n-1,m) + WspDwum(n-1,m-1);
  return(wd);
}
/*Procedura iteracyjna do obliczenia współczynnika
dwumianowego (symbolu Newtona)*/
int WspDwumIterac(int nn,int mm)
{
  int wd=0;// współczynnik dwumianowy
  struct s_stos
  {
    int n, m;
  } s[100];//stos na 100 elementów
  int i=0;//indeks stosu
  //Pierwsze zapisywanie do stosu:
  s[i].n=nn; s[i].m=mm; i++;
  while (i>0)
  {
    int n,m;//zmienne lokalne
    //Czytanie ze stosu:
    i--; n=s[i].n; m=s[i].m;
    if (n==m || m==0) wd+=1;
    else
    {
      //Zapisywanie do stosu pierwszego składnika:
      s[i].n=n-1; s[i].m=m; i++;
      //Zapisywanie do stosu drugiego składnika:
      s[i].n=n-1; s[i].m=m-1; i++;
    }
  }
  return(wd);
}
//Realizacją kolejki w języku C++
class klKolej
{
  typedef void* pointer;
  pointer *kolej; // wskaźnik na tablicę - kolejkę
  int rozm; // maksymalny rozmiar kolejki
  int indKon; // indeks końca kolejki
  int indPocz; // indeks początku kolejki
public:
  klKolej(int rozmiar)
  {//konstruktor
    rozm=rozmiar;
    kolej=new pointer[rozm]; /* alokacja tablicy -
kolejki */
    for (int i=0;i<rozm;i++) *(kolej+i)=0;
    indKon=0; // indeks końca kolejki
    indPocz=0; // indeks początku kolejki
  }
  void ZeroKolej()
  {// podprogram do zerowania kolejki
    indKon=0; // indeks końca kolejki
    indPocz=0; // indeks początku kolejki
  }
  bool CzyKolejPusta()
  {// podprogram sprawdzający czy kolejka jest pusta
    return(indKon==indPocz);
  }
  bool CzyKolejZapeln()
  {//sprawdzanie, czy kolejka jest zapełniona
    int indTemp=indKon;
    indTemp++; if (indTemp==rozm) indTemp=0;
    return(indTemp==indPocz);
  }
  bool KolejZapis(void* nowyElem)
  {// podprogram do zapisywania do kolejki
    if (CzyKolejZapeln())
      return false; //zapisywanie nie udało się
    else
    {
      kolej[indKon]=nowyElem;//zapisuje się nowy element
      //indeks końca kolejki zwiększa się o jeden
      indKon++; if (indKon==rozm) indKon=0;
      return true; //zapisywanie udało się
    }
  }
  bool KolejCzyt(void** ppEl)
  {// podprogram do czytania z kolejki
    if (CzyKolejPusta())
      return false; //odczyt jest nieudany
    else
    {
      (*ppEl)=kolej[indPocz]; //odczyt z tablicy
      //indeks początku kolejki zwiększa się o jeden
      indPocz++; if (indPocz==rozm) indPocz=0;
      return true; //odczyt jest udany
    }
  }
};
//Listy
typedef char typ_dana;/* przykładowo */
struct sElem
{
  typ_dana dana;//pole elementu danych
  sElem *nast;//wskaźnik na element następny
};
//Bazy danych
struct sOsoba
{
  unsigned char flagi;//8 flag bitowych:
  // zapis pusta/niepusta, aktualna/nieaktualna itp.
  char nazwisko[29];//pole nazwiska
  char imie_1[16];//pole pierwszego imienia
  char imie_2[16];//pole drugiego imienia
  short rok_ur;//pole roku urodzenia
};
//========================================
//=== Rozdział 5 ============================
//========================================
//Zbiory danych
struct sStudent
{
char nazwisko[30];//pole do nazwiska
char imie_1[20];//pole do pierwszego imienia
char imie_2[20];//pole do drugiego imienia
};
//Tablicowa reprezentacja zbioru
struct sStudent2
{
  char nazwisko[30];//pole do nazwiska
  char imie_1[20];//pole do pierwszego imienia
  char imie_2[20];//pole do drugiego imienia
  sStudent2(char *nazw, char *im1, char *im2)
  {
    strcpy(nazwisko, nazw);
    strcpy(imie_1,im1);
    strcpy(imie_2,im2);
  }
};
//Listowa reprezentacja zbioru
struct sStudent3
{
  char nazwisko[30];//pole do nazwiska
  char imie_1[20];//pole do pierwszego imienia
  char imie_2[20];//pole do drugiego imienia
  sStudent3 *nast;//wskaźnik na element następny
  sStudent3(char *nazw, char *im1, char *im2)
  {
    strcpy(nazwisko, nazw);
    strcpy(imie_1,im1);
    strcpy(imie_2,im2);
  }
};
//Realizacja algorytmu do generowania podzbiorów k - elementowych
bool GenerPodzbior(int *P, int k, int n)
{
  if (P[k-1] < n-1) P[k-1]++;
  else /* jeśli P[k-1] równa się (n-1) */
  {
    for (int j = k-2; j >= 0; j--)
      if (P[j] < n - k + j) break;
    if (j < 0) return false;
    P[j]++;
    while (j+1 < k )
    {
      P[j+1] = P[j] + 1; j++;
    }
  }
  return true;
}
//Reprezentacja grafu tablicą par wierzchołków
struct sW
{
  char litera; // pola struktury
  int liczba;
  sW (char lit, int licz) // konstruktor
    { litera = lit; liczba = licz; };
};
/*Reprezentacja w postaci macierzy sąsiedztwa wierzchołków*/
void fLadowanieWierzchGraf(sW* pW[], int rozm)
{/*przykładowy podprogram do ładowania danych*/
  for (int i=0;i<rozm;i++)
  {
    pW[i]->litera=(char)('A'+i); pW[i]->liczba=10+i;
  }
}
/*Reprezentacja grafu w postaci macierzy incydencji*/
struct sW1
{
  char litera; // pola struktury
  int liczba;
  sW1(char lit, int licz) // konstruktor
    { litera = lit; liczba = licz; };
};
void fLadowanie1(sW1* pW1[], int rozm)
{/*przykładowy podprogram do ładowania danych*/
  for (int i=0;i<rozm;i++)
  {
    pW1[i]->litera=(char)('A'+i); pW1[i]->liczba=10+i;
  }
}
/*Reprezentacja grafu listami incydencji wierzchołków*/
struct sListaIncyd
{
  int indeks; // pole indeksu wierzchołka
  sListaIncyd *nast;//pole wskaźnika na
//element następny
  sListaIncyd(int ind, sListaIncyd *pp)//konstruktor
  {
    indeks=ind; nast=pp;
  }
};
//Drzewo a graf
//Struktury drzewiaste
struct sW2
{
  char ch; // pola z danymi
  sW2 *pSasiad;
  sW2 *nast;
  sW2() //konstruktor
  { pSasiad = 0; nast = 0; }
  sW2(char c) //konstruktor drugi
  { ch = c; pSasiad = 0; nast = 0; }
};
//========================================
//=== Rozdział 6,a ============================
//========================================
/*Realizacja wyszukiwania elementu w liście jednokierunkowej*/
typedef char typ_dana2;/* przykładowo */
struct sElem2
{
  typ_dana2 dana;//pole elementu danych
  sElem2 *nast;//wskaźnik na element następny
  sElem2(char c) //konstruktor
  { dana = c; nast = 0; }
};
bool SzukaElemListJednokier(sElem2 *pPocz, typ_dana2 szukD,
  sElem2 **pp)
{
  (*pp)=0; /* wstępnie, na wypadek wyniku
negatywnego */
  sElem2 *p=pPocz;
  while (p!=0)
  {
    (*pp)=p;// wstępnie
    if (p->dana==szukD) return true;
    p=p->nast;/* do następnego elementu */
  }
  return false;/* wynik negatywny */
}
/*Realizacja dodawania elementu do listy niecyklicznej jednokierunkowej*/
void DodawElemListNiecyklJednokier(sElem2 **ppPocz, typ_dana2 nowyDane)
{
  sElem2 *p=new sElem2(' ');//krok 1: alokacja
  p->dana=nowyDane;//krok 2: kopiowanie danych
  p->nast=*ppPocz;//krok 3: łączenie z listą
  *ppPocz=p;//krok 4: korekta wskaźnika na początek
}
//Realizacja dodawania elementu na końcu listy niecyklicznej jednokierunkowej
void DodawElemListKoniecNiecyklJednokier(sElem2 **ppPocz,
  typ_dana2 nowyDane)
{
  sElem2 *p=new sElem2(' ');//krok 1: alokacja
  p->dana=nowyDane;//krok 2: kopiowanie danych
  p->nast=0;//do kroku 2: ustawienie końca
  if (*ppPocz==0)
	*ppPocz=p;
  else
  {
    sElem2 *pt=*ppPocz;
    while (pt->nast!=NULL)
	    pt=pt->nast;//krok 3: szukanie końca listy
    pt->nast=p;//krok 4: łączenie z listą
  }
}
//Realizacja usuwania elementu na początku listy niecyklicznej jednokierunkowej
void UsuwElemList(sElem2 **ppPocz)
{
  if (*ppPocz==NULL)
	  return;//nic nie robić (lista pusta)
  sElem2 *p=*ppPocz;//zapamiętanie wartości
  *ppPocz=p->nast;// przełączenie wskaźnika
  delete p;//zwolnienie pamięci
}
//Realizacja usuwania elementu na końcu listy niecyklicznej jednokierunkowej
void UsuwElemListKoniec(sElem2 *pPocz)
{
  if (pPocz==0)
	return;//nic nie robić (lista pusta)
  sElem2 *ppop=0;//wskaźnik na poprzedni
  sElem2 *p=pPocz;//krok 1: szukanie końca listy
  while (p->nast!=0)
  {
    ppop=p;//zapisywanie wartości wskaźnika
    p=p->nast;//krok 1: szukanie końca listy
  }
  delete p;//krok 2: zwolnienie pamięci
  ppop->nast=0;// krok 3: zerowanie wskaźnika
}
//Realizacja zamiany elementu listy
bool ZamianaElemList(sElem2 *pPocz, typ_dana2 szukD, typ_dana2 zamD)
{
  if (pPocz==0)
    return false;//nic nie robić (lista pusta)
  sElem2 *p=pPocz;//krok 1: szukanie elementu
  while (p!=0)
  {
    if (p->dana==szukD)
    {
      p->dana=zamD;//krok 2: zamiana
      return true;
    }
    p=p->nast;//krok 1: szukanie elementu
  }
  return false;//nie znalezione
}
//Realizacja łączenia list cyklicznych dwukierunkowych
typedef char typ_dana3;/* przykładowo */
struct sElem3
{
  typ_dana3 dana;//pole elementu danych
  sElem3 *pN;//wskaźnik na element następny
  sElem3 *pP;//wskaźnik na element poprzedni
  sElem3(typ_dana3 da) //konstruktor
  { dana=da; pN = 0; pP = 0;}
};
void LanczListCyklDwukier(sElem3 **ppPocz, sElem3 *pLista)
{
  if (pLista==0)
	return;//nic nie robić (lista wejściowa pusta)
  if (*ppPocz==0)
  {//zamiana na listę wejściową
     *ppPocz=pLista;
     return;
  }
//krok 1: wskaźnik na końcowy element listy bazowej:
  sElem3* pKonBaz=(*ppPocz)->pP;
//krok 2: wskaźnik na końcowy element listy dodawanej:
  sElem3* pKonDod=pLista->pP;
  //krok 3: łączenie pól pN:
  pKonBaz->pN = pLista;
  pKonDod->pN = *ppPocz;
  //krok4: łączenie pól pP:
  pLista->pP = pKonBaz;
  (*ppPocz)->pP = pKonDod;
}
//Realizacja rozdzielenia jednokierunkowej listy według indeksu
void RozlaczListIndeks(sElem2 *pPocz, int ind, sElem2 **ppL2)
{
  (*ppL2)=0;//wstępnie
  if (pPocz==0)	return;//nic nie robić (lista pusta)
  int ii=0;
  sElem2 *p=pPocz;//krok 1: szukanie elementu
  while (p!=0)
  {
    if (ii==ind)//warunek „zadany indeks"
    {
      (*ppL2)=p->nast;//krok 2: kopiowanie
      p->nast=0;//krok 2: koniec listy 1
      return;
    }
    ii++;
    p=p->nast;//krok 1: szukanie elementu
  }
  return;//nie znalezione
}
//Realizacja usuwania listy cyklicznej jednokierunkowej
void UsuwListCyklJednokier(sElem2 **ppPocz)
{
  if (*ppPocz==0) return;//nic nie robić (lista pusta)
  sElem2 *p=*ppPocz;
  while (p!=0)
  {
    sElem2 *ptemp=p->nast;
    delete p;//zwolnienie pamięci
    p=ptemp;
    if (p==(*ppPocz)) break;
  }
  *ppPocz=0;// lista pusta
}
//Realizacja skrócenia listy jednokierunkowej po elemencie z zadaną wartością
void SkrocListJednokierWart (sElem2 *pPocz, typ_dana2 ostatn)
{
  if (pPocz==0)	return;//nic nie robić (lista pusta)
  sElem2 *p=pPocz;//zapamiętanie wartości
  while (p!=0)
  {
    if (p->dana==ostatn)//porównanie elementów
    {
      sElem2 *ptemp=p->nast;
      p->nast=0;//nowy koniec listy
      p=ptemp;
      while (p!=0)
      {
        ptemp=p->nast;
        delete p;//krok 2: zwolnienie pamięci
        p=ptemp;
      }
      break;//koniec szukania elementu
    }
    else
      p=p->nast;//krok 1: szukanie elementu
  }
}
//Nie rekurencyjna realizacja algorytmu przeszukiwania w głąb
typedef char typ_dana;
struct typL
{/*opis elementu listy incydencji*/
  int indeks; /* pole indeksu wierzchołka*/
  typL *nast;/*pole wskaźnika na element następny */
  typL(int wart) /*konstruktor*/
  { indeks = wart; nast = 0; }
};
struct typW
{/*opis elementu tablicy wierzchołków*/
  typ_dana dana; /*pole danych wierzchołka */
  typL *pElPocz; /*wskaźnik na pierwszy element listy
incydencji*/
  bool fl; /*flaga odwiedzenia wierzchołka*/
  typW(typ_dana wart) /*konstruktor*/
  { dana = wart; pElPocz = 0; fl = false;}
};
int LadowanieGrafu(typW* twg[])
{
  typW* pA = new typW('A'); typW* pB = new typW('B');
  typW* pC = new typW('C'); typW* pD = new typW('D');
  typW* pE = new typW('E'); typW* pF = new typW('F');
  typW* pG = new typW('G'); typW* pH = new typW('H');
  twg[0] = pA; twg[1] = pB; twg[2] = pC; twg[3] = pD;
  twg[4] = pE; twg[5] = pF; twg[6] = pG; twg[7] = pH;
  typL* p1 = new typL(1); pA->pElPocz = p1; /*A-->B*/
  typL* p2 = new typL(5); p1->nast = p2; /*A-->F*/
  p1 = new typL(1); pB->pElPocz = p1; /*B-->B*/
  p2 = new typL(3); p1->nast = p2; /*B-->D*/
  typL* p3 = new typL(4); p2->nast = p3; /*B-->E*/
  p1 = new typL(1); pC->pElPocz = p1; /*C-->B*/
  p1 = new typL(2); pD->pElPocz = p1; /*D-->C*/
  p2 = new typL(4); p1->nast = p2; /*D-->E*/
  p1 = new typL(0); pE->pElPocz = p1; /*E-->A*/
  p1 = new typL(4); pF->pElPocz = p1; /*F-->E*/
  p2 = new typL(6); p1->nast = p2; /*F-->G*/
  p1 = new typL(4); pG->pElPocz = p1; /*G-->E*/
  p2 = new typL(7); p1->nast = p2; /*G-->H*/
  p1 = new typL(5); pH->pElPocz = p1; /*H-->F*/
  return 8;
}
void PrzegladDFSstos(typW* twg[],int pocz)
{
  klStos stos; /*stos jako obiekt klasy klStos*/
  stos.ZeroStos();
  typW* pw=twg[pocz];
  stos.StosZapis((void*)pw);
  while (stos.CzyStosPusty()==false)
  {
    stos.StosFront((void **)&pw);
    if (pw->fl==false)
    {
      char buff[256];
      sprintf(buff,"Wierzchołek %c",pw->dana);
      MessageBox(NULL,buff,"Komunikat",
        MB_OK|MB_APPLMODAL);/*komunikat o wierzchołku*/
      pw->fl=true;
    }
    typL *pel=pw->pElPocz;
    while (pel!=0)
    {
      typW* pw2 = twg[pel->indeks];
      if (pw2->fl==0)
      {
        if (stos.StosZapis((void *)pw2)==0)
        {
          MessageBox(NULL,"Przepełnienie stosu","Komunikat",
          MB_OK|MB_ICONSTOP|MB_APPLMODAL);/*komunikat o przepełnieniu stosu*/
          return;
        }
        break;
      }
      else
        pel=pel->nast;
    }
    if (pel==0)
      stos.StosCzyt((void **)&pw);
  }
}
void PrzegladDFSgraf(typW* twg[], int NN)
{
  for (int i=0;i<NN;i++) twg[i]->fl=false;
  for (int j=0;j<NN;j++)
    if (twg[j]->fl==false)
      PrzegladDFSstos(twg,j);
}
//Rekurencyjna realizacja algorytmu przeszukiwania w głąb
void PrzegladDFSrekur(typW* twg[], int pocz)
{
  typW* pw = twg[pocz];
  pw->fl=true;/*zaznaczamy wierzchołek jako odwiedzony*/
  char buff[256];
  sprintf(buff,"Wierzchołek %c",pw->dana);
  MessageBox(NULL,buff,"Komunikat",
    MB_OK|MB_APPLMODAL);/*komunikat o wierzchołku*/
  typL *pEl=pw->pElPocz;
  while (pEl!=0)
  {
    int ind=pEl->indeks;
    if (twg[ind]->fl==false)
      PrzegladDFSrekur(twg,ind); /* rekurencja, jeżeli
wierzchołek „ind" jest nie odwiedzony */
    pEl=pEl->nast;
  }
}
void PrzegladRekurDFSgraf(typW* twg[], int NN)
{
  for (int i=0;i<NN;i++) twg[i]->fl=false;
  for (int j=0;j<NN;j++)
    if (twg[j]->fl==false)
      PrzegladDFSrekur(twg,j);
}
//Realizacja algorytmu przeszukiwania w wszerz
void PrzegladBFSkolej(typW* twg[], int rozm, int pocz)
{
  klKolej* pkolej=new klKolej(rozm); // definicja kolejki
  pkolej->ZeroKolej();
  typW* pw=twg[pocz];
  pkolej->KolejZapis(pw);/*zapisywanie pierwszego wierzchołka*/
  while (pkolej->CzyKolejPusta()==false)
  {
    pkolej->KolejCzyt((void **)&pw);
    if (pw->fl==false)
    {
      char buff[256];
      sprintf(buff,"Wierzchołek %c",pw->dana);
      MessageBox(NULL,buff,"Komunikat",
        MB_OK|MB_APPLMODAL);/*komunikat o wierzchołku*/
      pw->fl=true;
      typL *pl=pw->pElPocz;
      while (pl!=0)
      {
        typW* pw2 = twg[pl->indeks];
        if (pw2->fl==false)
        {
          if (pkolej->KolejZapis((void *)pw2)==false)
           {
            MessageBox(NULL,"Przepełnienie kolejki","Komunikat",
            MB_OK|MB_ICONSTOP|MB_APPLMODAL);/*komunikat o przepełnieniu kolejki*/
             return;
           }
        }
        pl=pl->nast;
      }
    }
  }
  delete pkolej;
}
void PrzegladBFSgraf(typW* twg[], int NN)
{
  for (int i=0;i<NN;i++) twg[i]->fl=false;
  for (int j=0;j<NN;j++)
    if (twg[j]->fl==false)
      PrzegladBFSkolej(twg, NN, j);
}
//Realizacja algorytmu obliczenia spójnych składowych
struct typW2
{/*opis elementu tablicy wierzchołków*/
  typ_dana dana; /*pole danych wierzchołka */
  typL *pElPocz; /*wskaźnik na pierwszy element listy incydencji*/
  int fl; /*flaga odwiedzenia wierzchołka i rejestrator spójnej składowej*/
  typW2(typ_dana wart) /*konstruktor*/
  { dana = wart; pElPocz = 0; fl = 0;}
};
int LadowanieGrafu2(typW2* twg[])
{
  typW2* pA = new typW2('A'); typW2* pB = new typW2('B');
  typW2* pC = new typW2('C'); typW2* pD = new typW2('D');
  typW2* pE = new typW2('E'); typW2* pF = new typW2('F');
  typW2* pG = new typW2('G'); typW2* pH = new typW2('H');
  twg[0] = pA; twg[1] = pB; twg[2] = pC; twg[3] = pD;
  twg[4] = pE; twg[5] = pF; twg[6] = pG; twg[7] = pH;
  typL *p1, *p2, *p3;
  p1 = new typL(1); pA->pElPocz = p1; /*A-->B*/
//  p2 = new typL(5); p1->nast = p2; /*A-->F*/
  p1 = new typL(1); pB->pElPocz = p1; /*B-->B*/
  p2 = new typL(3); p1->nast = p2; /*B-->D*/
  p3 = new typL(4); p2->nast = p3; /*B-->E*/
  p1 = new typL(1); pC->pElPocz = p1; /*C-->B*/
  p1 = new typL(2); pD->pElPocz = p1; /*D-->C*/
  p2 = new typL(4); p1->nast = p2; /*D-->E*/
  p1 = new typL(0); pE->pElPocz = p1; /*E-->A*/
  p1 = new typL(4); pF->pElPocz = p1; /*F-->E*/
  p2 = new typL(6); p1->nast = p2; /*F-->G*/
  p1 = new typL(4); pG->pElPocz = p1; /*G-->E*/
  p2 = new typL(7); p1->nast = p2; /*G-->H*/
  p1 = new typL(5); pH->pElPocz = p1; /*H-->F*/
  return 8;
}
void PrzegladDFSstos2(typW2* twg[],int pocz)
{
  klStos stos; /*stos jako obiekt klasy klStos*/
  stos.ZeroStos();
  typW2* pw=twg[pocz];
  stos.StosZapis((void*)pw);
  while (stos.CzyStosPusty()==false)
  {
    stos.StosFront((void **)&pw);
    if (pw->fl==0)
    {
      pw->fl=pocz+1;/* rejestracja spójnej składowej */
      char buff[256];
      sprintf(buff,"Wierzchołek %c\n spójna składowa %d",pw->dana, pw->fl);
      MessageBox(NULL,buff,"Komunikat",
        MB_OK|MB_APPLMODAL);/*komunikat o wierzchołku*/
    }
    typL *pel=pw->pElPocz;
    while (pel!=0)
    {
      typW2* pw2 = twg[pel->indeks];
      if (pw2->fl==0)
      {
        if (stos.StosZapis((void *)pw2)==0)
        {
          MessageBox(NULL,"Przepełnienie stosu","Komunikat",
          MB_OK|MB_ICONSTOP|MB_APPLMODAL);/*komunikat o przepełnieniu stosu*/
          return;
        }
        break;
      }
      else
        pel=pel->nast;
    }
    if (pel==0)
    {
      stos.StosCzyt((void **)&pw);
    }
  }
}
void SpojneSkladDFSgraf(typW2* twg[],int NN)
{
  for (int i=0;i<NN;i++) twg[i]->fl=false;
  for (int j=0;j<NN;j++)
    if (twg[j]->fl==0)
      PrzegladDFSstos2(twg,j);
}
//Realizacja algorytmu obliczenia drzewa rozpinającego
void DrzewoRozpinBFSkolej(typW* twg[], int rozm, int pocz)
{
  klKolej* pkolej=new klKolej(rozm); // definicja kolejki
  pkolej->ZeroKolej();
  typW* pw = twg[pocz];
  pkolej->KolejZapis(pw);/*zapisywanie pierwszego wierzchołka*/
  pw->fl=true;
  while (pkolej->CzyKolejPusta()==false)
  {
    pkolej->KolejCzyt((void **)&pw);
    char buff[64];
    sprintf(buff,"Wierzchołek %c",pw->dana);
    MessageBox(NULL,buff,"Komunikat",
      MB_OK|MB_APPLMODAL);/*komunikat o wierzchołku*/
    typL *pp = 0; /*wskaźnik na poprzednika w liście*/
    typL *pel=pw->pElPocz;
    while (pel!=0)
    {
      typW* pw2 = twg[pel->indeks];
      if (pw2->fl==false)
      {
        pw2->fl=true;
        if (pkolej->KolejZapis(pw2)==false)
        {
          MessageBox(NULL,"Przepełnienie kolejki","Komunikat",
          MB_OK|MB_ICONSTOP|MB_APPLMODAL);/*komunikat o przepełnieniu kolejki*/
          return;
        }
        pp = pel;
        pel = pel->nast;
      }
      else
      {/* znaleziono cięciwę*/
        char buff2[64];
        sprintf(buff2,"Cięciwa do wierzchołka %c",pw2->dana);
        MessageBox(NULL,buff2,"Komunikat",
          MB_OK|MB_APPLMODAL);/*komunikat o cięciwę*/
        /* wyeliminowanie elementu listy: */
        typL* ptemp = pel->nast; /*wskaźnik tymczasowy*/
        delete(pel);/* niszczenie elementu listy */
        if (pp == 0) pw->pElPocz = ptemp;
        else pp->nast = ptemp;
        pel = ptemp;
      }
    }
  }
  delete pkolej;
}
void DrzewoRozpinBFSgraf(typW* twg[], int NN)
{
  for (int i=0;i<NN;i++) twg[i]->fl = false;
  for (int j=0;j<NN;j++)
    if (twg[j]->fl==false)
      DrzewoRozpinBFSkolej(twg, NN, j);
}
//========================================
//=== Rozdział 6,b ============================
//========================================
//Realizacja wyszukiwania elementu w drzewie spadowym
typedef int typ_spad;/* przykładowo*/
struct sElSpad
{
  typ_spad dana;/*pole elementu danych*/
  int indL;/*indeks korzenia lewego poddrzewa*/
  int indP;/*indeks korzenia prawego poddrzewa*/
  sElSpad(typ_spad d) /*konstruktor 1*/
  {dana = d; indL = -1; indP = -1;};
  sElSpad(typ_spad d, int iL, int iP) /*konstruktor 2*/
  {dana = d; indL = iL; indP = iP;};
};
int LadowanieDrzewaSpad(sElSpad* M[])
{
  M[0] = new sElSpad(40, 1, 2); M[1] = new sElSpad(20, 3, 4);
  M[2] = new sElSpad(60, 5, 6); M[3] = new sElSpad(10, -1, -1);
  M[4] = new sElSpad(20, -1, -1); M[5] = new sElSpad(50, -1, -1);
  M[6] = new sElSpad(70, -1, 7); M[7] = new sElSpad(70, -1, -1);
  return 8;
}
int WyszukDrzewoSpad(sElSpad* M[], int korz, typ_spad szukD)
{/*szukD - szukana dana typu typ_spad*/
/*pW - wskaźnik na indeks wyszukanego elementu*/
  int ind=korz;
  while (ind>=0)
  {
    if (szukD == M[ind]->dana) return ind;
    if (szukD < M[ind]->dana)
      ind=M[ind]->indL;/*następny element - lewy*/
    else
      ind=M[ind]->indP;/*następny element - prawy*/
  }
  return -1;/*wynik negatywny*/
}
//Realizacja dodawania elementu w drzewie spadowym
void DodawDrzewoSpad(sElSpad* M[], int korz, int indD)
{/*dodawD - dodawana dana typu typ_dana*/
/* indD - indeks dla dodawanego elementu*/
  if (korz<0)
  {/* dodajemy pierwszy element */
    korz = indD;
    return;
  }
  int ind=korz;
  while (ind>=0)
  {
    if (M[indD]->dana < M[ind]->dana)
    {
      if (M[ind]->indL == -1)
      {
        M[ind]->indL = indD;
        return;
      }
      ind=M[ind]->indL;/*następny element - lewy*/
    }
    else
    {/* (M[indD]->dana >= M[ind]->dana) */
      if (M[ind]->indP == -1)
      {
        M[ind]->indP = indD;
        return;
      }
      ind=M[ind]->indP;/*następny element-prawy*/
    }
  }
}
//Realizacja usuwania elementu w drzewie spadowym
void UsuwDrzewoSpad(sElSpad* M[], int korz, typ_spad usuwD)
{/*usuwD - usuwana dana typu typ_spad*/
/*Wyszukiwanie elementu i jego poprzednika: */
  int popszU = -1;
  int indU=korz;/* indeks usuwanego elementu */
  while (indU>=0)
  {
    if (usuwD == M[indU]->dana) break;
    popszU = indU;
    if (usuwD < M[indU]->dana)
      indU=M[indU]->indL;/*następny - lewy*/
    else
      indU=M[indU]->indP;/*następny - prawy*/
  }
  if (indU < 0) return;/* nie znaleziono */
  if (M[indU]->indL == -1 && M[indU]->indP == -1)
  {/* list drzewa; odłączenie lista: */
    if (M[popszU]->indL == indU)
      M[popszU]->indL = -1;
    else M[popszU]->indP = -1;
    return;
  }
  if (M[indU]->indL != -1 && M[indU]->indP == -1)
  {/* jest lewy; przełączenie poprzednika: */
    if (M[popszU]->indL == indU)
      M[popszU]->indL = M[indU]->indL;
    else M[popszU]->indP = -1;
    return;
  }
  if (M[indU]->indL == -1 && M[indU]->indP != -1)
  {/* jest prawy; przełączenie poprzednika: */
    if (M[popszU]->indL == indU)
      M[popszU]->indL = -1;
    else M[popszU]->indP = M[indU]->indP;
    return;
  }
  /* przypadek dwóch następników */
  int indK;/* indK - indeks kandydata */
  int popszK=indU;/*popszK - poprzednik kandydata*/
  /* krok w prawo: */
  indK=M[indU]->indP;/* element z prawej strony*/
  /* kroki w lewo: */
  while (M[indK]->indL != -1)
  {
    popszK=indK;/*poprzednik kandydata*/
    indK=M[indK]->indL;/*element z lewej strony*/
  }
  /* przeniesienie elementu - kandydata: */
  M[indU]->dana = M[indK]->dana;
  /* czy jest prawy następnik kandydata? */
  if (M[indK]->indP != -1)
  {/* jest prawy; przełączenie poprzednika: */
    M[popszK]->indL = M[indK]->indP;
  }
  else
    M[popszK]->indL = -1;/*odłączenie kandydata*/
  return;
}
//Realizacja rozdzielenia drzewa spadowego
int RozdzDrzewoSpad(sElSpad* M[], int* pkorz, typ_spad rozD)
{/* Podprogram zwraca indeks korzenia drugiego
drzewa; rozD jest daną typu typ_dana wskazującej
miejsce rozłączania */
  /* Wyszukiwanie elementu i jego poprzednika: */
  int popszR = -1;
  int korz = *pkorz;
  int indR = korz;/* indeks rozłączanego elementu */
  if (indR < 0) return -1;/* nie znaleziono */
  while (indR>=0)
  {
    if (rozD == M[indR]->dana) break;
    popszR = indR;
    if (rozD < M[indR]->dana)
      indR=M[indR]->indL;/*następny - lewy*/
    else
      indR=M[indR]->indP;/*następny - prawy*/
  }
  /* odłączenie poprzednika: */
  if (popszR == -1)
  {
    *pkorz = M[korz]->indL;
    M[korz]->indL = -1;
    return korz;
  }
  else
  {
    if (M[popszR]->indL == indR) M[popszR]->indL = -1;
    else M[popszR]->indP = -1;
    return indR;
  }
}
//Realizacja dodawania elementu w drzewie AVL
typedef int typ_AVL;/* przykładowo*/
struct sElAVL
{
  typ_AVL dana;/*pole elementu danych*/
  int egz;/*liczba egzemplarzy elementów danych */
  int iL;/*indeks korzenia lewego poddrzewa*/
  int iP;/*indeks korzenia prawego poddrzewa*/
  int rw;/*różnica wysokości poddrzew*/
  sElAVL(typ_AVL d) /* konstruktor*/
  { dana = d; egz = 1; iL = -1; iP = -1; rw = 0;};
  sElAVL(typ_AVL d, int ii1, int ii2, int r) /* konstruktor2*/
  { dana = d; egz = 1; iL = ii1; iP = ii2; rw = r;};
};
int LadowanieDrzewaAVL(sElAVL* M[])
{
  M[0] = new sElAVL(40, 1, 2, +1); M[1] = new sElAVL(20, 3, 4, 0);
  M[2] = new sElAVL(60, 5, 6, +1); M[3] = new sElAVL(10, -1, -1, 0);
  M[4] = new sElAVL(30, -1, -1, 0); M[5] = new sElAVL(50, -1, -1, 0);
  M[6] = new sElAVL(70, -1, 7, +1); M[7] = new sElAVL(80, -1, -1, 0);
  return 8;
}
void DodawDrzewoAVL(sElAVL* M[], int *pkorz, typ_AVL dodawD, int iD)
{/*(*pkorz) - indeks korzenia drzewa*/
/*dodawD - dodawana dana typu typ_AVL*/
/* iD - wolny indeks tablicy M */
  #define RMS 10
  int stos[RMS], js=-1;/* js - indeks stosu */
  if (*pkorz<0)
  {/* dodajemy pierwszy element */
    *pkorz = iD;
    M[iD] = new sElAVL(dodawD);
    return; /*wyważenie nie jest potrzebne*/
  }
  bool F; /*znacznik „maksymalna wysokość poddrzewa wy-
rosła"*/
  int ii = *pkorz;
  while (ii>=0)
  {
    if (dodawD < M[ii]->dana)
    { /*lewe poddrzewo*/
      if (M[ii]->iL == -1)
      {/* miejsce dla liścia */
        M[ii]->iL = iD;
        F = (M[ii]->rw == 0);/*rw nie może być równa -1*/
        M[ii]->rw--;
        M[iD] = new sElAVL(dodawD);
        break;/*cykl while*/
      }
      else
      {
        js++; stos[js]=ii; /*indeks odkładamy na stos*/
        ii=M[ii]->iL;/*następny element - lewy*/
      }
    }
    else
    if (dodawD > M[ii]->dana)
    { /*prawe poddrzewo*/
      if (M[ii]->iP == -1)
      {/* miejsce dla liścia */
        M[ii]->iP = iD;
        F = (M[ii]->rw == 0);/*rw nie może być równa +1*/
        M[ii]->rw++;
        M[iD] = new sElAVL(dodawD);
        break;/*cykl while*/
      }
      else
      {
        js++; stos[js]=ii; /*indeks odkładamy na stos*/
        ii=M[ii]->iP;/*następny element-prawy*/
      }
    }
    else
    {/* (dodawD = M[ii]->dana) */
      M[iD]->egz++;
      return; /*wyważenie nie jest potrzebne*/
    }
  }
  /*sprawdzanie wyważenia*/
  int i1,i2,i3,i4; /*indeksy następników*/
  i1 = ii;
  while (F == true && js >= 0)
  {
    i2=i1;
    i1=stos[js]; js--; /*zdejmowanie indeksu*/
    if (M[i1]->iL == i2)
    {/*następnik znajdował się z lewej strony*/
      M[i1]->rw--;
      switch (M[i1]->rw) {
      case 0: /*maks. wysokość nie zmieniła się*/
        F = false; /*koniec zmian*/
        break;
      case -1: /*maks. wysokość zwiększyła się*/
        break;
      case -2: /*jest potrzebne wyważenie*/
        i1=M[i1]->iL;
        if (M[i1]->rw == -1)
        { /*transformacja dwóch wierzchołków*/
          M[i1]->iL = M[i2]->iP; M[i2]->iP = i1;
          M[i1]->rw = 0; M[i2]->rw = 0;
          if (js == -1) *pkorz = i2;
          else
          {
            i3=stos[js]; /*indeks z frontu stosu*/
            if (M[i3]->iP == i1) M[i3]->iP = i2;
            else M[i3]->iL = i2;
          }
        }
        else
        { /*transformacja trzech wierzchołków*/
          i3 = M[i2]->iP;
          M[i2]->iP = M[i3]->iL; M[i3]->iL = i2;
          M[i1]->iL = M[i3]->iP; M[i3]->iP = i1;
          if (M[i3]->rw == -1) M[i1]->rw = +1;
          else M[i1]->rw = 0;
          if (M[i3]->rw == +1) M[i2]->rw = -1;
          else M[i2]->rw = 0;
          M[i3]->rw = 0;
          if (js == -1) *pkorz = i3;
          else
          {
            i4=stos[js]; /*indeks z frontu stosu*/
            if (M[i4]->iP == i1) M[i4]->iP = i3;
            else M[i4]->iL = i3;
          }
        }
        break;
      }
    }
    else
    {/*następnik znajdował się z prawej strony*/
      M[i1]->rw++;
      switch (M[i1]->rw) {
      case 0: /*wysokość nie zmieniła się*/
        F = false; /*koniec zmian*/
        break;
      case +1: /*wysokość zwiększyła się*/
        break;
      case +2: /*jest potrzebne wyważenie*/
        if (M[i2]->rw == +1)
        { /*transformacja dwóch wierzchołków*/
          M[i1]->iP = M[i2]->iL; M[i2]->iL = i1;
          M[i1]->rw = 0; M[i2]->rw = 0;
          if (js == -1) *pkorz = i2;
          else
          {
            i3=stos[js]; /*indeks z frontu stosu*/
            if (M[i3]->iL == i1) M[i3]->iL = i2;
            else M[i3]->iP = i2;
          }
        }
        else
        { /*transformacja trzech wierzchołków*/
          i3 = M[i2]->iL;
          M[i2]->iL = M[i3]->iP; M[i3]->iP = i2;
          M[i1]->iP = M[i3]->iL; M[i3]->iL = i1;
          if (M[i3]->rw == +1) M[i1]->rw = -1;
          else M[i1]->rw = 0;
          if (M[i3]->rw == -1) M[i2]->rw = +1;
          else M[i2]->rw = 0;
          M[i3]->rw = 0;
          if (js == -1) *pkorz = i3;
          else
          {
            i4=stos[js]; /*indeks z frontu stosu*/
            if (M[i4]->iL == i1) M[i4]->iL = i3;
            else M[i4]->iP = i3;
          }
        }
        F = false; /*koniec zmian*/
        break;
      }
    }
  }
}
//Realizacja wyszukiwania elementu w drzewie RST
typedef int typ_RST;/* przykładowo*/
struct sElRST
{
  typ_RST dana;/*pole elementu danych*/
  int iL;/*indeks korzenia lewego poddrzewa*/
  int iP;/*indeks korzenia prawego poddrzewa*/
  sElRST(typ_RST d) /*konstruktor 1*/
  {dana = d; iL = -1; iP = -1;};
  sElRST(typ_RST d, int iiL, int iiP) /*konstruktor 2*/
  {dana = d; iL = iiL; iP = iiP;};
};
int LadowanieDrzewaRST(sElRST* M[])
{
  M[0] = new sElRST(0x2, 1, 2); M[1] = new sElRST(0xC, 3, 4);
  M[2] = new sElRST(0x1, -1, -1); M[3] = new sElRST(0x4, -1, -1);
  M[4] = new sElRST(0x6, -1, 5); M[5] = new sElRST(0xE, -1, -1);
  return 6;
}
int WyszukDrzewoRST(sElRST* M[], int korz, typ_RST szukD)
{/*(*pkorz) - indeks korzenia drzewa*/
/*szukD - szukana dana typu typ_dana*/
  int maska = 1; /*maska do wyboru kierunku*/
  int ind = korz;
  while (ind>=0)
  {
    if (szukD == M[ind]->dana) return ind;
    if ((szukD & maska) == 0)
      ind = M[ind]->iL;/*następny element - lewy*/
    else
      ind = M[ind]->iP;/*następny element - prawy*/
    maska <<= 1;
  }
  return -1;/*wynik negatywny*/
}
//Realizacja dodawania elementu w drzewie RST
void DodawDrzewoRST(sElRST* M[], int *pkorz, typ_RST dodawD, int iD)
{/*indeks korzenia drzewa*/
/*dodawD - dodawana dana typu typ_dana*/
/*iD - wolny indeks w tablicę M*/
  int maska = 1; /*maska do wyboru kierunku*/
  int mm;
  int rodz = -1; /*indeks rodzica*/
  int ind = *pkorz;
  while (ind>=0)
  {
    if (dodawD == M[ind]->dana)
      return;/*jest element*/
    rodz = ind; /* węzeł - rodzic */
    mm = dodawD & maska;
    if (mm == 0)
      ind=M[ind]->iL;/*następny element - lewy*/
    else
      ind=M[ind]->iP;/*następny element - prawy*/
    maska <<= 1; /*mnożenie maski o 2*/
  }
  /* dodawanie: */
  M[iD] = new sElRST(dodawD);
  if (rodz != -1)
  {
    if (mm == 0)
      M[rodz]->iL = iD;/*następny element - lewy*/
    else
      M[rodz]->iP = iD;/*następny element - prawy*/
  }
  else *pkorz = iD;
}
//Realizacja usuwania elementu w drzewie RST
void UsuwDrzewoRST(sElRST* M[], int *pkorz, typ_RST usuwD)
{/*(*pkorz) - indeks korzenia drzewa*/
/*usuwD - usuwana dana typu typ_RST*/
  int mm;
  int maska = 1; /*maska do wyboru kierunku*/
  int rodz = -1; /*indeks rodzica*/
  int ind = *pkorz;
  while (ind>=0)
  {
    if (usuwD == M[ind]->dana)
      goto usuw;/* element jest znaleziony */
    rodz = ind; /* węzeł - rodzic */
    mm = usuwD & maska;
    if (mm == 0)
      ind=M[ind]->iL;/*następny element - lewy*/
    else
      ind=M[ind]->iP;/*następny element - prawy*/
    maska <<= 1; /*mnożenie maski o 2*/
  }
  return; /*element nie jest znaleziony*/
usuw: /* usuwanie: */
  if (M[ind]->iL == -1 && M[ind]->iP == -1)
  { /*liść*/
    if (rodz != -1)
    { /* jest rodzic*/
      if (M[rodz]->iL == ind)
        M[rodz]->iL = -1;
      else
        M[rodz]->iP = -1;
    }
    else
      *pkorz = -1;
  }
  /* szukamy liść: */
  int rodz2 = rodz; /*indeks rodzica*/
  int ind2 = ind;
  while (ind2>=0)
  {
    if (M[ind2]->iL == -1 && M[ind2]->iP == -1)
      break;
    rodz2 = ind2; /* węzeł - rodzic */
    if (M[ind2]->iL != -1)
      ind2=M[ind2]->iL;/*następny z lewa*/
    else
      ind2=M[ind2]->iP;/*następny z prawa*/
  }
  M[ind]->dana = M[ind2]->dana;
  /* odłączenie liścia: */
  if (M[rodz2]->iL == ind2)
     M[rodz2]->iL = -1;
  else
     M[rodz2]->iP = -1;
}
//Realizacja rozdzielenia drzewa RST
void TransformRST(sElRST* M[], int *pkorz)
{/*transformacja od indeksu (*pkorz) w tablicę M*/
  #define RK2 200
  int kolejI[RK2]; /*tablica - kolejka dla indeksów*/
  typ_RST kolejD[RK2];/*tablica-kolejka dla danych*/
  int ikk=0; /*indeks końca kolejek*/
  int ipk=0; /*indeks początku kolejek*/
  int i1,i2; /*indeksy tymczasowe */
  /*zapisywanie drzewa do kolejki: */
  /*zapisywanie pierwszego węzła do kolejki: */
  i2 = *pkorz;
  kolejI[ikk]=i2; kolejD[ikk]=M[i2]->dana; ikk++;
  while (ipk < ikk) /*czy kolejka pusta?*/
  {
    i1=kolejI[ipk]; /*odczyt z kolejki*/
    ipk++;/*plus 1 do indeksu początku kolejki*/
    if (M[i1]->iL != (-1))
    {/*zapisywanie lewego węzła do kolejki: */
      i2 = M[i1]->iL;
      kolejI[ikk]=i2; kolejD[ikk]=M[i2]->dana; ikk++;
    }
    if (M[i1]->iP != -1)
    {/*zapisywanie prawego węzła do kolejki: */
      i2 = M[i1]->iP;
      kolejI[ikk]=i2; kolejD[ikk]=M[i2]->dana; ikk++;
    }
  }
  /*budowanie nowego drzewa: */
  typ_RST da;
  ipk = 0; /*znowu na początek kolejek*/
  /*odczyt z kolejek pierwszego węzła:*/
  i1=kolejI[ipk]; da=kolejD[ipk]; ipk++;
  M[i1]->dana = da; M[i1]->iL = -1; M[i1]->iP = -1;
  while (ipk < ikk)
  {/*odczyt z kolejek*/
    i1=kolejI[ipk]; da=kolejD[ipk]; ipk++;
    DodawDrzewoRST(M,pkorz, da, i1);
  }
}
void RozdzDrzewoRST(sElRST* M[], int *pkorz1, int *pkorz2, typ_RST rozdzD)
{/* (*pkorz1), (*pkorz2) - indeksy korzeni drzewa*/
/*rozdzD - dana typu typ_RST jako nowy korzeń*/
  int mm;
  int maska = 1; /*maska do wyboru kierunku*/
  int rodz = -1; /*indeks rodzica*/
  int ind = *pkorz1;
  while (ind>=0)
  {
    if (rozdzD == M[ind]->dana)
      goto rozdz;/* element jest znaleziony */
    rodz = ind; /* węzeł - rodzic */
    mm = rozdzD & maska;
    if (mm == 0)
      ind=M[ind]->iL;/*następny element - lewy*/
    else
      ind=M[ind]->iP;/*następny element - prawy*/
    maska <<= 1; /*mnożenie maski o 2*/
  }
  return; /*element nie jest znaleziony*/
rozdz: /* rozdzielenie: */
  if (ind == -1)
  { /* drzewo puste*/
    *pkorz2=-1; return;
  }
  if (rodz == -1)
  { /* korzeń jest miejscem rozdzielenia*/
    if (M[ind]->iL == -1 || M[ind]->iP == -1)
    { /*pusto z lewej lub prawej lub z obydwóch stron*/
      *pkorz2=*pkorz1; *pkorz1=-1;
      return;
    }
    *pkorz2 = *pkorz1;/*drugie drzewo zawiera prawe pod-
drzewo*/
    *pkorz1 = M[ind]->iL;
    M[ind]->iL = -1; /* odłączenie lewego poddrzewa*/
    TransformRST(M,pkorz1);
    return;
  }
  else
  { /*węzeł lub liść jest miejscem rozdzielenia */
    *pkorz2=ind;/*drugie drzewo zawiera liść lub węzeł*/
    if (M[ind]->iL != -1 || M[ind]->iP != -1)
    { /*węzeł jest miejscem rozdzielenia */
      TransformRST(M, pkorz2);
    }
    if (M[rodz]->iL == ind) M[rodz]->iL = -1;
    else M[rodz]->iP = -1; /* odłączenie od rodzica*/
  }
}
//Realizacja wyszukiwania elementu w drzewie TRIE
typedef int typ_TRIE;/* przykładowo*/
struct sElTRIE
{
  int iD;/*indeks elementu danych w tablicę D*/
  int iL;/*indeks w tablicę M lewego poddrzewa*/
  int iP;/*indeks w tablicę M prawego poddrzewa*/
  sElTRIE(int d) /*konstruktor 1*/
  {iD = d; iL = -1; iP = -1;};
  sElTRIE(int d, int iiL, int iiP) /*konstruktor 2*/
  {iD = d; iL = iiL; iP = iiP;};
};
int LadowanieDrzewaTRIE(sElTRIE* M[], typ_TRIE *D)
{
  M[0] = new sElTRIE(-1, 1, 2); M[1] = new sElTRIE(-1, 3, 4);
  D[0] = 0x1; M[2] = new sElTRIE(0, -1, -1);
  M[3] = new sElTRIE(-1, -1, 5); M[4] = new sElTRIE(-1, 6, 7);
  M[5] = new sElTRIE(-1, 8, 9);
  D[1] = 0x2; M[6] = new sElTRIE(1, -1, -1);
  M[7] = new sElTRIE(-1, 10, 11);
  D[2] = 0x4; M[8] = new sElTRIE(2, -1, -1);
  D[3] = 0xC; M[9] = new sElTRIE(3, -1, -1);
  D[4] = 0x6; M[10] = new sElTRIE(4, -1, -1);
  D[5] = 0xE; M[11] = new sElTRIE(5, -1, -1);
  return 12;
}
int WyszukDrzewoTRIE(sElTRIE* M[], typ_TRIE *D, int korz, typ_TRIE szukD)
{/*korz - indeks korzenia drzewa*/
/*szukD - szukana dana typu typ_TRIE*/
  int maska = 1; /*maska do wyboru kierunku*/
  int ind = korz;
  while (ind>=0)
  {
    int kk = M[ind]->iD;
    if (kk!= -1) /*liść*/
      if (szukD == D[kk]) return ind;
      else return -1; /*wynik negatywny*/
    if ((szukD & maska) == 0)
      ind=M[ind]->iL;/*następny element - lewy*/
    else
      ind=M[ind]->iP;/*następny element - prawy*/
    maska <<= 1;
  }
  return -1;/*wynik negatywny*/
}
//Realizacja wyszukiwania elementu w drzewie PATRICIA
typedef int typ_PATRICIA;/* przykładowo*/
struct sElPATRICIA
{
  unsigned int m;/* maska bitowa dla elementu danych*/
  typ_PATRICIA dana;/*element danych*/
  sElPATRICIA* pL;/*wskaźnik na lewe poddrzewo*/
  sElPATRICIA* pP;/*wskaźnik na prawe poddrzewo*/
  sElPATRICIA(int mask, typ_PATRICIA d) /*konstruktor*/
  { m = mask; dana = d; pL = 0; pP = 0;};
  void Ust(unsigned int mask, typ_PATRICIA d,
     sElPATRICIA* ipL, sElPATRICIA* ipP)
  { m = mask; dana = d; pL = ipL; pP = ipP;};
};
sElPATRICIA* LadowanieDrzewaPATRICIA()
{/* zwraca wskaźnik na korzeń drzewa*/
  sElPATRICIA* pm[11];
  for (int i=0;i<11;i++)
    pm[i] = new sElPATRICIA(0,(typ_PATRICIA)0);
  pm[0]->Ust(0x1, (typ_PATRICIA)0x1, pm[1], pm[2]);
  pm[1]->Ust(0x2, (typ_PATRICIA)0x4, pm[3], pm[4]);
  pm[2]->Ust(  0, (typ_PATRICIA)0x1, 0, 0); /*liść*/
  pm[3]->Ust(0x8, (typ_PATRICIA)0x4, pm[7], pm[8]);
  pm[4]->Ust(0x4, (typ_PATRICIA)0x2, pm[5], pm[6]);
  pm[5]->Ust(  0, (typ_PATRICIA)0x2, 0, 0); /*liść*/
  pm[6]->Ust(0x8, (typ_PATRICIA)0x6, pm[9], pm[10]);
  pm[7]->Ust(  0, (typ_PATRICIA)0x4, 0, 0); /*liść*/
  pm[8]->Ust(  0, (typ_PATRICIA)0xC, 0, 0); /*liść*/
  pm[9]->Ust(  0, (typ_PATRICIA)0x6, 0, 0); /*liść*/
  pm[10]->Ust(  0, (typ_PATRICIA)0xE, 0, 0); /*liść*/
  return pm[0];
}
void NiszczenieDrzewaPATRICIA(sElPATRICIA* pkorz)
{
  #define RKD 1000
  sElPATRICIA* kolej[RKD]; /*tablica - kolejka*/
  int ikk=0; /*indeks końca kolejek*/
  int ipk=0; /*indeks początku kolejek*/
  /*zapisywanie drzewa do kolejki: */
  kolej[ikk]=pkorz; ikk++;/*pierwszy węzeł --> do kolejki*/
  while (ipk < ikk) /*czy kolejka pusta?*/
  {
    sElPATRICIA* pp = kolej[ipk]; /*odczyt z kolejki*/
    ipk++;/*plus 1 do indeksu początku kolejki*/
    if (pp->pL != 0)
    {/*zapisywanie lewego węzła do kolejki: */
      kolej[ikk]=pp->pL; ikk++;
    }
    if (pp->pP != 0)
    {/*zapisywanie prawego węzła do kolejki: */
      kolej[ikk]=pp->pP; ikk++;
    }
  }
  /*węzły i liścia są zapisane do tablicy - kolejki
  od indeksu 0 do indeksu (ipk-1)*/
  while (ipk > 0)
  {/*odczyt z kolejki w odwrotnej kolejnosci*/
    ipk--;
    if (kolej[ipk] != 0) delete kolej[ipk];
  }
}
sElPATRICIA* WyszukDrzewoPATRICIA(sElPATRICIA* pkorz, typ_PATRICIA szukD)
{/* pkorz - wskaźnik na korzeń drzewa*/
/*szukD - szukana dana*/
  sElPATRICIA* pp = pkorz; /*tymczasowy wskaźnik */
  while (pp != 0)
  {
    if (pp->m == 0) /*liść*/
    {
      if (szukD == pp->dana) return pp;
      else return 0; /*wynik negatywny*/
    }
    if ((szukD & pp->m) == 0)
      pp = pp->pL;/*następny element - lewy*/
    else
      pp = pp->pP;/*następny element - prawy*/
  }
  return 0;/*wynik negatywny*/
}
//Realizacja dodawania elementu w drzewie PATRICIA
#define MMP 0x80000000 /*maska maksymalna*/
void AnalizaGrupy(typ_PATRICIA d1, typ_PATRICIA d2,
  unsigned int mm, unsigned int* pgr)
{/* maska bitowa maska ma postać 00010000 */
  unsigned int maska = 1; /*tj. 00000001 */
  while (maska < mm)
  {
    if ((d1 & maska) != (d2 & maska)) break;
    maska <<= 1; /*mnożenie o 2*/
  }
  *pgr = maska;
}
void DodawDrzewoPATRICIA(sElPATRICIA **ppkorz, typ_PATRICIA dodawD)
{/*pkorz - wskaźnik na korzeń drzewa*/
/*dodawD - dodawana dana typu typ_PATRICIA*/
  if (*ppkorz == 0)
  { /*drzewo puste; pierwszy element - liść*/
    *ppkorz = new sElPATRICIA(0,dodawD);
    return;
  }
  sElPATRICIA *prodz = 0; /*wskaźnik na rodzica*/
  sElPATRICIA *pt, *ps;/*wskaźniki tymczasowe*/
  unsigned int gr = 0; /*maska - granica, od której cyfry są nie jednakowe*/
  sElPATRICIA* pp = *ppkorz;/*tymczasowy wskaźnik na element drzewa*/
  while (pp != 0)
  {
    if (pp->pL == 0 && pp->pP == 0)
    { /*liść*/
      if (pp->dana == dodawD)
        return; /* element danych już istnieje*/
      goto lisc;/*liść*/
    }
    else
      gr = gr;
    AnalizaGrupy(dodawD, pp->dana, pp->m, &gr);
    if (gr < pp->m) goto wezel;
    prodz = pp; /* węzeł - rodzic */
    if ((dodawD & pp->m) == 0)
      pp = pp->pL;/*następny element - lewy*/
    else pp = pp->pP;/*następny element - prawy*/
  }
  return;
lisc: /* dodawanie „w liście": */
  AnalizaGrupy(dodawD, pp->dana, MMP, &gr);
  pp->m = gr; /*liść "pp" --> węzeł */
  pt = new sElPATRICIA(0,pp->dana);/*nowy liść równy "pp"*/
  prodz = pp;
  pp = new sElPATRICIA(0,dodawD);/*nowy liść*/
  if ((dodawD & gr) == 0)
  { prodz->pL = pp; prodz->pP = pt; }
  else { prodz->pP = pp; prodz->pL = pt; }
  return;
wezel: /* dodawanie węzła przed węzłem: */
  pt = new sElPATRICIA(gr,dodawD);/*dodatkowy węzeł*/
  if (prodz->pL == pp) /*przełączenie rodzica*/
  {
    ps = prodz->pL;
    prodz->pL = pt;
  }
  else
  {
    ps = prodz->pP;
    prodz->pP = pt;
  }
  prodz = pt;
  pp = new sElPATRICIA(0,dodawD);/*nowy liść*/
  if ((dodawD & gr) == 0)
  { prodz->pL = pp; prodz->pP = ps; }
  else { prodz->pP = pp; prodz->pL = ps; }
  return;
}
//Realizacja usuwania elementu w drzewie PATRICIA
void UsuwDrzewoPATRICIA(sElPATRICIA **ppkorz, typ_PATRICIA usuwD)
{/* ppkorz - adres wskaźnika na korzeń drzewa*/
/*usuwD - usuwana dana typu typ_PATRICIA*/
  sElPATRICIA *prodz = 0; /*wskaźnik na rodzica*/
  sElPATRICIA *pt;/*wskaźnik tymczasowy*/
  unsigned int gr=0; /*maska - granica, od której cyfry są nie jednakowe*/
  sElPATRICIA* pp = *ppkorz;/*aktualny wskaźnik na element*/
  if (pp == 0) return; /*drzewo jest puste*/
  while (pp != 0)
  {
    if (pp->pL == 0 && pp->pP == 0)
    { /*liść*/
      if (pp->dana == usuwD)
        goto usuw; /*znalazłyśmy liść*/
      else return; /*element nie istnieje*/
    }
    AnalizaGrupy(usuwD, pp->dana, pp->m, &gr);
    if (gr != pp->m) return; /*element nie istnieje*/
    prodz = pp; /* węzeł - rodzic */
    if ((usuwD & pp->m) == 0)
      pp = pp->pL;/*następny element - lewy*/
    else pp = pp->pP;/*następny element - prawy*/
  }
  return; /*błąd w drzewie*/
usuw: /* usuwanie liścia: */
  if (prodz == 0)
  { /*w drzewie jeden liść*/
    delete pp; /*zwolnienie pamięci*/
    *ppkorz = 0;
    return;
  }
  if (prodz->pL == pp) /*analiza rodzica*/
    pt = prodz->pP; /*brat*/
  else pt = prodz->pL; /*brat*/
  /*kopiowanie brata:*/
  prodz->pP = pt->pP; prodz->pL = pt->pL;
  prodz->m = pt->m; prodz->dana = pt->dana;
  delete pp; /*zwolnienie pamięci*/
  delete pt; /*niszczenie brata*/
  return;
}
/* Realizacja algorytmu Forda - Bellmana do znajdowania w grafie
drogi z najmniejszą długością */
#define NNW 999999.0 /* „wielka" waga */
int LadowanieGrafUjemnWagi(double* mwag)
{
  int rmw = 8;
  for (int j = 0; j < rmw; j++)
  {
    int kk = j * rmw;
    for (int i = 0; i < rmw; i++)
      mwag[kk+i] = NNW;
  }
  mwag[0 * rmw + 1] = 2; /*A-->B*/
  mwag[0 * rmw + 5] = 6; /*A-->F*/
  mwag[1 * rmw + 1] = 2; /*B-->B*/
  mwag[1 * rmw + 3] = 3; /*B-->D*/
  mwag[1 * rmw + 4] = 8; /*B-->E*/
  mwag[2 * rmw + 1] = -3; /*C-->B*/
  mwag[3 * rmw + 2] = 4; /*D-->C*/
  mwag[3 * rmw + 4] = 5; /*D-->E*/
  mwag[4 * rmw + 0] = 9; /*E-->A*/
  mwag[5 * rmw + 4] = 5; /*F-->E*/
  mwag[5 * rmw + 6] = 1; /*F-->G*/
  mwag[6 * rmw + 4] = 9; /*G-->E*/
  mwag[6 * rmw + 7] = 4; /*G-->H*/
  mwag[7 * rmw + 5] = -4; /*H-->F*/
  return rmw;
}
double SumaWag(double s1, double s2)
{
  if (s1 > NNW - 1.0 || s2 > NNW - 1.0)
    return NNW;
  else return (s1 + s2);
}
void ZnajdNajmnDrogiFordBellman(double* mwag, int rm, int pocz,
  double *dgraf)
{/* pocz - indeks wierzchołka początkowego */
  int jj = pocz * rm;
  for (int i = 0; i < rm; i++)
    dgraf[i]=mwag[jj + i];/*początkowa zawartość tablicy D*/
  for (int krok = 1; krok < rm; krok++)
    for (int k = 0; k < rm; k++)
    {
      if (k == pocz) continue;/* bez wierzchołka początkowego */
      for (int j = 0; j < rm; j++)
      {
        int ii = j * rm;
        double ss = SumaWag(dgraf[j],mwag[ii+k]);
        if (dgraf[k] > ss)
          dgraf[k] = dgraf[j] + mwag[ii+k];
      }
    }
}
/* Realizacja algorytmu Dijkstry do znajdowania w
grafie z wagami nieujemnymi drogi z najmniejszą długością*/
int LadowanieGrafNieujemnWagi(double mwag[])
{
  int rmw = 8;
  for (int j = 0; j < rmw; j++)
  {
    int kk = j * rmw;
    for (int i = 0; i < rmw; i++)
      mwag[kk+i] = NNW;
  }
  mwag[0 * rmw + 1] = 2; /*A-->B*/
  mwag[0 * rmw + 5] = 6; /*A-->F*/
  mwag[1 * rmw + 1] = 2; /*B-->B*/
  mwag[1 * rmw + 3] = 3; /*B-->D*/
  mwag[1 * rmw + 4] = 8; /*B-->E*/
  mwag[2 * rmw + 1] = 3; /*C-->B*/
  mwag[3 * rmw + 2] = 4; /*D-->C*/
  mwag[3 * rmw + 4] = 5; /*D-->E*/
  mwag[4 * rmw + 0] = 9; /*E-->A*/
  mwag[5 * rmw + 4] = 5; /*F-->E*/
  mwag[5 * rmw + 6] = 1; /*F-->G*/
  mwag[6 * rmw + 4] = 9; /*G-->E*/
  mwag[6 * rmw + 7] = 4; /*G-->H*/
  mwag[7 * rmw + 5] = 4; /*H-->F*/
  return rmw;
}
bool CzyNieWiecej2(double *dgraf, int elem1, int elem2)
{/* elem1, elem2 - indeksy w tablicy D */
  return(dgraf[elem1] <= dgraf[elem2]);
}
bool CzyMniej2(double *dgraf, int elem1, int elem2)
{/* elem1, elem2 - indeksy w tablicy D */
  return(dgraf[elem1] < dgraf[elem2]);
}
bool CzyNieMniej2(double *dgraf, int elem1, int elem2)
{/* elem1, elem2 - indeksy w tablicy D */
  return(dgraf[elem1] >= dgraf[elem2]);
}
void BudowaKopca2(int n, int *tabl, double *dgraf)
{
  int k=n-1;
  while (k>0)
  {
    k--;
    int j=k;
    while (j<n-1)
    {
      int i=(j+n+1)>>1;//tj. i=(j+n+1)/2
      if (CzyNieWiecej2(dgraf,tabl[i],tabl[j])==true)
        break;
      int w=tabl[i]; tabl[i]=tabl[j]; tabl[j]=w;
      j=i;
    }
  }
}
void UporzTabl2(int n, int *tabl, double *dgraf)
{
  if (n<=0) return;//tablica jest pusta
  int k=0;
  while (k<n-1)
  {
    //Zapisywanie do ciągu wynikowego:
    int w=tabl[k]; tabl[k]=tabl[n-1]; tabl[n-1]=w;
    int j=n-1;
    while (j>k)
    {
      int i=j<<1;//tj. i=j*2
      i-=n;// i=j*2-n
      if (i<=k) break;
      if (i>k+1 && CzyMniej2(dgraf,tabl[i-1],tabl[i])==true) i--;
      if (CzyNieMniej2(dgraf,tabl[i],tabl[j])==true) break;
      w=tabl[i]; tabl[i]=tabl[j]; tabl[j]=w;
      j=i;
    }// while (j>k)
    k++;
  }// while (k<n-1)
  for (int r = 0; r < n; r++)
    tabl[r] = tabl[r];
}
void SortowanieKopcowe2(int rozm, int *tabl, double *dgraf)
{
  if (rozm<=1) return;/* tablica jest pusta albo w tablicy
jest tylko jeden element */
  BudowaKopca2(rozm,tabl, dgraf);
  UporzTabl2(rozm,tabl, dgraf);
}
void ZnajdNajmnDrogiDijkstra(double mwag[], int rm,
        int pocz, double *D)
{/* pocz - indeks wierzchołka początkowego */
  int *T = new int[rm];/* tablica z drzewem kopcowym T */
  int jj = pocz * rm;
  for (int i = 0; i < rm; i++)
  {
    D[i]=mwag[jj + i];/* początkowa zawartość tablicy D */
    T[i] = i; /* zapisywanie do tablicy T */
  }//i
  for (int j = 0; j < rm; j++)
  {/* j jest granicą tablicy kopcowej */
    SortowanieKopcowe2(rm-j, &T[j], D);/* powtarzamy
sortowanie po każdej korekcie tablicy D */
    int n = T[j];/* indeks najmniejszego elementu w D */
    if (D[n] == NNW) /* koniec sprawdzania */
      break;
    int iw = n * rm;
    for (int id = 0; id < rm; id++)
    {
      if (id == pocz)
        continue;/* bez wierzchołka początkowego */
      bool b = true;/* znacznik tymczasowy */
      /* czy id nie jest indeksem ostateczną odległości? : */
      for (int m = 0; m <= j; m++)
      {/*na początku T indeksy ostatecznych odległości*/
        if (T[m] == id) /* bez ostatecznych odległości */
        {
          b = false;
          break; /* wyjście z pętli m */
        }
      }
      if (b == true)
      {
        double ss = SumaWag(D[n],mwag[iw+id]);
        if (D[id] > ss)
          D[id] = D[n] + mwag[iw+id];
      }
    }//k
  }//j
  delete [] T;
}
/* Realizacja algorytmu znajdowania drogi z najmniej-
szą długością w sieci acyklicznej */
int LadowanieGrafAcykl(double mwag[])
{
  int rmw = 8;
  for (int j = 0; j < rmw; j++)
  {
    int kk = j * rmw;
    for (int i = 0; i < rmw; i++)
      mwag[kk+i] = NNW;
  }
  mwag[0 * rmw + 1] = -2; /*A-->B*/
  mwag[0 * rmw + 5] = -6; /*A-->F*/
  mwag[1 * rmw + 2] = -3; /*B-->C*/
  mwag[1 * rmw + 3] = -3; /*B-->D*/
  mwag[1 * rmw + 4] = -8; /*B-->E*/
  mwag[2 * rmw + 3] = -4; /*C-->D*/
  mwag[3 * rmw + 4] = -5; /*D-->E*/
  mwag[5 * rmw + 4] = -5; /*F-->E*/
  mwag[5 * rmw + 6] = -1; /*F-->G*/
  mwag[5 * rmw + 7] = -4; /*F-->H*/
  mwag[6 * rmw + 4] = -9; /*G-->E*/
  mwag[7 * rmw + 6] = -4; /*H-->G*/
  return rmw;
}
void PrzestawWierzch(double M[], int rm, int pocz, int *indP)
{/* indeksy macierzy M do tablicy „indP" */
  int *kraw = new int[rm];/* liczby krawędzi dochodzących do
wierzchołka */
  int i,j;
  for (i = 0; i < rm; i++)
  {
    kraw[i]=0;/*początkowa zawartość elementu kraw[i]*/
    for (j = 0; j < rm; j++)
    {
      int jbaz = j * rm;
      if (M[jbaz+i] < NNW)
        kraw[i]++;/* liczymy krawędzi dochodzące */
    }
  }
  int ii=0; /* indeks w tablicy „indP" */
  int *stos = new int[rm], js=-1;/* js - indeks stosu */
  js++; stos[js]=pocz;/* zapisywanie do stosu */
  while (js>=0)
  {
    i=stos[js]; js--;/* zdejmowanie ze stosu */
    indP[ii]=i; ii++;
    for (j = 0; j < rm; j++)
    {
      int ibaz = i * rm;
      if (M[ibaz+j] < NNW)
      {
        kraw[j]--;/* zmniejszamy liczbę krawędzi przy-
chodzących do wierzchołka j */
        if (kraw[j]==0)
        {
          js++; stos[js]=j;/* zapisywanie do stosu */
        }
      }
    }
  }
  delete [] stos;
  delete [] kraw;
}
void ZnajdNajmnDrogiAcykl(double M[], int rm,
        int pocz, double *D)
{/* pocz - indeks wierzchołka początkowego */
  int *indP = new int[rm];/* indeksy wierzchołków w kolejności po-
sortowanej*/
  PrzestawWierzch(M, rm, pocz,indP);/* indeksy do tablicy „indP"*/
  int ii = pocz * rm;
  for (int i = 0; i < rm; i++)
  {
    D[i]=M[ii+i];/* początkowa zawartość tablicy D */
  }
  int i1, i2;
  for (int k = 1; k < rm; k++)
  {
    i2=indP[k]; /* przekształcenie indeksu */
    for (int j = 0; j < k; j++)
    {
      i1=indP[j]; /* przekształcenie indeksu */
      ii = i1 * rm;
      double ss = SumaWag(D[i1],M[ii+i2]);
      if (D[i2] > ss)
        D[i2] = D[i1] + M[ii+i2];
    }
  }
  delete [] indP;
}
/*Realizacja algorytmu do znajdowania wszystkich
najmniejszych odległości*/
int LadowanieWagOdlegl(double M[])
{
  int rmw = 5;
  for (int j = 0; j < rmw; j++)
  {
    int kk = j * rmw;
    for (int i = 0; i < rmw; i++)
      M[kk+i] = NNW;
  }
  M[0 * rmw + 1] = 2; /*A-->B*/
  M[1 * rmw + 1] = 2; /*B-->B*/
  M[1 * rmw + 3] = 3; /*B-->D*/
  M[1 * rmw + 4] = 8; /*B-->E*/
  M[2 * rmw + 1] = 3; /*C-->B*/
  M[3 * rmw + 2] = 4; /*D-->C*/
  M[3 * rmw + 4] = 5; /*D-->E*/
  M[4 * rmw + 0] = 9; /*E-->A*/
  return rmw;
}
void MnozMacz(double M[], int rm, double *D)
{/* „mnożenie" macierzy D na macierz M  */
  int i,j,k;
  for (i = 0; i < rm; i++)
  {/* i - indeks wiersza */
    int ibaz = i * rm;
    for (j = 0; j < rm; j++)
    {/* j - indeks kolumny */
      for (k = 0; k < rm; k++)
      {/* k - indeks elementu w wierszu i i kolumnie j*/
        int kbaz = k * rm;
        if (D[ibaz+j] > SumaWag(D[ibaz+k],M[kbaz+j]))
          D[ibaz+j] = D[ibaz+k] + M[kbaz+j];
      }
    }
  }
}
void ZnajdNajmnOdlegl(double M[], int rm, double *D)
{
  int i,j,m;
  for (i = 0; i < rm; i++) /* i - indeks wiersza */
  {
    int ibaz = i * rm;
    for (j = 0; j < rm; j++) /*j - indeks kolumny*/
      D[ibaz+j]=M[ibaz+j];/*początkowa zawartość macierzy D*/
  }
  for (m = 0; m < rm-2; m++)
    MnozMacz(M, rm, D); /*wyniki w  D[][]*/
}
/*Realizacja algorytmu do obliczenia maksymalnego
przepływu przez sieć*/
int LadowanieMaksPrzepl(double mwag[])
{
  int rmw = 8;
  for (int j = 0; j < rmw; j++)
  {
    int kk = j * rmw;
    for (int i = 0; i < rmw; i++)
      mwag[kk+i] = NNW;
  }
  /* A, B, C, D, F, G, H, E */
  /* źro'dło A musi mieć indeks 0; ujście E - indeks 7 */
  mwag[0 * rmw + 1] = 22; /*A-->B*/
  mwag[0 * rmw + 4] = 6; /*A-->F*/
  mwag[1 * rmw + 2] = 3; /*B-->C*/
  mwag[1 * rmw + 3] = 3; /*B-->D*/
  mwag[1 * rmw + 7] = 8; /*B-->E*/
  mwag[2 * rmw + 3] = 4; /*C-->D*/
  mwag[3 * rmw + 7] = 5; /*D-->E*/
  mwag[4 * rmw + 7] = 5; /*F-->E*/
  mwag[4 * rmw + 5] = 1; /*F-->G*/
  mwag[4 * rmw + 6] = 4; /*F-->H*/
  mwag[5 * rmw + 7] = 9; /*G-->E*/
  mwag[6 * rmw + 5] = 4; /*H-->G*/
  return rmw;
}
bool GenerPodzbior2(int *TP, int k, int n)
{
  if (TP[k-1] < n-1) TP[k-1]++;
  else /* jeśli P[k-1] równa się (n-1) */
  {
    for (int j = k-2; j >= 0; j--)
      if (TP[j] < n - k + j) break;
    if (j < 0) return false;
    TP[j]++;
    while (j+1 < k )
    {
      TP[j+1] = TP[j] + 1;
      j++;
    }
  }
  return true;
}
double ObliczMaksPrzepl(double M[], int rm, bool *KZ)
{
  double Smax = NNW; /*maksymalny przepływ przez sieć*/
  int i,j,k;
  int *TP = new int[rm]; /*tablica - podzbiór z indeksami*/
  bool *F = new bool[rm]; /*flagi przynależności do zbioru W*/
  F[0]=true; /*źródło jest zawsze w zbiorze W*/
  for (i = 1; i < rm; i++)
    F[i]=false; /* zerowanie flagi*/
  double S=0.0; /* tymczasowa suma przepustowości*/
  /*w podzbioru W znajduje się tylko źródło:*/
  S=0.0;
  for (i = 1; i < rm; i++)
    if (M[0+i] < NNW) S += M[0+i];
  if (Smax > S)
  {
    Smax = S;
    for (i = 0; i < rm; i++)
      KZ[i]=F[i]; /* zapisywanie „krytycznego" zbioru*/
  }
  /*obliczenie k - elementowych podzbiorów:*/
  for (k = 1; k < rm-2; k++)
  {
    for (j = 0; j < k; j++)
      TP[j]=j; /*zapisywanie do P liczb od 0 do (k-1)*/
powt:
    /*wykorzystanie podzbioru: */
    for (i = 1; i < rm; i++)
      F[i]=false; /* zerowanie flag*/
    for (j = 0; j < k; j++)
    {
      i = TP[j] + 1; /*korekta indeksu*/
      F[i] = true; /* ustawienie flagi*/
    }
    S=0.0;
    for (j = 0; j < rm; j++)
    {
      int jbaz = j * rm;
      if (F[j]==true) /*wiersz z podzbioru W*/
        for (i = 0; i < rm; i++)
          if (F[i]==false && M[jbaz+i] < NNW) S += M[jbaz+i];
    }
    if (Smax > S)
    {
      Smax = S;
      for (i = 0; i < rm; i++)
        KZ[i]=F[i];/*zapisywanie „krytycznego" zbioru*/
    }
    if (GenerPodzbior2(TP, k, rm-2) == true) goto powt;
  } /* cykl k*/
  delete [] F;
  delete [] TP;
  return Smax;
}
//========================================
//=== Rozdział 7 ============================
//========================================
//Realizacja algorytmu sortowania przez proste wstawianie
bool CzyNieWiecej4(int elem1, int elem2)
{
  return (elem1<=elem2);
}
void SortowanieProsteWstawianie(int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  int i=1;
  while (i<n)
  {
    int w=M[i];
    int j=i-1;
    while (j>=0)
    {
      if (CzyNieWiecej4(M[j],w)==true) break;
      M[j+1]=M[j]; j--;
    }
    j++;
    M[j]=w; i++;
  }
}
//Realizacja algorytmu sortowania przez proste wybieranie
bool CzyMniej4(int elem1, int elem2)
{
  return (elem1 < elem2);
}
void SortowanieProsteWybieranie (int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  int i=0;
  while (i<n)
  {
    int w=M[i]; int j=i+1; int k=i;
    while (j<n)
    {
      if (CzyMniej4(M[j],w)==true) { w=M[j]; k=j; }
      j++;
    }
    M[k]=M[i]; M[i]=w; i++;
  }
}
//Realizacja algorytmu sortowania przez prostą zamianę
void SortowanieProstaZamiana(int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  for (int i=0;i<n-1;i++)
    for (int j=i+1;j<n;j++)
      if (CzyMniej4(M[j],M[i])==true)
      {
        int w=M[i]; M[i]=M[j]; M[j]=w;
      }
}
//Realizacja algorytmu sortowania bąbelkowego
bool CzyWiecej4(int elem1, int elem2)
{
  return (elem1>elem2);
}
void SortowanieBabelkowe(int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  for (int i=0;i<n-1;i++)
    for (int j=n-1;j>i;j--)
      if (CzyWiecej4(M[j-1],M[j])==true)
      {
        int w=M[j]; M[j]=M[j-1]; M[j-1]=w;
      }
}
//Realizacja ulepszonego algorytmu sortowania bąbelkowego
void SortowanieBabelkoweUlepsz(int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  int f=0;//flaga „zakończ"
  for (int i=0;i<n-2;i++)
  {
    if (f==1) return;//zakończenie procedury
    f=1;
    for (int j=n-1;j>i;j--)
      if (CzyWiecej4(M[j-1],M[j])==true)
      {
        int w=M[j]; M[j]=M[j-1]; M[j-1]=w;
        f=0;
      }
  }
}
//Realizacja algorytmu sortowania mieszanego
void SortowanieMieszane(int n, int *M)
{
  if (n<=0)
    return;//tablica jest pusta
  int p=0, np=0;//granica początkowa
  int k=n-1, nk=n-1;//granica końcowa
  int j;//indeks pary
  do
  {
    if (p>=k) return;//zakończenie procedury
    // kierunek „od końca"
    j=k;//indeks pary
    do
    {
      if (CzyWiecej4(M[j-1],M[j])==true)
      {
        int w=M[j]; M[j]=M[j-1]; M[j-1]=w;
        np=j; //nowa granica początkowa
      }
      j--;
    }
    while (j>p);
    if (p>=np) return;//zakończenie procedury
    p=np;
    if (p>=k) return;//zakończenie procedury
    //kierunek „od początku"
    j=p;//indeks pary
    do
    {
      if (CzyMniej4(M[j+1],M[j])==true)
      {
        int w=M[j]; M[j]=M[j+1]; M[j+1]=w;
        nk=j; //nowa granica końcowa
      }
      j++;
    }
    while (j<k);
    if (k<=nk) return;//zakończenie procedury
    k=nk;
  }
  while (true);
}
//Realizacja algorytmu sortowania metodą Shella przez wstawianie
void SortowanieMetodaShella (int n, int *M)
{
  const int h[2] = {3,1};
  int m = 2;
  if (n<=0) return;//tablica jest pusta
  for (int r = 0; r < m; r++)
  {
    int k = h[r];
    int i = k;
    while (i < n)
    {
      int w = M[i];
      int j = i-k;
      while (j>=0)
      {
        if (CzyNieWiecej4(M[j],w)==true)
          break;// cykl j
        M[j+k]=M[j];
        j-=k;
      }//j
      j += k;
      M[j]=w; i++;
    }
  }//cykl r
}
//Realizacja algorytmu sortowania kopcowego
bool CzyNieMniej4(int elem1, int elem2)
{
  return (elem1>=elem2);
}
void BudowaKopca(int n, int *M)
{
  int k=n-1;
  while (k>0)
  {
    k--;
    int j=k;
    while (j<n-1)
    {
      int i=(j+n+1)>>1;//tj. i=(j+n+1)/2
      if (CzyNieWiecej4(M[i],M[j])==true) break;
      int w=M[i]; M[i]=M[j]; M[j]=w;
      j=i;
    }
  }
}
void UporzTabl(int n, int *M)
{
  if (n<=0) return;//tablica jest pusta
  int k=0;
  while (k<n-1)
  {
    //Zapisywanie do ciągu wynikowego:
    int w=M[k]; M[k]=M[n-1]; M[n-1]=w;
    int j=n-1;
    while (j>k)
    {
      int i=j<<1;//tj. i=j*2
      i-=n;// i=j*2-n
      if (i<=k) break;
      if (i>k+1 && CzyMniej4(M[i-1],M[i])==true) i--;
      if (CzyNieMniej4(M[i],M[j])==true) break;
      w=M[i]; M[i]=M[j]; M[j]=w;
      j=i;
    }// while (j>k)
    k++;
  }// while (k<n-1)
}
void SortowanieKopcowe(int n, int *M)
{
  if (n<=1) return;/* tablica jest pusta albo w tablicy
jest tylko jeden element */
  BudowaKopca(n,M);
  UporzTabl(n,M);
}
//Realizacja algorytmu sortowania przez podział (sortowanie „szybkie")
int Podzial_tablicy(int il, int ip, int *M)
{//il - granica lewa („od początku")
 //ip - granica prawa („od końca")
  if (ip<=il) return -1;//tablica jest pusta
  int i=il; int j=ip+1;
  do
  {
    i++;
    while (i<=ip && CzyMniej4(M[i],M[il])==true) i++;
    j--;
    while (j>=il && CzyMniej4(M[il],M[j])==true) j--;
    if (i<j){ int w=M[i]; M[i]=M[j]; M[j]=w;}
   }
   while (i<j);
   int w=M[il]; M[il]=M[j]; M[j]=w;
   return j;
}
void SortowaniePodzial(int il, int ip, int *M)
{//il - granica lewa („od początku")
 //ip - granica prawa („od końca")
  if (ip<=il) return;//w tablicy jeden element
  int j=Podzial_tablicy(il,ip,M);
  if (j>il+1)
    SortowaniePodzial(il,j-1,M); //rekurencja
  if (j>=0 && j<ip-1)
    SortowaniePodzial(j+1,ip,M); //rekurencja
}
//Realizacja algorytmu sortowania rzędowego
int Indeks10(int jr, int liczba)
{//jr - indeks cyfry dziesiętnej, przykładowo jr=2
  int temp = liczba;// przykładowo temp=37598
  for (int k=0;k<jr;k++)
    temp/=10; //przykładowo temp => 375
  int temp2=(temp/10)*10; //przykładowo temp2 => 370
  return(temp-temp2); //przykładowo temp-temp2 => 5
}
#define maxRozmKolej 100
void SortowanieRzedowe10_1 (int mr,int n, int *M)
{// mr - maksymalna liczba cyfr w liczbach
// M - tablica z n liczb
#define mG 10 //liczba kolejek w przypadku: P=10, r=1
#define rCyfr 1 //liczba cyfr w grupie
  if (n<=1) return;/* tablica M jest pusta albo w ta-
blicy jest tylko jeden element */
klKolej* pG1[mG];/* mG wskaźników na kolejki grupy G1 */
klKolej* pG2[mG];/* mG wskaźników na kolejki grupy G2 */
int i,j;
int *pi;
int jr=0;//indeks aktualnej cyfry
//---Zerowanie kolejek
  for (i=0;i<mG;i++)
  {//alokacja 2*mG kolejek
    pG1[i]=new klKolej(maxRozmKolej);//tablicy-kolejki
    pG2[i]=new klKolej(maxRozmKolej);//tablicy-kolejki
  }
//---Zapisywanie liczb do grupy kolejek G1---
  for (i=0;i<n;i++)
  {
    j=Indeks10(jr,M[i]);
    int* pliczba=new int;
    *(pliczba)=M[i];
    pG1[j]->KolejZapis((void *)pliczba);
  }
//---Przejście do następnej cyfry
ms1:
  jr+=rCyfr;
  if (jr>=mr) goto mz1;
//---Przeniesienie liczb z kolejek G1 do kolejek G2
  for (i=0;i<mG;i++)
    while (pG1[i]->KolejCzyt((void**)&pi)==true)
    {
      j=Indeks10(jr,(*pi));
      pG2[j]->KolejZapis((void *)pi);
    }
//---Przejście do następnej cyfry
  jr+=rCyfr;
  if (jr>=mr) goto mz2;
//--- Przeniesienie liczb z kolejek G2 do kolejek G1
  for (i=0;i<mG;i++)
    while (pG2[i]->KolejCzyt((void**)&pi)==true)
    {
      j=Indeks10(jr,(*pi));
      pG1[j]->KolejZapis((void *)pi);
    }
  goto ms1;//powrót na powtórzenie
//--- Przeniesienie wyników z kolejek G1 do tablicy M
mz1:
  j=0; //indeks tablicy wynikowej
  for (i=0;i<mG;i++)
    while (pG1[i]->KolejCzyt((void**)&pi)==true)
      M[j++]=*(pi);
  return;
//--- Przeniesienie wyników z kolejek G2 do tablicy M
mz2:
  j=0; //indeks tablicy wynikowej
  for (i=0;i<mG;i++)
    while (pG2[i]->KolejCzyt((void**)&pi)==true)
      M[j++]=*(pi);
  return;
}
//Realizacja algorytmu łączenia tablic
int LaczenieTablicPosortowanych(int m, int *pnj, int **pM, int *pW)
{//m - liczba tablic Mj
//pnj - wskaźnik na tablicę z rozmiarami tablic Mj
//pM - wskaźnik na tablicę wskaźników na tablicy Mj
//pW - wskaźnik na tablicę wynikową
  int *pk=new int[m];//tablica indeksów
  for (int i=0;i<m;i++)
    pk[i]=0; //zerowanie indeksów
  int jW=0;//indeks do tablicy wynikowej
  bool flagaKoniec=false;
  while (flagaKoniec == false)
  {
    int jTabl=0;
    int minLiczba=0;
    flagaKoniec = true;
    bool flagaPierwsz=true;
    for (int i=0;i<m;i++)
    {
      int indLiczba=pk[i];
      int granIndeks=pnj[i];
      if (indLiczba < granIndeks)
      {
        if (flagaPierwsz)
        {
          minLiczba=pM[i][indLiczba];
          jTabl=i;
          flagaPierwsz=false;
        }
        else
        {
          if (minLiczba > pM[i][indLiczba])
          {
            minLiczba=pM[i][indLiczba];
            jTabl=i;
          }
        }
        flagaKoniec=false;
      }//if
    }//for
    if (flagaKoniec == false)
    {
      pW[jW++]=minLiczba;//zapisywanie liczby
      pk[jTabl]++;//zwiększenie indeksu
    }
  }
  delete [] pk;
  return jW;//rozmiar tablicy wynikową
}
//========================================
//=== Rozdział 8 ============================
//========================================
//Algorytm połówkowy
bool CzyJestKopia_polowkowy(int rM, int M[],int W)
{//rM - rozmiar tablicy M
  int p=0;//początkowy indeks części tablicy
  int k=rM;//końcowy indeks części tablicy
  int i;// indeks centralnego elementu
  do
  {
    if (k < p+1) return false;/*nie znaleziono*/
    i=(p+k)>>1;
    if (M[i] == W) return true;/* znaleziono */
    if (M[i] < W)
    {
      if (i+1 == k) return false;/*nie znaleziono*/
      p=i+1;
    }
    else
    if (M[i] > W)
    {
      if (i == p) return false;/*nie znaleziono*/
      k=i;
    }
  }
  while (true);
}
//Wyszukiwanie „naiwne"
bool CzyJestWyraz(int rM, char M[], int rW, char W[])
{//rM - rozmiar tekstowej tablicy M
//rW - rozmiar wyrazu (wzorca tekstowego) W
  for (int i=0; i < rM - rW; i++)
  {
    bool flaga = true;
    for (int j=0; j < rW; j++)
      if (W[j] != M[i+j])
      {
        flaga = false;/*fragment jest nie równy wzorcu*/
        break;//skracamy porównanie w cyklu j
      }
    if (flaga) return true;/*kopia wzorca istnieje*/
  }
  return false;/* nie znaleziono kopii wzorca */
}
//Automat do rozpoznawania podsłów
bool AutomatBAOBAB(char lit)
{//lit - litera wejściowego alfabetu
static int stan=0;
  switch (stan) {
    case 0:
      switch (lit) {
        case 'a': stan=2; break;
        case 'b': stan=1; break;
        case 'o': stan=3; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 1:
      switch (lit) {
        case 'a': stan=2; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 2:
      switch (lit) {
        case 'b': stan=6; break;
        case 'o': stan=3; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 3:
      switch (lit) {
        case 'b': stan=4; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 4:
      switch (lit) {
        case 'a': stan=5; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 5:
      switch (lit) {
        case 'b': stan=6; break;
        case '$': stan=0; break;
        default: stan=7; break;
      }
      break;
    case 6:
      switch (lit) {
        case '$': stan=0; break;
        default: stan=7; break;
      }
    case 7: /*stan oczekiwania na koniec wzorca*/
      switch (lit) {
        case '$': stan=0; break;
        default: stan=7; break;
      }
  }//koniec switch (stan)
  if (stan>=1 && stan<=6) return true;
  return false;
}
bool DopasowWzorca(int rW, char W[])
{//rW - rozmiar wzorca tekstowego W
  AutomatBAOBAB('$'); /*ustawienie w stan początkowy*/
  for (int j=0; j < rW; j++)
  {
    if (AutomatBAOBAB(W[j])==false)
      return false; /*wzorzec nie jest rozpoznany;
skracamy porównanie w cyklu*/
  }
  return true; /* wzorzec jest rozpoznany */
}
//========================================
//=== Rozdział 9 ============================
//========================================
/*Realizacja algorytmu znajdowania najmniejszej liczby*/
bool NajmniejszaLiczba(int rozmiar, int *pTablica,
  int& wynik)
{
  if (rozmiar<=0)return false;//tablica jest pusta
  wynik = pTablica[0];
  for (int indeks=1; indeks<rozmiar; indeks++)
    if (wynik > pTablica[indeks])
      wynik = pTablica[indeks];
  return true;
}
/*Realizacja algorytmu Euklidesa do obliczenia NWP*/
int NWP_euklides(int A, int B)
{
  if (A<=0 || B<=0) return 0;
  int R;
  int M=A;
  int N=B;
  do
  {
    R=M%N; // tj. R = mod(M,N);
    if (R!=0)
    {
      M=N; N=R;
    }
  }
  while (R!=0);
  return N;
}
/*Realizacja algorytmu obliczenia NWP przez odejmowanie*/
int NWP_odejmowanie(int A, int B)
{
  if (A<=0 || B<=0) return 0;
  int M=A;
  int N=B;
  while (M!=N)
  {
    if (M>N)
      M=M-N;
    else //tj.(M<N)
      N=N-M;
  }
  return N;
}
//Realizacja binarnego algorytmu obliczenia NWP
int NWP_binarny(int A, int B)
{
  if (A<=0 || B<=0) return 0;
  int K=1; //współczynnik wspomagający
  int M=A;
  int N=B;
  while (M!=N)
  {
    if (M & 1) //M nieparzyste
    {
      if (N & 1) //N nieparzyste
      {
        if (M>N) M-=N; else if (M<N) N-=M;
      }
      else //N parzyste, M nieparzyste
      {
        N >>= 1; /*przesuwanie w prawo o jeden
                 bit, tj. dzielenie na 2*/
      }
    }
    else //M parzyste
    {
      M >>= 1; //przesuwanie w prawo o jeden
               // bit, tj. dzielenie na 2
      if ((N & 1)==0) //N parzyste, M parzyste
      {
        N >>= 1; //przesuwanie w prawo o jeden
               // bit, tj. dzielenie na 2
        K <<= 1; //przesuwanie w lewo o jeden
               // bit, tj. mnożenie razy 2
      }
    }
  } // koniec cyklu while
  return (N * K);
}
//Realizacja algorytmu znalezienia drogi skoczka szachowego
struct s_skok
{
  int pozX, pozY; /* pozycja bieżąca */
  s_skok()
  {
    pozX=pozY=0;
  }
};
struct s_pole
{
  int numerSkoku; /* numer skoku */
  int nzakaz, zakazX[8], zakazY[8]; /* pozycje zakazane */
  s_pole()
  {
    numerSkoku=-1;
    nzakaz=0;
    for (int j=0;j<8;j++) { zakazX[j]=-1; zakazY[j]=-1; }
  }
};
//========================================
//=== Programy ============================
//========================================
void __fastcall TForm1::BitBtnKoniecClick(TObject *Sender)
{
Sender=Sender;
  Close();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox2Click(TObject *Sender)
{
Sender=Sender; /* miejsce punktu zatrzymania ("breakpoint") */
  switch (ListBox2->ItemIndex)
  {
    case 0: /*Pomiar czasu wykonania algorytmu*/
    {
      clock_t start, koniec;
      start = clock();
      //... działania, których czas zamierzamy zmierzyć
      koniec = clock();
      long delta=(long)(koniec - start);//czas działań w ms
      delta=delta; //debug
    }
      break;
    case 1: /*Ustawienie wskaźnika na funkcję*/
    {
      double x=3.1415,y=0.0;
      double (* pf) (double arg);
      // wskaźnik "pf" na funkcję zwracającą wartość typu "double"
      if (x > 0.5) pf = sin;
      // funkcja "sinus" zwracającą wartość typu "double" oraz przyjmująca argument "arg" typu "double"
      else pf = cos;
      // funkcja "cosinus" zwracającą wartość typu "double" oraz przyjmująca argument "arg" typu "double"
      y = (*pf)(x);
      y=y;
    }
      break;
    case 2: /*Definicja klasy*/
    {//Patrz rozdział "Definicje"
    }
      break;
    case 3: /*Definicja klasy z uprawnieniami dostępu*/
    {//Patrz rozdział "Definicje"
    }
      break;
    case 4: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox4Click(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox4->ItemIndex)
  {
    case 0: /*Listy*/
    {//Patrz rozdział "Definicje"
      sElem *pPocz;//wskaźnik na początek listy
      sElem *p;//tymczasowa zmienna - wskaźnik
      p=new sElem;//alokacja nowego elementu
      p->dana='c';
      p->nast=NULL;//koniec listy
      pPocz=p;//lista zawiera literę c
      p=new sElem;//alokacja nowego elementu
      p->dana='b';
      p->nast=pPocz;//łączenie elementów
      pPocz=p;//lista zawiera litery b, c
      p=new sElem;//alokacja nowego elementu
      p->dana='a';
      p->nast=pPocz;//łączenie elementów
      pPocz=p;//lista zawiera litery a,
    }
      break;
    case 1: /*Realizacją stosu na bazie tablicy*/
    {
      #define RS 1000 /*rozmiar stosu*/
      double stos[RS]; /*stos - tablica*/
      int js=-1; /*definicja indeksu stosu*/
      double dd=0.1;
      //...
      js++; stos[js] = dd; /*odkładanie „dd" na stos*/
      //...
      dd = stos[js]; js--; /*zdejmowanie „dd" ze stosu*/
      //...
      if (js != -1) /*sprawdzanie „czy stos pusty?"*/
        dd = stos[js]; /*pobranie „dd" z frontu stosu*/
      //...
    }
      break;
    case 2: /*Realizacją stosu dla wskaźników na pewne obiekty*/
    {//Patrz definicję
      klStos stos;
      int elem=7;
      int* pElem=0;
      bool czyPoprawZap=stos.StosZapis((int *)&elem);
      if (czyPoprawZap)
      {
        bool czyPoprawCzyt=stos.StosCzyt((void **)&pElem);
        czyPoprawCzyt=czyPoprawCzyt;
      }
    }
      break;
    case 3: /*Procedura rekurencyjna do obliczenia współczynnika
dwumianowego (symbolu Newtona)*/
    {//Patrz rozdział "Definicje"
      int komb = WspDwum(5, 2);
      komb = komb;
    }
      break;
    case 4: /*Procedura iteracyjna do obliczenia współczynnika
dwumianowego (symbolu Newtona)*/
    {//Patrz rozdział "Definicje"
      int komb = WspDwumIterac(5, 2);
      komb = komb;
    }
      break;
    case 5: /*Realizacją kolejki na bazie tablicy dla zmiennych typu
double*/
    {//
      #define RK 1000 /*rozmiar kolejki*/
      double kolej[RK]; /*kolej - tablica*/
      int ikk=0; /*definicja indeksu końca kolejki*/
      int ipk=0; /*definicja indeksu początku kolejki*/
      double dd=0.1;
      //...
      ikk = 0; ipk = 0; /*zerowanie kolejki*/
      //...
      kolej[ikk] = dd; /*zapisywanie „dd" do kolejki*/
      ikk++; if (ikk >= RK) ikk=0;
      //...
      dd = kolej[ipk]; /*odczyt „dd" z kolejki*/
      ipk++; if (ipk >= RK) ipk=0;
      //...
      if (ipk != ikk) /*sprawdzanie „czy kolejka pusta?"*/
        dd = kolej[ipk]; /*pobranie „dd" z frontu kolejki*/
      //...
    }
      break;
    case 6: /*Realizacją kolejki w postaci klasy*/
    {/* Następujący tekst zawiera przykłady wywołania podprogramów
klasy klKolej: */
      klKolej *pkolej=new klKolej(100);
      int elem=3;
      int* pElem;
      bool czyPoprawZap=pkolej->KolejZapis((void*)&elem);
      if (czyPoprawZap)
      {
        bool czyPoprawCzyt=pkolej->KolejCzyt((void**)&pElem);
        czyPoprawCzyt=czyPoprawCzyt;
      }
    }
      break;
    case 7: /*Bazy danych*/
    {//Patrz rozdział "Definicje"
    }
      break;
    case 8: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox5Click(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox5->ItemIndex)
  {
    case 0: /*Zbiory danych*/
    {//Patrz rozdział "Definicje"
    }
      break;
    case 1: /*Tablicowa reprezentacja zbioru*/
    {//Patrz rozdział "Definicje"
      sStudent2 *zb3[25];//tablica z 25 wskaźnikami
      zb3[0]=new sStudent2("Azorski", "Jan", "Piotr");
      zb3[1]=new sStudent2("Brzeski", "Kliff", "Jacek");
      //...
    }
      break;
    case 2: /*Listowa reprezentacja zbioru*/
    {//Patrz rozdział "Definicje"
      sStudent3 *pPocz;//wskaźnik na początek listy
      sStudent3 *p;//tymczasowa zmienna - wskaźnik
      p=new sStudent3("Azorski", "Jan", "Piotr");//alokacja nowego elementu
      p->nast=0;//koniec listy
      pPocz=p;//lista zawiera element 1
      p=new sStudent3("Brzeski", "Kliff", "Jacek");//alokacja nowego elementu
      p->nast=pPocz;//łączenie elementów
      pPocz=p;//lista zawiera elementy 2, 1
      p=new sStudent3("Kopcowa", "Joanna", "Maria");//alokacja nowego elementu
      p->nast=pPocz;//łączenie elementów
      pPocz=p;//lista zawiera elementy 3,2,1
    }
      break;
    case 3: /*Realizacja algorytmu do generowania podzbiorów k - elementowych*/
    {//Patrz rozdział "Definicje"
      #define RN 4
      int *P = new int[RN]; /*tablica - podzbiór z indeksami*/
      for (int k = 1; k <= RN; k++)
      {
        for (int j = 0; j < k; j++)
          P[j]=j; /*zapisywanie do P liczb od 0 do (k-1)*/
        while (GenerPodzbior(P, k, RN) == true)
          for (int j = 0; j < k; j++)
            P[j]=P[j]; /*kontrola*/
      } /* cykl k*/
      delete [] P;
    }
      break;
    case 4: /*Reprezentacja grafu przez tablicę par wierzchołków*/
    {//Patrz rozdział "Definicje"
      sW *pW[5];/*wskaźniki na elementy zbioru wierzchołków*/
      pW[0]=new sW('A',10);//dana wierzchołka A
      pW[1]=new sW('B',20);//dana wierzchołka B
      pW[2]=new sW('C',30);//dana wierzchołka C
      pW[3]=new sW('D',40);//dana wierzchołka D
      pW[4]=new sW('E',50);//dana wierzchołka E
      int tablKraw[7][2]={{0,1},{1,1},{1,3},{2,1},{3,2},
        {3,4},{4,0}};//tablica par indeksów wierzchołków
      int i1=tablKraw[0][0];
      pW[i1]=pW[i1];
      int i2=tablKraw[0][1];
      pW[i2]=pW[i2];
    }
      break;
    case 5: /*Reprezentacja grafu w postaci macierzy sąsiedztwa wierzchołków*/
    {//Patrz rozdział "Definicje"
      sW *pW[5];/*wskaźniki na elementy zbioru wierzchołków*/
      for (int ii=0;ii<5;ii++)
        pW[ii]=new sW(' ',0);//alokacja elementów
      fLadowanieWierzchGraf(pW, 5);//ładowanie danych
      int macSasied[5][5]={{0,1,0,0,0},{0,1,0,1,0},
        {0,1,0,0,0},{0,0,1,0,1},{1,0,0,0,0}};//macierz sąsiedztwa wierzchołków
      int i1=macSasied[0][0];
      pW[i1]=pW[i1];
      int i2=macSasied[0][1];
      pW[i2]=pW[i2];
      int i3=macSasied[0][2];
      pW[i3]=pW[i3];
      int i4=macSasied[0][3];
      pW[i4]=pW[i4];
      int i5=macSasied[0][4];
      pW[i5]=pW[i5];
    }
      break;
    case 6: /*Reprezentacja grafu w postaci macierzy incydencji*/
    {//Patrz rozdział "Definicje"
      sW1 *pW1[5];//wskaźniki na elementy zbioru wierzchołków
      for (int ii=0;ii<5;ii++)
        pW1[ii]=new sW1(' ',0);//alokacja elementów
      fLadowanie1(pW1,5);//ładowanie danych
      int zbKraw1[6][2]={{0,1},{0,4},{1,2},{1,3},{2,3},{3,4}};// zbiór krawędzi
      int macIncyd1[5][6]={{1,1,0,0,0,0},{1,0,1,1,0,0},{0,0,1,0,1,0},{0,0,0,1,1,1},
        {0,1,0,0,0,1}};//macierz incydencji
      int i,j,k;
      j = macIncyd1[0][0];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
      j = macIncyd1[0][1];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
      j = macIncyd1[0][2];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
      j = macIncyd1[0][3];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
      j = macIncyd1[0][4];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
      j = macIncyd1[0][5];//indeks krawędzi
      i=zbKraw1[j][0];//indeks wierzchołka
      pW1[i]=pW1[i];
      k=zbKraw1[0][1];//indeks wierzchołka
      pW1[k]=pW1[k];
    }
      break;
    case 7: /*Reprezentacja grafu listami incydencji wierzchołków*/
    {//Patrz rozdział "Definicje"
      sW *pW[5];//wskaźniki na elementy zbioru wierzchołków
      for (int ii=0;ii<5;ii++)
        pW[ii]=new sW(' ',0);//alokacja elementów
      fLadowanieWierzchGraf(pW,5);//ładowanie danych
      sListaIncyd *pPoczList[5];//wskaźniki na listy
      for (int kk=0;kk<5;kk++)
        pPoczList[kk]=NULL;// NULL oznacza brak listy
      sListaIncyd *p=NULL;//p - wskaźnik tymczasowy
      //dalej tworzenie kolejno każdej listy od końca:
      //tworzenie elementu 1 listy A; wskaźnik na listę A:
      pPoczList[0]=new sListaIncyd(1,NULL);
      //tworzenie elementu 2 listy B:
      p=new sListaIncyd(3,NULL);
      //tworzenie elementu 1 listy B; wskaźnik na listę B:
      pPoczList[1]=new sListaIncyd(1,p);
      //tworzenie elementu 1 listy C; wskaźnik na listę C:
      pPoczList[2]=new sListaIncyd(1,NULL);
      //tworzenie elementu 2 listy D:
      p=new sListaIncyd(4,NULL);
      //tworzenie elementu 1 listy D; wskaźnik na listę D:
      pPoczList[3]=new sListaIncyd(2,p);
      //tworzenie elementu 1 listy E; wskaźnik na listę E:
      pPoczList[4]=new sListaIncyd(0,NULL);
      p=p;
    }
      break;
    case 8:/*Drzewo a graf*/
    {
      sW* pWd[5];//wskaźniki na elementy zbioru wierzchołków
      pWd[0] = new sW('A', 10);//dane wierzchołka A
      pWd[1] = new sW('B', 20);//dane wierzchołka B
      pWd[2] = new sW('C', 30);//dane wierzchołka C
      pWd[3] = new sW('D', 40);//dane wierzchołka D
      pWd[4] = new sW('E', 50);//dane wierzchołka E
      int tKd[5][2] =
        {{2, 1}, {2, 3}, {1, 0}, {3, 4}, {2, 5}};//tablica par indeksów wierzchołków
      int i1 = tKd[0][0];
      sW* p1 = pWd[i1];
      p1=p1;
      int i2 = tKd[0][1];
      sW* p2 = pWd[i2];
      p2 = p2;
    }
      break;
    case 9: /*Struktury drzewiaste*/
    {//Patrz rozdział "Definicje"
      sW2 *pKorzen=0;//pKorzen - wskaźnik na korzeń
      sW2 *p1=0,*p2=0,*p3=0;//wskaźniki tymczasowe
      //tworzenie wierzchołków (węzłów) od liści:
      //tworzenie wierzchołka A:
      p1=new sW2('A');//ładowanie danych wierzchołka A
      //tworzenie wierzchołka B:
      p2=new sW2('B');//ładowanie danych wierzchołka B
      p2->nast=p1;//wskaźnik na wierzchołek A
      //tworzenie wierzchołka C:
      p3=new sW2('C');//ładowanie danych wierzchołka C
      p3->nast=p2;//wskaźnik na wierzchołek B
      pKorzen=p3;//wskaźnik na korzeń
      //tworzenie wierzchołka F:
      p1=new sW2('F');//ładowanie danych wierzchołka F
      p2->pSasiad=p1;// wskaźnik na wierzchołek F
      //tworzenie wierzchołka E:
      p2=new sW2('E');//ładowanie danych wierzchołka E
      //tworzenie wierzchołka D:
      p3=new sW2('D');//ładowanie danych wierzchołka D
      p3->nast=p2;//wskaźnik na wierzchołek E
      p1->pSasiad=p3;//wskaźnik na wierzchołek D
      pKorzen=pKorzen;
    }
      break;
    case 10: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox6aClick(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox6a->ItemIndex)
  {
    case 0: /*Realizacja wyszukiwania elementu w liście jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;/*wskaźnik na początek listy*/
      typ_dana2 szukD;
      sElem2 *p;
      sElem2 *p1=0,*p2=0,*p3=0;//wskaźniki tymczasowe
      //tworzenie elementów:
      //tworzenie elementu A:
      p1=new sElem2('A');//ładowanie danych elementu A
      //tworzenie elementu B:
      p2=new sElem2('B');//ładowanie danych elementu B
      p2->nast=p1;//wskaźnik na element A
      //tworzenie elementu C:
      p3=new sElem2('C');//ładowanie danych elementu C
      p3->nast=p2;//wskaźnik na element B
      pPocz=p3;//wskaźnik na korzeń
      szukD='A';
      bool bb=SzukaElemListJednokier(pPocz, szukD,&p);
      bb=bb;
    }
      break;
    case 1: /*Realizacja dodawania elementu do listy niecyklicznej jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'D');
      pPocz=pPocz;
    }
      break;
    case 2: /*Realizacja dodawania elementu na końcu listy niecyklicznej jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'A');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'B');
      pPocz=pPocz;
    }
      break;
    case 3: /*Realizacja usuwania elementu na początku listy niecyklicznej jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'A');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'B');
      UsuwElemList(&pPocz);
      pPocz=pPocz;
    }
      break;
    case 4: /*Realizacja usuwania elementu na końcu listy niecyklicznej jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'A');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'B');
      UsuwElemListKoniec(pPocz);
      pPocz=pPocz;
    }
      break;
    case 5: /*Realizacja zamiany elementu listy*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'A');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'B');
      ZamianaElemList(pPocz, (typ_dana2)'A', (typ_dana2)'C');
      pPocz=pPocz;
    }
      break;
    case 6: /*Realizacja łączenia list cyklicznych dwukierunkowych*/
    {//Patrz rozdział "Definicje"
      //lista pierwsza:
      sElem3 *pPocz = new sElem3('A');//wskaźnik na początek listy pierwszej
      pPocz->pN = pPocz; pPocz->pP = pPocz; //jeden element
      sElem3 *p = new sElem3('B');//alokacja
      pPocz->pN = p;
      p->pN = pPocz;
      p->pP = pPocz;
      pPocz->pP = p;
      //lista druga:
      sElem3 *pLista = new sElem3('C');//wskaźnik na początek listy drugiej
      pLista->pN = pLista;
      pLista->pP = pLista;
      p = new sElem3('D');//alokacja
      pLista->pN = p;
      p->pN = pLista;
      p->pP = pLista;
      pLista->pP = p;
      LanczListCyklDwukier(&pPocz, pLista);
      pPocz=pPocz;
    }
      break;
    case 7: /*Realizacja rozdzielenia jednokierunkowej listy według indeksu*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      sElem2 *pL2=0;//wskaźnik na początek listy drugiej
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'A');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'B');
      DodawElemListKoniecNiecyklJednokier(&pPocz, (typ_dana2)'C');
      RozlaczListIndeks(pPocz, 1, &pL2);
      pPocz=pPocz;
    }
      break;
    case 8: /*Realizacja usuwania listy cyklicznej jednokierunkowej*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'C');
      sElem2 *pOstat=pPocz;//wskaźnik na element ostatni
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'B');
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'A');
      pOstat->nast=pPocz;//cykl
      UsuwListCyklJednokier(&pPocz);
      pPocz=pPocz;
    }
      break;
    case 9: /*Realizacja skrócenia listy jednokierunkowej
             po elemencie z zadaną wartością*/
    {//Patrz rozdział "Definicje"
      sElem2 *pPocz=0;//wskaźnik na początek listy
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'C');
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'B');
      DodawElemListNiecyklJednokier(&pPocz, (typ_dana2)'A');
      SkrocListJednokierWart(pPocz, (typ_dana2)'B');
      pPocz=pPocz;
    }
      break;
    case 10: /*Nie rekurencyjna realizacja algorytmu przeszukiwania w głąb*/
    {//Patrz rozdział "Definicje"
      typW* twg[100];/* tablica wskaźników na wierzchołki */
      int NN=LadowanieGrafu(twg);
      PrzegladDFSgraf(twg, NN);
    }
      break;
    case 11: /*Rekurencyjna realizacja algorytmu przeszukiwania w głąb*/
    {//Patrz rozdział "Definicje"
      typW* twg[100];/* tablica wskaźników na wierzchołki */
      int NN=LadowanieGrafu(twg);
      PrzegladRekurDFSgraf(twg, NN);
    }
      break;
    case 12: /*Realizacja algorytmu przeszukiwania w wszerz*/
    {//Patrz rozdział "Definicje"
      typW* twg[100];/* tablica wskaźników na wierzchołki */
      int NN=LadowanieGrafu(twg);
      PrzegladBFSgraf(twg, NN);
    }
      break;
    case 13: /*Realizacja algorytmu obliczenia spójnych składowych*/
    {//Patrz rozdział "Definicje"
      int LadowanieGrafu2(typW2* twg[]);
      typW2* twg[100];/* tablica wskaźników na wierzchołki */
      int NN=LadowanieGrafu2(twg);
      SpojneSkladDFSgraf(twg, NN);
    }
      break;
    case 14: /*Realizacja algorytmu obliczenia drzewa rozpinającego*/
    {//Patrz rozdział "Definicje"
      #define RM 100
      typW* twg[RM];/* tablica wskaźników na wierzchołki */
      int NN=LadowanieGrafu(twg);
      DrzewoRozpinBFSgraf(twg, NN);
    }
      break;
    case 15: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox6bClick(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox6b->ItemIndex)
  {
    case 0: /*Realizacja wyszukiwania elementu w drzewie spadowym*/
    {//Patrz rozdział "Definicje"
      sElSpad* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaSpad(M);
      int ind = WyszukDrzewoSpad(M, 0, 50);
      ind = ind;
    }
      break;
    case 1: /*Realizacja dodawania elementu w drzewie spadowym*/
    {//Patrz rozdział "Definicje"
      sElSpad* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaSpad(M);
      M[8] = new sElSpad(25);
      DodawDrzewoSpad(M, 0, 8);
    }
      break;
    case 2: /*Realizacja usuwania elementu w drzewie spadowym*/
    {//Patrz rozdział "Definicje"
      sElSpad* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaSpad(M);
      UsuwDrzewoSpad(M, 0, (typ_spad)40);
    }
      break;
    case 3: /*Realizacja rozdzielenia drzewa spadowego*/
    {//Patrz rozdział "Definicje"
      sElSpad* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaSpad(M);
      int korz = 0;
      int ind = RozdzDrzewoSpad(M, &korz, (typ_spad)40);
      ind = ind;
    }
      break;
    case 4: /*Realizacja dodawania elementu w drzewie AVL*/
    {//Patrz rozdział "Definicje"
      #define RMM 1000
      sElAVL* M[RMM]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaAVL(M);
      int korz = 0;
      DodawDrzewoAVL(M, &korz, (typ_AVL)75, 8);
    }
      break;
    case 5: /*Realizacja wyszukiwania elementu w drzewie RST*/
    {//Patrz rozdział "Definicje"
      sElRST* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaRST(M);
      int ind = WyszukDrzewoRST(M, 0, (typ_RST)0x6);
      ind = ind;
    }
      break;
    case 6: /*Realizacja dodawania elementu w drzewie RST*/
    {//Patrz rozdział "Definicje"
      #define RM 100
      sElRST* M[RM]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaRST(M);
      int korz = 0;
      DodawDrzewoRST(M, &korz, (typ_RST)0xF, 8);
    }
      break;
    case 7: /*Realizacja usuwania elementu w drzewie RST*/
    {//Patrz rozdział "Definicje"
      sElRST* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaRST(M);
      int korz = 0;
      UsuwDrzewoRST(M, &korz, (typ_RST)0x6);
    }
      break;
    case 8: /*Realizacja rozdzielenia drzewa RST*/
    {//Patrz rozdział "Definicje"
      sElRST* M[100]; /*tablica M z elementami drzewa*/
      LadowanieDrzewaRST(M);
      int korz1 = 0, korz2 = -1;
      RozdzDrzewoRST(M, &korz1, &korz2, (typ_RST)0xC);
      korz1 = korz1;  korz2 =  korz2;
      int ind = WyszukDrzewoRST(M, korz2, (typ_RST)0xE);
      ind = ind;
    }
      break;
    case 9: /*Realizacja wyszukiwania elementu w drzewie TRIE*/
    {//Patrz rozdział "Definicje"
      #define RMT 100
      sElTRIE* M[RMT]; /*tablica M z elementami drzewa*/
      typ_TRIE D[RMT];/*tablica z elementami danych*/
      LadowanieDrzewaTRIE(M, D);
      int ind = WyszukDrzewoTRIE(M, D, 0, (typ_TRIE)0x6);
      ind = ind;
    }
      break;
    case 10: /*Realizacja wyszukiwania elementu w drzewie PATRICIA*/
    {//Patrz rozdział "Definicje"
      sElPATRICIA* pkorz = LadowanieDrzewaPATRICIA();
      sElPATRICIA* ps = WyszukDrzewoPATRICIA(pkorz, (typ_PATRICIA)0x6);
      ps = ps;
      NiszczenieDrzewaPATRICIA(pkorz);
    }
      break;
    case 11: /*Realizacja dodawania elementu w drzewie PATRICIA*/
    {//Patrz rozdział "Definicje"
      sElPATRICIA* pkorz = LadowanieDrzewaPATRICIA();
      DodawDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0xF);/*w "liście"*/
      DodawDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0x8);/*w "węźle"*/
      NiszczenieDrzewaPATRICIA(pkorz);
    }
      break;
    case 12: /*Realizacja usuwania elementu w drzewie PATRICIA*/
    {//Patrz rozdział "Definicje"
      sElPATRICIA* pkorz = LadowanieDrzewaPATRICIA();
      DodawDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0xF);/*w "liście"*/
      DodawDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0x8);/*w "węźle"*/
      UsuwDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0xF);
      UsuwDrzewoPATRICIA(&pkorz, (typ_PATRICIA)0x8);
      NiszczenieDrzewaPATRICIA(pkorz);
    }
      break;
    case 13: /*Realizacja algorytmu Forda - Bellmana do znajdowania
    w grafie drogi z najmniejszą długością*/
    {//Patrz rozdział "Definicje"
      #define RMW 100 /* liczba wierzchołków grafu */
      double MWag[RMW * RMW];/* macierz wag */
      double DGraf[RMW];/* tablica odległości D[k] */
      int pocz = 0;
      int nn = LadowanieGrafUjemnWagi(MWag);
      ZnajdNajmnDrogiFordBellman(MWag, nn, pocz, DGraf);
      for (int i = 0; i < nn; i++)
        DGraf[i] = DGraf[i];
    }
      break;
    case 14: /*Realizacja algorytmu Dijkstry do znajdowania w
grafie z wagami nieujemnymi drogi z najmniejszą długością*/
    {//Patrz rozdział "Definicje"
      #define RMW 100 /* liczba wierzchołków grafu */
      double MWag[RMW * RMW];/* macierz wag */
      double DGraf[RMW];/* tablica odległości D[k] */
      int pocz = 0;
      int nn = LadowanieGrafNieujemnWagi(MWag);
      ZnajdNajmnDrogiDijkstra(MWag, nn, pocz, DGraf);
      for (int i = 0; i < nn; i++)
        DGraf[i] = DGraf[i];
    }
      break;
    case 15: /*Realizacja algorytmu znajdowania drogi z najmniejszej długością
    w sieci acyklicznej*/
    {//Patrz rozdział "Definicje"
      #define RMW 100 /* liczba wierzchołków grafu */
      double MWag[RMW * RMW];/* macierz wag */
      double DGraf[RMW];/* tablica odległości D[k] */
      int pocz = 0;
      int nn = LadowanieGrafAcykl(MWag);
      ZnajdNajmnDrogiAcykl(MWag, nn, pocz, DGraf);
      for (int i = 0; i < nn; i++)
        DGraf[i] = DGraf[i];
    }
      break;
    case 16: /*Realizacja algorytmu do znajdowania wszystkich
najmniejszych odległości*/
    {//Patrz rozdział "Definicje"
      #define RMW 100 /* liczba wierzchołków grafu */
      double MWag[RMW * RMW];/* macierz wag */
      double D[RMW * RMW];/* macierz odległości D[i,j] */
      int nn = LadowanieWagOdlegl(MWag);
      ZnajdNajmnOdlegl(MWag, nn, D);
      for (int i = 0; i < nn; i++)
        for (int j = 0; j < nn; j++)
          D[(i*nn)+j] = D[(i*nn)+j];
    }
      break;
    case 17: /*Realizacja algorytmu do obliczenia maksymalnego
przepływu przez sieć*/
    {//Patrz rozdział "Definicje"
      #define RMW 100 /* liczba wierzchołków grafu */
      double MWag[RMW * RMW];/* macierz wag */
      int nn = LadowanieMaksPrzepl(MWag);
      bool *KZ = new bool[nn]; /*flagi przynależności do "krytycznego"
zbioru wierzchołków */
      double Smax = ObliczMaksPrzepl(MWag, nn, KZ);
      Smax = Smax;
      for (int i = 0; i < nn; i++)
        KZ[i] = KZ[i];
      delete [] KZ;
    }
      break;
    case 18: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox7Click(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox7->ItemIndex)
  {
    case 0: /*Realizacja algorytmu sortowania przez proste wstawianie*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieProsteWstawianie(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 1: /*Realizacja algorytmu sortowania przez proste wybieranie*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieProsteWybieranie(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 2: /*Realizacja algorytmu sortowania przez prostą zamianę*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieProstaZamiana(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 3: /*Realizacja algorytmu sortowania bąbelkowego*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieBabelkowe(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 4: /*Realizacja ulepszonego algorytmu sortowania bąbelkowego*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieBabelkoweUlepsz(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 5: /*Realizacja algorytmu sortowania mieszanego*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieMieszane(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 6: /*Realizacja algorytmu sortowania metodą Shella przez wstawianie*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieMetodaShella(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 7: /*Realizacja algorytmu sortowania kopcowego*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowanieKopcowe(nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 8: /*Realizacja algorytmu sortowania przez podział (sortowanie „szybkie")*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      SortowaniePodzial(0, nn - 1, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 9: /*Realizacja algorytmu sortowania rzędowego*/
    {//Patrz rozdział "Definicje"
      int nn = 10;
      int M[10]={25,12,46,7,25,89,66,15,478,5};
      int mr = 3; // maksymalna liczba cyfr w liczbach
      SortowanieRzedowe10_1(mr, nn, M);
      for (int j = 0; j < nn; j++)
        M[j]=M[j]; /*kontrola*/
    }
      break;
    case 10: /*Realizacja algorytmu łączenia tablic posortowanych*/
    {//Patrz rozdział "Definicje"
      int m = 3;//liczba tablic Mj
      int M1[4]={3,46,72,125};
      int M2[6]={9,25,35,43,64,70};
      int M3[10]={5,7,12,15,25,25,46,66,89,478};
      int pnj[3] = {4, 6, 10};//tablica z rozmiarami tablic Mj
      int* pM[3] = {M1, M2, M3};//tablica wskaźników na tablicy Mj
      int pW[20]; //tablica wynikowa
      int jW = LaczenieTablicPosortowanych(m, pnj, pM, pW);
      jW = jW; //rozmiar tablicy wynikową
      for (int j = 0; j < jW; j++)
        pW[j]=pW[j]; /*kontrola*/
    }
      break;
    case 11: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox8Click(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox8->ItemIndex)
  {
    case 0: /*Algorytm połówkowy*/
    {//Patrz rozdział "Definicje"
      int M[10]={5,7,12,15,25,25,46,66,89,478};
      int rM = 10; //rozmiar tablicy M
      int W = 15; //element wyszukiwany
      bool bb = CzyJestKopia_polowkowy(rM, M, W);
      bb = bb;
      int W2 = 14; //element wyszukiwany
      bool bb2 = CzyJestKopia_polowkowy(rM, M, W2);
      bb2 = bb2;
    }
      break;
    case 1: /*Wyszukiwanie „naiwne"*/
    {//Patrz rozdział "Definicje"
      char M[] = "Tekst testowy"; //tekstowa tablica M
      int rM = strlen(M);//rozmiar tekstowej tablicy M
      char W[]="test"; //wyraz (wzorzec tekstowy) W
      int rW = strlen(W);//rozmiar wyrazu (wzorca tekstowego) W
      bool bb = CzyJestWyraz(rM, M, rW, W);
      bb = bb;
      char W2[]="tet"; //wyraz (wzorzec tekstowy) W
      int rW2 = strlen(W2);//rozmiar wyrazu (wzorca tekstowego) W
      bool bb2 = CzyJestWyraz(rM, M, rW2, W2);
      bb2 = bb2;
    }
      break;
    case 2: /*Automat do rozpoznawania podsłów*/
    {//Patrz rozdział "Definicje"
      char W[]="bao";
      int rW = strlen(W);
      bool bb = DopasowWzorca(rW, W);
      bb = bb;
      char W2[]="bb";
      int rW2 = strlen(W2);
      bool bb2 = DopasowWzorca(rW2, W2);
      bb2 = bb2;
    }
      break;
    case 3: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ListBox9Click(TObject *Sender)
{
Sender=Sender; /* miejsce "breakpoint" */
  switch (ListBox9->ItemIndex)
  {
    case 0: /*Realizacja algorytmu znajdowania najmniejszej liczby*/
    {//Patrz rozdział "Definicje"
      int Tablica[10]={25,12,46,7,55,89,66,15,478,5};
      int rozmiar = 10;
      int wynik = 0;
      bool bb = NajmniejszaLiczba (rozmiar, Tablica, wynik);
      bb = bb;
      wynik = wynik;
    }
      break;
    case 1: /*Realizacja algorytmu Euklidesa do obliczenia NWP*/
    {//Patrz rozdział "Definicje"
      int A = 201, B = 132;
      int NWP = NWP_euklides(A, B);
      NWP = NWP;
    }
      break;
    case 2: /*Realizacja algorytmu obliczenia NWP przez odejmowanie*/
    {//Patrz rozdział "Definicje"
      int A = 201, B = 132;
      int NWP = NWP_odejmowanie(A, B);
      NWP = NWP;
    }
      break;
    case 3: /*Realizacja binarnego algorytmu obliczenia NWP*/
    {//Patrz rozdział "Definicje"
      int A = 201, B = 132;
      int NWP = NWP_binarny(A, B);
      NWP = NWP;
    }
      break;
    case 4: /*Realizacja algorytmu znalezienia drogi skoczka szachowego*/
    {//Patrz rozdział "Definicje"
      const int deltaX[] = {1, 2, 2, 1, -1, -2, -2, -1};
      const int deltaY[] = {2, 1, -1, -2, -2, -1, 1, 2};
      #define RSZACH 64
      s_skok skoki[RSZACH];/* tablica-stos z pozycjami skoczka*/
      int js = -1; /*indeks stosu-tablicy pozycji */
      s_pole pola[RSZACH];/* tablica z numerami skoków*/
      /*zapisywanie do stosu pierwszej pozycji skoczka:*/
      js++; skoki[js].pozX = 0; skoki[js].pozY = 0; //"a1"
      pola[0].numerSkoku=0;
      while (js < (RSZACH - 1) && js >= 0)
      {
        /* odczyt z frontu stosu: */
        s_skok* pskok=&skoki[js];
        int pozX = pskok->pozX, pozY = pskok->pozY;
        s_pole* ppo=&pola[(pozX<<3)+pozY];
        /* obliczenie następnej pozycji skoczka: */
        bool flSkok=false;
        int jproba;
        for (jproba=0;jproba<8;jproba++)
        {
          int ix = pozX + deltaX[jproba], iy = pozY + deltaY[jproba];
          if (ix>=0 && ix<=7 && iy>=0 && iy<=7)
          {
            /*sprawdzanie, czy pozycja jest wykorzystana:*/
            s_pole* pproba=&pola[(ix<<3)+iy];
            if (pproba->numerSkoku==-1)
            {
              /*sprawdzanie, czy skok jest zakazany:*/
              bool flZakaz=false;
              for (int r=0;r<ppo->nzakaz;r++)
              {
                int zakazX=ppo->zakazX[r];
                int zakazY=ppo->zakazY[r];
                if (zakazX>=0 && zakazY>=0 && zakazX==ix && zakazY==iy)
                {
                  flZakaz=true; break;//r
                }
              }//r
              if (flZakaz==false)
              {
                /*zapisywanie do stosu pozycji skoczka:*/
                js++;
                s_skok* pnast=&skoki[js];
                pnast->pozX=ix; pnast->pozY=iy;
                pproba->numerSkoku=js;
                /* zdejmowanie zakazów: */
                for (int jz=0;jz<pproba->nzakaz;jz++)
                {
                  pproba->zakazX[jz]=-1; pproba->zakazY[jz]=-1;
                }
                pproba->nzakaz=0;
                flSkok=true;
                break; //jproba
              }
            }//if (pp->numerSkoku==-1)
          }//if (ix>=0 && ix<=7 && iy>=0 && iy<=7)
        }// jproba
        if (flSkok==false)
        { //próba nieudana - nie ma drogi
          ppo->numerSkoku=-1;
          js--;/*zdejmowanie ze stosu pozycji skoczka*/
          if (js>=0)
          { /*zaznaczenie zakazu skoku:*/
            s_skok* ppopsz=&skoki[js];
            int popszX = ppopsz->pozX, popszY = ppopsz->pozY;
            s_pole* ppol=&pola[(popszX<<3)+popszY];
            ppol->zakazX[ppol->nzakaz]=pozX;
            ppol->zakazY[ppol->nzakaz]=pozY;
            ppol->nzakaz++;
          }
        }
      }
      for (int j=0;j<RSZACH;j++)
      {
        s_skok* pskok=&skoki[j];
        int pozX = pskok->pozX, pozY = pskok->pozY;
        char chX = (char)('a' + pozX), chY = (char)('1' + pozY);
        AnsiString as=AnsiString(chX) + AnsiString(chY);
        as=as;
      }
    }
      break;
    case 5: /**/
    {//Patrz rozdział "Definicje"
    }
      break;
  }
}
//---------------------------------------------------------------------------