PODATKOVNI TIPI V JEZIKU C Osnovni podatkovni tipi

PODATKOVNI TIPI V JEZIKU C++ Osnovni podatkovni tipi Sestavljeni podatkovni tipi Celoštevilčni: Izpeljani: - int (zasede 4 zloge) - kazalci (4 zloge) - short (2 zloga) - reference - long (4 zloge) Znakovni: - char (1 zlog) Homogeni: - polja Nehomogeni: Realni: - strukture - float (4 zloge) - unije - double (8 zlogov) - long double (8 zlogov) Naštevni: - enum (4 zloge) Logični: - bool (1 zlog)

POLJA Polje je zaporedje vrednosti istega tipa, ki jim damo eno ime. Posamezne vrednosti oziroma elemente polja dosegamo z indeksom. Definiramo lahko polja poljubnih tipov (polje celih števil, polje realnih števil, polje znakov, polje struktur, polje polj, itd. ). POMNILNIK Fizični naslovi Vsebina Logični naslovi Polje je sestavljeni podatkovni tip, sestavljen iz elementov istega tipa. Deklaracija polja in dostop do elementov Pri deklaraciji polja se za shranjevanje elementov polja v pomnilniku rezervira ustrezno število sosednjih pomnilniških celic. Zato moramo določiti velikost polja, to je število, ki pove, koliko elementov polje vsebuje. Npr. z deklaracijo int test[4] test[3] test[2] test[1] test = 0 x 0012 fe 84 določimo polje test s štirimi elementi tipa int. Pri tem imajo elementi polja nedoločene vrednosti. Do elementov polja dostopamo tako, da za imenom polja zapišemo indeks v oglatem oklepaju. Vrednost izraza, ki predstavlja indeks, mora biti celoštevilčnega tipa. Indeks polja mora biti v območju [0, velikost polja-1], v našem primeru v območju [0, 3]. test[0] = 238; Zaslon 238 test[0]

