Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (int). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog.

Napisati dodatnu funkciju koja e uveati za 10 sve lanove dok ne doe do lana sa vrijednou 0. Taj lan, i sve lanove nakon njega e umanjiti za 10. Funkcija stogu smije pristupati samo preko funkcija za rad sa stogom (ne smije direktno pristupati elementima polja). Dozvoljeno je koritenje pomonog stoga. Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(int zapis, int stog[], int n, int *vrh); int skini(int *zapis, int stog[], int *vrh);

int f1(int stog[], int *vrh) { int pomstog[MAXSTOG]; int pomvrh=-1; int element; while( skini(&element, stog, vrh)!=0) { if(element==0) { dodaj((element-10), pomstog, MAXSTOG, &pomvrh); while( skini(&element, stog, vrh)!=0) dodaj((element-10),pomstog, MAXSTOG, &pomvrh); } else dodaj((element+10),pomstog, MAXSTOG &pomvrh); } while(skini(&element, pomstog, &pomvrh)==1) dodaj(element, stog, MAXSTOG, vrh); return 1; }
/************************************************************************ int f2(int stog[], int *vrh) { int pomstog[MAXSTOG]; int pomvrh=-1; int element; do{ skini(stog,vrh,&element); if(element==0){ dodaj(pomstog,&pomvrh,element-10); break; } dodaj(pomstog,&pomvrh,element+10); } while(element!=0); while(skini(stog,vrh,&element)) dodaj(pomstog,&pomvrh,element-10); while(skini(pomstog,&pomvrh,&element)) dodaj(stog,vrh,element); return 1; } *********************************************/

Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (int). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog. Napisati dodatnu funkciju koja e iz zadanog stoga izbaciti sve negativne lanove, a sve pozitivne uveati za 1. Ta funkcija stogu smije pristupati samo preko funkcija za rad sa stogom (ne smije direktno pristupati elementima polja). Dozvoljeno je koritenje pomonog stoga. Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(int zapis, int stog[], int n, int *vrh); int skini(int *zapis, int stog[], int *vrh); int f3(int stog[], int *vrh) { int pomstog[MAXSTOG]; int pomvrh=-1; int element; while( skini(&element, stog, vrh) ==1 ) { if(element>0) dodaj(element+1, pomstog, MAXSTOG, &pomvrh); } while( skini(&element, pomstog, &pomvrh)!=0) dodaj(element, stog, MAXSTOG, vrh); return 1; }

Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (int). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog. Napisati dodatnu funkciju koja e iz zadanog stoga izbaciti sve pozitivne lanove. Ta funkcija stogu smije pristupati samo preko funkcija za rad sa stogom (ne smije direktno pristupati elementima polja). Dozvoljeno je koritenje pomonog stoga. Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(int zapis, int stog[], int n, int *vrh); int skini(int *zapis, int stog[], int *vrh);

int f4(int stog[], int *vrh) { int pomstog[MAXSTOG]; int pomvrh=-1; int element; while( skini(&element, stog, vrh) !=0) { if(element<=0) dodaj(element, pomstog, MAXSTOG, &pomvrh); } while(skini(&element, pomstog, &pomvrh)==1) dodaj(element, stog, MAXSTOG, vrh); return 1; }

Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (long). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog. Napisati dodatnu funkciju koja e iz zadanog stoga izbaciti sve nule. Ta funkcija stogu smije pristupati samo preko funkcija za rad sa stogom (ne smije direktno pristupati elementima polja). Dozvoljeno je koritenje pomonog stoga. Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(long zapis, long stog[], int n, int *vrh); int skini(long *zapis, long stog[], int *vrh); int f5(long stog[], int *vrh) { long pomstog[MAXSTOG]; int pomvrh=-1; long element; while( skini(&element, stog, vrh) ==1 ) { if(element!=0) dodaj(element, pomstog, MAXSTOG, &pomvrh); } while( skini(&element, pomstog, &pomvrh)!=0) dodaj(element, stog, MAXSTOG, vrh); return 1; } Napisati funkciju koja e koritenjem pomonog stoga prebrojati sve stavke koje su negativni brojevi . Nakon obavljanja funkcije na stog treba ostati nepromijenjen. Funkcija treba vratiti broj negativnih elemenata . Koristiti funkcije dodaj i skini zadanih prototipova (pretpostaviti da funkcije postoje): int dodaj(float stavka, float stog[], int n, int *vrh); int skini(float *stavka, float stog[], int *vrh); int f6(float stog[], int *vrh) { float pomstog[MAXSTOG]; int pomvrh=-1; float element; int brojNegativnih; brojNegativnih=0; while( skini(&element, stog, vrh) ==1 ) { if(element<0) brojNegativnih++; dodaj(element, pomstog, MAXSTOG, &pomvrh); } while( skini(&element, pomstog, &pomvrh)!=0) dodaj(element, stog, MAXSTOG, vrh);

return brojNegativnih; }

Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (int). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog. Napisati dodatnu funkciju koja e preurediti stog tako da svi pozitivni elementi budu iznad svih negativnih elemenata. Dozvoljeno je unutar funkcije koistiti jedan ili vie pomonih stogova, ali za pristup i rad sa stogom se mogu koristiti samo funkcije skini() i dodaj(). Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(int zapis, int stog[], int n, int *vrh); int skini(int *zapis, int stog[], int *vrh);

int f7(int stog[], int *vrh) { int pomStogPoz[MAXSTOG], pomVrhPoz=-1; int pomStogNule[MAXSTOG], pomVrhNule=-1; int pomStogNeg[MAXSTOG], pomVrhNeg=-1; int element; while( skini(&element, stog, vrh) !=0) { if(element>0) dodaj(element, pomStogPoz, MAXSTOG, &pomVrhPoz); if(element==0) dodaj(element, pomStogNule, MAXSTOG, &pomVrhNule); if(element<0) dodaj(element, pomStogNeg, MAXSTOG, &pomVrhNeg); } while( skini(&element, pomStogNeg, &pomVrhNeg)) dodaj(element, stog, MAXSTOG, vrh); while( skini(&element, pomStogNule, &pomVrhNule)) dodaj(element, stog, MAXSTOG, vrh); while( skini(&element, pomStogPoz, &pomVrhPoz)) dodaj(element, stog, MAXSTOG, vrh); return 1; }

