III. Adatszerkezetek és algoritmusok

III. Adatszerkezetek és algoritmusok 40

Bevezetés Adatszerkezet egyszerű vagy összetett alapadatok rendszerének matematikai, logikai modellje elég jó ahhoz, hogy tükrözze a valós kapcsolatokat elég egyszerű a kezeléshez Adatszerkezet típusok Tömbök lineáris egy vagy többdimenziós Kapcsolt listák a kapcsolati információ is adat Gráf adathalmaz adatpárok kapcsolattal Fa hurok nélküli gráf Verem LIFO (Last In First Out) Sor FIFO (First In First Out). Műveletek feldolgozási tevékenységek (algoritmusok) Bejárás - az elemek elérése Keresés - adott értéknek megfelelő elemek kiválasztása Beszúrás - új adat beillesztése Törlés - adatelem eltávolítása Rendezés - elemeket logikai sorrendbe Összeválogatás - különböző rendezett adathalmazokból új elemhalmaz kialakítása Bonyolultság futási idő vagy helyigény az adatok számának függvényében 41 B(n)

III.1 Lineáris tömbök N db. azonos típusú adatelem az elemekre egymást követő számokból álló indexhalmazzal hivatkozunk az elemeket egymást követő memóriahelyek tárolják az elemekhez bejárás nélkül férünk hozzá LB LB+1 UB-1 UB Lower Bound Upper Bound Hosszúság (Length) L = UB-LB+1 Indexelt alak A 1, A 2 A(1), A(2) A[1], A[2] Példa (C#) int [] DATA; DATA = new int [5]; DATA[0]=154 ; DATA[3]=-33 ; DATA[4]=1 ; 154-33 1 154. -33 1 III.1.1 Hozzáférés tömbelemhez - indexelés (C) int DATA[5]; LOC(DATA) LOC(DATA[4]) LOC(DATA[k])=LOC(DATA)+w * k ; w az alapadat tárolási mérete 42

III.1.2 Bejárás Ha L n elemű lineáris tömb, akkor minden eleme kiírható k számláló k=0 k<n k=k+1 PRINT L[k] Példa (C#) const int n = 6; int[] l; l = new int[n]; Random vletlen = new Random(); l[k] = vletlen.next(100); Console.WriteLine(l[k]); III.1.2.1 Pl 90 94 65 38 51 83 Példa (C) const int n = 10; int l[n]; l[k] = rand(); printf("%i\n",l[k]); 43

III.1.3 Rendezés Ha L n elemű lineáris tömb, akkor rendezett, ha L[0]< L[1]< L[2]<L[3]... L[n-1]<L[n] III.1.3.1 Buborék rendezés k, p számláló, s segéd k=0 k<n k=k+1 p<n-1-k L[p]>L[p+1] s=l[p] L(p)=L[p+1] L[p+1]=s p=p+1 p=0 n ( n 1 ) Bonyolultság : 2 O( n ) 2 44

Példa (C#) const int n =6; int[] l; l = new int[n]; Random vletlen=new Random(); l[k] = vletlen.next(100); for (int p=0; p<n-1-k;p++){ if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; Console.WriteLine(l[k]); Példa (C) const int n = 6; int l[n]; l[k] = rand(); for (int p=0; p<n-1-k;p++) { if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; printf("%i\n",l[k]); 45

III.1.3.2 Például 90 94 65 38 51 83 90 65 94 38 51 83 90 65 38 94 51 83 90 65 38 51 94 83 90 65 38 51 83 94 65 90 38 51 83 94 65 38 90 51 83 94 65 38 51 90 83 94 65 38 51 83 90 94 38 65 51 83 90 94 38 51 65 83 90 94 38 51 65 83 90 94 46

III.1.4 Keresés III.1.4.1 Szekvenciális keresés KER-t keressük, az n elemű L elemei között, LOC a keresett pozíció L[n]=KER K=0 L[K] KER LOC=k Példa (C#) Bonyolultság : n 1 O( n ) k=k+1 const int n = 6; int[] l; l = new int[n+1]; Random vletlen = new Random(); l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); int ker=5; l[n]=ker; int j = 0; while (l[j]!=ker) { j++; Console.WriteLine("Az 5 a {0.", j); III.1.4.2 Pl. 0 9 0 6 0 4 Az 5 a 6. - nincs ilyen Példa (C) const int n = 10; int l[n+1]; l[k] = rand(); int ker=l[7]; l[n]=ker; int j = 0; while (l[j]!=ker) { j++; printf("az %i az %i.\n",l[7],j); 47

III.1.4.3 Bináris keresés KER-t keressük, ha L sorbarendezett, Beg, End, Mid segédváltozók, LOC a keresett pozíció, (INT) az egészrész Beg=LB(L) End=UB(L) Mid=INT((Beg+End)/2) LOC=Mid End=Mid-1 Beg<End és L(Mid) KER L[Mid]=KER Mid=(INT)((Beg+End)/2) KER<L[Mid] LOC=Null Beg=Mid+1 Bonyolultság : A legalább szükséges összehasonlítások száma f(n), Minden összehasonlításkor feleződik a minta f ( n ) 2 n f ( n) log2 ( n) 1 48

Példa (C#) const int n = 10; int[] l; l = new int[n + 1]; Random vletlen = new Random(); l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); Console.WriteLine("Sorbarakva"); Array.Sort(l); Console.WriteLine("l[{0]={1", k, l[k]); int beg = 0; int end = n - 1; int mid = (int)((beg + end) / 2); int ker = 5; while ((beg<end) && (l[mid]!=ker)) { if (ker < l[mid]) end=mid-1; else beg=mid+1; mid = (int)((beg + end) / 2); if (l[mid] == ker) Console.WriteLine("Az 5 az {0.",mid); else Console.WriteLine("Nincs 5"); Példa (C) const int n = 10; int l[n+1]; l[k] = rand(); printf("%i") for (int p=0; p<n-1-k;p++) { if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; int beg = 0; int end = n - 1; int mid = (int)((beg + end) / 2); int ker = l[7]; while ((beg<end) && (l[mid]!=ker)) { if (ker < l[mid]) end=mid-1; else beg=mid+1; mid = (int)((beg + end) / 2); if (l[mid] == ker) printf("az %i az %i.",l[mid],mid); else 49 printf("nincs");

III.1.4.4 Pl. 2 4 3 2 4 7 7 2 1 2 Sorbarakva 1 2 2 2 2 3 4 4 7 7 beg=0 mid=4 end=9 beg=5 mid=7 end=9 beg=8 mid=8 end=9 Az 7 az 8. 50

III.2. Többdimenziós tömbök N * M db. azonos típusú adatelem az elemekre egymást követő számokból álló indexhalmazokból alkotott számpárokkal hivatkozunk az elemeket egymást követő memóriahelyek tárolják az elemekhez bejárás nélkül férünk hozzá III.2.1 Hozzáférés tömbelemhez - indexelés Kétdimenziós eset LB SOR1 LB SOR1 +1 UB SOR1-1 UB SOR1 LB SOR2 LB SOR2 +1 UB SOR2-1 UB SOR 2 LB SORn-1 LB SORn-1 +1 UB SORn-1-1UB SORn-1 LB SORn LB SORn +1 UB SORn -1 UB SOR n Indexelt alak A 1,1, A 12 A(1,1), A(1,2) A[1,1], A[1,2] Memória pozíció (A m * n-es mátrix) LOC(A(j,k))=LOC(A)+w * (n * j+k) ; w az alapadat tárolási mérete 51

Példa (C#) float[,] matrix; matrix = new float [3,3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) matrix[i, j] = 1; else matrix[i, j] = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) Console.Write("{0,8:f2",matrix[i, j]); Console.WriteLine(); Példa (C) float matrix [3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) matrix[i][ j] = 1; else matrix[i][j] = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) printf("%8.2f",matrix[i][j]); printf("\n"); III.2.2 Pl. 1,00 0,00 0,00 0,00 1,00 0,00 0,00 0,00 1,00 52

III.3. Rekordok, rekordszerkezetek, állományok A rekord egymáshoz tartozó (a világ egy egyedére vonatkozó) adattételek (mezők, attribútumok) gyűjteménye. az adattételek lehetnek összetettek** és tovább nem bonthatók egyszerűek*. például változó méretű adatsorok, szabálytalan tömbök tárolására használható Az állomány rekordok összessége. Név LB Lakcím** SOR1 +1 Testmagasság Testsúly* Példa (C#) struct ember { public String nev; public String lakcim; public int testmagassag; public int testsuly; // ember x; x = new ember(); x.nev = "Lajos"; x.lakcim = "Budapest"; x.testmagassag = 160; x.testsuly = 50; Console.WriteLine(x.nev + " " + x.lakcim + " " + x.testmagassag + " " + x.testsuly); Console.ReadLine(); LB SOR1 #include <stdio.h> #include <conio.h> #include <string.h> int _tmain(int argc, _TCHAR* argv[]) { struct ember { char nev[64]; char lakcim[64]; int testmagassag; int testsuly; ; // ember x; strcpy(x.nev,"lajos"); strcpy(x.lakcim,"budapest"); x.testmagassag = 160; x.testsuly = 50; printf("%s ",x.nev); printf("%s ",x.lakcim); printf("%i ",x.testmagassag); printf("%i \n",x.testsuly); getch(); return 0; Példa (C) 53

III.3.1 Szintszám, minősítés Az adattételek lehetnek összetettek, altételekkel. Például: Gyermek Név Apa Anya Példa (C#) struct ember { public string nev; public int apa; public int anya; static void Main(string[] args) { ember[] x; x = new ember[5]; x[0].nev = "Ádám"; x[1].nev = "Éva"; x[2].nev = "Káin"; x[2].apa = 0; // tömbindex a pointer helyett x[2].anya = 1; Console.ReadLine(); Név Példa (C) struct ember { char nev[64]; int apa; int anya; ; ember x[5]; strcpy(x[0].nev,"ádám"); strcpy(x[1].nev, "Éva"); strcpy(x[2].nev, "Káin"); x[2].apa = 0; // tömbindex a pointer helyett x[2].anya = 1; Név 54

III.4. Kapcsolt listák A kapcsolt lista vagy egyirányú lista adatelemek, vagy csomópontok lineáris gyűjteménye, ahol az elemek sorrendjét mutatók rögzítik. Start a mutatókat tároló elemet kapcsolómezőnek hívjuk. x III.4.1 Kapcsolt listák a memóriában Minden csomóponthoz egy tömbelemet (INFO(k) az indexelt csomópont), Minden követőhöz egy másik tömbelemet (LINK(k)) rendelünk. Start INFO (0,0) (100,100) (100,0) (0,100) (0,0) LINK 3 4 2 5 x III.4.2 Kapcsolt listák bejárása A PTR mutató az éppen feldolgozott csomópontra mutat. A kezdetet a START mutató jelöli. A vége NULL Hasonló a lineáris tömbhöz. 55

III.4.3 Példa Mutató aritmetika, csoport elemeinek bejárása Ha P változó mutató, akkor a P+1 kifejezés a következő memóriacímet jelenti Példa (C#) /unsafe (Property/Build/Allow unsafe code) const int n=10; P=C k int[] l; l = new int[n]; Random vletlen= new Random(); l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); Console.WriteLine(); unsafe { int i=4; fixed ( int * ipk=&l[i]) { fixed ( int * ipv=&l[8]) { int * ip = ipk; while (ip < ipv) { Console.WriteLine( "l[{0]={1", i++, *ip++); P=P+1 Bejárás P<C v const int n=10; Példa (C) int l[n]; l[k] = 10*(float)rand()/RAND_MAX; printf("l[%2i]=%3i\n", k, l[k]); printf("\n"); int i=4; int * ipk=&l[i]; int * ipv=&l[8]; int * ip = ipk; while (ip < ipv) { printf("l[%2i]=%2i ", i++, *ip++); 56

III.4.4 Példa Csoport elemeinek bejárása tömbelemmutatóval PTR=START PTR NULL Példa (C#) const int n=10; int[,] l; l = new int[n,3]; // [x,y,következő] Random vletlen= new Random(); int start=0; l[k,0] = vletlen.next(10); l[k,1] = vletlen.next(10); if (k==n-1) l[k, 2] = -1; else l[k, 2] = k+1; Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", k,l[k, 0],l[k, 1]); Console.WriteLine(); int akt=start; // bejárás while (true) { Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", akt,l[akt,0],l[akt, 1]); if (l[akt, 2] == -1) break; akt = (int)l[akt, 2]; PTR=LINK(PTR) {PTR INFO feldolgozás const int n=10; int l[n][3]; Példa (C) // [x,y,következő] int start=0; l[k][0] = 10*(float)rand()/RAND_MAX; l[k][1] = 10*(float)rand()/RAND_MAX;; if (k==n-1) l[k][2] = -1; else l[k][2] = k+1; printf("l[%1i,1]=%2i l[%1i,2]=%2i\n", k,l[k][0],l[k][1]); printf("\n"); int akt=start; // bejárás while (true) { printf("l[%1i,1]=%2i l[%1i,2]=%2i\n", akt,l[akt][0],l[akt][1]); if (l[akt][2] == -1) break; akt = (int)l[akt][2]; 57

l[0,1]=7 l[0,2]=3 következő=l[0,3]=1 l[1,1]=3 l[1,2]=4 következő=l[1,3]=2 l[2,1]=1 l[2,2]=0 következő=l[2,3]=3 l[3,1]=0 l[3,2]=6 következő=l[3,3]=4 l[4,1]=6 l[4,2]=0 következő=l[4,3]=5 l[5,1]=4 l[5,2]=0 következő=l[5,3]=6 l[6,1]=6 l[6,2]=1 következő=l[6,3]=7 l[7,1]=0 l[7,2]=6 következő=l[7,3]=8 l[8,1]=3 l[8,2]=7 következő=l[8,3]=9 l[9,1]=0 l[9,2]=9 következő=l[9,3]=-1 l[0,1]=7 l[0,2]=3 következő=l[0,3]=1 l[1,1]=3 l[1,2]=4 következő=l[1,3]=2 l[2,1]=1 l[2,2]=0 következő=l[2,3]=3 l[3,1]=0 l[3,2]=6 következő=l[3,3]=4 l[4,1]=6 l[4,2]=0 következő=l[4,3]=5 l[5,1]=4 l[5,2]=0 következő=l[5,3]=6 l[6,1]=6 l[6,2]=1 következő=l[6,3]=7 l[7,1]=0 l[7,2]=6 következő=l[7,3]=8 l[8,1]=3 l[8,2]=7 következő=l[8,3]=9 l[9,1]=0 l[9,2]=9 következő=l[9,3]=-1 58

III.4.5 Keresés kapcsolt listában (tömbös) Ugyanaz mint lineáris esetben, csak az összehasonlítás és a léptetés elválik PTR=START Példa (C#) LOC= {PTR PTR=LINK(PTR) const int n = 10; int[,] l; l = new int[n, 2]; //szam,következő Random vletlen = new Random(); int start = 0; l[k, 0] = vletlen.next(10); if (k == n - 1) l[k, 1] = -1; else l[k, 1] = k + 1; Console.WriteLine( "l[{0,0]={1 következő {2", k,l[k,0],l[k,1]); int keres = l[4, 1]; Console.WriteLine("A keresett={0", keres); Console.WriteLine(); // kereses int akt = start; while (l[akt,1]!=-1) { if (keres == l[akt, 0]) Console.WriteLine("l[{0,1]={1", akt, l[akt, 0]); akt = (int)l[akt, 1]; KER= {PTR INFO PTR NULL const int n = 10; int l[n][2]; Példa (C) //szam,következő int start = 0; l[k][0] = 10*(float)rand()/RAND_MAX; if (k == n - 1) l[k][1] = -1; else l[k][1] = k + 1; printf( "l[%1i,0]=%2i kovetkezo %2i\n", k,l[k][0],l[k][1]); int keres = l[4][1]; printf("a keresett=%2i", keres); printf("\n"); // kereses int akt = start; while (l[akt][1]!=-1) { if (keres == l[akt][ 0]) printf("l[%1i,1]=%2i ", akt, l[akt][0]); 59 akt = (int)l[akt][1];

III.4.6 Beszúrás kapcsolt listába (tömbök) Start x Start élda (C#) x const int n = 11; int[,] l; l = new int[n + 1, 3]; //x,y,következő Random vletlen = new Random(); int start = 0; l[k, 0] = vletlen.next(10); l[k, 1] = vletlen.next(10); if (k == n - 1) l[k, 2] = -1; else l[k, 2] = k + 1; Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", k, l[k, 0], l[k, 1]); int akt = start; // beszúrás while (akt!=2) { akt = (int)l[akt, 2]; l[n, 2] = l[akt, 2]; l[akt, 2] = n ; l[n, 0] = 1000; l[n, 1] = 1000; int j = 0; do { Console.WriteLine("l[{0,1]={1 l[{0,2]={2", j, l[j, 0], l[j, 1]); j = l[j, 2]; while (l[j, 2]!= -1); Példa (C) const int n = 11; int l[n + 1][ 3]; //x,y,következő int start = 0; l[k][0] = 10*(float)rand()/RAND_MAX; l[k][1] = 10*(float)rand()/RAND_MAX;; if (k == n - 1) l[k][2] = -1; else l[k][2] = k + 1; printf("l[%i,1]=%i l[%i,2]=%i\n", k, l[k][0], k, l[k][1]); int akt = start; // beszúrás while (akt!=2) { akt = (int)l[akt][2]; l[n][2] = l[akt][2]; l[akt][2] = n ; l[n][0] = 1000; l[n][1] = 1000; int j = 0; do { printf("l[%i,1]=%i l[%i,2]=%i\n", j, l[j][0], j, l[j][1]); j = l[j][2]; while (l[j][2]!= -1); 60

l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=3 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 l[9,1]=6 l[9,2]=6 l[9,3]=-1 Beszúrás l[2,2]=10 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 Lista l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=10 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 l[9,1]=6 l[9,2]=6 l[9,3]=-1 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 Bejárás l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=10 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 61

III.4.7 Törlés kapcsolt listából Start x Start x III.4.8 Kétirányú listák Minden irányban bejárható Első INFO x INFO INFO INFO x III.4.9 Beszúrás kétirányú listába Első INFO x INFO INFO INFO x Utolsó Utolsó INFO III.4.10 Törlés kétirányú listából Első INFO x INFO INFO INFO x Utolsó 62

l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=4 l[4,1]=5 l[4,2]=5 következő=l[4,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 A 4-e elem törlése l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=5 l[4,1]=5 l[4,2]=5 következő=l[4,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 Bejárás l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 63

III.5. Verem (Stack) Last In First Out Új elem behelyezése (PUSH) a tetejére (TOP) Elem leemelése (POP) III.5.1 A verem tárolása a b c d III.5.1.1 PUSH TOP TOP=TOP+1 STACK(TOP)=Elem maxstk TOP<MAXSTK III.5.1.2 POP túlcsordul Elem=STACK(TOP) TOP=TOP-1 TOP=0 alulcsordul 64

public class stack { public const int max_stack = 10; public int stack_pointer = 0; public double[] x; public stack() { x = new double[max_stack]; public void push(double be) { if (stack_pointer < max_stack) x[stack_pointer++] = be; public double pop() { return x[--stack_pointer]; stack s = new stack(); Console.WriteLine("Először bekerül a 13"); s.push(13); Console.WriteLine("Utána bekerül a 14"); s.push(14); Console.WriteLine("Először a {0 jön ki", s.pop()); Console.WriteLine("Aztán a {0 jön ki", s.pop()); 65

Példa C++ class stack { public: static const int max_stack = 10; int stack_pointer; double * x; stack() { x = new double[max_stack]; stack_pointer=0; void push(double be) { if (stack_pointer < max_stack) x[stack_pointer++] = be; double pop() { return x[--stack_pointer]; ; //Verem létrehozása stack * s=new stack(); printf("eloszor bekerul a 13\n"); s->push(13); printf("utana bekerul a 14\n"); s->push(14); printf("eloszor a %f jon ki\n", s->pop()); printf("aztan a %f jon ki\n", s->pop()); 66

III.5.2 Rekurzió III.5.2.1. Faktoriális iteratív definíció n!=1 2 3 (n-2) (n-1) n N=0 Fakt=1 k=1 k<=n k=k+1 Fakt=Fakt*k III.5.2.2. Faktoriális rekurzív definíció 0!=1 ; n!=n (n-1)! N=0 Fakt=1 Fakt()=n * Fakt(n-1) Fakt()=1 A verem és az alprogram kapcsolata Példa (C#) public class Szamitasok { public static int fakt(int n) { if (n<2) return 1; else return n*fakt(n-1); Console.Write("Nem negatív egész="); int n=convert.toint32(console.readline()); Console.WriteLine("{0!={1",n, Szamitasok.fakt(n)); 67

III.6. Sor (Queue) First In First Out III.6.1 A sor tárolása (lebegő sor) a BOT b c d TOP maxque III.6.1.1 PUSH TOP=TOP+1 QUE(TOP)=Elem TOP<MAXQUE-1 III.6.1.2 POP túlcsordul Elem=QUE(BOT) BOT=BOT+1 BOT>TOP üres 68

public class queue { public const int size = 10; public int max_queue = 0; public int min_queue = 0; public double[] x; public queue() { x = new double[size]; public void push(double be) { if (max_queue< size -1) x[max_queue++] = be; public double pop() { if (min_queue < max_queue) return x[min_queue++]; else return 99999; //Sor létrehozása queue q = new queue(); Console.WriteLine("Először bekerül a 13"); q.push(13); Console.WriteLine("Utána bekerül a 14"); q.push(14); Console.WriteLine("Először a {0 jön ki", q.pop()); Console.WriteLine("Aztán a {0 jön ki", q.pop()); #include "stdafx.h" #include <conio.h> #include <stdlib.h> class queue { public: static const int size = 10; int max_queue; int min_queue; double x[size]; queue() { max_queue=0; min_queue=0; void push(double be) { if (max_queue< size -1) x[max_queue++] = be; double pop() { if (min_queue < max_queue) return x[min_queue++]; else return 99999; ; Példa (C) int _tmain(int argc, _TCHAR* argv[]) {//Sor létrehozása queue q = queue(); printf("eloszor bekerul a 13.0\n"); q.push(13); printf("utana bekerul a 14.0\n"); q.push(14); printf("eloszor a %f jon ki\n", q.pop()); printf("aztan a %f jon ki\n", q.pop()); getch(); 69 return 0;

III.7. Bináris fa Elemek véges halmaza, amely vagy üres vagy egyetlen T elemhez (gyökér) kapcsolt két diszjunkt T1 ésd T2 részfa alkotja A H D B C E F G I K J A gyökér (szülő, apa) R(A) - jobboldali részfa (C,F,G, I, J, K) L(A) baloldali részfa (B, D, E, H) C A jobboldali szukcesszora (gyermek, leszármazott) B A baloldali szukcesszora Minden csomópontnak 0, 1, illetve 2 szukcesszora lehet Zárócsomópont - 0 szukcesszor Az összekötő vonalak - élek, 0 szukcesszor - levél utolsó él - ág Szintszám : gyökér - 0 leszármazott - szülő+1 Generáció : azonos szintszámú elemek Mélység : az azonos ágon elhelyezkedő elemek maximális száma Teljes : az utolsó szintet kivéve a csp-k száma maximális 70 Kiterjesztett bináris fa minden csomópontnak 0/2 gyermeke van

III.7.1 Bináris fák ábrázolása kapcsolt szerkezettel Root A B C D x x E x x F x G x H x x I x J x III.7.2 Bináris fák ábrázolása tömbökkel x K x Root 1 2 3 4 5 6 7 8 9 10 11 12 13 Avail L(Root) R(Root) A C G J K F I B D H E 10 7 8 5 0 0 0 11 12 0 0 2 3 4 0 0 0 0 13 0 0 0 71

III.7.3 Bináris fák szekvenciális ábrázolása a gyökér T(1) ha egy csomópont a T(k)-n van, akkor ha van L(T(k))=T(2*k) egyébként NULL akkor ha van R(T(k))=T(2*k+1) egyébként NULL A B C D E F G 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A B C D E F G NULL NULL NULL NULL NULL NULL NULL NULL III.7.4 Bináris fák bejárása Több lehetőség. Pl. a G gyökér Az L(G) bejárása az irányítás szerint, Az R(G) bejárása az irányítás szerint, D B A C E F G H I J K 72

III.7.4.1. Pl. az irányítással megegyező bejárás (I.8.1 tárolás) NULL a STACK-en PTR a gyökéren Ameddig a PTR!=NULL az összes L() feldolgozása az összes R() a STACK-re PTR=L(PTR) léptetés utána PTR=STACK legfelső elemével (ha nem NULL, R feldolgozás) TOP=0 STACK(TOP)=NULL PTR=Gyökér PTR NULL STACK(TOP)=R(PTR) TOP=TOP+1 R(PTR) NULL ADAT(PTR) feldolgozás A PTR=L(PTR) B C D E F G L(PTR) NULL H I J TOP=TOP-1 PTR=STACK(TOP) K 73

III.8. Általános fa Elemek véges halmaza (T), amely Tartalmaz egy kitüntetett R gyökérelemet A többi elem nem nulla diszjunkt részfája T-nek A B C D E F G H I J K L III.8.1 Tárolás számítógépen INFO(k) - az elem adatai GYERMEK(k) - az első gyermek TESTVÉR(k) - az első testvér 1 2 3 4 5 6 7 8 9 10 11 12 13 INFO A B C D E F G H I J K L TESTVÉR GYERMEK 0 3 5 0 7 8 0 10 0 12 13 0 2 6 0 9 11 0 0 0 0 0 0 0 74

III.9 Gráf Két halmazzal jellemezhető adatszerkezet Csomópontok sorszámozott halmaza (csúcsok) Az elemeket összekötő e=[u,v] számpárral jellemzett élek halmaza az összekötött csomópontokat szomszédoknak hívjuk deg(u) a csomópont foka, a befutó élek száma deg(u)=0 izolált csomópont v 0 -ból v n -be haladó élek halmazát P(v 0, v 1, v 0 ) útnak nevezzük. P út zárt, ha v 0 =v n P út egyszerű, ha minden pontja különböző Kör a 3-nál hosszabb egyszerű zárt út. Összefüggő egy gráf, ha bármely két pontja között létezik út. Egy G gráf akkor és csak akkor összefüggő, ha bármely két pontja között létezik egyszerű út. Egy gráf teljes, ha minden csomópontja minden csomópontjával össze van kötve. A fa köröket nem tartalmazó összefüggő gráf G gráf címkézett, ha éleihez adatokat rendelünk. Ha G gráf éleihez rendelt adatok nem negatívak, akkor a gráfot súlyozottnak hívjuk. G gráf irányított, ha az éleknek irányítottságuk van 75

III.9.1 Szekvenciális tárolás számítógépen Szomszédsági mátrix a i,j =1 ha i-ből j felé halad él a i,j =0 egyébként C A B A A B C D A 0 1 1 0 B 0 0 0 0 C 0 0 0 1 D D 0 0 0 0 Ha A a G gráf szomszédsági mátrixa, akkor A k mátrix i,j. eleme az i-ből j-be vezető K hosszú utak számát adja. A 2 A B C D A 0 0 0 1 Útmátrix p i,j =1 ha i-ből j felé halad valamilyen út p i,j =0 - egyébként B 0 0 0 0 C 0 0 0 0 D 0 0 0 0 U A B C D A 0 1 1 1 B 0 0 0 0 C 0 0 0 1 D 0 0 0 0 Egy m pontból álló irányított gráf útmátrixának p ij tagja akkor és csak akkor 1, ha Az A szomszédsági mátrixból képzett A+A 2 +.+A m mátrix i,j. eleme nem 0. 76

III.10. Alkalmazások III.10.1. Bejárás négyzetszámok összege szorzata Feltöltés k=0 k<=n k=k+1 L[k]=k 2 Számítás sz=0 p=1 k=0 k<=n k=k+1 int n=10; int[] L = new int [n+1]; for (int k=0; k<=n; k++) { L[k]=k*k; int sz=0; int p=1; for (int k=0; k<=n; k++) { sz+=l[k]; p*=l[k]; sz+=k 2 p * =k 2 const int n=10; int L[n+1]; for (int k=0; k<=n; k++) { L[k]=k*k; int sz=0; int p=1; for (int k=0; k<=n; k++) { sz+=l[k]; p*=l[k]; 77

III.10.2. Bejárás - numerikus integrálás, deriválás Numerikus derivált f x = f n f n 1 x n x n 1 h = x n x n 1 df(x) dx f n f n 1 h x + y n 1 Numerikus integrál (trapéz szabály) h (f i 1 + f i ) 2 f n 1 x n 1 x n f n Feltöltés k=0 k<=n k=k+1 f[k]=x[k] 2-0.25 x[k]=k*0.1 78

Számítás derivált és integrál integ=0 k=1 k<=n k=k+0.1 integ += f k 1 + f[k] 2 (x k x k 1 ) d[k] = f k + f[k 1] x k x k 1 double[] f = new double[n + 1]; double[] x = new double[n + 1]; double[] d = new double[n + 1]; double dt=0.1; for (int k = 0; k <= n; k++) { x[k] = k * dt; f[k] = x[k] * x[k] - 0.25; double integ = 0; for (int k = 1; k <= n; k++) { integ += (f[k - 1] + f[k]) / 2 * (x[k] - x[k - 1]); d[k] = (f[k] + f[k - 1]) / (x[k] - x[k - 1]); double f[n + 1]; double x[n + 1]; double d[n + 1]; double dt=0.1; for (int k = 0; k <= n; k++) { x[k] = k * dt; f[k] = x[k] * x[k] - 0.25; double integ = 0; for (int k = 1; k <= n; k++) { integ += (f[k - 1] + f[k]) / 2 * (x[k] - x[k - 1]); d[k] = (f[k] + f[k - 1]) / (x[k] - x[k - 1]); 79

III.10.3. Gyökkeresés Gyökkeresés bejárással gyok=-1 k=0 k<=n k=k+1 gyok = x k + x[k 1] 2 dt f k f k 1 0 double gyok = -1; for (int k = 1; k <= n; k++) { if (f[k - 1] * f[k]<=0) gyok = dt*(x[k] + x[k - 1])/2; double gyok = -1; for (int k = 1; k <= n; k++) { if (f[k - 1] * f[k]<=0) gyok = dt*(x[k] + x[k - 1])/2; 80

Bináris gyökkeresés B=0 V=n V B < ε gyok=k*dt V=K B=K F[B] *f[k] <0 K= V+B 2 int K; int B=0; int V=n; while (V-B>=1) { K = (B + V) / 2; if (f[b] * f[k] < 0) V = K; else { if (f[k]!=0) B = K; else B=V=K; double gyok=k*dt; int K; int B=0; int V=n; while (V-B>1) { K = (B + V) / 2; if (f[b] * f[k] < 0) V = K; else { if (f[k]!=0) B = K; else B=V=K; double gyok=k*dt; 81