Strukture
Strukturirani (sloeni) tip podataka
koji definie korisnik
sastoji se od vie komponenti
komponente imaju identifikatore
ne moraju biti istog tipa
struktura se smatra jednim objektom
(moe biti i vrednost funkcije)
Strukture
Definicija naredbom struct + ime + opis
struct tacka
{int x, y;} a, b, c;
struct pravougaonik
{struct tacka dole_levo, gore_desno;};
struct krug
{double r; struct tacka centar;};
1
Strukture
Razlike u odnosu na niz
kod niza istorodne komponente - zasebni
objekti, identifikuju se indeksima
vrednost funkcije ne moe da bude niz
(moe pokaziva)
Koristi se za sloene objekte
logiki povezane informacije
Strukture
komponente
vidljive samo unutar strukure kojoj
pripadaju
mogu ista imena u razliitim
strukturama
mogu ista imena kao promenljive
 Strukture Strukture

definisanje promenljivih ovog tipa dodela poetnih vrednosti

mogue pozvati se na ranije definisanu niz vrednosti unutar zagrada

strukturu (kao kod niza)
(za poziv na tip mora: struct + identifikator konstantni izrazi
strukture - kao kod enum) dodeljuju se sukcesivnim komponenatama
strukture
broj i tipovi vrednosti moraju da se slau sa
dati njen opis direktno komponentama, vie vrednosti nije dozvoljeno
(moe se izostaviti identifikator strukture) ako je manje vrednosti, preostale komponente
se inicijalizuju nulama

Strukture Strukture

dodela poetnih vrednosti

mogu se definisati i nizovi struktura
u obliku izraza
koji predstavlja poziv funkcije
koja je tipa te strukture ako se sa typedef
definie strukturni tip,
struct tacka p = {35, -12}, q; njegov identifikator se moe
struct pravougaonik w, x, y = {{1, 1}, koristiti kao oznaka tipa
{3, 3}}; i bez slubene rei struct

2
 Strukture Upotreba struktura

typedef struct {char ime[16], prezime[16];} ime;

typedef struct {
char dan, mesec; short int godina;
dozvoljena dodela vrednosti (=)
} datum;
za promenljive istog strukturnog tipa
typedef struct {
char maticni_broj[13];
ime osoba; prepiu se sve komponente
datum datum_rodjenja;
char adresa[30];
} gradjanin;

gradjanin g1, g2, g3;

Upotreba struktura Upotreba struktura

dve strukturne promenjive Primer:

su istog tipa ako:
a i b razliitog tipa imaju isti opis
su definisane istom naredbom
struct {int x,y;} a;
za njihovu definiciju se koristi struct {int x,y;} b;
isti identifikator tipa

3
 Upotreba struktura
mogua primena adresnog operatora,
kao i pokazivai na strukture
struct krug *p;
struktura moe biti i
argument funkcije (po vrednosti)
kao i vrednost funkcije
Upotreba struktura
za pristup komponentama se koristi
binarni operator taka (.)
a.x
(*p).r (zagrade su neophodne !!!)
zbog iste upotrebe pokazivaa na
strukture - binarni operator ->
p->r
4
Upotreba struktura
kako niz ne moe biti vrednost funkcije,
moe struktura sa nizom kao jednom
komponentom
od struktura mogu da se prave nizovi
veliina strukture se dobija sa sizeof
(ne mora da bude zbir komponenti ako
postoje neka ogranienja u smetanju)
Upotreba struktura
a.x=13; a.z=-22;
a={13,-22} (samo inicijalizacija !!!)
x.dole_levo.x=4; x.dole_levo.y=-5;
x.gore_desno.x=7; x.gore_desno.y=0;
w.dole_levo=a; w.gore_desno=p;
 Upotreba struktura Upotreba struktura
/* definisanje tipa Tacka */
/* izraunavanje rastojanja izmeu taaka */
struct tacka {int x,y;};
typedef struct tacka Tacka;
#include <math.h>

/* formiranje take od zadatih komponenti*/

double rastojanje (Tacka g, Tacka h) {
Tacka pravi_tacku (int x, int y) { return sqrt(pow(g.x-h.x,2)+pow(g.y-h.y,2));
Tacka t; }
t.x=x;
t.y=y; const Tacka NULA = {0,0};
return t; ...
}
...

Upotreba struktura Dinamike strukture podataka

/* nalaenje take najblie koordinatnom poetku */

