III. Adatszerkezetek és algoritmusok

III. Adatszerkezetek és algoritmusok 1

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 B(n) 2

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 3

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]); 4

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 ) 2 Bonyolultság : = O( n ) 2 5

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]); 6

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 7

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); 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); III.1.4.2 Pl. 0 9 0 6 0 4 Az 5 a 6. - nincs ilyen 8

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 9

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

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. 11

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 12

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 13

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. LB Név SOR1 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(); #include <stdio.h> #include <conio.h> Példa (C) #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; 14

III.3.1 Szintszám, minősítés Az adattételek lehetnek összetettek, altételekkel. Például: Gyermek Név Apa Anya Név Név 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(); 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; 15

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 Kétirányú listák Minden irányban bejárható Első INFO x INFO INFO INFO x Utolsó Ciklikusan kapcsolt listák Nem rendelkeznek első és utolsó elemmel, mert az utolsó elem az első -re mutat 16

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 17

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()); 18

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) Példa (C#) public class Szamitasok { public static int fakt(int n) { if (n<2) return 1; else return n*fakt(n-1); Fakt()=1 Console.Write("Nem negatív egész="); int n=convert.toint32(console.readline()); Console.WriteLine("{0!={1",n, Szamitasok.fakt(n)); 19

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 20

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(); return 0; 21

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 Kiterjesztett bináris fa minden csomópontnak 0/2 gyermeke van 22

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 A C G J K F I B D H E L(Root) 10 7 8 5 0 0 0 11 12 0 0 R(Root) 23 2 3 4 0 0 0 0 13 0 0 0

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 24

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 25

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 26

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. 27

III.10. Alkalmazások 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]; 28