Stog realiziran poljem sadri zapise oblika: ifra kamiona (int), preeni broj kilometara (int). Pretpostavite da su ve napisane funkcije za dodavanje i skidanje elemenata sa stoga, te pomou njih realizirajte funkciju koja vraa prosjean broj preenih kilometara za podatke na stogu. Prototipi funkcija za dodavanje i skidanje elemenata na stogu su: int dodaj(zapis stavka, zapis stog[], int n, int *vrh); int skini(zapis *stavka, zapis stog[], int *vrh);

struct s { int sifVozila; int pBrKm; }; typedef struct s zapis; . . . float prosjekKm(zapis stog[], int *vrh) { zapis pomstog[MAXSTOG]; zapis element; int pomvrh=-1; int pBrKmSvihVozila=0; int brVozila=0; while( skini(&element, stog, vrh)!=0) { pBrKmSvihVozila += element.pBrKm; brVozila++; dodaj(element, pomstog, MAXSTOG, &pomvrh); } while(skini (&element, pomstog, &pomvrh)!=0) dodaj(element, stog, MAXSTOG, vrh); return (float)brKmSvihVozila/brVozila; }

Napisati funkciju koja e koritenjem pomonog stoga izbaciti sa stoga sve stavke koje su parni brojevi . Nakon obavljanja funkcije na stogu trebaju ostati neparni brojevi. Funkcija treba vratiti broj izbaenih elemenata . Koristiti funkcije dodaj i skini zadanih prototipova (pretpostaviti da funkcije postoje): int dodaj(float stavka, float stog[], int n, int *vrh); int skini(float *stavka, float stog[], int *vrh);

int f8(float stog[], int *vrh) { float pomstog[MAXSTOG]; int pomvrh=-1; float element; int brojIzbacenihElemenata=0;

//broj parnih;

while(skini (&element, stog, vrh)==1) { if( (element%2!=0) || (element==0) ) dodaj(element, pomstog, MAXSTOG, &pomvrh); else brojIzbacenihElemenata++; } while(skini (&element, pomstog, &pomvrh)) dodaj(element, stog, MAXSTOG, vrh); return brojIzbacenihElemenata; }

Na stog realiziran poljem spremaju se podaci cjelobrojnog tipa (int). Ve su napisane funkcije za skidanje sa stoga i stavljanje na stog. Napisati dodatnu funkciju koja e svim elementima stoga upisati vrijednost 0. Ta funkcija stogu smije pristupati samo preko funkcija za rad sa stogom (ne smije direktno pristupati elementima polja). Dozvoljeno je koritenje pomonog stoga. Prototipi funkcija za stavljanje i skidanje elemenata sa stoga su: int dodaj(zapis stavka, zapis stog[], int n, int *vrh); int skini(zapis *stavka, zapis stog[], int *vrh);