POLJA int _tmain(int argc, _TCHAR* argv[]) { int test[4]; test[0] = 10; test[1] = 5; test[2] = 3; test[3] = 200; int vsota; vsota = test[0] + test[1] + test[2] + test[3]; printf("Vsota elementov polja je: %dn“, vsota); return 0; } Pri deklaraciji polja določimo podatkovni tip elementov polja, ime polja ter število elementov polja. Ime polja je konstantni kazalec, ki vsebuje fizični naslov prve lokacije prvega elementa polja. Pri deklaraciji polja prevajalnik dodeli začetni naslov in zadostno količino pomnilnika, kjer bodo shranjeni elementi polja. Začetni naslov polja je začetna lokacija v pomnilniku, kjer je polje shranjeno, in hkrati naslov prvega elementa polja (elementa z indeksom 0). POMNILNIK Fizični naslovi int test[4] = {8, 7, 6, 4}; Logični naslovi 200 test[3] 3 test[2] 5 test[1] test = 0 x 0012 fe 84 10 test[0] 0 x 0012 fe 80 218 vsota Zaslon Inicializacija polja pomeni, da poleg definicije polja navedemo še vrednosti elementov, s katerimi polje napolnimo. Polje torej lahko inicializiramo tako, da med zavitimi oklepaji naštejemo vrednosti elementov, ki jih ločimo z vejicami. Vsebina

POLJA Prenos polja v funkcijo const int vel_polja = 4; int Sestej(int polje[vel_polja]) { int vsota=0; for (int i=0; i<vel_polja; i++) vsota += polje[i]; return vsota; } int _tmain(int argc, _TCHAR* argv[]) { int prvo[vel_polja]; int drugo[vel_polja]; POMNILNIK Fizični naslovi 0 x 0014 a 960 Vsebina 4 Logični naslovi vel_polja prvo[3] prvo[2] prvo[1] prvo = 0 x 0012 fe 84 prvo[0] drugo[3] drugo[2] drugo[1] randomize(); drugo = 0 x 0012 fe 74 for (int i=0; i<vel_polja; i++) { prvo[i] = random(31); drugo[i] = prvo[i] * prvo[i]; } Zaslon printf("Prvo polje: %d %dn", prvo[0], prvo[1], prvo[2], prvo[3]); printf("Drugo polje: %d %dn", drugo[0], drugo[1], drugo[2], drugo[3]); printf("Vsota stevil je %dn", Sestej(prvo)); printf("Vsota kvadratov je %dn", Sestej(drugo)); return 0; } drugo[0]

POLJA POMNILNIK Prenos polja se vedno izvaja po referenci. Vrednosti, ki jih v funkciji Fizični spremenimo v polju, ostanejo spremenjene tudi po zaključku funkcije naslovi Če želimo polje prenesti v funkcijo, kot dejanski argument zapišemo ime polja: Sestej(prvo), formalni argument funkcije Sestej() pa 0 x 0014 a 960 zapišemo enako kot definiramo polje: int Sestej(int polje[vel_polja]) Ob klicu funkcije se torej opravi deklaracija reference polja, ki ga navedemo kot dejanski argument pri klicu funkcije. (Npr. : int polje[vel_polja] = prvo; // oz. polje = prvo) V funkciji Sestej() uporabljamo konstantno spremenljivko vel_polja in jo zato definiramo globalno. Vemo, da lahko kazalcem prištevamo cela števila. Če mu prištejemo vrednost 1, se bo kazalec premaknil za toliko zlogov, kolikor je velikost tipa, na katerega kaže. Zapis (polje+i) pravzaprav pomeni polje = (polje+i*sizeof(int)). Programerju torej ni potrebno skrbeti za pravilno 0 x 0012 fe 74 premikanje kazalca ne glede na to, katerega podatkovnega tipa so elementi polja. Nad kazalci lahko izvajamo dve aritmetični operaciji. Prištevamo in 0 x 0012 fe 70 odštevamo jim lahko cela števila ter jih med seboj odštevamo. Če 0 x 0012 fe 6 c kazalcu prištejemo ali od njega odštejemo celo število, dobimo novi kazalec, pri odštevanju dveh kazalcev pa dobimo celo število, 0 x 0012 fe 68 ki pove razdaljo med kazalcema. int _tmain(int argc, _TCHAR* argv[]) { const int velikost = 5; int polje[velikost] = {1, 100, 10000}; int *zac_naslov = polje; // oz. &polje[0] int *konc_naslov = &polje[velikost-1]; int st_elementov = konc_naslov - zac_naslov + 1; printf("%dn", st_elementov); return 0; } Zaslon Vsebina Logični naslovi 5 velikost 10000 polje[4] 100 polje[3] 100 polje[2] 10 polje[1] 1 polje[0] 0 x 0012 fe 74 zac_naslov 0 x 0012 fe 84 konc_naslov 5 st_elementov

PODATKOVNI TIPI V JEZIKU C++ Osnovni podatkovni tipi Sestavljeni podatkovni tipi Celoštevilčni: Izpeljani: - int (zasede 4 zloge) - kazalci (4 zloge) - short (2 zloga) - reference - long (4 zloge) Znakovni: - char (1 zlog) Homogeni: - polja Nehomogeni: Realni: - strukture - float (4 zloge) - unije - double (8 zlogov) - long double (8 zlogov) Naštevni: - enum (4 zloge) Logični: - bool (1 zlog)

STRUKTURE POMNILNIK Struktura omogoča združitev podatkov različnega podatkovnega tipa v skupni objekt novega podatkovnega tipa. S strukturami združimo sorodne podatke pod enim imenom in jih nato obravnavamo kot celoto, ki vsebuje posamezne elemente, komponente oz. člene. Podatkom lahko še dodamo metode (funkcije), ki se izvajajo nad temi podatki. Sintaksa: struct ime_strukture { podatkovni_tip element 1; podatkovni_tip element 2; podatkovni_tip element 3; } ime_objekta 1, ime_objekta 2; Fizični naslov 2; moj_naslov. post. St = 2390; naslov 2. post. St = 2380; Logični naslovi moj_naslov. mesto moj_naslov. ulica 0 x 0012 ff 40 2390 moj_naslov. post. St naslov 2. mesto Do posamezne komponente strukture dostopamo z izrazom ime_objekta. komponenta. Strukturni operator “. ” naredi povezavo med imenom objekta in njegovo komponento. 0 x 0012 fe 84 Primer: struct naslov { char mesto[20]; char ulica[20]; int post. St; } moj_naslov; Vsebina Zaslon naslov 2. ulica 2380 naslov 2. post. St

STRUKTURE Prenos strukture v funkcijo Primer: enum spol {moski, zenski}; struct datum { int dan; int mesec; int leto; }; struct oseba { char ime_o[20]; spol_o; char naslov_o[30]; datum_r; }; void Izpisi. Osebo(oseba); void Izpisi. Osebo(oseba nekdo) { printf("Ime osebe: %sn", nekdo. ime_o); printf("Spol: %sn", ((nekdo. spol_o == moski)? "moski": “zenski")); printf("Naslov: %sn", nekdo. naslov_o); datum_r = nekdo. datum_r; printf("Datum rojstva: %d. %dn", datum_r. dan, datum_r. mesec, datum_r. leto); } int _tmain(int argc, _TCHAR* argv[]) { oseba sosed = {"Marko", moski, "Trg svobode 13", {25, 2, 1998}}; Izpisi. Osebo(sosed); oseba soseda = {"Klara", zenski, "Trg svobode 13", {6, 2, 1995}}; Izpisi. Osebo(soseda); oseba klon. Soseda; klon. Soseda = soseda; klon. Soseda. ime_o[4]='o'; klon. Soseda. spol_o=moski; Izpisi. Osebo(klon. Soseda); return 0; } POMNILNIK Fizični naslovi Vsebina Logični naslovi

STRUKTURE Kazalci na strukture Kot pri ostalih podatkovnih tipih lahko tudi pri strukturah uporabimo kazalce. Kazalec definiramo kot kazalec na objekt strukture ter ga inicializiramo s fizičnim pomnilniškim naslovom, kjer se objekt te strukture nahaja v pomnilniku. POMNILNIK Fizični naslovi Primer: #include<iostream. h> #include<stdlib. h> struct str_film { char naslov [70]; int leto; }; int _tmain(int argc, _TCHAR* argv[]) { char vmesnik[70]; str_film, *kaz_film; kaz_film = &film; printf("Naslov: "); cin. getline(kaz_film->naslov, 70); printf("Leto: "); cin. getline(vmesnik, 70); kaz_film->leto = atoi(vmesnik); printf("n. Vnesel si: %s (%d)n", kaz_film->naslov, kaz_film->leto); return 0; } Operator -> uporabljamo za dostop do posamezne komponente strukture, na katero kaže kazalec. Imenujemo ga dereferenčni operator. Namesto (*kaz_film). naslov lahko napišemo kaz_film->naslov. Zaslon Vsebina Logični naslovi

PODATKOVNI TIPI V JEZIKU C++ Osnovni podatkovni tipi Sestavljeni podatkovni tipi Celoštevilčni: Izpeljani: - int (zasede 4 zloge) - kazalci (4 zloge) - short (2 zloga) - reference - long (4 zloge) Znakovni: - char (1 zlog) Realni: - float (4 zloge) - double (8 zlogov) - long double (8 zlogov) Naštevni: - enum (4 zloge) Logični: - bool (1 zlog) Homogeni: - polja Nehomogeni: - strukture - unije

UNIJE, Bitna polja VARČEVANJE S SPOMINOM C++ nam omogoča varčevati s spominom na dva načina. Spremenljivke, ki obsegajo malo vrednosti, lahko opišemo s toliko biti, kot je to potrebno in nič več. Večje strukture pa lahko razbijemo glede na to, kaj trenutno lahko vsebujejo. Bitna polja Precej potratno je za spremenljivko, ki lahko zasede samo dve vrednosti, uporabiti tip char, ki lahko zasede 256 vrednosti. Zato lahko več takšnih spremenljivk povežemo v strukturo, ki bo zavzela toliko prostora, kot ga spremenljivke potrebujejo. Bitna polja definiramo preprosto kot strukture, katere elementi so vsi tipa unsigned int, le da vsakemu elementu dodamo še podatek, ki pove število bitov, ki jih bo ta podatek zasedel: struct tiskalnik { unsigned prost : 1; unsigned pise : 1; unsigned papir_vstavljen : 1; unsigned tip_papirja : 1; unsigned font : 3; } Unije so podobne strukturam, le da je v njih vedno veljaven le en element. Unija zasede vedno toliko prostora, kot ga zasede njen največji element: #include <iostream. h> struct complex { double re, im; }; union vrednost { int v_int; double v_dbl; complex v_cpx; }; void main() { vrednost v; printf("Velikost celotne unije: %dn", sizeof(vrednost)); printf("Velikost elementa int: %dn", sizeof(v. v_int)); printf("Vel. elementa double: %dn", sizeof(v. v_dbl)); printf("Vel. elementa complex: %dn", sizeof(v. v_cpx)); printf("Naslovi spremenljivk so: n"); printf("naslov v: %dn", &v); printf("naslov v. v_int: %dn", &v. v_int); printf("naslov v. v_dbl: %dn", &v. v_dbl); printf("naslov v. v_cpx: %dn", &v. v_cpx); printf("naslov v. v_cpx. re: %dn", &v. v_cpx. re); printf("naslov v. v_cpx. im: %dnn", &v. v_cpx. im); }

GENERIRANJE NAKLJUČNIH ŠTEVIL #include <stdlib. h> #include <stdio. h> #include <time. h> #define SPODNJA_M 65 #define ST_ELEM 26 Naključna števila se generirajo na osnovi trenutnega časa. Zato so generirana števila vedno drugačna. POMNILNIK Fizični naslovi Vsebina int main(void) { srand((unsigned)time(NULL)); // Prikaz 10 naključnih števil. int i; Običajno želimo for(i = 0; i < 10; i++) generirati števila znotraj printf(" %6 dn", rand()); printf("n"); nekega razpona. // Generiranje naključnih števil v razponu od 1 do 6: for (i = 0; i < 10; i++) { int rand 100 = (((double)rand() / (double)RAND_MAX) * 6 + 1); printf( " %6 dn", rand 100); } printf("n"); // Generiranje naključnih črk v razponu od A do Z: for (i = 0; i < 10; i++) { int rand 100 = (((double)rand() / (double)RAND_MAX) * ST_ELEM + SPODNJA_M); printf( " %6 cn", (char)rand 100); } } Logični naslovi Zaslon

Delo z datotekami Kaj je datoteka. Datoteka je osnovna organizacijska enota z računalnikom zapisanih podatkov, pri čemer je podatek vse, kar lahko zapišemo na pomnilniški nosilec. POMNILNIK Fizični naslovi Vsebina Logični naslovi Vsebina vsake datoteke je niz binarnih števil. Njen binarni prikaz je nepregledna množica ničel in enic. Bolj pregleden je njen šestnajstiški zapis, ker je vsak bajt predstavljen le z dvema šestnajstiškima števkama. Seveda bo nam najbolj razumljiv izpis datoteke v obliki ASCII znakov, vendar bo tak izpis smiseln le, če datoteka predstavlja besedilo. Vsaka datoteka ima svoje ime in zaseda določen prostor na disku. Lahko je različnega tipa – lahko vsebuje besedilo, lahko so izvršljive in podobno. Katerega tipa je datoteka, pa nam pove njena končnica, npr. . doc, . exe, . bmp itn. Pri delu z datotekami upoštevamo standardno zaporedje postopkov: 1. Deklariramo datotečni kazalec 2. Odpremo podatkovni tok in ga usmerimo proti datoteki 3. Beremo ali zapisujemo podatke (z zanko while) 4. Datoteko zapremo Zaslon

Delo z datotekami Primer: POMNILNIK Fizični naslovi char beseda[30]; FILE* tok 1; tok 1 = fopen("c: \test 1. txt", "rt"); while(! feof(tok 1)) { fscanf(tok 1, "%s", beseda); printf("%sn", beseda); } fclose(tok 1); Datoteko lahko odpremo v različnih načinih. Najpogostejši so: "r" - odpre datoteko za branje; če datoteka ne obstaja, vrne fopen vrednost NULL. "w" - odpre prazno datoteko za pisanje; če datoteka že obstaja, bo njena vsebina zbrisana. "a" - odpre datoteko za dodajanje teksta na konec; če datoteka ne obstaja, jo fopen ustvari. "r+" - odpre datoteko za branje in pisanje; datoteka mora obstajati. "w+" - odpre prazno datoteko za branje in pisanje; če datoteka že obstaja, bo njena vsebina uničena. Vsebina Logični naslovi

Delo z datotekami Nekatere funkcije (metode razreda FILE) za delo z datotekami: POMNILNIK Fizični naslovi fopen(…) – odpre datoteko, fclose(…) – zapre datoteko, feof(…) – ugotavlja konec datoteke, fscanf(…) – formatirano branje iz datoteke, fprintf(…) – formatirano pisanje v datoteko, rewind(…) – vrnitev datotečnega kazalca na začetek, fgetc(…) – branje enega znaka, fputc(…) – pisanje enega znaka, fread(…) – neformatirano branje, fwrite(…) – neformatirano pisanje, fgetpos(…) – vrne pozicijo datotečnega kazalca, fsetpos(…) – nastavi pozicijo datotečnega kazalca, … Vsebina Logični naslovi

Delo z datotekami POMNILNIK Fizični naslovi Vsebina Logični naslovi Še en primer programa: int _tmain(int argc, _TCHAR* argv[]) { int stevila[10] = {123, 231, 304, 512, 8, 65, 66, 67, 10, 13}; FILE* tok 1; tok 1 = fopen("c: \Zdravko\Šola\test 1. bin", "w"); fwrite(stevila, sizeof(int), 10, tok 1); fclose(tok 1); printf("Konecn"); return 0; } Zaslon

Urejanje podatkov Podatke v tabelah lahko uredimo na več možnih načinov: POMNILNIK Fizični naslovi Urejanje po metodi izbora najmanjšega elementa: • poiščemo najmanjše število v neurejeni tabeli, • postavimo ga na prvo mesto neurejenega dela tabele, hkrati pa število, ki je bilo do tedaj na prvem mestu neurejenega dela tabele, postavimo na mesto, na katerem smo našli najmanjše število v neurejeni tabeli, • neurejeni del tabele se s tem zmanjša za eno število, • to ponavljamo dokler v neurejenem delu tabele ne ostane samo eno število, ki je hkrati največje v urejeni tabeli. Vsebina Logični naslovi 5 DIM 66 stevila[4] 512 stevila[3] 123 stevila[2] 231 stevila[1] 304 stevila[0] #define DIM 5 void Uredi. Tabelo(int[], int); int Najmanjse(int[], int); int _tmain(int argc, _TCHAR* argv[]) { int stevila[DIM] = {304, 231, 123, 512, 66}; Uredi. Tabelo(stevila, DIM); for(int i = 0; i < DIM; i++) printf("%dn", stevila[i]); return 0; } Zaslon

Urejanje podatkov void Uredi. Tabelo(int tabela[], int dim) { int indeks, pom; for(int i = 0; i < dim-1; i++) { indeks = Najmanjse(tabela, dim, i); pom = tabela[i]; tabela[i] = tabela[indeks]; tabela[indeks] = pom; } } int Najmanjse(int polje[], int ki, int zi) { int naj. S = polje[zi]; int ind = zi; for(int j = zi+1; j < ki; j++) { if(polje[j] < naj. S) { naj. S = polje[j]; ind = j; } } return ind; } POMNILNIK Fizični naslovi Vsebina Logični naslovi 5 DIM, dim 66 stevila[4], tabela[4] 512 stevila[3], tabela[3] 123 stevila[2], tabela[2] 231 stevila[1], tabela[1] 304 stevila[0], tabela[0] indeks pom i Zaslon

Urejanje podatkov void Uredi. Tabelo(int tabela[], int dim) { int indeks, pom; for(int i = 0; i < dim-1; i++) { indeks = Najmanjse(tabela, dim, i); pom = tabela[i]; tabela[i] = tabela[indeks]; tabela[indeks] = pom; } } int Najmanjse(int polje[], int ki, int zi) { int naj. S = polje[zi]; int ind = zi; for(int j = zi+1; j < ki; j++) { if(polje[j] < naj. S) { naj. S = polje[j]; ind = j; } } return ind; } POMNILNIK Fizični naslovi Vsebina Logični naslovi 5 DIM, dim, ki 66 stevila[4], tabela[4], polje[4] 512 stevila[3], tabela[3], polje[3] 123 stevila[2], tabela[2], polje[2] 231 stevila[1], tabela[1], polje[1] 304 stevila[0], tabela[0], polje[0] indeks pom i, zi naj. S ind j Zaslon

Urejanje podatkov Urejanje po metodi mehurčkov (Bubble sort): POMNILNIK Fizični naslovi • začnemo na začetku tabele, primerjamo i-ti in i+1 -vi element tabele; če nista v predpisanem zaporedju, ju zamenjamo, • v enem prehodu skozi tabelo pomaknemo največje število na konec tabele, manjša števila pa pomikamo proti začetku tabele, • zgornja koraka ponavljamo dokler ni tabela urejena. Vsebina Logični naslovi 5 DIM 66 stevila[4] 512 stevila[3] 123 stevila[2] 231 stevila[1] 304 stevila[0] #define DIM 5 void Bubble(int[], int); int _tmain(int argc, _TCHAR* argv[]) { int stevila[DIM] = {304, 231, 123, 512, 66}; Bubble(stevila, DIM); for(int i = 0; i < DIM; i++) printf("%dn", stevila[i]); return 0; } Zaslon

Urejanje podatkov POMNILNIK Fizični naslovi void Bubble(int tabela[], int n) { int pom; for(int i = 0; i < n; i++) { for(int j = 0; j < n-1; j++) { if(tabela[j] > tabela[j+1]) { pom = tabela[j]; tabela[j] = tabela[j+1]; tabela[j+1] = pom; } } Vsebina Logični naslovi 5 DIM, n 66 stevila[4], tabela[4] 512 stevila[3], tabela[3] 123 stevila[2], tabela[2] 231 stevila[1], tabela[1] 304 stevila[0], tabela[0] pom i j Zaslon

Urejanje podatkov Urejanje z vstavljanjem: POMNILNIK Fizični naslovi Vse elemente od drugega mesta do konca tabele vstavimo na ustrezno mesto v urejeni del tabele. Vedno primerjamo vrednost elementa, ki ga vstavljamo z vsemi predhodnimi elementi v urejenem delu tabele. Pri tem vse večje elemente pomikamo za eno mesto v desno, da pridobimo prostor za vstavljanje na ustrezno mesto v urejenem delu tabele. Z ustreznim vstavljanjem enega elementa se urejeni del tabele poveča za ena. Vsebina Logični naslovi 5 DIM 66 stevila[4] 512 stevila[3] 123 stevila[2] 231 stevila[1] 304 stevila[0] #define DIM 5 void Uredi. Vstavi(int[], int); int _tmain(int argc, _TCHAR* argv[]) { int stevila[DIM] = {304, 231, 123, 512, 66}; Uredi. Vstavi(stevila, DIM); for(int i = 0; i < DIM; i++) printf("%dn", stevila[i]); return 0; } Zaslon

Urejanje podatkov void Uredi. Vstavi(int tabela[ ], int n) { int element; for(int i = 1; i < n; i++) { element = tabela[i]; for(int j = 0; j < i; j++) { if(element < tabela[j]) { for(int k = i-1; k >= j; k--) { tabela[k+1] = tabela[k]; } tabela[j] = element; break; } } POMNILNIK Fizični naslovi Vsebina Logični naslovi 5 DIM, n 66 stevila[4], tabela[4] 512 stevila[3], tabela[3] 123 stevila[2], tabela[2] 231 stevila[1], tabela[1] 304 stevila[0], tabela[0] element i i k Zaslon

Iskanje podatkov Podatke v tabelah lahko poiščemo na več načinov. Zaporedno iskanje: #define DIM 5 int Poisci. Zaporedno(int[], int); int _tmain(int argc, _TCHAR* argv[]) { int iskano. St = 123; int stevila[DIM] = {304, 231, 123, 512, 66}; int ind = Poisci. Zaporedno(stevila, DIM, iskano. St); if(ind >= 0) printf("%d je v tabeli na indeksu %dn", iskano. St, ind); else printf("%d ni v tabelin", iskano. St); return 0; } int Poisci. Zaporedno(int tabela[], int n, int stevilo) { int indeks; for(indeks = 0; indeks < n; indeks++) { if(tabela[indeks] == stevilo) return indeks; } return (-1); } POMNILNIK Fizični naslovi Vsebina Logični naslovi 5 DIM, n 66 stevila[4], tabela[4] 512 stevila[3], tabela[3] 123 stevila[2], tabela[2] 231 stevila[1], tabela[1] 304 stevila[0], tabela[0] 123 iskano. St, stevilo indeks Zaslon

Iskanje podatkov Podatke v tabelah lahko poiščemo na več načinov. Binarno iskanje: Pogoj za binarno iskanje je, da so elementi tabele urejeni po velikosti. Urejeno tabelo razdelimo enakomerno na dve polovici. Iskani podatek je lahko v prvi ali drugi polovici. Ustrezno polovico tabele izberemo s pomočjo primerjave iskanega podatka s sredinskim elementom tabele. Tako izločimo polovico tabele. Iskanje nadaljujemo na isti način v izbrani polovici. V dveh korakih izločimo tri četrtine podatkov. Postopek ponavljamo dokler ne najdemo števila, ki ga iščemo ali dokler ne ugotovimo, da iskanega števila ni v tabeli. POMNILNIK Fizični naslovi Vsebina 5 Logični naslovi DIM 512 stevila[4] 304 stevila[3] 231 stevila[2] 123 stevila[1] 66 stevila[0] 304 iskano. St ind #define DIM 5 int Poisci. Binarno(int[], int); int _tmain(int argc, _TCHAR* argv[]) { int iskano. St = 304; int stevila[DIM] = {66, 123, 231, 304, 512}; int ind = Poisci. Binarno(stevila, DIM, iskano. St); if(ind >= 0) printf("%d je v tabeli na indeksu %dn", iskano. St, ind); else printf("%d ni v tabelin", iskano. St); return 0; } Zaslon

Iskanje podatkov int Poisci. Binarno(int tabela[ ], int n, int stevilo) { int sredina; int spodaj = 0; int zgoraj = n-1; while(spodaj <= zgoraj) { sredina = (spodaj+zgoraj)/2; if(stevilo > tabela[sredina]) spodaj = sredina + 1; else if(stevilo < tabela[sredina]) zgoraj = sredina; else return sredina; } return (-1); } POMNILNIK Fizični naslovi Vsebina 5 Logični naslovi DIM, n 512 stevila[4], tabela[4] 304 stevila[3], tabela[3] 231 stevila[2], tabela[2] 123 stevila[1], tabela[1] 66 stevila[0], tabela[0] 304 iskano. St, stevilo sredina spodaj zgoraj Zaslon

REKURZIJA Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: POMNILNIK Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) Zaslon

REKURZIJA Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: POMNILNIK Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) 3* fakt(3) Zaslon

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) Zaslon 3* fakt(3) 2* fakt(2)

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) Zaslon 3* fakt(3) 2* fakt(2) 1 fakt(1)

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) Zaslon 3* fakt(3) 2* 1 fakt(2) fakt(1) 1

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* fakt(4) Zaslon 3* 2* fakt(3) 1 fakt(2) 2 fakt(1) 1

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* Zaslon 3* fakt(4) 2* fakt(3) 6 1 fakt(2) 2 fakt(1) 1

REKURZIJA POMNILNIK Rekurzivne funkcije so takšne funkcije, ki kličejo same sebe. Uporabljamo jih takrat, ko lažje izrazimo rešitev problema tako, da se pri rešitvi sklicujemo na rešitev samo. Primer Faktoriela (rekurzivna definicija): n! = n * (n-1) * (n-2) * … * 3 * 2 * 1 To lahko zapišemo tudi na drugi način: n * (n-1) * (n-2) * … * 3 * 2 * 1 = n * (n-1)! Po predpostavki, da je 1! enaka 1 lahko zapišemo naslednji program: Fizični naslovi Vsebina Logični naslovi int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fakt(4)); return 0; } int fakt(int n) { if (n == 1) return 1; return n * fakt(n - 1); } 4* 3* fakt(4) 24 Zaslon 2* fakt(3) 6 1 fakt(2) 2 fakt(1) 1

REKURZIJA Naloga: POMNILNIK Fizični naslovi Vsebina Logični naslovi 1. Napišite rekurzivno funkcijo, ki poišče vsoto N celih števil. 2. Napišite rekurzivno funkcijo, ki vpisana števila izpiše v obratnem vrstnem redu. Zaslon

DREVESNA REKURZIJA Oglejmo si zaporedje Fibonaccijevih števil: 0, 1, 1, 2, 3, 5, 8, 13, 21, . . . To zaporedje je definirano z naslednjo enačbo: fib(n) = fib(n - 1) + fib(n - 2) Pri tem velja, da je fib(0) = 0 in fib(1) = 1 POMNILNIK Fizični naslovi Vsebina Logični naslovi Program, ki računa Fibonaccijeva števila je naslednji: int _tmain(int argc, _TCHAR* argv[]) { printf("%dn", fib(5)); return 0; } int fib(int n) { if(n <= 0) return 0; else if(n == 1) return 1; else return fib(n - 1) + fib(n - 2) ; } Zaslon

DREVESNA REKURZIJA fib(5)

DREVESNA REKURZIJA fib(5) fib(4) fib(3)

DREVESNA REKURZIJA fib(5) fib(4) fib(3)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(0) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(0) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(0) 1 fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) fib(0) 1 fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) 1 1 fib(0) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) 1 1 fib(0) fib(1) fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) 1 fib(0) 1 0 fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) 1 fib(0) 1 0 fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) fib(2) fib(1) 1 0 fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) 1 fib(1) 1 0 fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) 1 fib(1) 1 0 fib(2)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) 1 fib(2) fib(1) 1 0 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) 1 fib(2) fib(1) 1 0 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) fib(3) 1 fib(2) 1 1 0 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1 fib(1) fib(0)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1 fib(1) fib(0)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1 fib(1) fib(0) 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 fib(2) 1 1 0 1 fib(1) fib(0) 1

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 fib(2) 1 1 fib(0)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 fib(2) 1 1 fib(0)

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 fib(2) 1 1 fib(0) 1 1 0

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 fib(2) 1 1 fib(0) 1 1 0

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 fib(2) 1 1 0

DREVESNA REKURZIJA fib(5) fib(3) fib(4) 2 1 1 0 1 1 1 0

DREVESNA REKURZIJA fib(5) fib(3) 3 2 1 1 0 1 1 1 0

DREVESNA REKURZIJA fib(5) fib(3). . . 3 2 1 1 0 1 1 1 0

DREVESNA REKURZIJA fib(5) fib(3) 3 2 1 1 0 1 0 1

DREVESNA REKURZIJA fib(5) 2 3 2 1 1 0 1 0 1

DREVESNA REKURZIJA 5 2 3 2 1 1 0 1 0 1