strukture pogodne za formiranje
Tacka * najbliza(Tacka a[], int n) {
sloenih dinamikih struktura
Tacka *min = a; podataka (promenljiva i veliina i
double r = rastojanje(a[0],NULA), s; logika povezanost)
for (int i=1; i<n; i++) {
s = rastojanje(a[i],NULA);
if (s<r) {r=s; min=a+i;} obino se sastoje od korisnog
} sadraja i pokazivaa na druge
return min; objekte
}

5
Dinamike strukture podataka Dinamike strukture podataka

Primer linearne liste za

definicija mogua jer je
predstavljanje nizova objekata
u trenutku deklaracije pokazivaa,
dinamiko stvaranje, brisanje, identifikator strukture
preureivanje objekata u listi
je ve definisan
typedef struct element {
int broj;
struct element *sled ; nemogua "rekurzivna" definicija
} Element; kada je komponenta strukture
sama ta struktura
sled - pokaziva na naredni lan liste

Dinamike strukture podataka Dinamike strukture podataka

Linearna lista dodavanje, brisanje i ureivanje

typedef struct element {
elemenata iskazuje podeavanje
int broj; pokazivaa
struct element *sled ;
} Element;
nedostaci:
Element *niz; dodatni prostor za pokazivae
samo sekvencijalan ali ne i direktan
sled - pokaziva na naredni lan liste pristup
niz pokaziva na poetak liste

6
Dinamike strukture podataka Dinamike strukture podataka

Druga primena - binarno stablo struct Cvor {

koren i dva podstabla
moe da se definie rekurzivno
jer je bilo koji podskup
povezanih vorova - stablo
int broj;
struct Cvor *levi, *desni;
} *stablo;
stablo - pokaziva na koreni vor
bolje definisati sa typedef
kao u primeru sa listom

Unije Unije

naredba union
strukturirani tipovi (sintaksa kao za struct)
koji omoguavaju da se u
isti memorijski prostor struct { union {
smetaju podaci razliitih tipova u int i; int i;
razliitim vremenskim intervalima double d; double d;
char *c; char *c;
} s; } u;
7
 Unije Unije

za razliku od strukture,
s: s.i s.d s.c u: u.i u jednom momentu
u.d samo jedna komponenta
u.c ima definisanu vrednost
sizeof s sizeof u
veliina odreena najveom
komponentom
) )

Unije Polja bitova

struktura
ije su komponente
programer treba da vodi rauna duine nekoliko bitova
o konzistentnom korienju (pakuju se na mainski zavisan nain)
komponenti
(posledice su nepredvidive esto za opisivanje hardverskih registara
ako se upie u jednu,
a koristi druga komponenta) programi koji koriste polja bitova su
obino mainski zavisni

8
 Polja bitova Polja bitova

Standard ne definie: deklaracija

da li polje bitova moe da bude due od

mainske rei kao za strukturne tipove

da li komponenta moe da bude dua od

mainske rei sve komponente moraju da budu
unsigned int
da li komponenta moe da prelazi granicu rei

da li se reaju zdesna ili obrnuto duina polja se navodi u bitovima

Polja bitova Jednostruko ulanane liste

struct {
lst: 5 3 2 6 5 3 NULL
unsigned int n:1, z:1, prio:4;
} status_reg;
typedef struct elem {
int broj;
status_reg.prio=5; struct elem
*sled;
if (status_reg.n != 1 && } Elem;
status_reg.z != 0) ...
9
 Obilazak liste odreivanje Obilazak liste ispisivanje svih
broja elemenata elemenata

int duz (Elem *lst) { void pisi (Elem *lst) {

Elem *tek; Elem *tek;
int n = 0; for (tek=lst; tek; tek=tek->sled)
for (tek=lst; tek; tek=tek->sled) printf ("%d ", tek->broj);
n++; printf ("\n");
return n; }
}

Dodavanje novog elementa na Dodavanje novog elementa na

poetak liste kraj liste

Elem *na_pocetak (Elem *lst, int b) { Elem *na_kraj (Elem *lst, int b) {
Elem *tek, *novi = malloc (sizeof(Elem));
Elem *novi = malloc (sizeof(Elem)); novi->broj = b;
novi->sled = NULL;
novi->broj = b;
if (!lst)
novi->sled = lst; lst = novi;
else {
lst = novi; for (tek=lst; tek->sled; tek=tek->sled);
return lst; tek->sled = novi;
}
} return lst;
}

10
 Umetanje elementa u rastue
