III. Adatszerkezetek és algoritmusok

Átírás

1 III. Adatszerkezetek és algoritmusok 40

2 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)

3 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 ; 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

4 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 Pl Példa (C) const int n = 10; int l[n]; l[k] = rand(); printf("%i\n",l[k]); 43

5 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 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

6 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

7 III Például

8 III.1.4 Keresés III 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 Pl 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

9 III 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

10 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");

11 III Pl Sorbarakva beg=0 mid=4 end=9 beg=5 mid=7 end=9 beg=8 mid=8 end=9 Az 7 az 8. 50

12 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

13 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

14 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

15 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

16 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 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

17 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

18 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

19 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

20 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];

21 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

22 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

23 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

24 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

25 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 PUSH TOP TOP=TOP+1 STACK(TOP)=Elem maxstk TOP<MAXSTK III POP túlcsordul Elem=STACK(TOP) TOP=TOP-1 TOP=0 alulcsordul 64

26 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

27 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

28 III.5.2 Rekurzió III 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 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

29 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 PUSH TOP=TOP+1 QUE(TOP)=Elem TOP<MAXQUE-1 III POP túlcsordul Elem=QUE(BOT) BOT=BOT+1 BOT>TOP üres 68

30 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;

31 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

32 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 Avail L(Root) R(Root) A C G J K F I B D H E

33 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 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

34 III 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

35 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 INFO A B C D E F G H I J K L TESTVÉR GYERMEK

36 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

37 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 B C D D 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 Útmátrix p i,j =1 ha i-ből j felé halad valamilyen út p i,j =0 - egyébként B C D U A B C D A B C D 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

38 III.10. Alkalmazások III 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

39 III 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] x[k]=k*0.1 78

40 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] ; 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] ; 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

41 III 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

42 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