Információs Technológia
|
|
|
- Fanni Barna
- 9 évvel ezelőtt
- Látták:
Átírás
1 Információs Technológia Sor és verem adatszerkezet Fodor Attila Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék november 19.
2 Alapötlet Sor adatszerkezet Sor adatszerkezet Az egymás után beírt adatokat a beírás sorrendjében vehetjük ki FIFO - First In First Out Például: Eszközök közötti átvitel biztosítása Az érkező adatok feldolgozási sorrendje fontos, de azokat bizonyos esetekben nem tudnánk folyamatosan feldolgozni ezért eltároljuk Billentyűzet kezelése, I/O műveletek (File kezelés/file rendszer), Memória kezelés Értelmezhető utasítások IN Egy elemet betesz a sorba Ha megtelt a sor hibaüzenetet kell adni OUT Kiveszi a sor következő elemét Ha a sor üres akkor hibaüzenet, vagy olyan adatot adunk vissza ami nem fordulhat elő egyébként (pl.: NULL) EMPTY - Leelenőrzi, hogy tartalmaz-e adatot a sor FULL - Leelenőrzi, hogy megtelt-e a sor Fodor A. (Pannon Egyetem) Információs technológia november / 41
3 Sor megvalósítása Sor adatszerkezet Sor adatszerkezet Statikus adatokkal Egy 1 dimenziós tömb Adatok tárolása Index (szám érték) Következő üres elemre mutat Sor elejére mutat Pointerekkel Egy 1 dimenziós mutatótömbbel Adatokra mutató mutatók tárolása Mutatók Következő üres elemre mutat Sor elejére mutat Speciálisan kezelt láncolt listával Fodor A. (Pannon Egyetem) Információs technológia november / 41
4 FIFO megvalósítása Sor adatszerkezet Sor adatszerkezet megvalósítása Adatszerkezet az adatok eltárolására #define MAX_MEMBER 10 typedef struct int First, Last; int v[max_member]; FIFO_TYPE; FIFO adatszerkezet inicializálása void FIFO_init(FIFO_TYPE *fifo) fifo->first = 0; fifo->last = 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
![v[max_member]; FIFO_TYPE; FIFO adatszerkezet inicializálása void FIFO_init(FIFO_TYPE](/docs-images/44/139468/images/page_4.jpg "*fifo) fifo->first = 0; fifo->last = 0; Fodor A.")
5 FIFO megvalósítása Sor adatszerkezet Sor adatszerkezet megvalósítása Új adat sorba való berakása int FIFO_in(FIFO_TYPE *fifo, int data) if (fifo->last == MAX_MEMBER) return 1; fifo->v[fifo->last] = data; fifo->last++; return 0; Adat sorból való kivétele int FIFO_out(FIFO_TYPE *fifo, int *data) if (fifo->first == fifo->last) return 1; *data = fifo->v[fifo->first]; fifo->first++; return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
6 FIFO megvalósítása Sor adatszerkezet Sor adatszerkezet megvalósítása Sor első tagjának megtekintése int FIFO_lookfirst(FIFO_TYPE *fifo, int *data) if (fifo->first == fifo->last) return 1; *data = fifo->v[fifo->first]; return 0; Sor ürességének tesztelése int FIFO_empty(FIFO_TYPE *fifo) return (fifo->last == fifo->first)?1:0; Megtelt-e a sor int FIFO_full(FIFO_TYPE *fifo) return (fifo->last == MAX_MEMBER)?1:0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
7 FIFO használata Sor adatszerkezet Sor adatszerkezet megvalósítása Adatszerkezet függvényeinek meghívása FIFO_TYPE fifo; int i, j; FIFO_init(&fifo); for(i=0; i<15; i++) FIFO_in(&fifo, i); for(i=0; i<15; i++) if (!FIFO_out(&fifo, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
8 FIFO használata Sor adatszerkezet Sor adatszerkezet megvalósítása Adatszerkezet függvényeinek meghívása FIFO_TYPE fifo; int i, j; FIFO_init(&fifo); for(i=0; i<5; i++) FIFO_in(&fifo, i); for(i=0; i<15; i++) if (!FIFO_out(&fifo, &j)) printf("%d ", j); for(i=0; i<15; i++) FIFO_in(&fifo, i); for(i=0; i<15; i++) if (!FIFO_out(&fifo, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
9 Sor adatszerkezet FIFO használata (problémák) Sor adatszerkezet megvalósítása Probléma a sor ilyen kezelésénél Sok adat ki és berakása esetén: A sor elején üresek a tömb mezői Ha a sor végére érünk nem tudunk további adatot berakni Megoldás Ha nincsen adat a sorban, akkor visszaáll a 0 értékre Nem biztos, hogy kiürül a sor Ez csak félmegoldás Az adatszerkezet ciklikus módon történő kezelése Ha a végére értünk a tömbnek, akkor azt az elejétől kezdjük feltölteni. Fodor A. (Pannon Egyetem) Információs technológia november / 41
10 Sor adatszerkezet FIFO megvalósítása (ciklikus módon) Sor adatszerkezet megvalósítása ciklikus módon Adatszerkezet az adatok eltárolására typedef struct int First, Last, N; int v[max_member]; cfifo_type; FIFO adatszerkezet inicializálása void cfifo_init(cfifo_type *fifo) fifo->first = 0; fifo->last = 0; fifo->n = 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
11 Sor adatszerkezet FIFO megvalósítása (ciklikus módon) Sor adatszerkezet megvalósítása ciklikus módon Új adat sorba való berakása int cfifo_in(cfifo_type *fifo, int data) if (fifo->n == MAX_MEMBER) return 1; if (fifo->last == MAX_MEMBER-1) fifo->v[fifo->last] = data; fifo->last = 0; else fifo->v[fifo->last] = data; fifo->last++; fifo->n++; return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
![(fifo->last == MAX_MEMBER-1) fifo->v[fifo->last] = data; fifo->last = 0; else fifo->v[fifo->last] = data;](/docs-images/44/139468/images/page_11.jpg "fifo->last++; fifo->n++; return 0; Fodor A. (Pannon Egyetem) Információs technológia 2009. november 19.")
12 Sor adatszerkezet FIFO megvalósítása (ciklikus módon) Sor adatszerkezet megvalósítása ciklikus módon Adat sorból való kivétele int cfifo_out(cfifo_type *fifo, int *data) if (fifo->n == 0) return 1; *data = fifo->v[fifo->first]; if (fifo->first == MAX_MEMBER-1) fifo->first=0; else fifo->first++; fifo->n--; return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
![return 1; *data = fifo->v[fifo->first]; if (fifo->first == MAX_MEMBER-1) fifo->first=0; else](/docs-images/44/139468/images/page_12.jpg "fifo->first++; fifo->n--; return 0; Fodor A. (Pannon Egyetem) Információs technológia 2009.")
13 Sor adatszerkezet FIFO megvalósítása (ciklikus módon) Sor első tagjának megtekintése int cfifo_lookfirst(cfifo_type *fifo, int *data) if (!fifo->n) return 1; *data = fifo->v[fifo->first]; return 0; Sor ürességének tesztelése int cfifo_empty(cfifo_type *fifo) return fifo->n?1:0; Megtelt-e a sor int cfifo_full(cfifo_type *fifo) return (fifo->n == MAX_MEMBER)?1:0; Sor adatszerkezet megvalósítása ciklikus módon Fodor A. (Pannon Egyetem) Információs technológia november / 41
![fifo->n) return 1; *data = fifo->v[fifo->first]; return 0; Sor ürességének tesztelése int cfifo_empty(cfifo_type *fifo)](/docs-images/44/139468/images/page_13.jpg "return fifo->n?1:0; Megtelt-e a sor int cfifo_full(cfifo_type *fifo) return (fifo->n == MAX_MEMBER)?")
14 Sor adatszerkezet Ciklikus módon kezelt FIFO használata Sor adatszerkezet megvalósítása ciklikus módon Adatszerkezet függvényeinek meghívása int i, j; cfifo_type cfifo; cfifo_init(&cfifo); for(i=0; i<5; i++) cfifo_in(&cfifo, i); for(i=0; i<15; i++) if (!cfifo_out(&cfifo, &j)) printf("%d ", j); for(i=0; i<15; i++) cfifo_in(&cfifo, i); for(i=0; i<15; i++) if (!cfifo_out(&cfifo, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
15 Sor adatszerkezet Sor adatszerkezet megvalósítására használható struktúrák Sor adatszerkezet megvalósítására használható struktúrák Az adatok helyet adatokra mutató mutató alkalmazása (tömbbe szervezve) typedef struct int First, Last, N; void *v[max_member]; cfifo_type_pointer; Az adatok helyet adatokra mutató mutató alkalmazása (tömbbe szervezve) Index helyett mutató alkalmazása (kezdő és a vég elemre mutat) typedef struct void *First, *Last; unsigned long int N; void *v[max_member]; cfifo_type_pointer2; Fodor A. (Pannon Egyetem) Információs technológia november / 41
16 Sor adatszerkezet FIFO megvalósítása (láncolt listával) Sor adatszerkezet megvalósítása láncolt listával Kettő megvalósítási filozófia 1. Filozófia A lista végére rakjuk az új adatot A lista elejéröl vesszük ki az adatot 2. Filozófia A lista elejére rakjuk az új adatot A lista végéről vesszük ki az adatot Lista adattag struct lista_elem void *adat; struct lista_elem *kov; ; lista_elem *kezd; Fodor A. (Pannon Egyetem) Információs technológia november / 41
17 Sor adatszerkezet FIFO megvalósítása (láncolt listával - 1.) A lista végére rakjuk az új adatot Sor adatszerkezet megvalósítása láncolt listával lista_elem* beszur_vege(lista_elem **kezd, int ujadat) lista_elem *uj, *akt; if (*kezd == NULL) *kezd = (lista_elem*) malloc(sizeof(lista_elem)); if (*kezd == NULL) return NULL; (*kezd)->adat = ujadat; (*kezd)->kov = NULL; return *kezd; else akt = *kezd; while (akt->kov!= NULL) akt = akt->kov; uj = (lista_elem*) malloc(sizeof(lista_elem)); if (uj == NULL) return NULL; akt->kov = uj; uj->kov = NULL; uj->adat = ujadat; return uj; Fodor A. (Pannon Egyetem) Információs technológia november / 41
18 Sor adatszerkezet FIFO megvalósítása (láncolt listával - 1.) Sor adatszerkezet megvalósítása láncolt listával A lista elejéről vesszük ki az adatot int torol_eleje(lista_elem **kezd, int *adat) lista_elem *del; if (*kezd == NULL) return -1; else del = *kezd; *kezd = (*kezd)->kov; *adat = del->adat; free(del); return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
19 Sor adatszerkezet Sor adatszerkezet megvalósítása láncolt listával Láncolt listával (1. filozófia) felépített FIFO használata Adatszerkezet függvényeinek meghívása lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) beszur_vege(&kezd, i); for(i=0; i<20; i++) if (!torol_eleje(&kezd, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
20 Sor adatszerkezet FIFO megvalósítása (láncolt listával - 2.) Sor adatszerkezet megvalósítása láncolt listával A lista elejére szurjuk be az új adatot lista_elem* beszur_eleje(lista_elem **kezd, int ujadat) lista_elem *uj; if (*kezd == NULL) *kezd = (lista_elem*) malloc(sizeof(lista_elem)); if (*kezd == NULL) return NULL; (*kezd)->adat = ujadat; (*kezd)->kov = NULL; else uj = (lista_elem*) malloc(sizeof(lista_elem)); if (uj == NULL) return NULL; uj->kov = *kezd; *kezd = uj; uj->adat = ujadat; return uj; Fodor A. (Pannon Egyetem) Információs technológia november / 41
21 Sor adatszerkezet FIFO megvalósítása (láncolt listával - 2.) A lista végéről vesszük ki az adatot Sor adatszerkezet megvalósítása láncolt listával int torol_vege(lista_elem **kezd, int *adat) lista_elem *del, *ujveg; if (*kezd == NULL) return -1; else del = *kezd; ujveg = NULL; while (del->kov!= NULL) ujveg = del; del = del->kov; if (ujveg!= NULL) ujveg->kov = NULL; else *kezd = NULL; *adat = del->adat; free(del); return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
22 Sor adatszerkezet Sor adatszerkezet megvalósítása láncolt listával Láncolt listával (2. filozófia) felépített FIFO használata Adatszerkezet függvényeinek meghívása lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) beszur_eleje(&kezd, i); for(i=0; i<20; i++) if (!torol_vege(&kezd, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
23 Sor adatszerkezet Láncolt listával felépített FIFO Sor adatszerkezet megvalósítása láncolt listával Kettő megvalósítási filozófia 1. Filozófia A lista végére rakjuk az új adatot A lista elejéröl vesszük ki az adatot 2. Filozófia A lista elejére rakjuk az új adatot A lista végéről vesszük ki az adatot Példa #ifdef LISTA_FILOZOFIA_1 #define LISTABA beszur_vege #define LISTABOL torol_eleje #else #define LISTABA beszur_eleje #define LISTABOL torol_vege #endif lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) LISTABA(&kezd, i); for(i=0; i<20; i++) if (!LISTABOL(&kezd, &j)) printf("%d ", j); Fodor A. (Pannon Egyetem) Információs technológia november / 41
24 Alapötlet Verem adatszerkezet Verem adatszerkezet Az egymás után beírt adatokat fordított sorrendben vehetjük ki A veremből mindig az utoljára bevitt adatot vehetjük ki először LIFO - Last In First Out Stack Alkalmazása például: Programokban a függvények meghívásakor Operációs rendszer, hardware Megszakítások (INT), eljárás hívás (CALL) Értelmezhető utasítások PUSH Egy elemet betesz a verembe Ha megtelt hibaüzenetet kell adni POP Kiveszi az utolsónak berakott elemet Ha a üres a verem akkor hibaüzenet, vagy olyan adatot adunk vissza ami nem fordulhat elő egyébként (pl.: NULL) EMPTY - Leelenőrzi, hogy tartalmaz-e adatot a verem FULL - Leelenőrzi, hogy megtelt-e a verem Fodor A. (Pannon Egyetem) Információs technológia november / 41
25 Verem megvalósítása Verem adatszerkezet Verem adatszerkezet Statikus adatokkal Egy 1 dimenziós tömb Adatok tárolása Indexek (szám érték) Következő üres elemre mutat Pointerekkel Egy 1 dimenziós mutatótömbbel Adatokra mutató mutatók tárolása Mutatók Következő üres elemre mutat Speciálisan kezelt láncolt listával Fodor A. (Pannon Egyetem) Információs technológia november / 41
26 LIFO megvalósítása Verem adatszerkezet Verem adatszerkezet Adatszerkezet az adatok eltárolására #define MAX_MEMBER 10 typedef struct int top; int v[max_member]; LIFO_TYPE; LIFO adatszerkezet inicializálása void LIFO_init(LIFO_TYPE *lifo) lifo->top = 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
27 LIFO megvalósítása Verem adatszerkezet Verem adatszerkezet PUSH - Új adat verembe való berakása int LIFO_push(LIFO_TYPE *lifo, int data) if (lifo->top == MAX_MEMBER) return 1; lifo->v[lifo->top] = data; lifo->top++; return 0; POP - Adat veremből való kivétele int LIFO_pop(LIFO_TYPE *lifo, int *data) if (!lifo->top) return 1; *data = lifo->v[lifo->top-1]; lifo->top--; return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
28 LIFO megvalósítása Verem adatszerkezet Verem adatszerkezet Verem felső tagjának megtekintése int LIFO_lookfirst(LIFO_TYPE *lifo, int *data) if (!lifo->top) return 1; *data = lifo->v[lifo->top-1]; return 0; Verem ürességének tesztelése int LIFO_empty(LIFO_TYPE *lifo) return (lifo->top==0)?1:0; Megtelt-e a verem int LIFO_full(LIFO_TYPE *lifo) return (lifo->top == MAX_MEMBER)?1:0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
29 LIFO megvalósítása Verem adatszerkezet Verem adatszerkezet Adatszerkezet függvényeinek meghívása int i, j; LIFO_TYPE lifo; LIFO_init(&lifo); for(i=0; i<15; i++) LIFO_push(&lifo, i); for(i=0; i<15; i++) if (!LIFO_pop(&lifo, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
30 Verem adatszerkezet LIFO megvalósítása (láncolt listával) Verem adatszerkezet megvalósítása láncolt listával Kettő megvalósítási filozófia 1. Filozófia A lista elejére rakjuk az új adatot A lista elejéről vesszük ki az adatot 2. Filozófia A lista végére rakjuk az új adatot A lista végéről vesszük ki az adatot Lista adattag struct lista_elem void *adat; struct lista_elem *kov; ; lista_elem *kezd; Fodor A. (Pannon Egyetem) Információs technológia november / 41
31 Verem adatszerkezet LIFO megvalósítása (láncolt listával - 1.) Verem adatszerkezet megvalósítása láncolt listával A lista elejére rakjuk be az új adatot lista_elem* beszur_eleje(lista_elem **kezd, int ujadat) lista_elem *uj; if (*kezd == NULL) *kezd = (lista_elem*) malloc(sizeof(lista_elem)); if (*kezd == NULL) return NULL; (*kezd)->adat = ujadat; (*kezd)->kov = NULL; else uj = (lista_elem*) malloc(sizeof(lista_elem)); if (uj == NULL) return NULL; uj->kov = *kezd; *kezd = uj; uj->adat = ujadat; return uj; Fodor A. (Pannon Egyetem) Információs technológia november / 41
32 Verem adatszerkezet LIFO megvalósítása (láncolt listával - 1.) Verem adatszerkezet megvalósítása láncolt listával A lista elejéről vesszük ki az adatot int torol_eleje(lista_elem **kezd, int *adat) lista_elem *del; if (*kezd == NULL) return -1; else del = *kezd; *kezd = (*kezd)->kov; *adat = del->adat; free(del); return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
33 Verem adatszerkezet Verem adatszerkezet megvalósítása láncolt listával Láncolt listával (1. filozófia) felépített LIFO használata Adatszerkezet függvényeinek meghívása lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) beszur_eleje(&kezd, i); for(i=0; i<20; i++) if (!torol_eleje(&kezd, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
34 Verem adatszerkezet Verem adatszerkezet megvalósítása láncolt listával Láncolt listával (1. filozófia) felépített LIFO használata Adatszerkezet függvényeinek meghívása #define PUSH #define POP beszur_eleje torol_eleje lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) PUSH(&kezd, i); for(i=0; i<20; i++) if (!POP(&kezd, &j)) printf("%d ", j); Futás eredménye Fodor A. (Pannon Egyetem) Információs technológia november / 41
35 Verem adatszerkezet LIFO megvalósítása (láncolt listával - 2.) A lista végére rakjuk az új adatot Verem adatszerkezet megvalósítása láncolt listával lista_elem* beszur_vege(lista_elem **kezd, int ujadat) lista_elem *uj, *akt; if (*kezd == NULL) *kezd = (lista_elem*) malloc(sizeof(lista_elem)); if (*kezd == NULL) return NULL; (*kezd)->adat = ujadat; (*kezd)->kov = NULL; return *kezd; else akt = *kezd; while (akt->kov!= NULL) akt = akt->kov; uj = (lista_elem*) malloc(sizeof(lista_elem)); if (uj == NULL) return NULL; akt->kov = uj; uj->kov = NULL; uj->adat = ujadat; return uj; Fodor A. (Pannon Egyetem) Információs technológia november / 41
36 Verem adatszerkezet LIFO megvalósítása (láncolt listával - 2.) A lista végéről vesszük ki az adatot Verem adatszerkezet megvalósítása láncolt listával int torol_vege(lista_elem **kezd, int *adat) lista_elem *del, *ujveg; if (*kezd == NULL) return -1; else del = *kezd; ujveg = NULL; while (del->kov!= NULL) ujveg = del; del = del->kov; if (ujveg!= NULL) ujveg->kov = NULL; else *kezd = NULL; *adat = del->adat; free(del); return 0; Fodor A. (Pannon Egyetem) Információs technológia november / 41
37 Verem adatszerkezet Verem adatszerkezet megvalósítása láncolt listával Láncolt listával (2. filozófia) felépített LIFO használata Adatszerkezet függvényeinek meghívása lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) beszur_vege(&kezd, i); for(i=0; i<20; i++) if (!torol_vege(&kezd, &j)) printf("%d ", j); Futás eredménye Nem praktikus a használata (listán végig kell menni) Fodor A. (Pannon Egyetem) Információs technológia november / 41
38 Verem adatszerkezet Láncolt listával felépített verem Verem adatszerkezet megvalósítása láncolt listával Kettő megvalósítási filozófia 1. Filozófia A lista elejére rakjuk az új adatot A lista elejéről vesszük ki az adatot 2. Filozófia A lista végére rakjuk az új adatot A lista végéről vesszük ki az adatot Példa #ifdef LISTA_FILOZOFIA_1 #define Push beszur_eleje #define Pop torol_eleje #else #define Push beszur_vege #define Pop torol_vege #endif lista_elem *kezd; kezd = NULL; for(i=0; i<15; i++) Push(&kezd, i); for(i=0; i<20; i++) if (!Pop(&kezd, &j)) printf("%d ", j); Fodor A. (Pannon Egyetem) Információs technológia november / 41
39 Lineáris keresés Kereső algoritmusok Velétlenszerűen elhelyezkedő adatokban Első adattól indul a keresés Végignézi az összes adatot int lin_keres(int v[], int n, int mit) int i; for(i=0; (i<n)&& (v[i]!= mit); i++ ); if (i == n) return -1; if (v[i]!= mit) return -1; return i; Fodor A. (Pannon Egyetem) Információs technológia november / 41
40 Lineáris keresés Kereső algoritmusok Rendezett adatokban Első adattól indul a keresés Végignézi az összes adatot, ameddig azok kisebbek, mint a keresendő int lin_keres(int v[], int n, int mit) int i; for(i=0; (i<n)&& (v[i] < mit); i++ ); if (i == n) return -1; if (v[i]!= mit) return -1; return i; Fodor A. (Pannon Egyetem) Információs technológia november / 41
41 Bináris keresés Kereső algoritmusok Rendezett adatokban Folyamatosan felezi az intervallumot, melyben keres Végignézi az összes adatot, ameddig azok kisebbek, mint a keresendő A keresés az elemszammal log 2 N kapcsolatban van int bin_keres(int v[], int Also, int Felso, int mit) int Kozepso; Kozepso = int ((Also+Felso)/2); while ((Also <= Felso) && (v[kozepso]!= mit)) if (v[kozepso] > mit) Felso = Kozepso-1; else Also = Kozepso+1; Kozepso = int ((Also+Felso)/2); if (v[kozepso] == mit) return Kozepso; else return -1; Fodor A. (Pannon Egyetem) Információs technológia november / 41
Adatszerkezetek Tömb, sor, verem. Dr. Iványi Péter
Adatszerkezetek Tömb, sor, verem Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot
Algoritmusok és adatszerkezetek gyakorlat 06 Adatszerkezetek
Algoritmusok és adatszerkezetek gyakorlat 06 Adatszerkezetek Tömb Ugyanolyan típusú elemeket tárol A mérete előre definiált kell legyen és nem lehet megváltoztatni futás során Legyen n a tömb mérete. Ekkor:
Adatszerkezetek 1. Dr. Iványi Péter
Adatszerkezetek 1. Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot kódoltan tároljuk
Miről lesz ma szó? A PROGAMOZÁS ALAPJAI 1. Dinamikus adatszerkezetek. Dinamikus adatszerkezetek. Önhivatkozó struktúrák. Önhivatkozó struktúrák
2012. március 27. A PROGAMOZÁS ALAPJAI 1 Vitéz András egyetemi adjunktus BME Híradástechnikai Tanszék vitez@hit.bme.hu Miről lesz ma szó? Dinamikus adatszerkezetek Önhivatkozó struktúra keresés, beszúrás,
Tartalom Keresés és rendezés. Vektoralgoritmusok. 1. fejezet. Keresés adatvektorban. A programozás alapjai I.
Keresés Rendezés Feladat Keresés Rendezés Feladat Tartalom Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
Keresés és rendezés. A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
Keresés Rendezés Feladat Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán 2016. november 7. Farkas B., Fiala
Információs Technológia
Információs Technológia Rekurzió, Fa adatszerkezet Fodor Attila Pannon Egyetem Műszaki Informatika Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010. november 18. Rekurzió Rekurzió
Elemi adatszerkezetek
2017/12/16 17:22 1/18 Elemi adatszerkezetek < Programozás Elemi adatszerkezetek Szerző: Sallai András Copyright Sallai András, 2011, 2014 Licenc: GNU Free Documentation License 1.3 Web: http://szit.hu
Információs Technológia
Információs Technológia ZH feladatok megoldása (2009.11.26.) Fodor Attila Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2009. november 26.
félstatikus adatszerkezetek: verem, várakozási sor, hasítótábla dinamikus adatszerkezetek: lineáris lista, fa, hálózat
Listák félstatikus adatszerkezetek: verem, várakozási sor, hasítótábla dinamikus adatszerkezetek: lineáris lista, fa, hálózat A verem LIFO lista (Last In First Out) angolul stack, románul stivă bevitel
Adatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája
Adatszerkezetek Összetett adattípus Meghatározói: A felvehető értékek halmaza Az értékhalmaz struktúrája Az ábrázolás módja Műveletei Adatszerkezet fogalma Direkt szorzat Minden eleme a T i halmazokból
Mutatók és címek (ism.) Programozás alapjai C nyelv 8. gyakorlat. Indirekció (ism) Néhány dolog érthetőbb (ism.) Változók a memóriában
Programozás alapjai C nyelv 8. gyakorlat Szeberényi mre BME T Programozás alapjai. (C nyelv, gyakorlat) BME-T Sz.. 2005.11.07. -1- Mutatók és címek (ism.) Minden változó és függvény
A programozás alapjai előadás. [<struktúra változó azonosítók>] ; Dinamikus adatszerkezetek:
![A programozás alapjai előadás. [<struktúra változó azonosítók>] ; Dinamikus adatszerkezetek:](/thumbs/88/114858127.jpg "A programozás alapjai előadás. [<struktúra változó azonosítók>] ; Dinamikus adatszerkezetek:")
A programozás alapjai 1 Dinamikus adatszerkezetek:. előadás Híradástechnikai Tanszék Dinamikus adatszerkezetek: Adott építőelemekből, adott szabályok szerint felépített, de nem rögzített méretű adatszerkezetek.
Programozás I. - 11. gyakorlat
Programozás I. - 11. gyakorlat Struktúrák, gyakorlás Tar Péter 1 Pannon Egyetem M szaki Informatikai Kar Rendszer- és Számítástudományi Tanszék Utolsó frissítés: November 16, 2009 1 tar@dcs.vein.hu Tar
Programozás alapjai C nyelv 8. gyakorlat. Mutatók és címek (ism.) Indirekció (ism)
Programozás alapjai C nyelv 8. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.07. -1- Mutatók és címek (ism.) Minden változó és függvény
Programozás alapjai II. (7. ea) C++
Programozás alapjai II. (7. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2016.04.05. - 1
Programozás alapjai II. (7. ea) C++ Speciális adatszerkezetek. Tömbök. Kiegészítő anyag: speciális adatszerkezetek
Programozás alapjai II. (7. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2016.04.05. - 1
Speciális adatszerkezetek. Programozás alapjai II. (8. ea) C++ Tömbök. Tömbök/2. N dimenziós tömb. Nagyméretű ritka tömbök
Programozás alapjai II. (8. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT Speciális adatszerkezetek A helyes adatábrázolás választása, a helyes adatszerkezet
A PROGAMOZÁS ALAPJAI 1. Függvény mint függvény paramétere. Függvény mint függvény paramétere. Függvény mint függvény paramétere
2012. április 10. A PROGAMOZÁS ALAPJAI 1 Vitéz András egyetemi adjunktus BME Híradástechnikai Tanszék vitez@hit.bme.hu Miről lesz ma szó? alaki szabályok használata - mintapélda használata - mintapélda
end function Az A vektorban elõforduló legnagyobb és legkisebb értékek indexeinek különbségét.. (1.5 pont) Ha üres a vektor, akkor 0-t..
A Név: l 2014.04.09 Neptun kód: Gyakorlat vezető: HG BP MN l 1. Adott egy (12 nem nulla értékû elemmel rendelkezõ) 6x7 méretû ritka mátrix hiányos 4+2 soros reprezentációja. SOR: 1 1 2 2 2 3 3 4 4 5 6
.Net adatstruktúrák. Készítette: Major Péter
.Net adatstruktúrák Készítette: Major Péter Adatstruktúrák általában A.Net-ben számos nyelvvel ellentétben nem kell bajlódnunk a változó hosszúságú tömbök, listák, sorok stb. implementálásával, mert ezek
Adatszerkezetek 7a. Dr. IványiPéter
Adatszerkezetek 7a. Dr. IványiPéter 1 Fák Fákat akkor használunk, ha az adatok között valamilyen alá- és fölérendeltség van. Pl. könyvtárszerkezet gyökér () Nincsennek hurkok!!! 2 Bináris fák Azokat a
5. SOR. Üres: S Sorba: S E S Sorból: S S E Első: S E
5. SOR A sor adatszerkezet is ismerős a mindennapokból, például a várakozási sornak számos előfordulásával van dolgunk, akár emberekről akár tárgyakról (pl. munkadarabokról) legyen szó. A sor adattípus
6. gyakorlat Egydimenziós numerikus tömbök kezelése, tömbi algoritmusok
6. gyakorlat Egydimenziós numerikus tömbök kezelése, tömbi algoritmusok 1. feladat: Az EURO árfolyamát egy negyedéven keresztül hetente nyilvántartjuk (HUF / EUR). Írjon C programokat az alábbi kérdések
Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK. Sapientia EMTE
Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK Sapientia EMTE 2015-16 1 Felülnézet 1 Feltételes fordítás #if, #else, #elif, #endif, #ifdef, #ifndef stb. Felülnézet 2 #include: hatására a preprocesszor
Verem Verem mutató 01
A számítástechnikában a verem (stack) egy speciális adatszerkezet, amiben csak kétféle művelet van. A berak (push) egy elemet a verembe rak, a kivesz (pop) egy elemet elvesz a verem tetejéről. Mindig az
Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]
![Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]](/thumbs/27/11691656.jpg "Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]")
Kupac adatszerkezet A bináris kupac egy majdnem teljes bináris fa, amely minden szintjén teljesen kitöltött kivéve a legalacsonyabb szintet, ahol balról jobbra haladva egy adott csúcsig vannak elemek.
Programozás I gyakorlat. 5. Struktúrák
Programozás I gyakorlat 5. Struktúrák Bemelegítés Írj programot, amely beolvassa 5 autó adatait, majd kiírja az adatokat a képernyőre. Egy autóról a következőket tároljuk: maximális sebesség fogyasztás
Egyirányban láncolt lista
Egyirányban láncolt lista A tárhely (listaelem) az adatelem értékén kívül egy mutatót tartalmaz, amely a következő listaelem címét tartalmazza. A láncolt lista első elemének címét egy, a láncszerkezeten
Láncolt lista. az itt adott nevet csak a struct deklaráción belül használjuk
Láncolt lista int szam char szoveg[10] következő elemre mutató pointer int szam char szoveg[10] következő elemre mutató pointer elem elem elem int szam char szoveg[10] következő elemre mutató pointer A
Láncolt Listák. Adat1 Adat2 Adat3 ø. Adat1 Adat2 ø Adat3
Láncolt Listák Adatszerkezetek Adatszerkezet: Az adatelemek egy olyan véges halmaza, amelyben az adatelemek között szerkezeti összefüggések vannak Megvalósítások: - Tömb, Láncolt lista, Fa, Kupac, Gráf,
Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)
Programozás alapjai C nyelv 5. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.10.17. -1- Tömbök Azonos típusú adatok tárolására. Index
A verem (stack) A verem egy olyan struktúra, aminek a tetejéről kivehetünk egy (vagy sorban több) elemet. A verem felhasználása
A verem (stack) A verem egy olyan struktúra, aminek a tetejére betehetünk egy új (vagy sorban több) elemet a tetejéről kivehetünk egy (vagy sorban több) elemet A verem felhasználása Függvény visszatérési
Bevezetés a Programozásba II 12. előadás. Adatszerkezetek alkalmazása (Standard Template Library)
Pázmány Péter Katolikus Egyetem Információs Technológiai és Bionikai Kar Bevezetés a Programozásba II 12. előadás (Standard Template Library) 2014.05.19. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
Ugrólisták. RSL Insert Example. insert(22) with 3 flips. Runtime?
Ugrólisták Ugrólisták Ugrólisták Ugrólisták RSL Insert Example insert(22) with 3 flips 13 8 29 20 10 23 19 11 2 13 22 8 29 20 10 23 19 11 2 Runtime? Ugrólisták Empirical analysis http://www.inf.u-szeged.hu/~tnemeth/alga2/eloadasok/skiplists.pdf
Adatszerkezetek 1. előadás
Adatszerkezetek 1. előadás Irodalom: Lipschutz: Adatszerkezetek Morvay, Sebők: Számítógépes adatkezelés Cormen, Leiserson, Rives, Stein: Új algoritmusok http://it.inf.unideb.hu/~halasz http://it.inf.unideb.hu/adatszerk
malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; }
![malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; }](/thumbs/92/108948272.jpg "malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; }")
malloc free malloc free int sum(int a[4]) { return a[0] + a[1] + a[2] + a[3]; int main() { int b[4] = {1, 2, 3, 4}; printf("%d\n", sum(b)); return 0; \ \t \n \r \r\n \r string char* \0 a l m a \0 "alma"
Információs Technológia
Információs Technológia A C programozási nyelv elemei, rendező algoritmusok Fodor Attila Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010.
11. gyakorlat Sturktúrák használata. 1. Definiáljon dátum típust. Olvasson be két dátumot, és határozza meg melyik a régebbi.
11. gyakorlat Sturktúrák használata I. Új típus új műveletekkel 1. Definiáljon dátum típust. Olvasson be két dátumot, és határozza meg melyik a régebbi. typedef struct datum { int ev; int ho; int nap;
Információs Technológia
Információs Technológia (Struktúra, mutatók, függvényhívás) Fodor Attila Pannon Egyetem Műszaki Informatika Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010 október 14/21. Struktúra
Láncolt listák. Egyszerű, rendezett és speciális láncolt listák. Programozás II. előadás. Szénási Sándor
Láncolt listák Egyszerű, rendezett és speciális láncolt listák előadás http://nik.uni-obuda.hu/prog2 Szénási Sándor szenasi.sandor@nik.uni-obuda.hu Óbudai Egyetem,Neumann János Informatikai Kar Láncolt
Adatszerkezetek és algoritmusok
2009. november 13. Ismétlés El z órai anyagok áttekintése Ismétlés Specikáció Típusok, kifejezések, m veletek, adatok ábrázolása, típusabsztakció Vezérlési szerkezetek Függvények, paraméterátadás, rekurziók
A lista eleme. mutató rész. adat rész. Listaelem létrehozása. Node Deklarálás. Létrehozás. Az elemet nekünk kell bef zni a listába
A lista eleme 0 adat rész mutató rész Listaelem létrehozása p: Node 0 0 3 0 Az elemet nekünk kell bef zni a listába Deklarálás struct Node { int int value; Node* next; next; adattagok Létrehozás Node*
Amortizációs költségelemzés
Amortizációs költségelemzés Amennyiben műveleteknek egy M 1,...,M m sorozatának a futási idejét akarjuk meghatározni, akkor egy lehetőség, hogy külön-külön minden egyes művelet futási idejét kifejezzük
Struktúrák (struct) A struktúra szerkezetét meghatározó deklaráció általános formája:
Struktúrák (struct) A struktúra egy olyan összetett adatszerkezet, amely nemcsak azonos típusú elemeket rendelhet össze. A struktúra definíciójában leírjuk, hogy a struktúra hogyan épül fel. A struktúra
Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)
Programozás alapjai C nyelv 7. gyakorlat Szeberényi Imre BME IIT Függvények C program egymás mellé rendelt függvényekből áll. A függvény (alprogram) jó absztrakciós eszköz a programok
1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon
1. Template (sablon) 1.1. Függvénysablon Maximum függvény megvalósítása függvénynév túlterheléssel. i n l i n e f l o a t Max ( f l o a t a, f l o a t b ) { return a>b? a : b ; i n l i n e double Max (
Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)
Programozás alapjai C nyelv 7. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.05. -1- Függvények C program egymás mellé rendelt függvényekből
Adatszerkezetek és algoritmusok
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ű
Körkörös listák. fej. utolsó. utolsó. fej
Körkörös listák fej utolsó fej utolsó Példa. Kiszámolós játék. Körben áll n gyermek. k-asával kiszámoljuk őket. Minden k-adik kilép a körből. Az nyer, aki utolsónak marad. #include using namespace
ISA szimulátor objektum-orientált modell (C++)
Budapesti Műszaki és Gazdaságtudományi Egyetem ISA szimulátor objektum-orientált modell (C++) Horváth Péter Elektronikus Eszközök Tanszéke 2015. február 12. Horváth Péter ISA szimulátor objektum-orientált
10. gyakorlat Tömb, mint függvény argumentum
10. gyakorlat Tömb, mint függvény argumentum 1. feladat: A 6. gyakorlat 1. feladatát oldja meg a strukturált programtervezési alapelv betartásával, azaz minden végrehajtandó funkciót külön függvényben
A lista adatszerkezet A lista elemek egymásutániságát jelenti. Fajtái: statikus, dinamikus lista.
Lista adatszerkezet A lista adatszerkezet jellemzői 1 Különböző problémák számítógépes megoldása során gyakran van szükség olyan adatszerkezetre, amely nagyszámú, azonos típusú elem tárolására alkalmas,
Például számokból álló, egyszeresen láncolt lista felépítéséhez az alábbi struktúra definíciót használhatjuk:
8. előadás Ismétlés Dinamikus adatszerkezetek: listák (egyszeresen vagy többszörösen láncolt), fák. Kétfelé ágazó fa: bináris fa Dinamikus adatszerkezetek - önhivatkozó adatstruktúrák: adatok és reájuk
Láncolt listák. PPT 2007/2008 tavasz.
Láncolt listák szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Témakörök Láncolt listák elvi felépítése Egyirányú egyszerű láncolt lista Egyirányú rendezett láncolt lista Láncolt
Programozás alapjai C nyelv 9. gyakorlat. Rekurzió. Rekurzív algoritmus
Programozás alapjai C nyelv 9. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.14. -1- Rekurzió A feladat algoritmusa eleve rekurzív
Rekurzió. Programozás alapjai C nyelv 9. gyakorlat. Rekurzív algoritmus. Rekurzív algoritmus fajtái. Példa: n! (2) Példa: n!
Programozás alapjai C nyelv 9. gyakorlat Szeberényi Imre BME IIT Rekurzió A feladat algoritmusa eleve rekurzív formában adott (ld: n!). A valójában nem rekurzív de valami hasznot húzunk
Programozás I. 5. Előadás: Függvények
Programozás I 5. Előadás: Függvények Függvény Egy alprogram Egy C program általában több kisméretű, könnyen értelmezhető függvényből áll Egy függvény megtalálható minden C programban: ez a main függvény
Programozás 5. Dr. Iványi Péter
Programozás 5. Dr. Iványi Péter 1 Struktúra Véges számú különböző típusú, logikailag összetartozó változó együttese, amelyeket az egyszerű kezelhetőség érdekében gyűjtünk össze. Rekord-nak felel meg struct
Programozás C++ -ban
Programozás C++ -ban 4. Bevezetés az osztályokba 4.1 Az adatokhoz való hozzáférés ellenőrzése Egy C programban a struktúrák minden része mindig elérhető. Ugyanakkor ez nem a legkedvezőbb helyzet. Több
21. Adatszerkezetek Az adattípus absztrakciós szintjei Absztrakt adattípus (ADT) Absztrakt adatszerkezet (ADS) Egyszerű adattípusok Tömbök
2. Adatszerkezetek Az adattípus absztrakciós szintjei http://people.inf.elte.hu/fekete/docs_/adt_ads.pdf Absztrakt adattípus (ADT) Az adattípust úgy specifikáljuk, hogy szerkezetére, reprezentálására,
Osztály és objektum fogalma
Osztály és objektum fogalma A C++ programozási nyelv I. CPP1/ 1 Az osztály (class) class: adatok és módszerek (method) (függvények) együttese, amely absztrakt adattípusként működik. objektum: egy osztály
Algoritmusok és adatszerkezetek I. 1. előadás
Algoritmusok és adatszerkezetek I 1 előadás Típusok osztályozása Összetettség (strukturáltság) szempontjából: elemi (vagy skalár, vagy strukturálatlan) összetett (más szóval strukturált) Strukturálási
Fejlett programozási nyelvek C++ Iterátorok
Fejlett programozási nyelvek C++ Iterátorok 10. előadás Antal Margit 2009 slide 1 Témakörök I. Bevezetés II. Iterátor definíció III. Iterátorok jellemzői IV. Iterátorkategóriák V. Iterátor adapterek slide
Láncolt listák Témakörök. Lista alapfogalmak
Láncolt listák szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Lista alapfogalmai Egyirányú egyszerű láncolt lista Egyirányú rendezett láncolt lista Speciális láncolt listák Témakörök
Programozási nyelvek Java
statikus programszerkezet Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 2. előadás csomag könyvtárak könyvtárak forrásfájlok bájtkódok (.java) (.class) primitív osztály
Buborékrendezés: Hanoi Tornyai: Asszimptótikus fv.ek: Láncolt ábrázolás: For ciklussal:
Buborékrendezés: For ciklussal: Hanoi Tornyai: Asszimptótikus fv.ek: Láncolt ábr.: ha p egy mutató típusú változó akkor p^ az általa mutatott adatelem, p^.adat;p^.mut. A semmibe mutató ponter a NIL.Szabad
Felvételi vizsga mintatételsor Informatika írásbeli vizsga
BABEȘ BOLYAI TUDOMÁNYEGYETEM MATEMATIKA ÉS INFORMATIKA KAR A. tételsor (30 pont) Felvételi vizsga mintatételsor Informatika írásbeli vizsga 1. (5p) Egy x biten tárolt egész adattípus (x szigorúan pozitív
ADATSZERKEZETEK (VEREM, SOR)
ADATSZERKEZETEK (VEREM, SOR) 1. ADATSZERKEZET FOGALMA Az adatszerkezet egymással kapcsolatban álló adatok összessége, amelyen meghatározott, az adatszerkezetre jellemző műveletek végezhetők el. Az adatok
Programozási módszertan. Mohó algoritmusok
PM-08 p. 1/17 Programozási módszertan Mohó algoritmusok Werner Ágnes Villamosmérnöki és Információs Rendszerek Tanszék e-mail: werner.agnes@virt.uni-pannon.hu PM-08 p. 2/17 Bevezetés Dinamikus programozás
C# osztályok. Krizsán Zoltán
C# osztályok Krizsán Zoltán Fogalma Önálló hatáskőrrel rendelkező, absztrakt adattípus, amely több, különböző elemet tartalmazhat. Minden esetben a heap-en jön létre! A programozó hozza létre, de a GC
Algoritmuselmélet 2. előadás
Algoritmuselmélet 2. előadás Katona Gyula Y. Budapesti Műszaki és Gazdaságtudományi Egyetem Számítástudományi Tsz. I. B. 137/b kiskat@cs.bme.hu 2002 Február 12. ALGORITMUSELMÉLET 2. ELŐADÁS 1 Buborék-rendezés
C programozási nyelv Pointerek, tömbök, pointer aritmetika
C programozási nyelv Pointerek, tömbök, pointer aritmetika Dr. Schuster György 2011. június 16. C programozási nyelv Pointerek, tömbök, pointer aritmetika 2011. június 16. 1 / 15 Pointerek (mutatók) Pointerek
Programozás alapjai 9.Gy: Struktúra 2.
Programozás alapjai 9.Gy: Struktúra 2. Ördögi részletek P R O A L A G 35/1 B ITv: MAN 2018.11.10 Euró árfolyam statisztika Az EURO árfolyamát egy negyedéven keresztül hetente nyilvántartjuk (HUF / EUR).
Adatszerkezetek Hasító táblák. Dr. Iványi Péter
Adatszerkezetek Hasító táblák Dr. Iványi Péter 1 Hash tábla A bináris fáknál O(log n) a legjobb eset a keresésre. Ha valamilyen közvetlen címzést használunk, akkor akár O(1) is elérhető. A hash tábla a
Programozas 1. Strukturak, mutatok
Programozas 1 Strukturak, mutatok Strukturak Tömb: több egyforma típusú változó együttese Struktúra: több különböző típusú de logikailag egybetartozó változó együttese, amelyet az egyszerű kezelhetőség
Programozás. C++ osztályok. Fodor Attila. Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.
Programozás C++ osztályok Fodor Attila Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010. április 8. Csak bázisosztályként használt/értelmezhető
Rekurzió. Dr. Iványi Péter
Rekurzió Dr. Iványi Péter 1 Függvényhívás void f3(int a3) { printf( %d,a3); } void f2(int a2) { f3(a2); a2 = (a2+1); } void f1() { int a1 = 1; int b1; b1 = f2(a1); } 2 Függvényhívás void f3(int a3) { printf(
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ű
1. ábra. Egy rekurzív preorder bejárás. Egy másik rekurzív preorder bejárás
Preorder ejárás Fa bejárásán olyan algoritmust értünk, amelynek bemenete egy F fa és egy M művelet, és az algoritmus adott sorrendben pontosan egyszer végrehajtja az M műveletet a fa pontjaiban lévő adatokra.
Algoritmizálás + kódolás C++ nyelven és Pascalban
Algoritmizálás + kódolás nyelven és ban Motiváció A Programozási alapismeretek tárgyban az algoritmizáláshoz struktogramot, a kódoláshoz nyelvet használunk, a Közismereti informatikában (a közoktatásban
C programozás. { Márton Gyöngyvér, 2009 } { Sapientia, Erdélyi Magyar Tudományegyetem } http://www.ms.sapientia.ro/~mgyongyi
C programozás Márton Gyöngyvér, 2009 Sapientia, Erdélyi Magyar Tudományegyetem http://www.ms.sapientia.ro/~mgyongyi 1 Könyvészet Kátai Z.: Programozás C nyelven Brian W. Kernighan, D.M. Ritchie: A C programozási
Adatszerkezet - műveletek
Adatszerkezet - műveletek adatszerkezet létrehozása adat felvétele adat keresése adat módosítása adat törlése elemszám visszaadása minden adat törlése (üresít) adatszerkezet felszámolása (megszüntet) +
Programozás 6. Dr. Iványi Péter
Programozás 6. Dr. Iványi Péter 1 Előfeldolgozás része Makrók A forrás kódban elvégzi a helyettesítéseket a fordító Csak egyszer végez helyettesítést Nem olyan makrók, mint a LISP vagy Scheme esetén Csak
Programozás II. 2. Dr. Iványi Péter
Programozás II. 2. Dr. Iványi Péter 1 C++ Bjarne Stroustrup, Bell Laboratórium Első implementáció, 1983 Kezdetben csak precompiler volt C++ konstrukciót C-re fordította A kiterjesztés alapján ismerte fel:.cpp.cc.c
Algoritmizálás. Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar
Algoritmizálás Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar horvath@inf.u-szeged.hu 0.1. Az algoritmikus tudás szintjei Ismeri (a megoldó algoritmust) Érti Le tudja pontosan
Programozási segédlet
Programozási segédlet Programozási tételek Az alábbiakban leírtam néhány alap algoritmust, amit ismernie kell annak, aki programozásra adja a fejét. A lista korántsem teljes, ám ennyi elég kell legyen
Adatszerkezetek Bevezetés Adatszerkezet Adatszerkezet típusok Műveletek Bonyolultság
datszerkezetek Bevezetés datszerkezet adatok rendszerének matematikai, logikai modellje elég jó ahhoz, hogy tükrözze a valós kapcsolatokat elég egyszerű a kezeléshez datszerkezet típusok Tömbök lineáris
Adatszerkezetek és algoritmusok
2009. november 20. Bevezet El z órák anyagainak áttekintése Ismétlés Adatszerkezetek osztályozása Sor, Verem, Lengyelforma Statikus, tömbös reprezentáció Dinamikus, láncolt reprezentáció El z órák anyagainak
... fi. ... fk. 6. Fabejáró algoritmusok Rekurzív preorder bejárás (elsőfiú-testvér ábrázolásra)
6. Fabejáró algoritmusok Fa bejárásán olyan algoritmust értünk, amelynek bemenete egy F fa és egy M művelet, és az algoritmus adott sorrendben pontosan egyszer végrehajtja az M műveletet a fa pontjaiban
2. Milyen értéket határoz meg az alábbi algoritmus, ha A egy vektor?. (2 pont)
A Név: l 2017.04.06 Neptun kód: Gyakorlat vezet : HG BP l 1. Az A vektor tartalmát az alábbi KUPACOL eljárással rendezzük át maximum kupaccá. A={28, 87, 96, 65, 55, 32, 51, 69} Mi lesz az értéke az A vektor
1. Feladat: beolvas két számot úgy, hogy a-ba kerüljön a nagyobb
1. Feladat: beolvas két számot úgy, hogy a-ba kerüljön a nagyobb #include main() { int a, b; printf( "a=" ); scanf( "%d", &a ); printf( "b=" ); scanf( "%d", &b ); if( a< b ) { inttmp = a; a =
C programozás. 6 óra Függvények, függvényszerű makrók, globális és
C programozás 6 óra Függvények, függvényszerű makrók, globális és lokális változók 1.Azonosítók A program bizonyos összetevőire névvel (azonosító) hivatkozunk Első karakter: _ vagy betű (csak ez lehet,
Programozás C és C++ -ban
Programozás C és C++ -ban 2. További különbségek a C és C++ között 2.1 Igaz és hamis A C++ programozási nyelv a C-hez hasonlóan definiál néhány alap adattípust: char int float double Ugyanakkor egy új
Járműfedélzeti rendszerek II. 2. előadás Dr. Bécsi Tamás
Járműfedélzeti rendszerek II. 2. előadás Dr. Bécsi Tamás 4.11. A C előfeldolgozó rendszer A fordítás első lépése a C esetében a különböző nyelvi kiterjesztések feldolgozása: másik állomány tartalmának
Bevezetés, a C++ osztályok. Pere László
Programozás módszertan II. p. Programozás módszertan II. Bevezetés, a C++ osztályok Pere László (pipas@linux.pte.hu) PÉCSI TUDOMÁNYEGYETEM TERMÉSZETTUDOMÁNYI KAR INFORMATIKA ÉS ÁLTALÁNOS TECHNIKA TANSZÉK
Szövegek C++ -ban, a string osztály
Szövegek C++ -ban, a string osztály A string osztály a Szabványos C++ könyvtár (Standard Template Library) része és bár az objektum-orientált programozásról, az osztályokról, csak később esik szó, a string
Algoritmusok és adatszerkezetek gyakorlat 07
Algoritmusok és adatszerkezetek gyakorlat 0 Keresőfák Fák Fa: összefüggő, körmentes gráf, melyre igaz, hogy: - (Általában) egy gyökér csúcsa van, melynek 0 vagy több részfája van - Pontosan egy út vezet
7 7, ,22 13,22 13, ,28
Általános keresőfák 7 7,13 13 13 7 20 7 20,22 13,22 13,22 7 20 25 7 20 25,28 Általános keresőfa Az általános keresőfa olyan absztrakt adatszerkezet, amely fa és minden cellájában nem csak egy (adat), hanem
STL. Algoritmus. Iterátor. Tároló. Elsődleges komponensek: Tárolók Algoritmusok Bejárók
STL Elsődleges komponensek: Tárolók Algoritmusok Bejárók Másodlagos komponensek: Függvény objektumok Adapterek Allokátorok (helyfoglalók) Tulajdonságok Tárolók: Vektor (vector) Lista (list) Halmaz (set)