Sortiranje liste metodom izbora
ureenu listu

Elem *umetni (Elem *lst, int b) { void uredi (Elem *lst) {

Elem *tek = lst, *pret = NULL, *novi;
while (tek && tek->broj < b) { Elem *i, *j; int p;
pret = tek; for (i=lst; i; i=i->sled)
tek = tek->sled;
} for (j=i->sled; j; j=j->sled)
novi = malloc (sizeof(Elem)); if (j->broj < i->broj) {
novi->broj = b; novi->sled = tek;
if (!pret) p = i->broj;
lst = novi; i->broj = j->broj;
else
pret->sled = novi;
j->broj = p;
return lst; }
}
}

Izostavljanje elemenata sa
Brisanje svih elemenata liste datom vrednou (1)

void brisi (Elem *lst) { Elem *izostavi (Elem *lst, int b) {

Elem *stari; Elem *tek = lst, *pret = NULL,
while (lst) { *stari;
stari = lst; while (tek)
lst = lst->sled; if (tek->broj != b) {
free (stari); pret = tek;
} tek = tek->sled; }
}
11
 Izostavljanje elemenata sa
Dvostruko ulanane liste
datom vrednou (2)

else { /* ako se element izostavlja */

stari = tek; prvi: NULL 5 3 6 2 NULL :posl
tek = tek->sled;
if (!pret)
lst = tek; typedef struct elem {
else int broj;
pret->sled = tek; struct elem *sled, *pret;
free (stari); } Elem;
}
return lst; typedef struct {
} Elem *prvi, *posl } Lista;

Prazna lista i
obilazak liste
Ispisivanje liste u napred

Prazna lista: oba pokazivaa su NULL void pisi_unapred (Lista lst) {

Lista lst = {NULL, NULL}; Elem *tek;
Obilazak u napred: for (tek=lst.prvi; tek; tek=tek->sled)
for (tek=lst.prvi; tek; tek=tek->sled) printf ("%d ", tek->broj);
{} printf ("\n");
Obilazak u nazad: }
for (tek=lst.posl; tek; tek=tek->pret)
{}

12
 Ispisivanje liste u nazad Nalaenje prve pojave broja

void pisi_unazad (Lista lst) { Elem *nadji_prvi (Lista lst, int b) {

Elem *tek; Elem *tek;
for (tek=lst.posl; tek; tek=tek->pret) for (tek=lst.prvi; tek; tek=tek->sled)
printf ("%d ", tek->broj); if (tek->broj == b) return tek;
printf ("\n"); return NULL;
} }

Nalaenje poslednje pojave broja Dodavanje na poetak

Elem *nadji_posl (Lista lst, int b) {
Elem *tek;
for (tek=lst.posl; tek; tek=tek->pret)
if (tek->broj == b) return tek;
return NULL;
} else
void na_pocetak (Lista *plst, int b) {
Elem *novi = malloc (sizeof(Elem));
novi->broj = b;
novi->sled = plst->prvi;
novi->pret = NULL;
if (! plst->posl) plst->posl = novi;
plst->prvi->pret = novi;
plst->prvi = novi;
}

13
 Dodavanje na kraj Brisanje svih elemenata

void na_kraj (Lista *plst, int b) { void brisi (Lista *plst) {

Elem *novi = malloc (sizeof(Elem)); Elem *tek = plst->prvi, *stari;
novi->broj = b; while (tek) {
novi->pret = plst->posl; stari = tek;
novi->sled = NULL; tek = tek->sled;
if (! plst->prvi) plst->prvi = novi; free (stari);
else plst->posl->sled = novi; }
plst->posl = novi; plst->prvi = plst->posl = NULL;
} }

Izostavljanje poslednje pojave

Izostavljanje prve pojave broja
broja

void izostavi_prvi (Lista *plst, int b) { void izostavi_posl (Lista *plst, int b){
Elem *tek = nadji_prvi (*plst, b); Elem *tek = nadji_posl (*plst, b);
if (tek) { if (tek) {
if (! tek->pret) plst->prvi = tek->sled; if (! tek->pret) plst->prvi = tek->sled;
else tek->pret->sled = tek->sled; else tek->pret->sled = tek->sled;
if (! tek->sled) plst->posl = tek->pret; if (! tek->sled) plst->posl = tek->pret;
else tek->sled->pret = tek->pret; else tek->sled->pret = tek->pret;
free (tek); free (tek);
} }
} }

14