int stog_nule(int stog[], int *vrh) { int pomstog[MAXSTOG]; //ili int pomstog[n]; int pomvrh = -1; int pom_element; while( skini(&pom_element, stog, vrh) !=0) dodaj( (0/pom_element), pomstog, MAXSTOG, &pomvrh); //ili dodaj(0, pomstog, MAXSTOG, &pomvrh); while(skini(&pom_element, pomstog, &pomvrh)==1) dodaj(pom_element, stog, MAXSTOG, vrh); return 1; }

LISTE primjeri...
// DODAVANJE U LISTU //

typedef struct s{ int mbr; char ime[21]; struct s *sljed; } cvor; int dodajNaKraj(cvor **glava, int matBroj, char *imeStud) { cvor *p = *glava; cvor *novi; novi=(cvor*)malloc(sizeof(cvor)); if( novi == NULL ) return 0; novi->mbr = matBroj; strcpy(novi->ime, imeStud); novi->sljed = NULL; if( *glava == NULL ) // ako je prazna ide na pocetak { *glava=novi; return 1; } while( p->sljed != NULL ) p=p->sljed; p->sljed=novi; return 1; }

int dodajNaPocetak(cvor **glava, int matBroj, char *imeStud) { cvor *novi; novi=(cvor*)malloc(sizeof(cvor)); if(novi==NULL) return 0; novi->mbr = matBroj; strcpy(novi->ime, imeStud); novi->sljed = *glava; *glava = novi; return 1; }

int dodajUSortiranuListu(cvor **glava, int matBroj, char *imeStud) { cvor *novi; cvor *p = *glava; novi=(cvor *)malloc(sizeof(cvor)); if(novi==NULL) return 0; novi->mbr = matBroj; strcpy(novi->ime, imeStud); if( (*glava==NULL) || (p->mbr > matBroj) ) { novi->sljed = *glava; *glava = novi; return 1; } while( (p->sljed != NULL) && (p->sljed->mbr <= matBroj) ) p=p->sljed; novi->sljed=p->sljed; p->sljed=novi; return 1; }

// BRISANJE IZ LISTE

//

int obrisiPrvog(cvor **glava) { cvor *p = *glava; if(p==NULL) return 0;

*glava=p->sljed; free(p); return 1; }

int obrisiZadnjeg(cvor **glava) { cvor *p = *glava; cvor *pp = NULL; if( p == NULL ) return 0;

if( p->sljed == NULL ) { *glava = NULL; // ili *glava = p->sljed; free(p); return 1; } while( p->sljed != NULL ) { pp=p; p=p->sljed; } pp->sljed = NULL; free(p); return 1; }

int obrisiListu(cvor **glava) { cvor *p = *glava; if( *glava == NULL ) while( p != NULL ) { *glava = p->sljed; free(p); p = *glava; } return 1; } return 0;

int obrisiSveNeparne(cvor **glava) { cvor *p = *glava; cvor *pp = NULL; if( *glava == NULL ) while( ( p != NULL) && { *glava = p->sljed; free(p); p = *glava; } if(p == NULL) return 1; return 0; ( p->mbr %2 == 1) )

while( p->sljed != NULL ) { if( p->sljed->mbr %2 == 1 ) { pp=p; p=p->sljed; pp->sljed=p->sljed; free(p); p=pp; } else p=p->sljed; } return 1; }

int obrisiPrvogZadanog(cvor **glava, int matBroj) { cvor *p = *glava; cvor *pp = NULL; if( p == NULL ) return 0; if( p->mbr == matBroj ) { *glava = p->sljed; free(p); return 1; } while( p->sljed != NULL ) { pp=p; p=p->sljed; if( p->mbr == matBroj ) { pp->sljed = p->sljed; free(p); return 1; } } return 0; }

int obrisiPrvogZadanog (cvor **glava, int broj) { cvor *p = *glava; cvor *pp = NULL; if(p == NULL) return 0; //lista je prazna //

for( p; p!=NULL; p=p->sljed ) { if( p->mbr == matBroj ) break; pp=p; } if( p == NULL) { printf("Nije pronadjen niti jedan takav objekt!\n"); return 0; } if(pp == NULL) //brise prvog { *glava=p->sljed; free(p); return 1; } else // brise sa sredine ili zadnjeg { pp->sljed = p->sljed; free(p); return 1; } }

Zadana je jednostruko povezana lista iji zapis sadri ifru artikla (long), naziv artikla (50+1 znak) i koliinu na skladitu(int). Potrebno je napisati funkciju koja e svim elementima liste koliinu uveati za poveanje iz argumenta. Prototip je:
void uvecaj(cvor *glava, int povecanje);

struct s { long sifra; char naziv[51]; int kolicina; struct s *sljed; }; typedef struct s cvor; void uvecaj(cvor *glava, int povecanje) { cvor *p; for(p=glava; p!=NULL; p=p->sljed) p->kolicina = p->kolicina + povecanje; }

// drugi nacin // void uvecaj(cvor *glava, int povecanje) { cvor *p; p=glava; while( p ) // ili while( p != NULL ) // { p->kolicina += povecanje; p=p->sljed; } }

Zadana je jednostruko povezana lista iji zapis sadri ifru artikla (long), naziv artikla (50+1 znak) i koliinu na skladitu(int). Potrebno je napisati funkciju koja e samo prvom lanu liste koliinu uveati za poveanje iz argumenta. Prototip je:

void uvecajPrvi(cvor *glava, int povecanje) { if(glava == NULL) return; glava->kolicina += povecanje; }

Zadana je jednostruko povezana lista iji zapis sadri ifru artikla (long), naziv artikla (50+1 znak) i koliinu na skladitu(int). Potrebno je napisati funkciju koja e posljednjem lanu liste koliinu uveati za poveanje iz argumenta. Prototip je: void uvecajZadnjem(cvor *glava, int povecanje) { if(glava == NULL) return; while ( glava->sljed != NULL ) glava = glava->sljed; glava->kolicina += povecanje; }

void uvecajManjimOdNule(cvor *glava, int povecanje) { if ( glava == NULL ) return; while( glava != NULL ) { if( glava->kolicina < 0 ) glava->kolicina += povecanje; glava = glava->sljed; } }

int ukupnaKolicinaSvih (cvor *glava) { int suma=0; if( glava == NULL ) return; while( glava != NULL ) { suma = suma + glava->kolicina; glava=glava->sljed; } return suma; }

Zadana je jednostruko povezana lista iji zapisi sadre: ifru proizvoda (int), naziv proizvoda (20+1 znak) i cijenu proizvoda (float). Napisati funkciju koja e vratiti broj elemenata koji sadre zapise o proizvodima koji su skuplji od zadane cijene. Funkcija mora imati prototip: int preskupi (cvor *glava, float zadana_cijena);

typedef struct s{ int sifraProizvoda; char nazivProizvoda[21]; float cijena; struct s *sljed; } cvor; int preskupi (cvor *glava, float zadana_cijena) { int brojSkupljih=0; if( glava == NULL ) { printf("lista je prazna\n,"); return 0; } while( glava ) // while (glava != NULL) { if( glava->cijena > zadana_cijena ) brojSkupljih++; glava = glava->sljed; } return brojSkupljih; }

//

Jednostruko povezana lista u memoriji sadri statistike podatke o svim dosadanjim nastupima jednog tenisaa na turnirima. Element liste sadri ifru turnira (int) i broj pobjeda na tom turniru (int). Napisati rekurzivnu funkciju koja e vratiti ukupan broj pobjeda tog tenisaa na svim turnirima. typedef struct s { int sifraTurnira; int brPob; struct s *sljed; } cvor; int broj_pobjeda(cvor *glava) { if( glava == NULL ) return 0; return glava->brPob + broj_pobjeda( glava->sljed ); }

U jednostruko povezanu listu spremaju se podaci o tvrtkama. Svaki zapis sadri matini broj tvrtke (long), naziv tvrtke (40+1 znak), broj iro rauna (20+1 znak) i telefonski broj osobe za kontakt (15+1 znak). Lista NIJE sortirana. Napisati REKURZIVNU funkciju koja e pronai tvrtku sa zadanim matinim brojem u listi. Ako ta tvrtka postoji, funkcija vraa pokaziva na odgovarajui zapis, u protivnom funkcija vraa NULL. Definirati strukture potrebne za rjeenje zadatka i odrediti apriornu sloenost funkcije. Funkcija mora imati prototip:

zapis *nadji(zapis *glava, long mbr);

struct s{ long matBroj; char naziv[40+1]; char brZiroRacun[20+1]; char telKontakt[15+1]; struct s *sljed; }; typedef struct s zapis; zapis *nadji(zapis *glava, long mbr) { if( glava != NULL) { if( glava->matBroj == mbr ) return glava; else return nadji( glava->sljed, mbr ); } else return NULL; } Napisat rekurzivnu funkciju koja trai studenta sa zadanim matinim brojem kroz jednostruko povezanu listu. Prototip funkcije je: void traziStudenta(cvor *glava, int matBroj); void traziStudenta(cvor *glava, int matBroj) { if( glava == NULL) { printf("Nema!\n"); return; } if( glava->mbr == matBroj ) { printf("%d %c",glava->mbr, glava->spol); return; } traziStudenta(glava->sljed, matBroj); }

Zadana je jednostruko povezana lista iji zapis sadri ifru artikla (int) i koliinu na skladitu(int). Potrebno je napisati funkciju koja e dodati dva elementa sa podacima iz argumenta na poetak liste. Ukoliko je dodavanje uspijelo funkcija veaa 1, a inae 0. Prototip funkcije je:
int dodaj_dva(cvor **glava, int sif1, int kol1, int sif2, int kol2); //....................... typedef struct cv{ int sifraArtikla; int kolicina; struct cv *sljed; cvor;

int dodaj_dva(cvor **glava, int sif1, int kol1, int sif2, int kol2) { cvor *novi1, *novi2; novi1 = (cvor *)malloc(sizeof (cvor)); novi2 = (cvor *)malloc(sizeof (cvor)); if( (novi1 == NULL) return 0; || (novi2 == NULL) )

novi1->sifraArtikla = sif1; novi1->kolicina = kol1; novi2->sifraArtikla = sif2; novi2->kolicina = kol2; novi1->sljed = novi2; novi2->sljed = *glava; *glava = novi1; return 1; }

Zadana je jednostruko povezana lista iji zapis sadri ifru artikla (long), naziv artikla (50+1 znak) i koliinu na skladitu(int). Potrebno je napisati funkciju koja e vratiti koliinu zapisanu u predzadnjem elementu liste! Ako je lista prazna funkcija vraa -1.
int kol_predzadnji(cvor *glava) { cvor *pp; if( (glava == NULL) || (glava->sljed == NULL) ) return -1; while( glava->sljed != NULL ) { pp = glava; //prethodni glava = glava->sljed; } return pp->kolicina; }

typedef struct stablo { int broj; struct stablo *lijevo; struct stablo *desno; } cvor;

#include<deepSonic.h> #include<sonicAnxiety.h> . . . ninoid++; return ninoid;

int brSvihCv(cvor *korijen) { if(korijen) return 1 + brSvihCv(korijen->lijevo) + brSvihCv(korijen->desno); else return 0; }

int brList (cvor *korijen) { if(korijen) { if( (!korijen->lijevo) return 1; else

&&

(!korijen->desno)

return brList(korijen->lijevo) + brList(korijen->desno); } else return 0; }

int suma(cvor *korijen) { if(korijen) return korijen->broj + suma(korijen->lijevo) + suma(korijen->desno); else return 0; }

int brNep(cvor *korijen) { if(korijen) { if(korijen->broj%2!=0) return 1 + brNep (korijen->lijevo) + brNep(korijen->desno); else return brNep(korijen->lijevo) + brNep(korijen->desno); } else return 0; }

int brNeg(cvor *korijen) { if(korijen) { if(korijen->broj < 0) return 1 + brNeg(korijen->lijevo) + brNeg(korijen->desno); else return brNeg(korijen->lijevo) + brNeg(korijen->desno); } else return 0; }

int nijeList(cvor *korijen) { if(korijen) { if( (korijen->lijevo) || (korijen->desno) ) return 1 + nijeList(korijen->lijevo) + nijeList(korijen->desno); else return 0; } return 0; }

void ispisListovi(cvor *korijen) { if(korijen) { if( (!korijen->lijevo) && (!korijen->desno) ) printf("%d\n",korijen->broj); ispisListovi(korijen->lijevo); ispisListovi(korijen->desno); } else return; }

void ispisListovaVecihOd(cvor *korijen, int br) { if(korijen) { if( (!korijen->lijevo) && (!korijen->desno) if(korijen->broj > br) printf("%d\n", korijen->broj); ispisListovaVecihOd(korijen->lijevo, br); ispisListovaVecihOd(korijen->desno, br); } else return; }

void ispisSvihCvorovaManjihOd(cvor *korijen, int br) { if(korijen) { if(korijen->broj < br) printf("%d\n",korijen->broj); ispisSvihCvorovaManjihOd(korijen->lijevo, br); ispisSvihCvorovaManjihOd(korijen->desno, br); } else return; }

cvor *traziKrozSortirano(cvor *korijen, int br) { if(korijen) { if(korijen->broj < br) return traziKrozSortirano(korijen->desno, br); else if(korijen->broj > br) return traziKrozSortirano(korijen->lijevo, br); else return korijen; } return korijen; //NULL }

cvor *traziKrozCijeloStablo(cvor *korijen, int trazeniBroj) { if(korijen) { if(korijen->broj == trazeniBroj) return korijen; else if(traziKrozCijeloStablo(korijen->lijevo, trazeniBroj)) return traziKrozCijeloStablo(korijen->lijevo, trazeniBroj); else if(traziKrozCijeloStablo(korijen->desno, trazeniBroj)) return traziKrozCijeloStablo(korijen->desno, trazeniBroj); else return NULL; } return korijen; }

void uvecajSamoManjeOd(cvor *korijen, int povecanje, int uvijet) { if(korijen) { if(korijen->broj < uvijet) korijen->broj += povecanje; uvecajSamoManjeOd(korijen->lijevo, povecanje, uvijet); uvecajSamoManjeOd(korijen->desno, povecanje, uvijet); } else return; }

int f(cvor *korijen, int brojX) { if(korijen) { if(korijen->broj == brojX) return 1 +f(korijen->lijevo, brojX) + f(korijen->desno, brojX); else return f(korijen->lijevo, brojX) + f(korijen->desno, brojX); } else return 0; }

int maxList(cvor *korijen) { int maxlijevo, maxdesno; if(korijen) { if( (!korijen->lijevo) && (!korijen->desno) ) return korijen->broj; else{ maxlijevo=maxList(korijen->lijevo); maxdesno=maxList(korijen->desno); if(maxlijevo > maxdesno) return maxlijevo; else return maxdesno; } } return 0; }

void ispisZadanaDubina(cvor *korijen, int trenutnaDubina,int zadanaDubina) { if(korijen) { if(trenutnaDubina==zadanaDubina) printf("%d\n",korijen->broj); ispisZadanaDubina(korijen->lijevo,trenutnaDubina+1,zadanaDubina); ispisZadanaDubina(korijen->desno,trenutnaDubina+1,zadanaDubina); } }

int nadjiDubinu(cvor *korijen, int dubina, int trazeniBroj) { if(korijen) { if(korijen->broj < trazeniBroj) return nadjiDubinu(korijen->desno, dubina+1, trazeniBroj); else if(korijen->broj > trazeniBroj) return nadjiDubinu(korijen->lijevo, dubina+1, trazeniBroj); else return dubina; } return 0; }

int f (cvor *korijen) { if(korijen) { if( (!korijen->lijevo) && (!korijen->desno) ) return korijen->broj; return f(korijen->lijevo) + f(korijen->desno); } return 0; }

int f(cvor *korijen) { if(korijen) { if( (!korijen->lijevo) && (!korijen->desno) ) return 0; return korijen->broj + f(korijen->lijevo) + f(korijen->desno); } return 0; }

void obrisisve(cvor **glava) { if (*glava) { obrisisve(&(*glava)->lijevo); obrisisve(&(*glava)->desno); free(*glava); *glava=NULL; } }

REKURZIJA, primjeri...
Niz brojeva definiran je rekurzivno na slijedei nain: fn = n + 1 , za n <= 1 fn = (fn-1 + 1)* fn-2 , za n > 1. Napisati rekurzivnu funkciju koja e izraunati n-ti lan niza. Odrediti apriornu sloenost funkcije! long f(int n) { if( n < 2 ) return (n+1); return ( f(n-1) + 1 ) * f(n-2); } O(2n )

long pot(long x, long y) { if(y <= 0) return 1; return x * pot(x, y-1); }

int aNiz(int a0, int d, int n) { if( n == 0 ) return a0; return d + aNiz(a0, d, n-1); }

int faktorijele(int n) { if(n <= 1) return 1; return n * faktorijele(n - 1); }

void ispis1(int n1, int n2) { if(n1 <=n2) { ispis1(n1, n2-1); printf("%d\n"n2); } } void ispis2(int n1, int n2) { if(n1 <= n2) { printf("%d\n",n1); ispis2(n1+1, n2); } }

void ispis1(int n1, int n2) { if(n1 <= n2) { ispis1(n1+1,n2); printf("%d\n",n1); } } void ispis2(int n1, int n2) { if(n1 <= n2) { printf("%d\n",n2); ispis2(n1, n2-1); } }

Napisati rekurzivnu funkciju koja e prvo silazno, pa uzlazno ispisati brojeve od 1 do n:

float ispis(int n) { if( n >= 1 ) { printf("%d\n",n); ispis(n-1); printf("%d\n",n); } return 0.00 }

Niz brojeva definiran je rekurzivno na slijedei nain: f 0 = 1, f 1 = 2, f 2 = 3, f n = (f n-1 + f n-2)* f n-3 , za n > 2. Napisati rekurzivnu funkciju koja e izraunati n-ti lan niza. Odrediti apriornu sloenost funkcije. Funkcija mora imati prototip: long f(int n); long f(int n) { if( n <= 2 ) return (n+1); return ( } O(3n ) f(n-1) + f(n-2) ) * f(n-3);

Napisati rekurzivnu funkciju koja e izraunati umnoak dva broja a i b koristei se samo operacijom zbrajanja. Odrediti apriornu sloenost funkcije. Funkcija mora imati prototip: int puta(int a, int b); int puta(int a, int b) { if( b == 0 ) return 0; return a + puta( a, b -1 ); } O(1n ) ****O(1)

Napisati rekurzivnu funkciju koja izraunava umnoak znamenki zadanog broja (n.pr. uz(329)=3*2*9=54). Koristiti operatore cjelobrojnog dijeljenja integera (/) i modulo operator (%). Prototip funkcije je: int uz (int a) int uz(int a) { int b = a%10; if( a/10 == 0 ) return a; return b * uz( a/10 ); }

Napisati rekurzivnu funkciju koja e vratiti indeks najveeg lana polja A[ ] koje ima n lanova. Prototip funkcije je: int maxclan (int A[], int i, int n); int maxclan (int A[], int i, int n) { int imax; if( i >= n-1 ) return n-1; imax = maxclan(A, i+1, n); if( A[i] > A[imax]) // da je trebao indeks najmanjeg ( < ) return i; return imax; }

Napisati rekurzivnu funkciju koja izraunava najveu zajedniku mjeru dva broja. Koristiti Euklidov algoritam koji kae da je za dva broja, a i b, najvea zajednika mjera a ako je b = 0, a inae je to najvea zajednika mjera od b i ostatka dijeljenja a sa b. Prototip funkcije je: int euklid(int a, int b) { if( b == 0 ) return a; return euklid(b, a%b); }

Jednostruko povezana lista u memoriji sadri statistike podatke o svim dosadanjim nastupima jednog tenisaa na turnirima. Element liste sadri ifru turnira (int) i broj pobjeda na tom turniru (int). Napisati rekurzivnu funkciju koja e vratiti ukupan broj pobjeda tog tenisaa na svim turnirima. typedef struct s { int sifraTurnira; int brPob; struct s *sljed; } cvor; int broj_pobjeda(cvor *glava) { if( glava == NULL ) return 0; return glava->brPob + broj_pobjeda( glava->sljed ); }

U jednostruko povezanu listu spremaju se podaci o tvrtkama. Svaki zapis sadri matini broj tvrtke (long), naziv tvrtke (40+1 znak), broj iro rauna (20+1 znak) i telefonski broj osobe za kontakt (15+1 znak). Lista NIJE sortirana. Napisati REKURZIVNU funkciju koja e pronai tvrtku sa zadanim matinim brojem u listi. Ako ta tvrtka postoji, funkcija vraa pokaziva na odgovarajui zapis, u protivnom funkcija vraa NULL. Definirati strukture potrebne za rjeenje zadatka i odrediti apriornu sloenost funkcije. Funkcija mora imati prototip:

zapis *nadji(zapis *glava, long mbr);

struct s{ long matBroj; char naziv[40+1]; char brZiroRacun[20+1]; char telKontakt[15+1]; struct s *sljed; }; typedef struct s zapis; zapis *nadji(zapis *glava, long mbr) { if( glava != NULL) { if( glava->matBroj == mbr ) return glava; else return nadji( glava->sljed, mbr ); } else return NULL; }

Napisati rekurzivnu funkciju koja zadani niz znakova ispisuje unatrag (npr. ako je zadan niz Abeceda, funkcija treba ispisati adecebA). Funkcija treba imati prototip: void ispisi_unatrag(char *niz); void ispisi_unatrag(char *niz) { if( *niz == NULL ) return ; ispisi_unatrag(niz+1); printf("%c\n",*niz); }

Kakva je apriorna sloenost i to e ispisati sljedea funkcija ako njen poziv glasi:

pisi(5);

// poziv funkcije pisi

//

void pisi(int broj) { broj--; if (broj<0) return; pisi (broj); printf ("%d",broj); } O(1) Ispis =====> 01234

Napisati rekurzivnu funkciju koja e izraunati istu sumu reda kao i zadana funkcija f: double f(int n) { double suma = 0; int i; for (i = 1; i < n; i++) suma += 1./(i * (i + 1) * (i + 2)); return suma; } Rjeenje: double f(int n) { --n; if (n<1) return 0; return 1./(n*(n+1)*(n+2)) + f(n); } ili double f(int n) { if (n<=1) return 0; return 1./((n-1)*(n)*(n+1)) + f(n-1); } sloenost: O(n)

Napisat rekurzivnu funkciju koja trai studenta sa zadanim matinim brojem kroz jednostruko povezanu listu. Prototip funkcije je: void traziStudenta(cvor *glava, int matBroj); void traziStudenta(cvor *glava, int matBroj) { if( glava == NULL) { printf("Nema!\n"); return; } if( glava->mbr == matBroj ) { printf("%d %c",glava->mbr, glava->spol); return; } traziStudenta(glava->sljed, matBroj); }

Napisati rekurzivnu funkciju koja e odrediti koji se znak u nekom sortiranom znakovnom polju dimenzije n+1 najee pojavljuje. Izlazni argument je naeni znak, a funkcija vraa broj pojavljivanja tog znaka. Prototip funkcije je: int mode (char *tekst, int n, char *znak) { char tmp; int i=1; int rek; tmp = tekst[n]; while (tekst[n-i]== tmp) i++; rek = mode (tekst, n-i, znak); if (rek > i) return rek; else { *znak=i; return i; } }

Napisat rekurzivnu funkciju koja e obaviti operaciju cijelobrojnog dijeljenja integera a i b koristei se samo operacijom oduzimanja. Prototip fuckcije je:

int podijeli(int a, int b); int podijeli(int a, int b) { if( b > a ) return 0; return 1 + podijeli(a-b, b); }

Napisat rekurzivnu funkciju koja e obaviti operaciju modulo ostatka cijelobrojnog dijeljenja (%) integera a sa integerom b koristei se samo operacinom oduzimanja. Prototip funkcije je: int modulo(int a, int b); int modulo(int a, int b) { if( b > a ) return a; return modulo(a-b, b); }

?????????????????????????????????????????????????????????????????? 1.) Napisati rekurzivnu funkciju koja e za realni broj x (|x| < 1) izraunati sumu reda:
x3 3 x5 5 x7 7 x 2n 1 ( 2n 1)

Ar th( x )

Funkciji se kao jedan od argumenata predaje broj n koji slui kao uvjet zaustavljanja.

2.) Napisati rekurzivnu funkciju koja e prvo uzlazno a zatim silazno ispisati n lanova aritmetikog niza s bazom a i udaljenou lanova d (a0 = a , an = a(n+1) +d). float niz (int n, float b, float d)

3.) Napisati rekurzivnu funkciju za izraunavanje sume geometrijskog reda od n lanova,

n

aq j
j 0

Prototip funkcije je: float SumaGeometrijskogReda (float a, float q, int n); Kolika je apriorna sloenost te funkcije?

????????????????????????????????????????????????????????????????????????????????????????

===>{ DVOSTRUKO POVEZANE LISTE }<===

// neke funkcije za rad sa ovim strukturama podataka...

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja e nai vor u koji je upisan traeni student (sa zadanim matinim brojem) i vratiti ime i prezime prethodnog studenta!

typedef struct cv { int mbr; char imePrezime[51]; char spol; struct cv *sljed; struct cv *pret; cvor;

char *vratiPrethodnog(cvor *glava, int matBroj) { if( (glava == NULL) || (glava->sljed == NULL) ) { printf("Nije moguce vratiti prethodnog studenta!\n"); return "Unesi jos elemenata...\n\n"; } printf("Pocinjem gledati od drugog studenta\n"); glava=glava->sljed; //jer nije moguce vratiti prethodnog od prvog while( glava != NULL ) { if( glava->mbr == matBroj ) { printf("Student pronadjen, vracam vam prethodnog studenta..\n"); return glava->pret->imePrezime; } glava=glava->sljed; } return "Ne postoji student sa zadanim maticnim brojem!\n"; }

Zadana je dvostruko povezana lista iji zapis sadri ifru artikla (long), naziv artikla (50+1 znak) i koliinu na skladitu (int). Potrebno je napisati funkciju koja e svim elementima liste koliinu uveati za uveanje iz argumenta. Prototip je: void uvecaj(cvor *glava, cvor *rep, int uvecanje); typedef struct cv{ long sifraArtikla; char naziv[51]; int kolicina; struct cv *sljed; struct cv *pret; cvor;

void uvecaj(cvor *glava, cvor *rep, int uvecanje) { if( rep == NULL ) { printf("Lista je prazna, unesi elemente!\n"); return; } while( rep != NULL ) { rep->kolicina += uvecanje; rep = rep->pret; } }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Napisati funkciju koja e ispisati ime i prezime prvog prethodnog i prvog sljedeeg studenta sa zadanim matinim brojem!
void ispisPrethodnogISljedeceg(cvor *glava, int matBr);

void ispisPrethodnogISljedeceg(cvor *glava, int matBr) { if( (glava == NULL) || ( glava->sljed == NULL ) ) { printf("\nNije moguce vratiti prethodnog i sljedeceg!\n"); return; } while(glava!=NULL) { if( glava->mbr == matBr ) { if(glava->pret == NULL) { printf("\n\nNije moguce ispisati prethodnog studenta za prvi element liste!\n"); printf("Ovo je sljedeci student: %-20s\n\n",glava->sljed->imePrezime); return; } else if(glava->sljed == NULL) { printf("\n\nNije moguce ispisati sljedeceg studenta za posljednji element liste!\n"); printf("Ovo je prethodni student: %-20s\n\n",glava->pret->imePrezime); return; } else { printf("\n\nOvo je prethodni student: %-20s\n",glava->pret->imePrezime); printf("Ovo je sljedeci student: %-20s\n\n",glava->sljed->imePrezime); return; } } glava=glava->sljed; } printf("\n\nNe postoji takav student!\n"); }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja e obrisati prvi element liste. Ukoliko je brisanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je: int obrisiPrvog(cvor **glava, cvor **rep);

int obrisiPrvog(cvor **glava, cvor **rep) { cvor *pom = *glava; if( *glava == NULL ) { printf("Lista je prazna, unesi elemente u listu!\n"); return 0; } if( (*glava)->sljed == NULL ) { *glava = (*glava)->sljed; free(pom); printf("Obrisan je posljednji element liste!\n"); *rep = NULL; return 1; } else { *glava = (*glava)->sljed; (*glava)->pret = NULL; free(pom); printf("\nPrvi element liste uspijesno izbrisan\n"); return 1; } }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja e obrisati posljednji zapis liste. Ukoliko je brisanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je: int obrisiZadnjeg(cvor **glava, cvor **rep);

int obrisiZadnjeg(cvor **glava, cvor **rep) { cvor *p = *glava; if(*glava==NULL) { printf("Lista je prazna, unesi elemente!\n"); return 0; } if((*glava)->sljed==NULL) { *glava=NULL; *rep=NULL; free(p); printf("\n\nPosljednji element liste je izbrisan!\n"); return 1; } p=*rep; *rep=(*rep)->pret; (*rep)->sljed=NULL; free(p); printf("\n\nPosljednji element liste je izbrisan!\n"); return 1; }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja e obrisati sve elemente liste. Ukoliko je brisanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je: int obrisiSveElemente(cvor **glava, cvor **rep);

int obrisiSveElemente(cvor **glava, cvor **rep) { cvor *pom; if( (*glava == NULL) && (*rep == NULL) ) { printf("Lista je prazna, unesi elemente!\n"); return 0; } pom = *glava; while( *glava != NULL ) { *glava = (*glava)->sljed; free(pom); pom=*glava; } *rep=NULL; printf("\nBrisanje uspijesno...\n"); return 1; }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja dodaje na poetak liste. Ukoliko je stavljanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je:
int dodajNaPocetak(cvor **glava, cvor **rep, int matBr, char *niz, char spol);

int dodajNaPocetak(cvor **glava, cvor **rep, int matBr, char *niz, char spol) { cvor *novi; novi=(cvor *)malloc(sizeof(cvor)); if( novi == NULL ) { printf("Nije moguce alocirati memoriju potrebnu za unos novog elementa!\n"); return 0; } novi->mbr = matBr; strcpy_s(novi->imePrezime, niz); novi->spol = spol; if( (*glava == NULL) && (*rep == NULL) ) { *glava = novi; *rep = novi; novi->sljed = NULL; novi->pret = NULL; printf("\nNovi element uspijesno dodan u listu...\n\n"); return 1; } novi->pret = NULL; novi->sljed = *glava; (*glava)->pret = novi; *glava=novi; printf("\nNovi element uspijesno dodan u listu...\n\n"); return 1; }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja dodaje na kraj liste. Ukoliko je dodavanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je:
int dodajNaKraj(cvor **glava, cvor **rep, int matBr, char *niz, char spol);

int dodajNaKraj(cvor **glava, cvor **rep, int matBr, char *niz, char spol) { cvor *novi; novi=(cvor *)malloc(sizeof(cvor)); if( novi == NULL ) { printf("Nije moguce alocirati memoriju potrebnu za unos novog elementa!\n"); return 0; } novi->mbr = matBr; strcpy_s(novi->imePrezime, niz); novi->spol = spol; if( (*glava == NULL) && (*rep == NULL) ) { *glava = novi; *rep = novi; novi->sljed = NULL; novi->pret = NULL; printf("\nNovi element uspijesno dodan u listu...\n\n"); return 1; } novi->sljed = NULL; novi->pret = *rep; (*rep)->sljed = novi; *rep = novi; printf("\nNovi element uspijesno dodan na kraj liste...\n\n"); return 1; }

Zadana je dvostruko povezana lista iji zapis sadri: matini broj (long), ime i prezime studenta (50+1 znak) i spol. Potrebno je napisati funkciju koja dodaje u sortiranu listu. Ukoliko je dodavanje uspjelo funkcija vraca 1 a inace 0. Prototip funkcije je:
int dodajUSortiranuListu(cvor **glava, cvor **rep, int matBr, char *niz, char spol) { cvor *novi; cvor *pom; novi=(cvor *)malloc(sizeof(cvor)); if( novi == NULL ) { printf("Nije moguce alocirati memoriju potrebnu za unos novog elementa!\n"); return 0; } novi->mbr = matBr; strcpy_s(novi->imePrezime, niz); novi->spol = spol; if( { ( *glava == NULL ) && ( *rep == NULL ) )

novi->sljed = *glava; novi->pret = NULL; *glava=novi; *rep=novi; printf("\nPrvi element uspijesno dodan u listu...\n\n"); return 1; } if( novi->mbr <= (*glava)->mbr ) { novi->sljed = *glava; novi->pret = NULL; (*glava)->pret = novi; *glava = novi; printf("\nElement uspijesno stavljen na pocetak liste...\n\n"); return 1; } pom = *glava; while( (pom->sljed != NULL) pom = pom->sljed;

&& (pom->sljed->mbr < novi->mbr) )

if(pom->sljed==NULL) { novi->pret=pom; novi->sljed=NULL; pom->sljed=novi; *rep=novi; printf("\nElement uspijesno dodan na kraj liste...\n\n"); return 1; } novi->sljed = pom->sljed; novi->pret = pom; pom->sljed->pret=novi; pom->sljed = novi; printf("\nElement uspijesno dodan untar liste...\n\n"); return 1; }

void {

ispisGlava(cvor *glava)
printf("\n\n"); if(glava==NULL) { printf("Lista je prazna, unesi elemente!\n"); return; } while(glava!=NULL) { printf("\t%4d %-20s %c\n",glava->mbr, glava->imePrezime, glava->spol); glava=glava->sljed; }

void ispisRep(cvor *rep) { printf("\n\n"); if(rep==NULL) { printf("Lista je prazna, unesi elemente!\n"); return; } while(rep!=NULL) { printf("\t%4d %-20s %c\n",rep->mbr, rep->imePrezime, rep->spol); rep=rep->pret; } }

10

RED

=={ FIFO }== QUEUE; Cikliko polje;

int dodajUred(int element, int red[], int *ulaz, int izlaz, int velicinaReda) { if( ((*ulaz+1) % velicinaReda) == izlaz) return 0; *ulaz += 1; *ulaz %= velicinaReda; red[*ulaz]=element; return 1; }

int skiniIzReda(int *element, int red[], int ulaz, int *izlaz,int velicinaReda) { if( ulaz == *izlaz ) return 0; *izlaz + =1; *izlaz %= velicinaReda; *element=red[*izlaz]; return 1; }

float popunjenost(int ulaz, int izlaz, int velicinaReda) { int brElement; if( ulaz >= izlaz ) brElement = ulaz - izlaz; else brElement = velicinaReda - ( izlaz - ulaz ); return (float) brElement / velicinaReda; }

int brojSlobodnih(int ulaz, int izlaz, int velicinaReda) { int brElement; if( ulaz >= izlaz ) brElement = ulaz - izlaz; else brElement = velicinaReda - ( izlaz - ulaz ); return velReda - brElement; }

Red je realiziran kao polje, koje moe primiti najvie n zapisa. Svaki zapis sadri sljedee podatke: ifru procesa (long) i opis procesa (40 + 1 znak). Potrebno je napisati funkciju koja dodaje zapis u red. Funkcija treba vratiti 1, ako je zapis dodan u red, a inae 0. Prototip funkcije je:
int dodajURed (proces element, proces red[], int n, int izlaz, int *ulaz);

struct s { long sifra; char opis[41]; }; typedef struct s proces; . . .

int dodajURed (proces element, proces red[], int n, int izlaz, int *ulaz)

{ if( ((*ulaz+1) % n) == izlaz) return 0; (*ulaz) += 1; (*ulaz) %= n; red[*ulaz] = element; return 1; }

Red je realiziran ciklikim jednodimenzionalnim poljem zapisa, gdje svaki zapis sadri ifru proizvoda (long), naziv proizvoda (50+1 znak) i cijenu (float). Potrebno je napisati funkciju koja dodaje zapis u red, te vraa 1 ukoliko je zapis uspjeno dodan, a 0 inae.
struct s { long sifra; char naziv[50 + 1]; float cijena; }; typedef struct s proizvod; . . . int dodajURed(proizvod element, proizvod red[], int n, int izlaz, int *ulaz)

{ if( (*ulaz+1) % n == izlaz) return 0; (*ulaz) += 1; (*ulaz) %= n; red[*ulaz] = element; return 1; };

//****************************************************************

Napisat funkciju koja brie sve elemente iz reda i u njega upisuje elemente. Prototip je:
int obrisiIdodaj(int red[], int *ulaz, int *izlaz, int element, int velicinaReda) { int tmpElement; while(skini (&tmpElement, red, *ulaz, izlaz, velicinaReda)!=0) dodaj(tmpElement, red, ulaz, *izlaz, velicinaReda); return 1;

} //***************************************************************;

Napisat funkciju koja e kao rezultat vratiti omjer slobodnog i zauzetog mjesta u redu. (Funkcija treba vratiti realan broj).

int omjer(int ulaz, int izlaz, int velicinaReda) { int brElement; if( ulaz >= izlaz ) else brElement = velicinaReda - (izlaz - ulaz); return (float) ( velicinaReda brElement ) / brElement; } brElement = ulaz - izlaz;