Embed Size (px)
Citation preview
1. 0B
2. PODSEĆANJE
1. /* Pokazivaci - osnovni pojam */
#include <stdio.h>
main()
{
int x = 3;
/* Adresu promenjive x zapamticemo u novoj promeljivoj.
Nova promenljiva je tipa pokazivaca na int (int*) */ int* px;
printf("Adresa promenljive x je : %p\n", &x);
printf("Vrednost promenljive x je : %d\n", x);
px = &x;
printf("Vrednost promenljive px je (tj. px) : %p\n", px);
printf("Vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px);
/* Menjamo vrednost promenljive na koju ukazuje px */
*px = 6;
printf("Vrednost promenljive na koju ukazuje px (tj. *px) je : %d\n", *px);
/* Posto px sadrzi adresu promenljive x, ona ukazuje na x tako da
je posredno promenjena i vrednost promenljive x */
printf("Vrednost promenljive x je : %d\n", x);
}
2. (DOMAC I) Popuniti sledecu tabelu:
A B C P1 P2
Init 1 2 3 &A &C
*P1 = (*P2)++ 3 2 4 &A &C P1 = P2 3 2 4 &C &C P1 = &B 3 2 4 &B &C
*P1 = *P1 - *P2 3 -2 4 &B &C
3. /* swap : Demonstracija prenosa argumenata preko pokazivaca */
#include <stdio.h>
/* Pogresna verzija funkcije swap. Zbog prenosa po vrednosti,
funkcija razmenjuje kopije promenljivih iz main-a, a ne samih
promenljivih */
void swap_wrong(int x, int y)
{
int tmp;
printf("swap_wrong: ");
printf("Funkcija menja vrednosti promenljivim na adresama : \n"); printf("x :
%p\n", &x);
printf("y : %p\n", &y);
tmp = x; x = y;
y = tmp;
}
/* Resenje je prenos argumenata preko pokazivaca */
void swap(int* px, int* py)
{
int tmp;
printf("swap : Funkcija menja vrednosti promenljivim na adresama : \n"); printf("px =
%p\n", px);
printf("py = %p\n", py);
tmp = *px;
*px = *py;
*py = tmp;
}
main()
{
int x = 3, y = 5;
printf("Adresa promenljive x je %p\n", &x); printf("Vrednost
promenljive x je %d\n", x); printf("Adresa promenljive y je
%p\n", &y); printf("Vrednost promenljive y je %d\n", y);
/* Pokusavamo zamenu koristeci pogresnu verziju funkcije */ swap_wrong(x,
y);
printf("Posle swap_wrong:\n"); printf("Vrednost promenljive x
je %d\n", x); printf("Vrednost promenljive y je %d\n", y);
/* Vrsimo ispravnu zamenu. Funkciji swap saljemo adrese
promenljvih x i y, a ne njihove vrednosti */
swap(&x, &y);
printf("Posle swap:\n");
printf("Vrednost promenljive x je %d\n", x); printf("Vrednost
promenljive y je %d\n", y);
}
2 Pokazivaci - veza sa nizovima
1. /* Pokazivacka aritmetika */
#include <stdio.h> main()
{
char s[] = "abcde";
int t[] = {1, 2, 3, 4, 5};
/* Inicijalizujmo pokazivace ps i pt na pocetke nizova s i t */ char* ps = &s[0];
int* pt = &t[0];
/* Pokazivace je moguce sabirati sa celim brojevima i od njih
je moguce oduzimati cele brojeve*/
/* Ispisimo vrednosti pokazivaca */ printf("ps = %p\n", ps);
printf("ps+1 = %p\n", ps+1);
printf("ps+2 = %p\n", ps+2);
printf("ps-1 = %p\n", ps-1);
printf("ps-2 = %p\n", ps-2);
/* Prilikom sabiranja pokazivaca i celih brojeva, dodaje se
velicina odgovarajuceg tipa. */
printf("pt = %p\n", pt);
printf("pt+1 = %p\n", pt+1);
printf("pt+2 = %p\n", pt+2);
printf("pt-1 = %p\n", pt-1);
printf("pt-2 = %p\n", pt-2);
/* Na pokazivace je moguce primenjivati i operatore ++ i -- */ for (ps = s; *ps; ps++)
putchar(*ps); putchar(’\n’);
/* Slicno, dva pokazivaca istog tipa se mogu oduzimati. Prilikom
sracunavanja rezultata, uzima se u obzir velicina tipa. */
ps = &s[3];
printf("s = %p\n", s);
printf("ps = %p\n", ps);
printf("ps - s = %d\n", ps - s);
pt = &t[3];
printf("t = %p\n", t);
printf("pt = %p\n", pt);
printf("pt - t = %d\n", pt - t);
}
2. /* Veza izmedju pokazivaca i nizova */
#include <stdio.h>
void print_array(int* pa, int
n); main()
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int num_of_elements = sizeof(a)/sizeof(int); int* pa;
/* Niz je isto sto i adresa prvog elementa */ printf("Niz
a : %p\n", a);
printf("Adresa prvog elementa niza a (&a[0]) : %p\n", &a[0]);
/* Moguce je dodeliti niz pokazivacu odgovarajuceg tipa */ pa = a;
printf("Pokazivac pa ukazuje na adresu : %p\n", pa);
/* Nizu nije moguce dodeliti pokazivacku promenljivu
(nizove mozemo smatrati KONSTANTNIM pokazivacima na prvi element) */
/* a = pa; */
/* Niz je moguce koristiti kao pokazivac tj. vaze pravila pokazivacke aritmetik
printf("a + 3 = %p\n", a + 3);
/* Vazi da je
a + i =
&a[
i] odnosno
*(a + i) =
a[i]
*/
printf("&a[3] = %p\n", &a[3]);
/* Identiteti
a + i =
&a[
i] odnosno
*(a + i) = a[i]
vazi i za pokazivace i za nizove */
/* Pokazivace je na osnovu prethodnog moguce indeksirati kao nizove */
printf("pa[5] = %d\n", pa[5]);
printf("*(pa + 5) = %d\n", *(pa+5));
/* Medjutim, sizeof(pa) je samo velicina pokazivaca, a ne niza */
printf("sizeof(a) = %d\n", sizeof(a));
printf("sizeof(pa) = %d\n", sizeof(pa));
/* Pozivamo funkciju za stampanje niza i saljemo joj niz */
print_array(a, num_of_elements);
/* Pozivamo funkciju za stampanje niza i saljemo joj pokazivac na pocetak niza
print_array(pa, num_of_elements);
}
/* Proslednjivanje niza u funkciju void
print_array(int pa[], int n);
je ekvivalentno prosledjivanju pokazivaca u funkciju void
print_array(int* pa, int n);
Izmedju ovih konstrukcija nema nikakve razlike.
*/
void print_array(int* pa, int n)
{
int i;
for (i = 0; i<n; i++) printf("%d ",
pa[i]);
putchar(’\n’);
}
3. /* strlen, strcpy, strcat, strcmp, strchr, strstr, ... - verzije sa
pokazivacima */
/* Vezbe radi, implementirane su funkcije biblioteke string.h */
#include <stdio.h>
#include <stdlib.h> /* Zbog NULL */
/* Izracunava duzinu
stringa */ int
string_length(char *s)
{
char* t;
for (t = s; *t; t++)
;
return t - s;
}
/* Kopira string src u string dest. Pretpostavlja da u dest ima dovoljno
prostora. void string_copy(char *dest, char *src)
{
/* Kopira karakter po karakter, sve dok nije iskopiran karakter ’\0’ */
while(*dest++ = *src++)
;
}
/* Nadovezuje string t na kraj stringa s. Pretpostavlja da u s ima dovoljno
prostor void string_concatenate(char *s, char *t)
{
/* Pronalazimo kraj stringa s */ while (*s)
s++;
/* Vrsi se kopiranje, slicno funkciji string_copy */ while (*s++
= *t++)
;
}
/* Vrsi leksikografsko poredjenje dva stringa.
Vraca :
0 - ukoliko su stringovi jednaki
<0 - ukoliko je s leksikografski ispred t
>0 - ukoliko je s leksikografski iza t
*/
int string_compare(char *s, char *t)
{
/* Petlja tece sve dok ne naidjemo na prvi razliciti karakter */ for (; *s
== *t; s++, t++)
if (*s == ’\0’) /* Naisli smo na kraj oba stringa, a nismo nasli
razliku */ return 0;
/* *s i *t su prvi karakteri u kojima se niske razlikuju
Na osnovu njihovog odnosa, odredjuje se odnos stringova */ return *s -
*t;
}
/* Pronalazi prvu poziciju karaktera c u stringu s, i vraca pokazivac
na nju, odnosno NULL ukoliko s ne sadrzi c */
char* string_char(char *s, char c)
{
for (; *s;
s++) if
(*s == c)
return s;
/* Nije nadjeno */ return NULL;
}
/* Pronalazi poslednju poziciju karaktera c u stringu s, i vraca pokazivac na nju,
odnosno NULL ukoliko s ne sadrzi c */
char* string_last_char(char *s, char c)
{
char *t = s;
/* Pronalazimo kraj stringa s */ while (*t++)
;
/* Krecemo od kraja i trazimo c unazad */ for (t--;
t >= s; t--)
if (*t == c)
return t;
/* Nije nadjeno */ return NULL;
}
/* Proverava da li string str sadrzi string sub.
Vraca poziciju na kojoj sub pocinje, odnosno -1 ukoliko ga nema
*/
char* string_string(char *str, char *sub)
{
char *s, *t;
/* Proveravamo da li sub pocinje na svakoj poziciji i */ for (;
*str; str++)
/* Poredimo sub sa str pocevsi od poziciji i sve dok ne naidjemo na razliku for
(s = str, t = sub; *s == *t; s++, t++)
/* Nismo naisli na razliku a ispitali smo sve karaktere niske sub */
9
if (*(t+1) == ’\0’) return
str;
/* Nije nadjeno */ return NULL;
}
main()
{
char s[100];
char t[] = "Zdravo"; char u[] = " svima"; char
r[] = "racunari";
string_copy(s, t); printf("%s\n", s);
string_concatenate(s, u); printf("%s\n", s);
printf("%d\n",string_char(r, ’n’) - r);
printf("%d\n",string_last_char(r, ’a’) - r);
printf("%d\n",string_string(r, "racun") - r);
printf("%d\n",string_string(r, "ari") - r);
printf("%d\n",string_string(r, "cun") - r);
printf("%p\n",string_string(r, "cna"));
}
10
3. LINEARNE STRUKTURE PODATAKA
3.1. 1BPOLJE
3.1.1. 5BDEFINICIJE I STRUKTURA
Polje (array) predstavlja linearnu homogenu statičku strukturu podataka i sastoji se od fiksnog
broja komponenata istog tipa. Svaki element polja se može označiti pomoću indeksa i svakom se
elementu može direktno pristupati. Ukupan broj komponenti polja određen je pri njegovom opisu i ne
može se menjati. Polje može biti jednodimenzionalno i višedimenzionalno.
Adresa i-te komponente vektora A je data jednačinom:
LR0R+c*(i-1),
gde su: LR0R – adresa prve reči prvog elementa vektora A, a c – broj reči pridružen svakom
elementu.
Dvodimenzionalna polja se mogu memorisati po vrstama ili kolonama i mogu se prikazati
ekvivalentnim jednodimenzionalnim vektorom. Adresa elementa A[i,j] dvodimenzionalnog polja
smeštenog po kolonama data je izrazom:
LR0R+c*[(j-1)*n + (i-1)],
gde je n broj vrsta.
Analogno, adresa elementa A[i,j] dvodimenzionalnog polja smeštenog po vrstama data je
izrazom:
LR0R+c*[(i-1)*n + (j-1)].
Analogno se smeštaju i višedimenzionalna polja u memoriju.
1. NCP koji sa standardnog ulaza učitava raspored 8 topova na šahovskoj tabli. Raspored
se učitava u formi 8 linija sa po 8 brojeva po liniji. Ako na datom polju nema topa, učitava se
0, a inače 1. Program mora da ispita validnost unetog rasporeda ( da li su učitani brojevi ili 0
ili 1, da li ima 8 topova) i ispita da li se u datom rasporedu dva topa tuku.
#include <stdio.h>
#include <stdlib.h>
main(){
int tabla[8][8]; /*matrica nula i jedinica cuva raspored 8
topova na tabli */
int suma; /* pamti se suma reda/kolone kao test osobina iz
zahteva zadatka */
int i,j; /*brojaci u petljama */
/*ucitavanje podataka o rasporedu topova uz sumiranje broja
topova i u slucaju greske stampa se odgovarajuca poruka i okoncava
programa */
suma=0;
for (i=0; i<8; i++ )
for (j=0; j<8; j++){
scanf("%d", &tabla[i][j]);
11
/*test korektnosti ulaza */
if (tabla[i][j] !=0 && tabla[i][j] !=1 ){
printf ("\nNekorektni ulazni podaci o rasporedu
topova\n");
exit(EXIT_FAILURE);
}
suma=suma + tabla[i][j];
}
/*greska je ako je broj topova na tabli razlicit od 8 */
if(suma !=8){
printf ("\nNekorektni ulazni podaci o broju topova\n");
exit(EXIT_FAILURE);
}
/*proveravanje da li se dva topa nalaze u istom redu , tj. da li
je suma clanova nekog reda veca od 1 */
for(i=0;i<8;i++){
suma=0;
for (j=0;j<8;j++) suma+=tabla[i][j];
if (suma >1 )
{ printf ("\nTopovi se tuku\n");
exit(EXIT_SUCCESS);
}
}
/*proveravanje da li se dva topa nalaze u istoj koloni , tj. da
li je suma clanova neke kolone veca od 1 */
for(j=0;j<8;j++)
{
suma=0;
for (i=0;i<8;i++) suma+=tabla[i][j];
if (suma >1 )
{ printf ("\nTopovi se tuku\n");
exit(EXIT_SUCCESS);
}
}
/*inace se topovi ne tuku */
printf ("\nTopovi se ne tuku\n");
exit(EXIT_SUCCESS);
}
3.1.2. Ubacivanje elementa u rastuce sortiran niz
public void InsertSortArray(int value, int[] niz) throws RuntimeException { if (brEleme == niz.length)
throw new RuntimeException(); int j = 0; // pozicija na koju se ubacuje nova vrednsto
while (j < brEleme && value > niz[j]) j++;
brEleme++;
for (int k = brEleme; k > j; k--)
niz[k] = niz[k - 1];
12
niz[j] = value;
}
3.1.3. Metoda int prosekParnih(int [] niz) koja računa i vraća prosek parnih elemenata niza (onih koji
imaju parne vrednosti, a ne na parnim mestima u nizu).
public double prosekParnih(int[] niz) { double zbir = 0; double broj = 0;
for (int i = 0; i <= niz.length - 1; i++) {
if (niz[i] % 2 == 0) { zbir
+= niz[i]; broj++;
}
}
if (broj == 0) return 0;
else
return zbir / broj; }
3.2. 4BLANČANE LISTE
3.2.1. 8B Definicija
Lančana lista, za razliku od prethodnih struktura koristi lančani (spregnuti) način zauzeća
memorije. Prednosti korišćenja lančane liste:
- Količina rezervisane memorije ne mora biti unapred zadata i fiksirana. Tačan iznos zauzete
memorije će zavisiti isključivo od količine podataka koji se obrađuju.
- Moguće je brzo i često brisanje i umetanje podataka.
Elementi lančane liste nisu memorisani u uzastopnim memorijskim lokacijama, već svaki element
eksplicitno ukazuje na naredni element u memoriji. Postoji nekoliko tipova listi:
1) jednostruko spregnuta lista
2) dvostruko spregnuta lista
3) kružna lista
3.2.2. 9BJEDNOSTRUKO SPREGNUTA LINEARNA LISTA
Svaki element ove strukture sadrži dva polja: podatak i pokazivač na naredni element u listi.
Glava liste je pokazivač koji sadrži adresu prvog elementa liste.
13
/* Rad sa jednostruko spregnutom listom - iterativne verzije funkcija za rad sa
povezanom listom */
#include <stdio.h>
#include <stdlib.h>
typedef struct elem {
int broj;
struct elem *sled;
} Elem; /*Element liste*/
int duz (Elem *lst); /* Broj elemenata liste. */
void pisi (Elem *lst); /* Ispisivanje liste. */
Elem *na_pocetak (Elem *lst, int b); /* Dodavanje na pocetak. */
Elem *na_kraj (Elem *lst, int b); /* Dodavanje na kraj. */
Elem *citaj1 (int n); /* Citanje liste stavljajuci brojeve na pocetak. */
Elem *citaj2 (int n); /* Citanje liste stavljajuci brojeve na kraj. */
Elem *umetni (Elem *lst, int b); /* Umetanje u uredjenu listu. */
void brisi (Elem *lst); /* Brisanje svih elemenata liste. */
Elem *izostavi (Elem *lst, int b); /* Izostavljanje svakog pojavljivanja. */
void main () {
Elem *lst = NULL; int kraj = 0, izbor, broj, n;
while (!kraj) {
printf ("\n1. Dodavanje broja na pocetak liste\n"
"2. Dodavanje broja na kraj liste\n"
"3. Umetanje broja u uredjenu listu\n"
"4. Izostavljanje broja iz liste\n"
"5. Brisanje svih elemenata liste\n"
"6. Citanje uz obrtanje redosleda brojeva\n"
"7. Citanje uz cuvanje redosleda brojeva\n"
"8. Odredjivanje duzine liste\n"
"9. Ispisivanje liste\n"
"0. Zavrsetak rada\n\n"
"Vas izbor? "
);
scanf ("%d", &izbor);
switch (izbor) {
case 1: case 2: case 3: case 4:
printf ("Broj? "); scanf ("%d", &broj);
switch (izbor) {
case 1: /* Dodavanje broja na pocetak liste: */
lst = na_pocetak (lst, broj); break;
case 2: /* Dodavanje broja na kraj liste: */
lst = na_kraj (lst, broj); break;
case 3: /* Umetanje broja u uredjenu listu: */
lst = umetni (lst, broj); break;
case 4: /* Izostavljanje broja iz liste: */
lst = izostavi (lst, broj); break;
}
break;
case 5: /* Brisanje svih elemenata liste: */
brisi (lst); lst = NULL; break;
case 6: case 7: /* Citanje liste: */
printf ("Duzina? "); scanf ("%d", &n);
printf ("Elementi? "); brisi (lst);
switch (izbor) {
case 6: /* uz obrtanje redosleda brojeva: */
lst = citaj1 (n); break;
case 7: /* uz cuvanje redosleda brojeva: */
lst = citaj2 (n); break;
14
}
break;
case 8: /* Odredjivanje duzine liste: */
printf ("Duzina= %d\n", duz (lst)); break;
case 9: /* Ispisivanje liste: */
printf ("Lista= "); pisi (lst); putchar ('\n'); break;
case 0: /* Zavrsetak rada: */
kraj = 1; break;
default: /* Pogresan izbor: */
printf ("*** Neozvoljeni izbor! ***\a\n"); break;
}
}
}
/* Definicije funkcija za obradu lista (iterativno). */
int duz (Elem *lst) { /* Broj elemenata liste. */
int n = 0;
while (lst){
n++;
lst = lst->sled;
} return n;
}
void pisi (Elem *lst){ /* Ispisivanje liste. */
while(lst){
printf("%d ",lst->broj);
lst = lst -> sled;
}
}
Elem *na_pocetak(Elem *lst, int b){ /* Dodavanje na pocetak. */
Elem *novi = malloc(sizeof(Elem));
novi->broj = b; novi->sled = lst;
return novi;
}
Elem *na_kraj (Elem *lst, int b) { /* Dodavanje na kraj. */
Elem *novi = malloc (sizeof(Elem));
novi->broj = b; novi->sled = NULL;
if (!lst) return novi;
else {
Elem *tek = lst;
while (tek->sled) tek = tek->sled;
tek->sled = novi;
return lst;
}
}
Elem *citaj1 (int n) { /* Citanje liste stavljajuci brojeve na pocetak. */
Elem *prvi = NULL; int i;
for (i=0; i<n; i++) {
Elem *novi = malloc (sizeof(Elem));
scanf("%d", &novi->broj);
novi->sled = prvi;
prvi = novi;
}
return prvi;
}
Elem *citaj2 (int n) { /* Citanje liste stavljajuci brojeve na kraj. */
Elem *prvi = NULL, *posl = NULL; int i;
for (i=0; i<n; i++) {
Elem *novi = malloc (sizeof(Elem));
15
scanf ("%d", &novi->broj); novi->sled = NULL;
if (!prvi)
prvi = novi;
else posl->sled = novi;
posl = novi;
}
return prvi;
}
Elem *umetni (Elem *lst, int b) { /* Umetanje u uredjenu listu. */
Elem *tek = lst, *pret = NULL, *novi;
while(tek && tek->broj < b){
pret = tek;
tek = tek->sled;
}
novi = malloc (sizeof(Elem));
novi->broj = b;
novi->sled = tek;
if(!pret)
lst = novi;
else pret->sled = novi;
return lst;
}
void brisi (Elem *lst) { /* Brisanje svih elemenata liste. */
while(lst){
Elem *stari = lst;
lst = lst->sled;
free (stari);
}
}
Elem *izostavi(Elem *lst, int b){ /* Izostavljanje svakog pojavljivanja. */
Elem *tek = lst, *pret = NULL;
while(tek)
if (tek->broj != b){
pret = tek;
tek = tek->sled;
}
else {
Elem *stari = tek;
tek = tek->sled;
if (!pret) lst = tek; else pret->sled = tek;
free (stari);
}
return lst;
}
16
/* Rad sa povezanom listom - REKURZIVNE verzije
funkcija za rad sa povezanom listom;
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct elem { int broj; struct elem *sled; } Elem; /*Element liste*/
int duz (Elem *lst); /* Broj elemenata liste. */
void pisi (Elem *lst); /* Ispisivanje liste. */
Elem *na_pocetak (Elem *lst, int b); /* Dodavanje na pocetak. */
Elem *na_kraj (Elem *lst, int b); /* Dodavanje na kraj. */
Elem *citaj1 (int n); /* Citanje liste stavljajuci brojeve na pocetak. */
Elem *citaj2 (int n); /* Citanje liste stavljajuci brojeve na kraj. */
Elem *umetni (Elem *lst, int b); /* Umetanje u uredjenu listu. */
void brisi (Elem *lst); /* Brisanje svih elemenata liste. */
Elem *izostavi (Elem *lst, int b); /* Izostavljanje svakog pojavljivanja. */
void main () {
Elem *lst = NULL; int kraj = 0, izbor, broj, n;
while (!kraj) {
printf ("\n1. Dodavanje broja na pocetak liste\n"
"2. Dodavanje broja na kraj liste\n"
"3. Umetanje broja u uredjenu listu\n"
"4. Izostavljanje broja iz liste\n"
"5. Brisanje svih elemenata liste\n"
"6. Citanje uz obrtanje redosleda brojeva\n"
"7. Citanje uz cuvanje redosleda brojeva\n"
"8. Odredjivanje duzine liste\n"
"9. Ispisivanje liste\n"
"0. Zavrsetak rada\n\n"
"Vas izbor? "
);
scanf ("%d", &izbor);
switch (izbor) {
case 1: case 2: case 3: case 4:
printf ("Broj? "); scanf ("%d", &broj);
switch (izbor) {
case 1: /* Dodavanje broja na pocetak liste: */
17
lst = na_pocetak (lst, broj); break;
case 2: /* Dodavanje broja na kraj liste: */
lst = na_kraj (lst, broj); break;
case 3: /* Umetanje broja u uredjenu listu: */
lst = umetni (lst, broj); break;
case 4: /* Izostavljanje broja iz liste: */
lst = izostavi (lst, broj); break;
}
break;
case 5: /* Brisanje svih elemenata liste: */
brisi (lst); lst = NULL; break;
case 6: case 7: /* Citanje liste: */
printf ("Duzina? "); scanf ("%d", &n);
printf ("Elementi? "); brisi (lst);
switch (izbor) {
case 6: /* uz obrtanje redosleda brojeva: */
lst = citaj1 (n); break;
case 7: /* uz cuvanje redosleda brojeva: */
lst = citaj2 (n); break;
}
break;
case 8: /* Odredjivanje duzine liste: */
printf ("Duzina= %d\n", duz (lst)); break;
case 9: /* Ispisivanje liste: */
printf ("Lista= "); pisi (lst); putchar ('\n'); break;
case 0: /* Zavrsetak rada: */
kraj = 1; break;
default: /* Pogresan izbor: */
printf ("*** Neozvoljeni izbor! ***\a\n"); break;
}
}
}
/* Definicije funkcija za obradu lista (REKURZIVNO). */
int duz (Elem *lst) { /* Broj elemenata liste. */
return lst ? duz (lst->sled) + 1 : 0;
}
void pisi (Elem *lst) { /* Ispisivanje liste. */
if (lst) { printf ("%d ", lst->broj); pisi (lst->sled); }
}
Elem *na_pocetak (Elem *lst, int b) { /* Dodavanje na pocetak. */
Elem *novi = malloc (sizeof(Elem));
novi->broj = b; novi->sled = lst;
return novi;
}
Elem *na_kraj (Elem *lst, int b) { /* Dodavanje na kraj. */
if (!lst) {
lst = malloc (sizeof(Elem));
lst->broj = b; lst->sled = NULL;
} else
lst->sled = na_kraj (lst->sled, b);
return lst;
}
Elem *citaj1 (int n) { /* Citanje liste uz obrtanje redosleda. */
if (n == 0) return NULL;
else {
Elem *novi = malloc (sizeof(Elem));
18
novi->sled = citaj1 (n - 1); scanf ("%d", &novi->broj);
return novi;
}
}
Elem *citaj2 (int n) { /* Citanje liste uz cuvanje redosleda. */
if (n == 0) return NULL;
else {
Elem *novi = malloc (sizeof(Elem));
scanf ("%d", &novi->broj); novi->sled = citaj2 (n - 1);
return novi;
}
}
Elem *umetni (Elem *lst, int b) { /* Umetanje u uredjenu listu. */
if (!lst || lst->broj >= b) {
Elem *novi = malloc (sizeof(Elem));
novi->broj = b; novi->sled = lst;
return novi;
} else {
lst->sled = umetni (lst->sled, b);
return lst;
}
}
void brisi (Elem *lst) { /* Brisanje svih elemenata liste. */
if (lst) { brisi (lst->sled); free (lst); }
}
Elem *izostavi (Elem *lst, int b){ /* Izostavljanje svakog pojavljivanja. */
if (lst) {
if (lst->broj != b) {
lst->sled = izostavi (lst->sled, b);
} else {
Elem *stari = lst;
lst = izostavi (lst->sled, b);
free (stari);
}
}
return lst;
}
3.2.3. Metoda int Prebroj(CvorListe Vrh) koja će vratiti koliko elemenata liste ima vrednost veću od elementa na početku liste.
public int prebroj(CvorJSListe pocetak) { if (pocetak == null) {
return 0;
}
int broj = 0; CvorJSListe pom = pocetak;
while (pom != null) { if (pom.podatak > pocetak.podatak) {
broj++;
}
pom = pom.sledeci;
}
return broj;
19
}
3.2.4. Metoda koja vraća broj ponavljanja zadate vrednosti u listi.
public int brPonavljanja(CvorJSListe prvi, int pod) { if (prvi == null)
return 0; int broj = 0; CvorJSListe pom = prvi; while (pom != null) {
if (pom.podatak == pod)
broj++;
pom = pom.sledeci;
}
return broj; }
3.2.5. Metoda koja izbacuje element koji se nalazi nakon elementa sa najmanjom
vrednošću.
public int posleNajmanjeg(CvorJSListe prvi) { if (prvi == null)
return Integer.MIN_VALUE; CvorJSListe
min = minElement(prvi);
if (min.sledeci == null) return
Integer.MIN_VALUE;
broj = min.sledeci.podatak; min.sledeci =
min.sledeci.sledeci; return broj;
}
3.2.6. Broj pozitivnih elemenata – rekurzivno
public int izbrojPozitivne(CvorJSListe pom) { if (pom == null)
return 0;
else {
if (pom.podatak > 0)
return 1 + izbrojPozitivne(pom.sledeci);
else
return izbrojPozitivne(pom.sledeci);
}
}
3.2.7. Metoda koja vraća invertovanu JSListu
public CvorJSListe invertuj(CvorJSListe p1){
CvorJSListe p2 = null;
20
while(p1 != null){ p2 = new CvorJSListe(p1.podatak, p2);
p1 = p1.sledeci;
}
return p2;
}
3.2.8. Metoda koja koja pravi indentičnu kopiju date JSListe
public CvorJSListe klonirana(CvorJSListe pom) {
if (pom != null) {
CvorJSListe novi = new CvorJSListe(pom.podatak, klonirana(pom.sledeci));
return novi; } else {
return null;
}
}
3.2.9. Metoda koja od JSListe pravi niz
public int[] transform(JSLista l) { int br = 0;
CvorJSListe pomocni = l.prvi;
while (pomocni != null) { br++;
pomocni = pomocni.sledeci;
}
pomocni = l.prvi;
int[] stack = new int[br];
for (int i = 0; i < stack.length; i++) { stack[i] = pomocni.podatak;
pomocni = pomocni.sledeci;
}
return stack;
}
3.2.10. Metoda koja od dve JSListe vraća treću listu koja predstavlja uniju datih
listi
public CvorJSListe unija(CvorJSListe c1, CvorJSListe c2) {
if (c1 == null && c2 == null) return null;
CvorJSListe novaLista = null; while (c1
!= null) {
if (!postoji(novaLista, c1.podatak)) {
21
novaLista = new CvorJSListe(c1.podatak, novaLista);
}
c1 = c1.sledeci;
}
while (c2 != null) {
if (!postoji(novaLista, c2.podatak)) {
novaLista = new CvorJSListe(c2.podatak, novaLista);
}
c2 = c2.sledeci;
}
return novaLista; }
3.2.11. Metoda koja proverava da li postoji vrednost u JSListi
private boolean postoji(CvorJSListe c2, int p) { while (c2 != null) {
if (c2.podatak == p) {
return true;
}
c2 = c2.sledeci;
}
return false;
}
3.2.12. KRUŽNO SPREGNUTA LINEARNA LISTA
Kod ovog tipa liste pokazivač poslednjeg elementa nema NULL vrednost već ukazuje na prvi
element liste. Prednosti ovog tipa liste su:
- Svakom elementu se može pristupiti polazeći od bilo kog elementa liste.
- Jednostavnije pronalaženje elemenata liste.
- Efikasnije operacije dodavanja i brisanja elemenata iz liste.
Kod ovog tipa liste neophodno je znati prvi ili poslednji element. To možemo rešiti na dva
načina:
1) Pokazivač na glavu liste
2) Označavanje početnog elementa liste. Npr. ostaviti prazno polje za podatak, ili u njega
upisati specijalni simbol... itd.
22
3.2.13. DVOSTRUKO POVEZANA LINEARNA LISTA
Kod ovog tipa listi, svaki element ima dva pokazivača koji ukazuju na prethodni i naredni
element (levi i desni ukazivač).
Levi ukazivač krajnjeg levog i desni pokazivač krajnjeg desnog elementa su NULL.
23
2. NCP koji iz neprazne datoteke broj.txt ucitava paran broj celih brojeva x[1], x[2],...,x[n],
gde n nije unapred poznato. Ispisati poruku na standardni izlaz da li vazi da x[1]==x[n],
x[2]==x[n-1],..., x[k]=x[k+1], k=1..n/2
#include <stdio.h>
#include <stdlib.h>
typedef struct listacv dvlista;
/*dvostruko povezana linearna lista*/
struct listacv{
int broj; /*informaciono polje je clan niza x*/
dvlista *sledeci, *prethodni;
};
dvlista *ubaci(dvlista *kraj, int broj){
dvlista *novi; /*novi cvor za umetanje u listu*/
novi=(dvlista *)malloc(sizeof(dvlista)); /*alokacija memorije za novi cvor
liste*/
novi->broj=broj; /*inicijalizacija polja broj u cvoru novi */
novi->sledeci=NULL;
novi->prethodni=kraj; /*novi element se dodaje na kraj postojece liste*/
kraj->sledeci=novi; /* do tada poslednji cvor kraj je ispred clana novi*/
kraj=novi; /*poslednji dodat element je novi kraj liste*/
return kraj;
}
main()
{
dvlista *prvi, *kraj; /*prvi i poslednji cvor dvostruke liste*/
int n; /*broj ucitanih celih brojeva*/
int broj; /*tekuci broj sa ulaza*/
int jednak; /*indikator jednakosti dva clana - cuva vrednost 0 ili 1 */
FILE *ulaz;
int i; /*brojacka promenljiva*/
/*otvaranje datoteke za citanje i upis brojeva iz datoteke u
dvostruku povezanu listu */
ulaz=fopen("broj.txt", "r");
fscanf(ulaz, "%d", &broj);
/*kreiranje prvog cvora liste za prvi ucitan broj */
prvi=(dvlista*)malloc(sizeof(dvlista));
prvi->broj=broj;
prvi->sledeci=NULL;
prvi->prethodni=NULL;
kraj=prvi; n=1; //za sada ucita je samo jedan clan
/*formiranje liste od brojeva koji se ucitavaju sve do kraja datoteke -
feof(ulaz) */
while (!feof(ulaz))
{ fscanf(ulaz, "%d", &broj);
kraj=ubaci (kraj, broj);
n++;
}
24
fclose(ulaz);
/*testiranje jednakih parova uz pomeranje tekuceg prvog clana i tekuceg
poslednjeg
clana ka sredini liste*/
jednak=1;
for(i=1; i<=n/2 && jednak; i++)
{ jednak=jednak&&(prvi->broj==kraj->broj);
prvi=prvi->sledeci; /*pomeranje ka sredini liste */
kraj=kraj->prethodni; /*pomeranje ka sredini liste */
}
printf("Za unete broje jednakost ");
if(!jednak) printf("ne ");
printf("vazi\n");
return 0;
}
3.2.14. PRIMENE SPREGNUTIH LINEARNIH LISTI
Prikaz polinoma
Pretpostavimo da imamo polinom od tri promenljive: 3X2 + 4XY + Y2 + XYZ
Svaki element liste koji prikazuje jedan član polinoma dat je na sledećoj slici:
Spregnuta lista za prikaz ovog polinoma izgledala bi:
Odgovarajuća struktura elementa bi bila:
typedef struct elem element;
struct elem{
int expx;
int expy;
int expz;
int koef;
element *naredni;
}
3. NCP-e za sabiranje, oduzimanje i množenje polinoma jedne promenljive.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
struct pnode{
double coef;
long power;
struct pnode *link;
};
typedef struct pnode poly;
#define COEF(a) ((a)->coef)
#define POWER(a) ((a)->power)
25
#define LINK(a) ((a)->link)
poly *addElem(poly *p, double coef, long pow){
poly *c,*newel,*pret=NULL;
c = p;
while(c && POWER(c) > pow){
pret=c;
c = LINK(c);
}
if(!c || POWER(c) < pow){
newel = (poly*)malloc(sizeof(poly));
COEF(newel) = coef;
POWER(newel) = pow;
LINK(newel) = c;
if(!pret)
p = newel;
else
LINK(pret) = newel;
return p;
}
if(POWER(c) == pow){
COEF(c) += coef;
return p;
}
}
poly *create(){
int pow;
double c;
poly *p=NULL;
printf("\nUnesite polinom pocev od najveceg stepena:\n");
while(1){
printf("\nKoeficijent: ");
scanf("%lf",&c);
printf("\nStepen: ");
scanf("%d",&pow);
if(c == 0)
break;
p = addElem(p,c,pow);
if(pow == 0)
break;
}
return p;
}
void display(poly *p){
poly *cur=p;
if(cur){
printf(" %c %.2f * X^%d",COEF(cur)<0?'-':'
',fabs(COEF(cur)),POWER(cur));
cur=LINK(cur);
}
while(cur != NULL){
printf(" %c %.2f * X^%d",COEF(cur)<0?'-
':'+',fabs(COEF(cur)),POWER(cur));
cur=LINK(cur);
}
}
poly *polyadd(poly* p1, poly* p2){
poly *p, *res=NULL;
p=p1;
while(p){
26
res=addElem(res,COEF(p),POWER(p));
p=LINK(p);
}
p=p2;
while(p){
res=addElem(res,COEF(p),POWER(p));
p=LINK(p);
}
return res;
}
poly *polysub(poly* p1, poly* p2){
poly *p, *res=NULL;
p=p1;
while(p){
res=addElem(res,COEF(p),POWER(p));
p=LINK(p);
}
p=p2;
while(p){
res=addElem(res,-COEF(p),POWER(p));
p=LINK(p);
}
return res;
}
poly *polymul(poly* p1, poly* p2){
poly *pom1,*pom2,*res=NULL;
pom1=p1;
while(pom1){
pom2=p2;
while(pom2){
res=addElem(res,COEF(pom1)*COEF(pom2),POWER(pom1)+POWER(pom2));
pom2=LINK(pom2);
}
pom1=LINK(pom1);
}
return res;
}
poly *polydif(poly* p1){
poly *pom1,*res=NULL;
pom1=p1;
while(pom1){
if(POWER(pom1)!=0)
res=addElem(res,COEF(pom1)*POWER(pom1),POWER(pom1)-1);
pom1=LINK(pom1);
}
return res;
}
void brisi(poly *p){
poly *stari;
while(p){
stari=p;
p=LINK(p);
free(stari);
}
}
void main(){
int ch;
poly *poly1,*poly2,*poly3;
poly1=poly2=poly3=NULL;
27
printf("\nUnesite prvi polinom:\n");
poly1=create();
display(poly1);
poly2=create();
display(poly2);
while(1){
printf("************************"
"\nOdaberi operaciju:\n"
"1.Sabiranje\n"
"2.Oduzimanje\n"
"3.Mnozenje\n"
"4.Izvod\n"
"5.Izlaz\n");
scanf("%d",&ch);
switch(ch){
case 1:
poly3=polyadd(poly1,poly2);
break;
case 2:
poly3=polysyb(poly1,poly2);
break;
case 3:
poly3=polymul(poly1,poly2);
break;
case 4:
poly3=polydif(poly1);
break;
default:
exit(1);
}
}
brisi(poly1);
brisi(poly2);
brisi(poly3);
}
3.2.15. Metoda koja prebacuje čvor sa najvećom vrednošću na početak te liste.
public void prebaciMaxElement(CvorDSListe poslednji) { CvorDSListe max = poslednji;
CvorDSListe pom = poslednji;
while (pom.prethodni != null) {
pom = pom.prethodni;
if (pom.podatak > max.podatak) {
max = pom;
}
}
if(max.prethodni == null) return;
max.prethodni.sledeci = max.sledeci;
if(max.sledeci != null)
max.sledeci.prethodni = max.prethodni;
max.prethodni = null;
28
max.sledeci = pom; pom.prethodni =
max;
}
3.2.16. Napisati metodu koja prikazuje (štampa na ekranu) onu polovinu liste (levo od p ili desno od p) koja ima veći zbir
public void veciZbir(CvorDSListe p) { CvorDSListe pom = p; int zbir1 = 0; int zbir2 = 0; while (pom != null) {
zbir1 = zbir1 + pom.podatak;
pom = pom.sledeci;
}
pom = p;
while (pom != null) {
zbir2 = zbir2 + pom.podatak;
pom = pom.prethodni;
}
if (zbir1 > zbir2) { pom = p.sledeci; while (pom != null) {
System.out.println(pom.podatak);
pom = pom.sledeci;
}
} else {
pom = p.prethodni;
while (pom != null) {
System.out.println(pom.podatak);
pom = pom.prethodni;
}
}
}
3.2.17. Dat je pokazivač na prvi element DSListe čiji čvorovi predstavljaju elemente reči (slovo ili prazno mesto). Napisati metodu koja proverava da li je data rečenica (reč) palindrom. Palindrom je reč (rečenica) koja se čita isto
sa obe strane (i sleva na desno i s desna na levo).
public static boolean daLiJePalindromDS(CvorDSListe p) { if (p == null) {
return false;
}
CvorDSListe pom = p;
while (pom.sledeci != null) {
29
pom = pom.sledeci;
}
while (p != pom && p.prethodni != pom) {
if (p.podatak == ' ') {
p = p.sledeci;
}
if (pom.podatak == ' ') { pom
= pom.prethodni;
}
if (p.podatak == pom.podatak) { p
= p.sledeci;
pom = pom.prethodni;
} else {
return false;
}
}
return true;
}
3.2.18. Data je dvostruko spregnuta (DS) lista čiji su elementi čvorova
pokazivači na početak jednostruko spregnute (JS) liste. Napisati klasu
koja opisuje čvor ovakve DS liste, a zatim napisati algoritam za ubacivanje novog elementa u ovako definisanu strukturu, koji funkcioniše po sledećem
principu: kreće se od početka DS liste. Ako je element koji se ubacuje manji od prvog elementa JS liste trenutnog čvora DS liste, onda se taj element ubacuje na kraj te JS liste. U suprotnom, prelazi se na sledeći čvor DS liste i algoritam se ponavlja. Ako se stigne do kraja DS liste, onda se kreira novi čvor i u njegovu JS listu se ubacuje novi element. Početna metoda prihvata pokazivač na početak DS liste i ceo broj koji se ubacuje.
public class CvorListe { private CvorListe sledeci; private CvorListe prethodni; private CvorJSListe prvi;
public void ubaci(CvorListe p, int pod) {
if (p == null) {
p = new CvorListe();
p.prvi = new CvorJSListe(pod, null); } else {
while (p.sledeci != null && p.prvi.podatak <= pod) {
p = p.sledeci;
}
30
if (p.prvi.podatak <= pod) { p.sledeci =
new CvorListe(); p.sledeci.prethodni
= p;
p.sledeci.prvi = new CvorJSListe(pod, null);
} else {
CvorJSListe pom = prvi;
while (pom.sledeci != null) {
pom = pom.sledeci;
}
pom.sledeci = new CvorJSListe(pod, null);
}
}
}
}
3.2.19. Dat je pokazivac na neki element DS liste celih brojeva. Napisati funkciju koja ce izbaciti iz liste onaj element koji sadrži najmanju vrednost u listi.
public int izbaciMin(CvorDSListe cvor) { if (cvor == null)
return Integer.MAX_VALUE;
while (cvor.prethodni != null) { cvor = cvor.prethodni;
}
CvorDSListe min = minElement(cvor);
if (min.prethodni != null) min.prethodni.sledeci =
min.sledeci;
if (min.sledeci != null)
min.sledeci.prethodni = min.prethodni;
return min.podatak;
}
3.2.20. Dat je pokazivač na prvi element DS liste. Napisati metodu koja vraća
pokazivač na element sa najmanjom vrednošću u listi.
private CvorDSListe minElement(CvorDSListe cvor) { CvorDSListe
min = cvor;
while (cvor != null) {
if (cvor.podatak < min.podatak)
min = cvor;
cvor = cvor.sledeci;
}
return min;
31
}
3.2.21. Dat je pokazivac na pocetni cvor DS liste sortirane u rastucem redosledu koja sadrži pozitivne cele brojeve. Napisati funkciju koja ce
izmedju svih onih elementa liste koji se po vrednosti razlikuju za više od 1 ubaciti u datu listu nove elemente tako da lista posle poziva operacije ima u sebi
sukcesivne cele brojeve. Na primer ako lista sadrži 3, 5, 8 nakon poziva ove opercije sadržace 3, 4, 5, 6, 7, 8
public void popuni(CvorDSListe prvi) { if (prvi == null || prvi.sledeci == null)
return;
if ((prvi.sledeci.podatak - prvi.podatak) > 1) {
CvorDSListe novi = new CvorDSListe(prvi.podatak + 1, prvi, prvi.sledeci);
prvi.sledeci.prethodni = novi;
prvi.sledeci = novi;
}
popuni(prvi.sledeci);
}
3.2.22. Dat je pokazivac na neki cvor DS liste celih brojeva koja sigurno
sadrži najmanje 4 elementa. Napisati funkciju ubaciNti(int A, int N) koja
ce ubaciti novi element sa sadržajem A i to tako da on bude na N-toj
poziciji od pocetka.
public void ubaciN(CvorDSListe cvor, int a, int n) { if (cvor == null)
return;
while (cvor.prethodni != null) cvor
= cvor.prethodni;
CvorDSListe pom = new CvorDSListe(a, null, null); if (n < 0) {
return;
}
if (n == 0) { pom.prethodni
= null; pom.sledeci =
cvor;
if (pom.sledeci != null) pom.sledeci.prethodni
= pom;
}
int i = 0; while (i++ < n - 1) {
if (cvor.sledeci == null) return;
cvor = cvor.sledeci;
}
32
pom.prethodni = cvor;
pom.sledeci = cvor.sledeci; if (cvor.sledeci != null)
cvor.sledeci.prethodni = pom; cvor.sledeci =
pom;
}
3.2.23. Metoda koja invertuje dvostruko-spregnutu listu.
public CvorDSListe invertujLIstu(CvorDSListe cvor) {
CvorDSListe c = null;
while (cvor != null) {
c = new CvorDSListe(cvor.podatak, null, c);
if (c.sledeci != null)
c.sledeci.prethodni = c;
cvor = cvor.sledeci;
}
return c; }
3.2.24. Metoda koja vraća DSListu koja predstavlja razliku (skupova) dve
DSListe
public CvorDSListe razlika(CvorDSListe c1, CvorDSListe c2) {
if (c1 == null || c2 == null) return c1;
CvorDSListe novi = null; CvorDSListe pom = c1; while (pom != null) {
if (!pronadji(pom.podatak, c2)) {
novi = new CvorDSListe(pom.podatak, null, novi);
if (novi.sledeci != null) { novi.sledeci.prethodni =
novi;
}
}
pom = pom.sledeci;
}
return novi;
}
3.2.25. Metoda koja poslednji element DSListe prebacuje na početak te
DSListe. Dati su pokazivačni na prvi i poslednji element
public void prebaciPoslednjiNaPocetak() { if (prvi == null) {
return;
}
33
if (prvi.sledeci == null) {
return;
}
CvorDSListe pom = poslednji;
poslednji = pom.prethodni; pom.sledeci =
prvi; prvi.prethodni = pom;
pom.prethodni.sledeci = null;
pom.prethodni = null;
prvi = pom;
}
3.2.26. Metoda koja računa zbir elemenata koji se ponavljaju. Primer: Ulaz 5
7 2 2 5 2. Rezultat je 2+5=7
public int ZbirDuplih(CvorDSListe p1) { if (p1 == null)
return 0; CvorDSListe tek = p1;
CvorDSListe tek1 = p1.sledeci;
CvorDSListe tek2 = tek.prethodni; int ima
= 0;
int suma = 0;
for (; tek != null; tek = tek.sledeci) {
for (; tek2 != null; tek2 = tek2.prethodni) {
if (tek.podatak == tek2.podatak) {
ima = 1;
break;
}
}
tek2 = tek;
if (ima == 0) {
for (; tek1.sledeci != null; tek1 = tek1.sledeci) {
if (tek.podatak == tek1.podatak) {
suma = suma + tek.podatak;
break;
}
}
}
if (tek1.sledeci != null) {
tek1 = tek1.sledeci;
}
}
return suma;
34
}
3.2.27. Metoda koja vraća pokazivač na prvi element ciklične DSListe sortirane u rastućem redosledu. Dat je pokazivač na neki element u listi.
public CvorDSListe vratiPokNaPrviEl(CvorDSListe p) {
if (p == null || (p.sledeci == p && p.prethodni == p))
return p; CvorDSListe pom = p;
while (pom.sledeci.podatak > pom.podatak
&& pom.prethodni.podatak < pom.podatak)
pom = pom.sledeci;
return pom.sledeci;
}
35
RETKO POSEDNUTE MATRICE
Realizuje se preko spregnutih listi i ima za cilj smanjenje broja izračunavanja, kao i smanjenje
potrebne memorije za čuvanje sturkture.
Jedna moguća reprezentacija dvodimenzionalne retko posednute matrice bi bila preko jedne
spregnute liste za svaki red i svaku kolonu matrice. Svaka od ovih listi ima zaglavlje, tj. glavu. Svakom
nenultom mestu u matrici odgovara jedan čvor oblika:
struct cvor {
int red;
int kolona;
int vrednost;
struct cvor *nar_u_kol;
struct cvor *nar_u_vrsti;
}
/* Implementacija dinamickih kvadratnih matrica preko pokazivaca na niz pokazivaca na
kolone */
#include <stdio.h>
#include <stdlib.h>
/* Tip elemenata matrice ce biti float */
typedef float tip;
/* Funkcija alocira matricu dimenzije n*n */
tip** allocate(int n){
tip **m;
int i;
/* Alocira se niz pokazivaca na kolone */
m=(tip**)malloc(n*sizeof(tip*));
for (i=0; i<n; i++)
/* Alociraju se nizovi brojeva koji predstavljaju kolone */
36
m[i]=(tip*)malloc(n*sizeof(tip));
return m;
}
/* Funkcija vrsi dealociranje date matrice dimenzije n */
void deallocate(tip** m, int n){
int i;
/* Uklanjaju se kolone */
for (i=0; i<n; i++)
free(m[i]);
/* Uklanja se niz pokazivaca na kolone */
free(m);
}
/* Funkcija ispisuje datu matricu dimenzije n */
void IspisiMatricu(tip** matrica, int n){
int i,j;
for (i=0; i<n; i++){
for(j=0; j<n; j++)
printf("%f\t",matrica[i][j]);
printf("\n");
}
}
/* Funkcija ucitava datu matricu i njenu dimenziju */
void UnesiMatricu(tip*** matrica,int *pn){
int i,j;
printf("Unesite dimenziju kvadratne matrice :");
scanf("%d",pn);
*matrica=allocate(*pn);
for (i=0; i<*pn; i++)
for(j=0; j<*pn; j++){
printf("A[%d][%d]=",i+1,j+1);
scanf("%f",&((*matrica)[i][j]));
}
}
/* Rekurzivna funkcija koja vrsi Laplasov razvoj - neefikasna, ali dobra vezba */
tip determinanta(tip** matrica, int n){
int i;
tip** podmatrica;
int det=0,znak;
/* Izlaz iz rekurzije je matrica 1x1 */
if (n==1)
return matrica[0][0];
/* Podmatrica ce da sadrzi minore polazne matrice */
podmatrica=allocate(n-1);
znak=1;
for (i=0; i<n; i++){
int vrsta,kolona;
for (kolona=0; kolona<i; kolona++)
for(vrsta=1; vrsta<n; vrsta++)
podmatrica[vrsta-1][kolona]=matrica[vrsta][kolona];
for (kolona=i+1; kolona<n; kolona++)
for(vrsta=1; vrsta<n; vrsta++)
podmatrica[vrsta-1][kolona-1]=matrica[vrsta][kolona];
det+=znak*matrica[0][i]*determinanta(podmatrica,n-1);
znak*=-1;
}
deallocate(podmatrica,n-1);
return det;
}
main(){
/* Matrica i njena dimenizija */
37
tip **matrica;
int n;
/* Unosi se matrica */
UnesiMatricu(&matrica,&n);
/* Ispisuje se determinanta */
printf("Determinanta je : %f\n",determinanta(matrica,n));
return 0;
}
3.3. BSTEK
3.3.1. 6BDEFINICIJE I STUKTURA
Stek (stack) ili magacin je jedna od najznačajnijih linearnih i dinamičkih struktura podataka. Stavljanje
(upis) ili brisanje (čitanje) elemenata se vrši samo na jednom kraju. Operacija stavljanja se naziva PUSH, a
brisanja POP. Stek se prazni i puni po tzv. LIFO strategiji.
#define MAXSTACKLEN 100 /* maksimalna dubina steka */
int stack[MAXSTACKLEN];/*vrednost steka */
int stackPointer;/*naredna slobodna pozicija na steku */
/* push: gurni na stek */
void push( int arg ){
if( stackPointer < MAXSTACKLEN )
stack[stackPointer++] = arg;
else
printf("greska: stek je pun, nemoguce je smestiti %g\n", arg);
}
/* pop: skini sa steka*/
int pop( void ){
if( stackPointer > 0 )
return stack[--stackPointer];
else{
printf("greska: stek je prazan\n" );
return 0;
}
}
int top(void){
if(stackPointer > 0)
return stack[stackPointer-1];
else{
printf("greska: stek je prazan\n");
return 0;
}
}
10BOpis zadatka:
Za aritmetičke izraze kao što su T2+3T, T2+3*4T, T(2+3)*4T, itd. sa kojima se tipično susrećemo kako u
matematici tako i u programiranju, kažemo da su zapisani u Tinfiksnoj formiT, s obzirom da se operator
nalazi TizmeđuT operanada. Najveća mana ovakvog zapisa leži u činjenici da je neophodno uspostaviti
konvencije o TprioritetuT pojedinih operatora (npr. konvenciju da množenje ima veći prioritet u odnosu na
sabiranje), i eventualno koristiti zagrade za promenu prioriteta.
38
U računarstvu je od velikog značaja jedan posve drugačiji zapis aritmetičkih izraza, poznat pod
imenom TpostfiksnaT ili Tobrnuta poljska notacijaT, u kojem se operatori navode TnakonT operanada (naziv
obrnuta poljska notacija dat je u čast poljskog matematičara Jana Lukasiewitza, koji je predložio upravo
obrnuti princip - da se operatori zapisuju TispredT operanada). Na primer, prethodna tri izraza zapisana u
infiksnoj notaciji, u obrnutoj poljskoj notaciji zapisuju se ovako:
2 3 +
2 3 4 * +
2 3 + 4 *
Izračunavanje izraza u obrnutoj poljskoj notaciji izvodi se tako da se svaki operand na koji se
naiđe dodaje na kraj liste (koja je na početku prazna), dok se prilikom nailaska na binarni operator
poslednja dva elementa iz liste brišu i zamenjuju rezultatom operacije (sličan princip može se
primeniti i na n-arne operatore). Broj koji na kraju izračunavanja ostane u listi predstavlja rezultat
izračunavanja (taj broj mora biti jedinstven ako je izraz bio ispravan). Uzmimo na primer, sledeći
izraz zapisan u obrnutoj poljskoj notaciji:
3 5 6 4 - * 6 + * 2 /
Izračunavanje ovog izraza teklo bi ovako:
3
3 5
3 5 6
3 5 6 4
3 5 2 T6 i 4 su zamijenjeni sa 6-4=2
3 10 T5 i 2 su zamijenjeni sa 5*2=10
3 10 6
3 16 T10 i 6 su zamijenjeni sa 10+6=16
48 T3 i 16 su zamijenjeni sa 3*16=48
48 2
24 T48 i 2 su zamijenjeni sa 48/2=24
Dakle, rezultat izračunavanja je 24. Jedna od glavnih prednosti obrnute poljske notacije leži u činjenici
da nije potrebno voditi računa o prioritetu operacija, kao i da je Tsvaki T izraz moguće zapisati Tbez upotrebe
zagradaT. Na primer, izraz koji bi se u infiksnom obliku zapisao kao
((3 + 5) / (7 - 2) + 4 / (8 - 5)) / (3 + 5 * (4 / (7 - 2)))
u obrnutoj poljskoj notaciji zapisuje se kao
3 5 + 7 2 - / 4 8 5 - / + 3 5 4 7 2 - / * + /
Stoga, kompajleri većine programskih jezika interno prevode sve aritmetičke izraze u obrnutu poljsku
notaciju pre bilo kakve dalje obrade. Vaš zadatak je da napravite program koji aritmetičke izraze u
infiksnom obliku koji se sastoje od jednoslovnih promjenljivih (a-z), četiri računske operacije (T+T, T-T, T*T i T/T), i
eventualno zagrada, pretvori u obrnutu poljsku notaciju.
11BUlazna datoteka:
U prvom i jedinom redu ulazne tekstualne datoteke TRPN.INT nalazi se niz znakova koji predstavlja
aritmetički izraz u infiksnoj notaciji koji treba pretvoriti u postfiksnu odnosno obrnutu poljsku notaciju.
39
Ispravan aritmetički izraz sme sadržavati samo jednoslovne promenljive pisane malim slovima (od "a" do
"z"), binarne operatore " T+T", "T-T", "T*T" i "T/T" kao i male zagrade "(" i ")" za promenu prioriteta operacija.
Ispravan aritmetički izraz neće sadržati nikakve razmake.
12BIzlazna datoteka:
Ukoliko ulazna datoteka sadrži ispravan aritmetički izraz u infiksnoj notaciji, tada u prvi i jedini red
izlazne tekstualne datoteke TRPN.OUTT treba upisati niz znakova koji predstavlja aritmetički izraz u obrnutoj
poljskoj notaciji. Ovaj izraz sastoji se od niza znakova koji smeju sadržavati samo mala slova (od "a" do
"z") i binarne operatore " T+T", "T-T", "T*T" i " T/T". Nikakvi razmaci u izrazu nisu dozvoljeni. Ukoliko ulazna datoteka
ne sadrži ispravan aritmetički izraz, u izlaznu datoteku treba samo ispisati tekst.
NEISPRAVAN IZRAZ
13BPrimeri:
TRPN.IN
x+y+z
TRPN.OUT
xy+z+
TRPN.IN
x+(y+z)
TRPN.OUT
xyz++
TRPN.IN
x+y*z
TRPN.OUT
xyz*+
TRPN.IN
(x+y)*z
TRPN.OUT
xy+z*
TRPN.IN
x*(y+z
TRPN.OUT
NEISPRAVAN IZRAZ
T
RPN.IN
a+b/c+d
TRPN.OUT
abc/+d+
TRPN.IN
(a+b)/(c+d)
TRPN.OUT
ab+cd+/
TRPN.IN
x*(y+z*(a+b*(c-d))/e)
TRPN.OUT
xyzabcd-*+*e/+*
/******************************************
* IZRACUNAVANJE IZRAZA KOJI JE ZADAT U *
* INVERZNOJ POLJSKOJ NOTACIJI *
*******************************************/
int computePolish(char izraz[]){
char symbol;
int sum,n,i;
n=(int)strlen(izraz);
i=0;
while (i<n){
symbol=izraz[i];
if((symbol - '0')>=0 && (symbol - '0')<=9){
push(symbol-'0');
}
if ( symbol == '+' || symbol == '-' || symbol == '*' || symbol == '/'){
int first, second;
first = pop();
second = pop();
switch(symbol){
case '+':
sum = first + second;
break;
40
case '-':
sum = second - first;
break;
case '*':
sum = second * first;
break;
case '/':
sum = second / first;
break;
}
push(sum);
}
i++;
}
return(top());
}
41
/* PREVODJENJE IZRAZA IZ INFIKS U POSTFIKS FORMU */
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <string.h>
int Priority(char Operator) {
if(Operator=='*'||Operator=='/') return 2;
else if(Operator=='+'||Operator=='-') return 1;
else return 0;}
char *Compile(char *Expr) {
static char *Error="NEISPRAVAN IZRAZ";
static char Comp[256]="";
char Last=0,Ch,Ch1,Stack[256]="";
int FindFlag,VarFlag=0,SSPtr=0,CompLen=0,SynError;
int I,Parenths=0,Balance=0;
for(I=0;I < (int)strlen(Expr);I++) {
Ch=Expr[I]; SynError=1;
if(Ch>='a' && Ch<='z' && !VarFlag) {
VarFlag=1; SynError=0; Balance++; Comp[CompLen++]=Ch;
} else VarFlag=0;
if(Priority(Ch)) {
if(Priority(Last)||Last=='(') return Error;
while(1) {
SynError=0; Ch1=Stack[SSPtr-1];
if(!SSPtr||Ch1=='('||Priority(Ch)>Priority(Ch1)) {
Stack[SSPtr++]=Ch; break;
}
Comp[CompLen++]=Ch1; SSPtr--;
Balance-=(Ch1=='+'||Ch1=='-'||Ch1=='*'||Ch1=='/');
}
}
if(Ch=='(') {
Stack[SSPtr++]='('; SynError=0; Parenths++;
}
if(Ch==')'&&!(SynError=--Parenths<0))
while((Ch1=Stack[--SSPtr])!='(') {
Comp[CompLen++]=Ch1;
Balance-=(Ch1=='+'||Ch1=='-'||Ch1=='*'||Ch1=='/');
}
if(SynError) return Error;
Last=Ch;
}
if(Parenths||SynError) return Error;
for(I=SSPtr-1;I>=0;I--) {
Ch=Comp[CompLen++]=Stack[I];
Balance-=(Ch=='+'||Ch=='-'||Ch=='*'||Ch=='/');
}
if(Balance!=1) return Error;
Comp[CompLen]=0;
return Comp;
}
int main(void) {
char Str[256];
//ifstream InFile("RPN.IN"); ofstream OutFile("RPN.OUT");
//InFile>>Str; OutFile<<Compile(Str);
FILE *f,*g;
f=fopen("rpn.in","r");
g=fopen("rpn.out","w");
fscanf(f,"%s",Str);
fprintf(g,"%s",Compile(Str));
fclose(f);fclose(g);
return 0;}
42
3.3.2. 7BPrimena steka – rekurzija
Prilikom rekurzije moraju se poštovati dva osnovna principa:
1) Svaki sledeći poziv mora voditi ka konačnom rešenju problema
2) Mora postojati uslov za završetak procesa
#define DIM 1000
int faktorijelRekurzivno(int n){
int retv,pom;
if(n==1)
retv=1;
else{
pom=faktorijelRekurzivno(n-1);
retv=n*pom;
}
return retv;
}
int faktorijelNerekurzivno(int n){
int top=-1, stn[DIM],stretv[DIM],stadr[DIM],stpom[DIM];
int retv,adr,pom;
step1:
if(n==1){
retv=1;
stretv[top]=retv;
}
else{
step2:
//prevodjenje poziva faktorijelRekurzivno(n-1)
top++;
stn[top] = n;
stretv[top] = retv;
stpom[top] = pom;
stadr[top] = 3;
//postavi paramertre na nove vrednosti
n--;
goto step1;
step3:
pom = retv;
retv = n*pom;
stretv[top]=retv;
}
//prevodjenje return
if(top == -1)
return retv;
else{
n = stn[top];
retv = stretv[top];
pom = stpom[top];
adr = stadr[top];
top--;
if(adr == 3)
goto step3;
//posto je samo jedan rekurzivan poziv
//jedno je i mesto odakle se posle pozivna nastavlja funkcija
43
//goto step3
}
}
void move(int d, char f, char t)
{
/* move disk d from peg f to peg t */;
printf("moving disk %d : %c --> %c\n", d, f, t);
}
void hanoi(int h, char f, char t, char r)
{
if (h > 0)
{
hanoi(h-1, f, r, t);
move (h, f, t);
hanoi(h-1, r, t, f);
}
}
void hanoiNerekurzivno(int n, char poc, char pom, char kraj){
int stn[DIM], stpoc[DIM], stpom[DIM], stkraj[DIM], stadr[DIM];
int top=-1, adr, tmp;
step1:
if(n==1){
printf("\n %c -> %c ", poc, kraj);
goto step5;
}
//prevodjenje poziva hanoi(n-1,poc,kraj,pom);
top++;
stn[top] = n;
stpoc[top] = poc;
stpom[top] = pom;
stkraj[top] = kraj;
stadr[top] = 3;
//setuj parametre na nove vrednosti
n--;
poc = poc;
tmp = pom;
pom = kraj;
kraj = tmp;
goto step1;
step3:
printf("\n %c -> %c ", poc, kraj);
//prevodjenje poziva hanoi(n-1,pom,poc,kraj)
top++;
stn[top] = n;
stpoc[top] = poc;
stpom[top] = pom;
stkraj[top] = kraj;
stadr[top] = 5;
//setuj parametre na nove vrednosti
n--;
tmp = poc;
poc = pom;
pom = tmp;
kraj = kraj;
goto step1;
step5:
if(top == -1)
return;
44
else{
n = stn[top];
poc = stpoc[top];
pom = stpom[top];
kraj = stkraj[top];
adr = stadr[top];
top--;
if(adr == 3)
goto step3;
if(adr == 5)
goto step5;
}
}
3.4. 3BRED
Kod steka se sva umetanja i brisanja izvršavaju na kraju koji se naziva vrh (TOP), dok se kod reda sva
umetanja izvršavaju na kraju – KRAJ, a sva brisanja na drugom kraju reda, tj. početku – Čelo.
Redovi su poznati kao FIFO memorije. Red S možemo implementirati kao konačan niz S[0..n-1] i pri
tome se koriste dva podatka, CELO i KRAJ da bi se oznčile granice reda. Ako je CELO < KRAJ tada se red
sastoji od S[CELO] ... S[KRAJ-1]. U suprotnom, ako je CELO > KRAJ, tada se red sastoji od
S[CELO],...,S[n-1],S[0],...,S[KRAJ-1], i ako je CELO = KRAJ, tada je red prazan.
45
46
4. NELINEARNE STRUKTURE PODATAKA
Najznačajnije nelinearne strukture podataka su stabla i grafovi.
4.1. STABLA
4.1.1. DEFINICIJE I KONCEPTI
Graf G=(V,E) se sastoji od nepraznog skupa čvorova G i skupa E koji je skup grana grafa.
Stablo je acikličan, orijentisan graf koji ima jedan čvor koji se zove koren (root) sa ulaznim stepenom 0
dok svi drugi čvorovi imaju ulazni stepen 1. Ako izbrišemo koren i njegove grane dobijamo skup disjunktnih
stabala. Svaki čvor kojiima izlazni stepen 0 naziva se terminalni čvor ili list, dok se svi drugi čvorovi
nazivaju čvorovi grananja (brunch nodes).
Nivo čvora je dužina puta od korena, d.
Dubina (visina) stabla je maksimalna vrednost nivoa nekog čvora u stablu.
Za stablo se kaže da je n-arno (reda n) ako svaki čvor ima najviše n podčvorova.
Za stablo se kaže da je puno ako se svi listovi nalaze na istom rastojanju od korena, tj. ako od
korena do svakog lista odgovara put dužine h-1.
Za stablo se kaže da je kompletno ako svi njegovi čvorovi koji ne predstavljaju listove imaju
svih n odlaznih potega.
Broj čvorova kompletnog punog stabla iznosi
C = n0 + n1 + n3 + ... + nh = ∑ 𝑛𝑗ℎ𝑗=0 =
(𝑛ℎ+1−1)
(𝑛−1)
Kapacitet čvora k predstavlja broj elemenata koji se može smestiti u čvor.
Za stablo se kaže da je balansirano ako za svaki čvor važi da se broj čvorova u svakom
njegovom podstablu ne razlikuje za više od 1.
Za stablo reda n čiji su svi čvorovi na nivoima od 1 do h-1 kompletni, kaže se da je optimalno
balansirano.
4.1.2. OPERACIJE NA BINARNIM STABLIMA
Neke od operacija nad binarnim stablom su: prolaz, umetanje, brisanje, pretraživanje i kopiranje.
47
/* rad sa binarnim stablom - implementacija funkcija koje vrse specificnu obradu nad
cvorovima
binarnog stabla */
#include <stdio.h>
#include <stdlib.h>
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
Stablo stvori (void); /* Stavaranje praznog stabla. */
int vel (Stablo koren); /* Broj cvorova u stablu. */
int zbir (Stablo koren); /* Zbir brojeva u stablu. */
void pisi_kld (Stablo koren); /* Prefiksno ispisivanje. */
void pisi_lkd (Stablo koren); /* Infiksno ispisivanje. */
void pisi_ldk (Stablo koren); /* Postfiksno ispisivanje. */
void crtaj (Stablo koren, int nivo); /* Graficki prikaz stabla. */
int pojav (Stablo koren, int b); /* Broj pojavljivanja u stablu. */
int min_u (Stablo koren); /* Najmanji u uredjenom stablu. */
int max_u (Stablo koren); /* Najveci u uredjenom stablu. */
int min_n (Stablo koren); /* Najmanji u neuredjenom stablu. */
int max_n (Stablo koren); /* Najveci u neuredjenom stablu. */
int uredjeno (Stablo koren); /* Da li je stablo uredjeno? */
Cvor *nadji_u (Stablo koren, int b); /* Trazenje u uredjenom stablu. */
Cvor *nadji_n (Stablo koren, int b); /* Trazenje u neuredjenom stablu. */
Stablo dodaj_u (Stablo koren, int b); /* Dodavanje u uredjeno stablo. */
Stablo dodaj_n (Stablo koren, int b); /* Dodavanje u neuredjeno stablo. */
Stablo citaj_u (int n); /* Citanje uredjenog stabla. */
Stablo citaj_n (int n); /* Citanje neuredjenog stabla. */
Stablo brisi (Stablo koren); /* Brisanje celog stabla. */
Stablo izost_u (Stablo koren, int b); /* Izost. iz uredjenog stabla. */
Stablo izost_n (Stablo koren, int b); /* Izost. iz neuredjenog stabla. */
Stablo balans_u (Stablo koren); /* Balansiranje uredjenog stabla. */
Stablo balans_n (Stablo koren); /* Balansiranje neuredjenog satbla.*/
int moze (Stablo koren); /* Da li moze uredjena radnja? */
Stablo radi (Stablo (*f)(Stablo,int), Stablo koren); /* Primena operacije na stablo za
svaki procitani broj */
void main () {
Stablo koren = stvori (); //stablo
int kraj = 0, broj, n; //indikator kraja rada, element u cvoru stabla, duzina
char izbor[2]; //izbor korisnika sa menija opcija
//obrada menija opcija koje se prikazuju korisniku
while (!kraj) {
printf ("\nDodavanje brojeva: a) uredjeno b) neuredjeno\n"
"Izostavljanje brojeva: c) uredjeno d) neuredjeno\n"
"Citanje stabla: e) uredjeno f) neuredjeno\n"
"Najmanji element: g) uredjeno h) neuredjeno\n"
"Najveci element: i) uredjeno j) neuredjeno\n"
"Pretrazivanje: k) uredjeno l) neuredjeno\n"
"Balansiranje: m) uredjeno n) neuredjeno\n"
"Pisanje stabla: p) koren-levo-desno\n"
" q) levo-koren-desno (uredjeno)\n"
" r) levo-desno-kren\n"
" s) crtanje\n"
"1. Velicina stabla 2. Zbir elemenata\n"
"3. Broj pojavljivanja 4. Praznjenje stabla\n"
" 0. Zavrsetak rada\n\n"
"Vas izbor? "
);
scanf ("%s", &izbor);
48
switch (izbor[0]) {
case 'a': case 'A': /* Dodavanje brojeva u uredjeno stablo: */
if (moze (koren)) koren = radi (dodaj_u, koren); break;
case 'b': case 'B': /* Dodavanje brojeva u neuredjeno stablo: */
koren = radi (dodaj_n, koren); break;
case 'c': case 'C': /* Izostavljanje brojeva iz uredjenog stabla: */
if (moze (koren)) koren = radi (izost_u, koren); break;
case 'd': case 'D': /* Izostavljanje brojeva iz neuredjenog stabla: */
koren = radi (izost_n, koren); break;
case 'e': case 'E': /* Citanje uredjenog stabla: */
printf ("Duzina? "); scanf ("%d", &n);
printf ("Brojevi? "); koren = brisi (koren); koren = citaj_u (n);
break;
case 'f': case 'F': /* Citanje neuredjenog stabla: */
printf ("Duzina? "); scanf ("%d", &n);
printf ("Brojevi? "); koren = brisi (koren); koren = citaj_n (n);
break;
case 'g': case 'G': case 'h': case 'H':
case 'i': case 'I': case 'j': case 'J':
if (koren) switch (izbor[0]) {
case 'g': case 'G': /* Najmanji element uredjenog stabla: */
if (moze (koren)) printf ("min= %d\n", min_u (koren)); break;
case 'h': case 'H': /* Najmanji element neuredjenog stabla: */
printf ("min= %d\n", min_n (koren)); break;
case 'i': case 'I': /* Najveci element uredjenog stabla: */
if (moze (koren)) printf ("max= %d\n", max_u (koren)); break;
case 'j': case 'J': /* Najveci element neuredjenog stabla: */
printf ("max= %d\n", max_n (koren)); break;
} else printf ("*** Stablo je parzno! ***\a\n");
break;
case 'k': case 'K': /* Broj pojavljivanja u uredjenom stablu: */
if (moze (koren)) {
printf ("Broj? "); scanf ("%d", &broj);
printf ("Broj se%s nalazi u stablu.\n",
(nadji_u (koren, broj) != NULL ? "" : " NE"));
} break;
case 'l': case 'L': /* Broj pojavljivanja u neuredjenom stablu: */
printf ("Broj? "); scanf ("%d", &broj);
printf ("Broj se%s nalazi u stablu.\n",
(nadji_n (koren, broj) != NULL ? "" : " NE"));
break;
case 'm': case 'M': /* Balansiranje uredjenog stabla: */
if (moze (koren)) koren = balans_u (koren); break;
case 'n': case 'N': /* Balansiranje neuredjenog stabla: */
koren = balans_n (koren); break;
case 'p': case 'P': /* Pisanje stabla koren-levo-desno: */
printf ("Stablo= "); pisi_kld (koren); putchar ('\n'); break;
case 'q': case 'Q': /* Pisanje stabla levo-koren-desno: */
printf ("Stablo= "); pisi_lkd (koren); putchar ('\n'); break;
case 'r': case 'R': /* Pisanje stabla levo-desno-koren: */
printf ("Stablo= "); pisi_ldk (koren); putchar ('\n'); break;
case 's': case 'S': /* Crtanje stabla: */
crtaj (koren, 0); break;
case '1': /* Velicina stabla: */
printf ("Vel= %d\n", vel (koren)); break;
case '2': /* Zbir elemenata stabla: */
printf ("Zbir= %d\n", zbir (koren)); break;
case '3': /* Broj pojavljivanja datog broja: */
printf ("Broj? "); scanf ("%d", &broj);
printf ("Broj se pojavljuje %d puta.\n", pojav (koren, broj));
break;
case '4': /* Praznjenje stabla: */
49
koren = brisi (koren); break;
case '0': /* Zavrsetak rada: */
kraj = 1; break;
default: /* Pogresan izbor: */
printf ("*** Nedozvoljeni izbor! ***\a\n"); break;
}
}
}
Stablo stvori (void) { return NULL; } /* Stvaranje praznog stabla. */
int vel (Stablo koren) /* Broj cvorova u stablu. */
{ return koren ? 1 + vel (koren->levo) + vel (koren->desno) : 0; }
int zbir (Stablo koren) /* Zbir brojeva u stablu. */
{ return koren ? koren->broj + zbir (koren->levo) + zbir (koren->desno) : 0; }
void pisi_kld (Stablo koren) { /* Prefiksno ispisivanje. */
if (koren) {
printf ("%d ", koren->broj); pisi_kld (koren->levo); pisi_kld (koren->desno);
}
}
void pisi_lkd (Stablo koren) { /* Infiksno ispisivanje. */
if (koren) {
pisi_lkd (koren->levo); printf ("%d ", koren->broj); pisi_lkd (koren->desno);
}
}
void pisi_ldk (Stablo koren) { /* Postfiksno ispisivanje. */
if (koren) {
pisi_ldk (koren->levo); pisi_ldk (koren->desno); printf ("%d ", koren->broj);
}
}
void crtaj (Stablo koren, int nivo) { /* Graficki prikaz stabla. */
if (koren) {
crtaj (koren->desno, nivo+1);
printf ("%*s%d\n", 4*nivo, "", koren->broj);
crtaj (koren->levo, nivo+1);
}
}
int pojav (Stablo koren, int b) /* Broj pojavljivanja broja b u stablu. */
{ return koren ? (koren->broj==b)+pojav(koren->levo,b)+pojav(koren->desno,b) : 0;}
int min_u (Stablo koren) /* Najmanji u uredjenom stablu. */
{ return koren->levo ? min_u (koren->levo ) : koren->broj; }
int max_u (Stablo koren) /* Najveci u uredjenom stablu. */
{ return koren->desno ? max_u (koren->desno) : koren->broj; }
int min_n (Stablo koren) { /* Najmanji u neuredjenom stablu. */
int m = koren->broj, k;
if (koren->levo ) { k = min_n (koren->levo ); if (k < m) m = k; }
if (koren->desno) { k = min_n (koren->desno); if (k < m) m = k; }
return m;
}
int max_n (Stablo koren) { /* Najveci u neuredjenom stablu. */
int m = koren->broj, k;
if (koren->levo ) { k = max_n (koren->levo ); if (k > m) m = k; }
50
if (koren->desno) { k = max_n (koren->desno); if (k > m) m = k; }
return m;
}
int uredjeno (Stablo koren) { /* Da li je stablo uredjeno? */
if (! koren) return 1;
if (koren->levo && (! uredjeno (koren->levo ) ||
max_u (koren->levo) > koren->broj)) return 0;
if (koren->desno && (! uredjeno (koren->desno) ||
min_u (koren->desno) < koren->broj)) return 0;
return 1;
}
Cvor *nadji_u (Stablo koren, int b) { /* Trazenje u uredjenom stablu. */
if (! koren) return NULL;
if (koren->broj == b) return koren;
if (koren->broj > b) return nadji_u (koren->levo, b);
return nadji_u (koren->desno, b);
}
Cvor *nadji_n (Stablo koren, int b) { /* Trazenje u neuredjenom stablu. */
if (! koren) return NULL;
if (koren->broj == b) return koren;
{ Cvor *cvr = nadji_n (koren->levo, b); if (cvr) return cvr; }
return nadji_n (koren->desno, b);
}
Stablo dodaj_u (Stablo koren, int b) { /* Dodavanje u uredjeno stablo. */
if (! koren) {
koren = malloc (sizeof(Cvor));
koren->broj = b; koren->levo = koren->desno = NULL;
} else if (koren->broj > b)
koren->levo = dodaj_u (koren->levo, b);
else if (koren->broj < b)
koren->desno = dodaj_u (koren->desno, b);
else if (rand() / (RAND_MAX+1.) < 0.5)
koren->levo = dodaj_u (koren->levo, b);
else
koren->desno = dodaj_u (koren->desno, b);
return koren;
}
Stablo dodaj_n (Stablo koren, int b) { /* Dodavanje u neuredjeno stablo. */
if (! koren) {
koren = malloc (sizeof(Cvor));
koren->broj = b; koren->levo = koren->desno = NULL;
} else if (rand() / (RAND_MAX+1.) < 0.5)
koren->levo = dodaj_u (koren->levo, b);
else
koren->desno = dodaj_u (koren->desno, b);
return koren;
}
Stablo citaj_u (int n) { /* Citanje uredjenog stabla. */
Stablo koren = NULL; int i, b;
for (i=0; i<n; i++) { scanf ("%d", &b); koren = dodaj_u (koren, b); }
return koren;
}
Stablo citaj_n (int n) { /* Citanje neuredjenog stabla. */
Stablo koren = NULL; int i, b;
for (i=0; i<n; i++) { scanf ("%d", &b); koren = dodaj_n (koren, b); }
51
return koren;
}
Stablo brisi (Stablo koren) { /* Brisanje celog stabla. */
if (koren) {
koren->levo = brisi (koren->levo); koren->desno = brisi (koren->desno);
free (koren); koren = NULL;
}
return koren;
}
Stablo izost_u (Stablo koren, int b) { /* Izost. iz uredjenog stabla. */
if (koren) {
if (koren->broj > b) koren->levo = izost_u (koren->levo, b);
else if (koren->broj < b) koren->desno = izost_u (koren->desno, b);
else if (koren->levo) {
int m = max_u (koren->levo);
koren->broj = m; koren->levo = izost_u (koren->levo, m);
} else if (koren->desno) {
int m = min_u (koren->desno);
koren->broj = m; koren->desno = izost_u (koren->desno, m);
} else {
free (koren); koren = NULL;
}
}
return koren;
}
Stablo izost_n (Stablo koren, int b) { /* Izost. iz neuredjenog stabla. */
if (koren) {
if (koren->broj == b) {
if (koren->levo ) {
koren->broj = koren->levo->broj;
koren->levo = izost_n (koren->levo, koren->broj);
} else if (koren->desno) {
koren->broj = koren->desno->broj;
koren->desno = izost_n (koren->desno, koren->broj);
} else { free (koren); koren = NULL; }
} else {
int v = vel (koren->levo); koren->levo = izost_n (koren->levo, b);
if (v == vel (koren->levo)) koren->desno = izost_n (koren->desno, b);
}
}
return koren;
}
Stablo balans_u (Stablo koren) { /* Balansiranje uredjenog stabla. */
if (koren) {
int k = vel (koren->levo) - vel (koren->desno);
for (; k>1; k-=2) {
koren->desno = dodaj_u (koren->desno, koren->broj);
koren->broj = max_u (koren->levo );
koren->levo = izost_u (koren->levo , koren->broj);
}
for (; k<-1; k+=2) {
koren->levo = dodaj_u (koren->levo , koren->broj);
koren->broj = min_u (koren->desno);
koren->desno = izost_u (koren->desno, koren->broj);
}
koren->levo = balans_u (koren->levo );
koren->desno = balans_u (koren->desno);
}
52
return koren;
}
Stablo balans_n (Stablo koren) { /* Balansiranje neuredjenog satbla.*/
if (koren) {
int k = vel (koren->levo) - vel (koren->desno);
for (; k>1; k-=2) {
koren->desno = dodaj_n (koren->desno, koren->broj);
koren->broj = koren->levo ->broj;
koren->levo = izost_n (koren->levo , koren->broj);
}
for (; k<-1; k+=2) {
koren->levo = dodaj_n (koren->levo , koren->broj);
koren->broj = koren->desno->broj;
koren->desno = izost_n (koren->desno, koren->broj);
}
koren->levo = balans_n (koren->levo );
koren->desno = balans_n (koren->desno);
}
return koren;
}
int moze (Stablo koren) { /* Da li moze uredjena radnja? */
if (! uredjeno (koren)) {
printf ("*** Stablo nije uredjeno! ***\a\n");
return 0;
}
else return 1;
}
/* Primena operacije na stablo za svaki procitani broj: */
Stablo radi (Stablo (*f)(Stablo,int), Stablo koren) {
int b; char zn;
printf ("Brojevi? ");
do { scanf ("%d%c", &b, &zn); koren = (*f) (koren, b); } while (zn != '\n');
return koren; /* do kraja reda */
}
1. U datoteci zad1in.txt se nalazi niz reči (koje su zapisane u posebnim redovima datoteke) od kojih ni jedna nije
dužine veće od 30 karaktera. Ispisati na standardni izlaz samo različite reči sortirane leksikografski. Uz svaku
reč ispisati i broj pojava. Kraj unosa je marker kraja (EOF). Smatrati da je reč niska sastavljen isključivo od
slova i cifara i broj pojava svake reči nije veći od 10000.
/* Samoreferentne strukture , binarno pretrazivacko stablo */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#define MAXREC 31
typedef struct drvo_tag{
char *rec; /* pokazuje na rec teksta */
int broj; /* broj pojavljivanja pod pretpostavkom da
je int dovoljan */
struct drvo_tag *levo; /* leva grana */
struct drvo_tag *desno; /* desna grana */
} drvo;
/* Prototipovi funkcija */
drvo *addtree(drvo *, char *);
void treeprint(drvo *);
53
int uzmi_rec(char *, int, FILE*);
drvo *talloc( void );
char *strdpl(char *);
void osloboditi( drvo *k);
main(){
drvo *koren; /*koren stabla pretrazivanja */
char rec[MAXREC]; /*sadrzaj reci sa ulaza */
FILE *f;
/*ucitavanje reci ciji broj pojavljivanja se broji */
koren = NULL;
f=fopen("zad1in.txt","r");
while( 1 ){
int kraj = uzmi_rec(rec, MAXREC, f);
/*dodavanje novog cvora u stablo ili izmena nad poljem broj vec postojeceg cvora
*/
if( strlen(rec)) koren = addtree( koren, rec);
if(kraj == EOF) break; /*ucitavanje se vrsi do markera kraja */
}
/*stampanje sadrzaja stabla -leksikografski poredak reci */
treeprint(koren);
/*oslobadjanje zauzetog prostora za stablo pretrage */
osloboditi(koren);
fclose(f);
return 0;
}
/* addtree - dodaje cvor sa tekstom na koji pokazuje w, na ili ispod p u drvetu*/
drvo *addtree( drvo *p, char *w )
{
int cond;
if( p == NULL ) /* naisla nova rec */
{
p = talloc();
p->rec = strdpl(w);
p->broj = 1;
p->levo = p->desno = NULL;
}
else if ((cond = strcmp(w,p->rec)) == 0 )
p->broj++; /* ponovljena rec */
else if ( cond < 0 ) /* manje => levi ogranak */
p->levo = addtree(p->levo, w);
else /*vece =>desni ogranak*/
p->desno = addtree(p->desno, w);
return p;
}
void treeprint(drvo *p) /* treeprint - rekurzivno stampanje drveta*/
{
if( p != NULL )
{
treeprint( p->levo );
printf("%4d %s\n", p->broj, p->rec );
treeprint( p->desno );
}
}
int uzmi_rec(char s[], int lim, FILE *f)
{
char c, i = 0;
/* preskociti sve znake do slova ili cifre */
while(!isalnum(c = s[0] = fgetc(f)) && c!=EOF);
if( c==EOF ) {s[0] = '\0'; return EOF;} /* prazna rec i vratiti EOF */
/* ucitati ostatak reci: (u s[0] se vec nalazi prvo slovo) */
while((c = fgetc(f)) != EOF && isalnum(c) && i < lim)
s[++i] = c;
54
s[++i] = '\0'; /* zavrsiti nisku */
if( c==EOF )
return EOF;
return i;
}
/* talloc pravi jedan cvor drveta */
drvo *talloc(void)
{ return (drvo *) malloc(sizeof(drvo)); }
char *strdpl(char *s) /* pravi se kopija niske s */
{
char *p;
p = (char *) malloc(strlen(s) + 1 );
if( p != NULL ) strcpy(p,s);
return p;
/* u <string.h> postoji standardna funkcija "strdup" koja obavlja navedene
operacije*/
}
void osloboditi( drvo *k)
{ /*rekurzivno se oslobadja levo i desno podstablo korena zadatog stabla */
if (k->levo) osloboditi (k->levo);
if (k->desno) osloboditi (k->desno);
free (k); /*brisanje cvora koji predstavlja koren zadatog stabla */
}
2. Napisati program koji sa standardnog ulaza čita aritmetički izraz zapisan u prefksnoj notaciji
operator izraz1 izraz2, smešta ga u niz karaktera dužine do 20 karaktera i formira stablo u
čijem se korenu nalazi zadati operator, u levom podstablu izraz1 a u desnom izraz2. Pri tome
se izraz zadaje ili kao ceo broj ili kao operator izraz1 izraz2. Napisati rekurzivnu funkciju koja
od učitanog stringa formira binarno stablo. Prilikom zadavanja izraza očekujemo da su svi
operandi razdvojeni jedan od drugog razmakom i da je izraz pravilno zadat. Napisati i
funkcije koje ovako zadato stablo ispisuju u prefksnom i infiksnom poretku i funkciju koja
računa vrednost izraza koji se nalazi u stablu.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* Definisemo novi tip operacija */
typedef enum operacija {pl = '+',min = '-', pod = '/', put = '*'}
operacija;
/* Struktura koja predstavlja jedan cvor */
typedef struct _cvor{
int ind; /* indikator da li se u cvoru nalazi operator (u tom slucaju ind ima
vrednost 1)
ili broj (u tom slucaju ind ima vrednost 0) */
int br; /* polje u kome cuvamo ceo broj, popunjeno samo ako je polje ind
postavljeno na 0 */
operacija op; /* polje u kome cuvamo operator, popunjeno samo ako je polje ind
postavljeno na 1 */
struct _cvor *l, *d;
} cvor;
/* Funkcija koja pravi jedan cvor pri cemu ostavlja neinicijalizovane vrednosti
br i op */
cvor * napravi_cvor(){
cvor * novi = (cvor *)malloc(sizeof(cvor));
if (novi == NULL){
fprintf(stderr, "greska prilikom alokacije memorije\n");
exit(1);
55
}
novi->l = NULL;
novi->d = NULL;
return novi;
}
/* Rekurzivna funkcija koja uklanja drvo, obilazak mora biti postorder */
void obrisi_drvo(cvor *drvo){
if (drvo!=NULL){
obrisi_drvo(drvo->l);
obrisi_drvo(drvo->d);
free(drvo);
}
}
/* Rekurzivna funkcija koja parsira string. Predajemo joj adresu stringa da bi
znali dokle smo stigli u toku parsiranja */
void pretvori_u_stablo(char ** s, cvor ** pdrvo){
int c, br;
cvor *novi;
/* Uzimamo sledeci karakter iz stringa. */
c = *(*s);
/* Ako smo stigli do kraja stringa izlazimo */
if (c == '\0') return;
/* U suprotnom popunjavamo kreiramo novi cvor */
novi = napravi_cvor();
/* Ako nije u pitanju cifra znaci da smo ucitali operator... */
if (!isdigit(c)){
/* ...postavljamo indikator na 1 */
novi->ind = 1;
/* ...i operator na ucitan karakter */
novi->op = c;
/* Unosimo podatak u drvo */
*pdrvo = novi;
/* Prelazimo na sledeci relevantan podatak, preskacemo blanko*/
*s = *s+2;
/* I rekurzivno parsiramo string da bismo formirali levo pa zatim i
desno podstablo */
pretvori_u_stablo(s, &((*pdrvo)->l));
pretvori_u_stablo(s, &((*pdrvo)->d));
}
/* A ako je u pitanju cifra... */
else{
/* ...ucitavamo i ostatak broja ako postoji*/
br = 0;
while(isdigit(c)){
br = br*10+c-'0'; /* uracunavamo tekuci karakter u broj */
(*s)++; /* pomeramo se za jedno mesto u stringu */
c = *(*s); /* i citamo sledeci karakter */
}
/* postavljamo indikator na 0 */
novi->ind = 0;
/* i brojevnu vrednost na br */
novi->br = br;
/* Unosimo podatak u drvo */
*pdrvo = novi;
/* Prelazimo na sledeci relevantan podatak. Uzimamo u obzir da
pokazivac vec pokazuje na blanko */
*s = *s+1;
}
}
56
void ispisi_drvo(cvor *drvo){
if (drvo!=NULL){
/* Prvo ispisujemo koren. Proveravamo vrednost indikatora */
if (!drvo->ind)
/* ako je indikator jednak 0 stampamo broj */
printf("%d", drvo->br);
else
/* a inace stampamo karakter */
printf("%c", drvo->op);
/* ...a zatim i levo pa desno podstablo. */
ispisi_drvo(drvo->l);
ispisi_drvo(drvo->d);
}
}
void ispisi_drvo_infiksno(cvor *drvo){
if (drvo == NULL)
return;
if (!drvo->ind)
/* Ako smo naisli na brojevnu vrednost stampamo je. */
printf("%d", drvo->br);
else{
/* U suprotnom imamo pravo stablo pa ispisujemo prvo levu zagradu...
*/
printf("(");
/* pa levi izraz... */
ispisi_drvo_infiksno(drvo->l);
/* pa operator... */
printf(" %c ", drvo->op);
/* pa desni izraz... */
ispisi_drvo_infiksno(drvo->d);
/* i na kraju ispisujemo desnu zagradu */
printf(")");
}
}
int izracunaj_drvo(cvor *drvo){
if (!drvo->ind)
return drvo->br;
else
switch (drvo->op){
case '+':
return izracunaj_drvo(drvo->l) +
izracunaj_drvo(drvo->d);
case '-':
return izracunaj_drvo(drvo->l) –
izracunaj_drvo(drvo->d);
case '*':
return izracunaj_drvo(drvo->l) *
izracunaj_drvo(drvo->d);
case '/':
return izracunaj_drvo(drvo->l) /
izracunaj_drvo(drvo->d);
}
}
main(){
cvor * drvo = NULL;
char s[20], *ps;
int i=0;
printf("unesite aritmeticki izraz u prefiksnoj notaciji, novi red za kraj\n");
/* Funkcija fgets cita sa standardnog ulaza (stdin) liniju (karaktere
57
do unetog novog reda) ili dok se ne popuni 20 karaktera */
if (fgets(s, 20, stdin) == NULL){
fprintf(stderr, "greska");
exit(1);
}
/* Kako s sada sadrzi i oznaku za novi red na kraju brisemo je */
while(s[i]!='\n')
i++;
/* i na kraju dodajemo '\0' da bi pripremili string za prenosenje u funkciju */
s[i] = s[i+1];
/* Kako je s niz karaktera (a niz je konstantni pokazivac) on ne
sme biti predat funkciji koja kreira stablo (posto funkcija
menja pokazivac koji dobija kao prvi argument) pa uzimamo
pomocni pokazivac da bismo mogli da menjamo njegovu vrednost */
ps = s;
/* Kreiramo stablo pozivom funkcije prevori_u_stablo */
pretvori_u_stablo(&ps, &drvo);
/* Ispisujemo ga u prefiksnom poredku */
ispisi_drvo(drvo);
printf("\n");
/* A zatim i u infiksnom. */
ispisi_drvo_infiksno(drvo);
/* Ispisujemo vrednost pocetnog izraza */
printf(" = %d\n", izracunaj_drvo(drvo));
obrisi_drvo(drvo);
}
58
4.2. GRAFOVI
Definicija: Graf G je uređeni par G=(V,E) gde je EVxV. Skup V je skup čvorova, dok skup E
predstavlja skup grana (veza između čvorova).
Grane usmerenog grafa su uređeni parovi čvorova i redosled dva čvora koje povezuje grana je bitan.
Za neusmeren graf važi da ukoliko je čvor u u vezi sa čvorom v, onda je i čvor v u vezi sa čvorom u.
Težinski graf je graf čijim granama su pridruženi jedan ili više realnih brojeva ( kao vrednost rastojanja, težina, cene,...).
usmeren graf neusmeren graf težinski graf
Stepen d(v) čvora v je broj grana susednih čvoru v (broj grana koje direktno povezuju čvor v sa
nekim drugim čvorom).
U usmerenom grafu razlikuju se ulazni stepen (broj grana čiji kraj je čvor v) i izlazni stepen (broj
grana za koje je čvor v početak).
Bipartitni graf je graf čiji se čvorovi mogu podeliti na dva disjunktna podskupa tako da u grafu
postoje samo grane između čvorova iz različitih podskupova.
Put od v1 do vk je niz čvorova v1, v2, . . . ,vk povezanih granama (v1, v2), (v2, v3), . . . , (vk-1, vk ).
Hamiltonov put je prosti ciklus ili put u kom se svaki čvor grafa pojavljuje tačno jednom.
NAPOMENA: Sve date definicije su opisne. Za precizne definicije matematičkih pojmova vezanih za
grafove konsultovati literaturu.
4.2.1. Predstavljanje grafova u memoriji računara
Predstavljanje uz pomoć matrice susedstva
Jedan način predstavljanja grafa sa n čvorova je uz pomoć matrice susedstva dimenzija n x n (svaka
vrsta i kolona odgovaraju po jednom čvoru grafa). Ukoliko postoji veza između čvorova vi i vj tada se u vrsti
koja odgovara čvoru vi i koloni koja odgovara čvoru vj je 1 (adj[vi, vj] = 1, ako (vi, vj) ivica u G). Ukoliko je e
ukupan broj ivica grafa, tada će u matrici postojati 2e elemenata matrice koji su jednaki 1, ako je G
59
neorijentisan graf. Ako je G usmeren graf, samo e elemenata matrice će biti 1. Primeri predstavljanja
grafova uz pomoć matrice susedstva su dati na sledećim slikama:
Graf Matrica susedstva Ulazni i izlazni stepeni čvora
Predstavljanje grafova uz pomoć povezanih listi
Drugi način predstavljanja grafa G je uz pomoć povezanih listi. Za svaki čvor konsturišemo povezanu
listu koja sadrži sve čvorove susedne datom čvoru.
60
4.2.2. Računanje ulaznog i izlaznog stepena čvora grafa predstavljenog pomoću matrice susedstva
#include <stdio.h>
#define MAX 10
/* funkcija uz pomoc koje pravimo matricu susedstva */
void buildadjm(int adj[][MAX], int n){
int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++){
printf("Enter 1 if there is an edge from %d to %d, otherwise enter 0
\n",i,j);
scanf("%d",&adj[i][j]);
}
}
/* funkcija za racunanje izlaznog stepena cvora */
int outdegree(int adj[][MAX],int x,int n){
int i, count =0;
for(i=0;i<n;i++)
if( adj[x][i] ==1) count++;
return(count);
}
/* funkcija za racunanje ulaznog stepena grafa */
int indegree(int adj[][MAX],int x,int n){
int i, count =0;
for(i=0;i<n;i++)
if( adj[i][x] ==1) count++;
return(count);
}
void main(){
int adj[MAX][MAX],node,n,i;
printf("Enter the number of nodes in graph maximum = %d\n",MAX);
scanf("%d",&n);
buildadjm(adj,n);
for(i=0;i<n;i++){
printf("The indegree of the node %d is %d\n",i,indegree(adj,i,n));
printf("The outdegree of the node %d is %d\n",i,outdegree(adj,i,n));
}
}
4.2.3. Obilazak grafa u širinu (BFS)
BREADTH-FIRST SEARCH je jeadan od najjednostavnijih algoritama za obilazak grafa. Za dati graf
G=(V,E) i startni čvor s, BFS obilazi graf G „otkrivajući“ svaki čvor koji je dostižan iz s. Istovremeno,
možemo računati i rastojanje čvora s do svakog čvora do kojeg postoji put iz s. Izvršenjem algoritma
možemo konstruisati tzv. BFS stablo koje će sadržati sve čvorove grafa G dostižne iz s. Algoritam se
može primeniti i na orijentisane i neorijentisane grafove. Na sledećoj slici ilustrovano je izvršenje BFS
algoritma za dati graf G i startni čvor s.
61
BFS(G, s)
for each vertex u V [G] - {s}
do color[u] ← WHITE
d[u] ← ∞
π[u] ← NIL
color[s] ← GRAY
d[s] ← 0
π[s] ← NIL
Q ← Ø
ENQUEUE(Q, s) while Q ≠ Ø
do u ← DEQUEUE(Q)
for each v Adj[u] do if color[v] = WHITE
then color[v] ← GRAY
d[v] ← d[u] + 1
π[v] ← u
ENQUEUE(Q, v)
color[u] ← BLACK
4.2.4. Obilazak grafa u dubinu (DFS)
Strategija koju koristi DFS algoritam je tražiti čvorove sve „dublje“ u grafu kad god je to moguće. Kod
DFS algoritma pretražujemo granu koja napušta čvor v i a zatim i sve naredne grane. Kada završimo sa
pretragom svih grana koje napuštaju čvor v vraćamo se unazad da bi smo nastavili sa pretragom grana
koje napuštaju čvor iz kojeg smo stigli u čvor v.
62
DFS(G) for each vertex u _ V [G]
do color[u] ← WHITE
π[u] ← NIL
time ← 0
for each vertex u V [G] do if color[u] = WHITE
then DFS-VISIT(u) DFS-VISIT(u)
color[u] ← GRAY White vertex u has just been discovered.
time ← time +1
d[u] <- time for each v in Adj[u] Explore edge(u, v).
do if color[v] = WHITE
then π[v] ← u
DFS-VISIT(v) color[u] <- BLACK Blacken u; it is finished.
f [u] ▹ time ← time +1
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
struct node{
int data;
struct node *link;
};
/* funkcija uz pomoc koje pravimo matricu susedstva */
void buildadjm(int adj[][MAX], int n){
int i,j;
for(i=0;i<n;i++)
63
for(j=0;j<n;j++){
printf("Unesi 1 ako postoji veza izmedju %d i %d, inace unesi 0 \n",i,j);
scanf("%d",&adj[i][j]);
}
}
/* funkcija za racunanje izlaznog stepena cvora */
int outdegree(int adj[][MAX],int x,int n){
int i, count =0;
for(i=0;i<n;i++)
if( adj[x][i] ==1) count++;
return(count);
}
/* funkcija za racunanje ulaznog stepena grafa */
int indegree(int adj[][MAX],int x,int n){
int i, count =0;
for(i=0;i<n;i++)
if( adj[i][x] ==1) count++;
return(count);
}
/* A function to insert a new node in queue*/
struct node *addqueue(struct node *p,int val){
struct node *temp;
if(p == NULL){
p = (struct node *) malloc(sizeof(struct node)); /* insert the new node
first node*/
if(p == NULL){
printf("Rezervisanje memorije nije uspelo\n");
exit(0);
}
p->data = val;
p->link=NULL;
} else {
temp= p;
while(temp->link != NULL){
temp = temp->link;
}
temp->link = (struct node*)malloc(sizeof(struct node));
temp = temp->link;
if(temp == NULL){
printf("Rezervisanje memorije nije uspelo\n");
exit(0);
}
temp->data = val;
temp->link = NULL;
}
return(p);
}
struct node *deleteq(struct node *p,int *val){
struct node *temp;
if(p == NULL){
printf("red je prazan\n");
return(NULL);
}
*val = p->data;
temp = p;
p = p->link;
free(temp);
return(p);
}
64
void bfs(int adj[][MAX], int x,int visited[], int n, struct node **p){
int y,j,k;
*p = addqueue(*p,x);
do{
*p = deleteq(*p,&y);
if(visited[y] == 0){
printf("\nObilazim cvor = %d\t",y);
visited[y] = 1;
for(j=0;j<n;j++)
if((adj[y][j] ==1) && (visited[j] == 0))
*p = addqueue(*p,j);
}
}while((*p) != NULL);
}
void dfs(int x,int visited[],int adj[][MAX],int n){
int j;
visited[x] = 1;
printf("Posecen je cvor %d\n",x);
for(j=0;j<n;j++)
if(adj[x][j] ==1 && visited[j] ==0)
dfs(j,visited,adj,n);
}
void main(){
int adj[MAX][MAX],n,i,s;
struct node *start=NULL;
int visited[MAX];
printf("Unesi broj cvorova grafa, maximum = %d\n",MAX);
scanf("%d",&n);
buildadjm(adj,n);
for(i=0;i<n;i++){
printf("Ulazni stepen cvora %d je %d\n",i,indegree(adj,i,n));
printf("Izlazni stepen cvora %d je %d\n",i,outdegree(adj,i,n));
}
while(1){
printf("\n****************** BFS algoritam *****************\n");
printf("Unesi startni cvor: ");
scanf("%d",&s);
if(s==0) break;
for(i=0; i<n; i++)
visited[i] = 0;
bfs(adj,s,visited,n,&start);
}
printf("\n****************** DFS algoritam *****************\n");
for(i=0; i<n; i++)
if(visited[i] ==0)
dfs(i,visited,adj,n);
}
4.2.5. Topološko sortiranje
Topološko sortiranje usmerenog acikličnog grafa G=(V,E) predstavlja linearno uređenje svih čvorova
tako da ukoliko graf G sadrži granu (u,v), tada se čvor u nalazi pre čvora v u dobijenom nizu čvorova.
Ukoliko graf nije acikličan, topološko sortiranje je nemoguće. Usmeren acikličan graf se veoma često koristi
za predstavljanje veze između događaja. Grana (u,v) znači da se događaj u mora završiti pre nego što
počne izvršenje događaja v.
65
Na slici je dat primer grafa koji predstavlja redosled oblačenja delova odeće i topološko sortiranje
datog grafa (slika (b)).
Algoritam topološkog sortiranje koristi DFS algoritam i može se prikazati kao:
TOPOLOGICAL-SORT(G) call DFS(G) to compute finishing times f[v] for each vertex v as each vertex is finished, insert it onto the front of a linked list return the linked list of vertices
3. Napisati program koji će topološki sortirati graf koji je predstavljen uz pomoć povezanih listi.
#include <stdio.h>
#include <stdlib.h>
#ifndef MAX_NAME_CHAR
#define MAX_NAME_CHAR 50
#endif
typedef enum {FALSE, TRUE} bool;
typedef struct node node;
struct node {
int count; // za cvorove grafa : ulazni stepen
// za cvorove u listi : cvor sa kojim je cvor grafa povezan
node *next;
};
node *graph;
node *zerolist;
void addToZerolist(int v){
/*
* dodajemo cvor v u zerolist ukoliko v ima ulazni stepen 0
*/
node *ptr = (node *)malloc( sizeof(node) );
ptr->count = v;
ptr->next = zerolist;
zerolist = ptr;
}
node *buildGraph(char *fileName, int *n) {
/* ucitavamo graf iz datoteke
66
pretpostavimo da u prvom redu datoteke imamo date brojeve m n
m - broj cvorova
n - broj grana
a u ostalih n redova sve grane grafa u obliku u v, gde su u i v cvorovi */
int i,edges,u,v;
FILE *f;
f=fopen(fileName,"r");
fscanf(f,"%d %d",n,&edges);
// inicijalizujemo graf
graph = (node *)malloc((*n)*sizeof(node));
for(i=0;i<(*n);i++) {
graph[i].count = 0;
graph[i].next = NULL;
}
// now add the list entries.
for( i=0; i<edges; ++i ) {
// dodajemo novi cvor u graf
node *ptr = (node *)malloc( sizeof(node) );
fscanf(f,"%d - %d",&u,&v);
ptr->count = v;
ptr->next = graph[u].next;
graph[u].next = ptr;
// increase indegree of dst.
graph[v].count++;
}
// kreiramo listu cvorova sa ulaznim stepenom 0
zerolist = NULL;
for(i=0;i<(*n);i++)
if(graph[i].count == 0 ) {
addToZerolist(i);
}
}
void printGraph(node *graph, int n) {
int i;
node *ptr;
for(i=0;i<n;i++){
node *ptr;
printf( "%d: pred=%d: ",i,graph[i].count);
for(ptr=graph[i].next; ptr; ptr=ptr->next )
printf( "%d ", ptr->count );
printf( "\n" );
}
printf( "zerolist: " );
for( ptr=zerolist; ptr; ptr=ptr->next )
printf( "%d ", ptr->count );
printf( "\n" );
}
int getZeroVertex() {
/*
* vraca cvor sa ulaznim stepenom 0.
* ukoliko takav cvor ne postoji vraca -1.
*/
int v;
node *ptr;
if( zerolist == NULL )
return -1;
ptr = zerolist;
67
v = ptr->count;
zerolist = zerolist->next;
free(ptr);
return v;
}
void removeVertex( int v ) {
/*
* brise cvor v i sve njegove odlazne grane iz grafa
*/
node *ptr;
graph[v].count = -1;
// oslobadjamo listu graph[v].next.
for( ptr=graph[v].next; ptr; ptr=ptr->next ) {
if( graph[ ptr->count ].count > 0 ) //
graph[ ptr->count ].count--;
if( graph[ ptr->count ].count == 0 )
addToZerolist( ptr->count );
}
}
void topsort( int nvert ) {
/*
* rekurzivna funkcija koja topoloski sortira graf
*/
int v;
if( nvert > 0 ) {
v = getZeroVertex();
if( v == -1 ) {
fprintf( stderr, "graph contains a cycle.\n" );
return;
}
printf( " -> %d", v );
removeVertex(v);
topsort( nvert-1 );
}
}
int main() {
int n;
buildGraph("mat.txt",&n);
printGraph(graph,n);
topsort(n);
}
Objašnjenje
Digraf G je predstavljen uz pomoć povezanih listi. U ovakvoj reprezentaciji G je niz graph[0…n–1],
gde je svaki element graph[i] povezana lista čvorova grafa sa kojima je čvor i povezan, a n je broj
čvorova u grafu G.
Promenljiva zerolist služi da bismo čuvali listu čvorova koji nemaju prethodnike.
Algoritam topsort() se služi rekurzijom. Iz promenljive zerolist, uklanjamo vektor v koji ima 0
prethodnika i štampa ga. Ovaj čvor v ili nema prethodnika u grafu G, ili su svi njegovi prethodnici već
obiđeni. Svi čvorovi u zerolist su potencijalni kandidati za sledeći čvor koji će biti odštampan, tj.
68
ubačen u sortirani niz. Nakon što smo odštampali v svi čvorovi sa kojima je on u vezi mogu postati
kandidati za sledeći odštampani čvor.
Primer: Analiza algoritma na sledećem grafu
Korak Zerolist Izlaz
0 {0} nil
1 {1, 2, 3} 0
2 {2, 3} 1
3 {3} 2
4 {4,5} 3
5 {5} 4
6 {} 5
4.2.6. Jako povezane komponente grafa
Povezana komponenta grafa je maksimalni podgraf dataog grafa koji je povezan. Razmotrimo sledeći
graf.
Povezana komponenta ovog grafa je:
69
Jako povezane komponente
Za digraf G, jako povezana komponenta je podgraf grafa G u kojem za svaki par čvorova (u,v) važi da
postoji put i od u do v i od čvora v do čvora u. Posmatrajmo graf na sledećoj slici.
Jako povezane komponente datog grafa su:
70
#include <stdio.h>
#include <stdlib.h>
#define MAXVERTICES 20
#define MAXEDGES 20
typedef enum {FALSE, TRUE, TRISTATE} bool;
typedef struct node node;
struct node {
int dst;
node *next;
};
void printGraph( node *graph[], int nvert ) {
/*
* prints the graph.
*/
int i;
for( i=0; i<nvert; ++i ) {
node *ptr;
for( ptr=graph[i]; ptr; ptr=ptr->next )
printf( "[%d] ", ptr->dst );
printf( "\n" );
}
}
void insertEdge( node **ptr, int dst ) {
/*
* insert a new node at the start.
*/
node *newnode = (node *)malloc( sizeof(node) );
newnode->dst = dst;
newnode->next = *ptr;
*ptr = newnode;
}
void buildGraph( node *graph[], int edges[2][MAXEDGES], int nedges ) {
/*
* fills graph as adjacency list from array edges.
*/
int i;
for( i=0; i<nedges; ++i ) {
insertEdge( graph+edges[0][i], edges[1][i] );
insertEdge( graph+edges[1][i], edges[0][i] ); // undirected graph.
}
}
void dfs( int v, int *visited, node *graph[] ) {
/*
* recursively traverse graph from v using visited.
* and mark all the vertices that come in dfs path to TRISTATE.
*/
node *ptr;
visited[v] = TRISTATE;
//printf( "%d \n", v );
for( ptr=graph[v]; ptr; ptr=ptr->next )
if( visited[ ptr->dst ] == FALSE )
dfs( ptr->dst, visited, graph );
}
void printSetTristate( int *visited, int nvert ) {
71
/*
* prints all vertices of visited which are TRISTATE.
* and set them to TRUE.
*/
int i;
for( i=0; i<nvert; ++i )
if( visited[i] == TRISTATE ) {
printf( "%d ", i );
visited[i] = TRUE;
}
printf( "\n\n" );
}
void compINC(node *graph[], int nvert) {
/*
* prints all connected components of graph represented using INC lists.
*/
int *visited;
int i;
visited = (int *)malloc( nvert*sizeof(int) );
for( i=0; i<nvert; ++i )
visited[i] = FALSE;
for( i=0; i<nvert; ++i )
if( visited[i] == FALSE ) {
dfs( i, visited, graph );
// print all vertices which are TRISTATE.
// and mark them to TRUE.
printSetTristate( visited, nvert );
}
free( visited );
}
int main() {
FILE *f;
int edges[2][MAXEDGES],i,nvert,nedges;
node **graph;
f=fopen("mat.txt","r");
fscanf(f,"%d %d",&nvert,&nedges);
for(i=0;i<nedges;i++)
fscanf(f,"%d %d",&edges[0][i],&edges[1][i]);
graph = (node **)calloc(nvert, sizeof(node *) );
buildGraph( graph, edges, nedges );
printGraph( graph, nvert );
compINC( graph, nvert );
fclose(f);
return 0;
}
Graf je predstavljen uz pomoć povezanih listi. Graf je predstavljen kao niz od n pokazivača gde n
predstavlja broj čvorova grafa. Svaki član niza i sadrži pokazivač na povezanu listu čvorova sa kojima je
čvor i u vezi. Na primer, sledeći graf:
72
se predstavlja sledećom strukturom:
4.2.7. Minimum Spanning Tree (minimalno razapinjuće stablo)
Definicija: Neka je dat povezan, neorijentisani graf G = (V, E) sa težinskom funkcijom w : E → R.
Minimalno razapinjuće stablo grafa G je podgraf (V,T), gde je T ⊆ E, koji povezuje sve čvorove grafa G i
čija je ukupna težina ∑ 𝑤(𝑢, 𝑣)(𝑢,𝑣)𝜖𝑇 minimalna.
Pretpostavimo da imamo povezan, neorijentisani graf G = (V, E) sa težinskom funkcijom w : E → R, i
želimo da nadjemo minimalno razapinjuće stablo za graf G. Dva algoritma koja ćemo predstaviti u osnovi
imaju istu strategiju nalaženja minimalnog razapinjućeg stabla. Naime, oba polaze od skupa grana A koji je
na početku prazan, a u svakom koraku dodaju tom skupu po jednu granu, koju nazivamo sigurna grana za
podgraf A (safe edge), sve dok ne dobijemo minimalno razapinjuće stablo (znači imamo n-1 koraka). U
svakom koraku A je podskup minimalnog razapinjućeg stabla.
GENERIC-MST(G, w)
A ← Ø
while A does not form a spanning tree do find an edge (u, v) that is safe for A
A ← A ∪ {(u, v)}
return A
73
Kruskal-ov algoritam
MST-KRUSKAL(G, w)
A ← Ø
for each vertex v V[G] do MAKE-SET(v)
sort the edges of E into nondecreasing order by weight w for each edge (u, v) E, taken in nondecreasing order by weight
do if FIND-SET(u) ≠ FIND-SET(v)
then A ← A _ {(u, v)}
UNION(u, v) return A
U toku generisanja minimalnog drveta razapinjanja, sve vreme se manipuliše sa supergrafom koji je
indukovan polaznim grafom. Ako je polazni graf G=(V,E), onda je supergraf uređeni par SG=(SV,SE),
takav da je:
SV skup čvorova;
SE skup superivica;
svaki superčvor sv je podskup skupa čvorova V;
svaka dva superčvora su disjunktna;
unija svih superčvorova je skup V;
između superčvorova su i sv postoji ivica ako i samo ako postoji čvor u su i čvor v sv, tako
da je (u,v)E.
dužina superivice (su,sv) je dužina najkraće ivice grafa (G,E) čiji je jedan kraj u superčvoru su, a drugi u superčvoru su.
Na početku izvršenja Kruskalovog algoritma superčvorovi su jednočlani, tj. svakom čvoru u polaznog
grafa odgovara superčvor su={u}, a Eπ je prazan. Algoritam je iterativan. U svakoj iteraciji SE izvršava
sledeći niz radnji:
dva superčvora se spajaju u jedan, čime se broj superčvorova smanjuje;
jedna ivica se dodaje minimalnom drvetu (skupu Eπ).
Pri tome:
spajaju se najbliži superčvorovi (superčvorovi između kojih je najmanje rastojanje);
određuje se najkraća ivica između čvorova koji su sadržani u paru prethodno određenih superčvorova i ta ivica se dodaje drvetu.
Petlja se ponavlja dok ne dobijemo supergraf sa samo jednim superčvorom. Kako je na početku
ukupno |V| superčvorova, izvršiće se ukupno |V|-1 iteracija.
#include <stdio.h>
#include <stdlib.h>
#define MAXV 20
74
#define MAXEDGES 190
void buildGraph(int adj[][MAXV], int nver, int edges[3][MAXEDGES], int nedges ) {
/*
* popunjavamo matricu susedstva
*/
int i,j;
for(i=0;i<nver;i++)
for(j=0;j<nver;j++)
adj[i][j]=0;
for( i=0; i<nedges; ++i ) {
adj[edges[0][i]][edges[1][i]]=edges[2][i];
adj[edges[1][i]][edges[0][i]]=edges[2][i];//neorijentisani graf
}
}
int mdr_kruskal(int vn, int e[][MAXV], int v1[], int v2[]){
/**************************************
vn - broj cvorova u polaznom grafu
e - matrica duzina ivica
v1 - niz za zapis prvog kraja ivica drveta
v2 - niz za zapis drugog kraja ivica drveta
rezultat:
0 - polazni graf je povezan, odredjeno drvo razapinjanja
-1 - polazni graf nije povezan, drvo nije odredjeno
****************************************/
int i,j,k,l1,l2;
int sv[MAXV];
for(i=0;i<vn;i++) sv[i]=i;
for(i=0;i<vn-1;i++){
for(j=0;j<vn;j++){
for(k=0;k<vn;k++)
if((sv[j]!=sv[k]) && (e[j][k]!= 0)) break;
if(k<vn) break;
}
if(j==vn) return -1;
l1=j;l2=k;
for(;j<vn;j++)
for(k=0;k<vn;k++)
if((sv[j]!=sv[k]) && (e[j][k]!=0) && (e[j][k]<e[l1][l2])){
l1=j;
l2=k;
}
v1[i]=l1;v2[i]=l2;
j=min(sv[l1],sv[l2]);
k=max(sv[l1],sv[l2]);
l1=j;l2=k;
for(j=0;j<vn;j++)
if(sv[j]==l2) sv[j]=l1;
}
return 0;
}
int main() {
FILE *f;
int edges[3][MAXEDGES],i,nvert,nedges,adj[MAXV][MAXV],v1[MAXV],v2[MAXV];
f=fopen("mat.txt","r");
fscanf(f,"%d %d",&nvert,&nedges);
for(i=0;i<nedges;i++)
fscanf(f,"%d %d %d",&edges[0][i],&edges[1][i],&edges[2][i]);
fclose(f);
75
buildGraph(adj,nvert,edges,nedges);
if(mdr_kruskal(nvert,adj,v1,v2)==-1){
printf("\nPolazni graf nije povezan. Nemoguce naci drvo razapinjanja.");
return 1;
}
printf("\nPronadjeno minimalno drvo razapinjanja:");
for(i=0;i<nvert-1;i++)
printf("\n%d -> %d",v1[i],v2[i]);
printf("\n*************** kraj ****************\n");
return 0;
}
Isti algoritam se može modifikovati tako da postane efikasniji. Naime, u svakom prolazu kroz
spoljašnju petlju se određuje najkraća ivica čiji su krajevi u različitim superčvorovima. Ako bi se ivice
sortirale pre početka izvršavanja te petlje, onda se računanje pojednostavljuje. Tada bismo u petlji
pronalazili sledeću ivicu čiji su krajevi u različitim superčvorovima, i dodavali bismo je drvetu.
76
77
Prim-ov algoritam
MST-PRIM(G, w, r) for each u _ V [G]
do key[u] ← ∞
π[u] ← NIL
key[r] ← 0
Q ← V [G]
while Q ≠ Ø
do u ← EXTRACT-MIN(Q)
for each v Adj[u] do if v Q and w(u, v) < key[v]
then π[v] ← u
key[v] ← w(u, v)
Kod Primovog algoritma drvo se generiše tako što se kreće od proizvoljnog čvora koji će biti koren
drveta, i dodaje jedan po jedan čvor. Tako da u toku izvršenja algoritma imamo:
skup U koji se sastoji od čvorova već dodatih drvetu i
skup V\U koji se sastoji od čvorova koji nisu u drvetu
Na početku se skup U sastoji samo od jednog čvora – izabrani koren drveta. U svakoj iteraciji se bira
nakraća ivica čiji je jedan kraj (čvor u) u skupu U, a drugi (čvor v) u skupu V\U. Čvor v se dodaje skupu U,
a ivica (u,v) se dodaje drvetu (Eπ).
Izbor najkrće ivice sa zadanim svojstvima je ekvivalentan izboru čvora iz skupa V\U koji je najbliži
skupu čvorova U. Rastojanje između čvora i skupa čvorova se definiše kao dužina najkraće ivice čiji je
jedan kraj upravo taj čvor, a drugi kraj je u skupu.
78
Da bismo smanjili računanje, nakon dodavanja novog čvora (u) u skup U, za sve čvorove iz skupa V\U
korigujemo najkraće rastojanje do skupa U. Korekciju izvodimo po formuli:
d(v,U{u}) = min {d(v,U),e(u,v)},
gde je e(u,v) dužina ivice (u,v).
Postupak se ponavlja sve dok skup U ne postane jednak skupu V. Kako se u svakom prolazu u skup
U dodaje jedan čvor, izvršava se ukupno |V|-1 iteracija. Funkcija se može zapisati na sledeći način: (glavni
program je identičan kao kod kruskalovig algoritma, sem poziva funkcije mdr_Prim umesto mdr_kruskal)
int mdr_Prim(int vn, int e[][MAXV],int v1[], int v2[]){
int i,j,k;
int vi[MAXV];
int vp[MAXV];
int dm[MAXV];
/*** vi[i] ima vrednost 1, ako je i vec ukljucen u drvo, 0 u suprotnom ***/
vi[0] = 1;
for(i=1;i<vn;i++){
vi[i]=0;
dm[i]=0;
}
for(i=1;i<vn;i++)
if(e[0][i] != 0){
/***
dm[i] je rastojanje cvora i od drveta,
vp[i] je cvor iz drveta koji je najblizi cvoru i, tj. vazi
dm[i]=e[vp[i]][i]
***/
vp[i]=0;
dm[i]=e[0][i];
}
for(i=0;i<vn-1;i++){
j=0;
while((j<vn)&&(vi[j] || (dm[j] == 0))) j++;
if(j==vn) return -1;
for(k=j++;j<vn;j++)
if(!vi[j] && (dm[j] != 0) && (dm[k] > dm[j])) k=j;
vi[k]=1;
v1[i]=vp[k];
v2[i]=k;
for(j=0;j<vn;j++)
if(!vi[j] && (e[k][j] != 0))
if((dm[j] == 0) || (dm[j] > e[k][j])){
vp[j]=k;
dm[j]=e[k][j];
}
}
return 0;
}
79
4.2.8. Nalaženje najkraćeg puta od jednog do svih ostalih čvorova
INITIALIZE-SINGLE-SOURCE(G, s) 1 for each vertex v _ V[G] 2 do d[v] ← ∞ 3 π[v] ← NIL 4 d[s] 0 RELAX(u, v, w) 1 if d[v] > d[u] + w(u, v)
80
2 then d[v] ← d[u] + w(u, v)
3 π[v] ← u
Bellman – Ford algoritam
Bellman-Ford algoritam nalazi najkraće rastojanje od datog čvora do svih ostlih čvorova grafa čak i za
slučaj kada postoje ivice sa negativnom dužinom. Algoritam otkriva postojanje negativnih petlji i u tom
slučaju daje odgovarajući izveštaj, odnosno ne određuje rastojanja.
Polazna ideja je da svaki put, pa i najkraći između bilo koja dva čvora, može imati najviše |V| -1 ivicu.
Tako se izvršava |V| -1 prolaz kroz petlju u kojoj se proverava za svaku ivicu da li smanjuje najkraće
rastojanje između polaznog čvora i nekog od preostalih čvorova.
Nakon toga još jednom ponovimo navedeni postupak za svaku ivicu. Ako se tim prolazom skrati neko
od izračunatih rastojanja, u grafu postoji petlja negativne dužine do koje se može stići od polaznog čvora
(s) i određivanje najkraćih rastojanja nema smisla.
BELLMAN-FORD(G, w, s) INITIALIZE-SINGLE-SOURCE(G, s)
for i ← 1 to |V[G]| - 1
do for each edge (u, v) _ E[G] do RELAX(u, v, w)
for each edge (u, v) _ E[G] do if d[v] > d[u] + w(u, v) then return FALSE return TRUE
Na slici je prikazan graf i rezultat izvršenja ovog algoritma.
81
#include <stdio.h>
#include <stdlib.h>
#define MAXV 20
#define MAXEDGES 190
#define NEPOZNATO 1000000
void buildGraph(int adj[][MAXV], int nver, int edges[3][MAXEDGES], int nedges ) {
/*
* popunjavamo matricu susedstva
*/
int i,j;
for(i=0;i<nver;i++)
for(j=0;j<nver;j++)
adj[i][j]=0;
for( i=0; i<nedges; ++i ) {
adj[edges[0][i]][edges[1][i]]=edges[2][i];//graf je orijentisan
}
}
int Ford_Belman(int vn, int vs, int e[][MAXV], int d[]){
/*****
ulaz:
vn - broj cvorova u grafu
vs - polazni cvor
e - duzine ivica
izlaz:
82
d - duzine najkracih puteva od vs do ostalih cvorova
rezultat:
0 - nije odredjeno rastojanje zato sto se od vs moze stici do ciklusa
negativne duzine
1 - odredjena su najkrca rastojanja i upisana su u niz d
******/
int i,j,k;
for(i=0;i<vn;i++)
if(e[vs][i] != 0)
d[i]=e[vs][i];
else
d[i]= NEPOZNATO;
for(i=1;i<vn;i++)
for(j=0;j<vn;j++)
for(k=0;k<vn;k++)
if(e[j][k] != 0)
if(d[j] != NEPOZNATO)
if((d[k]==NEPOZNATO) || (d[j]+e[j][k]<d[k]))
d[k]=d[j]+e[j][k];
for(j=0;j<vn;j++)
for(k=0;k<vn;k++)
if(e[j][k] != 0)
if((d[j] != NEPOZNATO) && (d[k] != NEPOZNATO) &&
(d[j]+e[j][k]<d[k]))
return 0;
return 1;
}
int main() {
FILE *f;
int edges[3][MAXEDGES],i,nvert,nedges,adj[MAXV][MAXV],d[MAXV],vs;
f=fopen("graph.txt","r");
fscanf(f,"%d %d",&nvert,&nedges);
for(i=0;i<nedges;i++)
fscanf(f,"%d %d %d",&edges[0][i],&edges[1][i],&edges[2][i]);
fclose(f);
buildGraph(adj,nvert,edges,nedges);
printf("\n************* ALGORITAM BELLMAN-FORD ******************\n");
printf("\nUnesi startni cvor (0-%d):",nvert-1);
scanf("%d",&vs);
if(!Ford_Belman(nvert,vs,adj,d)){
printf("\nPolazni graf sadrzi cikl negativne duzine. Nemoguce odrediti
rastojanja!");
return 1;
}
for(i=0;i<nvert;i++)
printf("\nRastojanje od cvora %d do cvora %d iznosi: %d",vs,i,d[i]);
printf("\n*************** kraj ****************\n");
return 0;
}
Dijkstrin algoritam za nalaženje najkraćih puteva
U svakoj iteraciji ovog algoritma se određuje najkraće rastojanje od početnog čvora (s) do jednog od
preostalih čvorova. U toku izvršavanja algoritma manipuliše se skupom čvorova U za koje je izračunato
najkraće rastojanje od čvora s.
Na početku taj skup se sastoji samo od jednog čvora (U={s}). U svakoj iteraciji skupu U se dodaje
jedan čvor. Pored toga, za svaki od čvorova vV\U određuje se najkraći put (dužina najkraćeg puta) od
83
čvora s do čvora v, pri čemu svi čvorovi na tom putu osim čvora v moraju biti u skupu U, naravno, ako
takav put postoji. Skupu U se dodaje čvor iz skupa V\U kome je taj put najkraći.
Dužine puteva se određuju na početku (kada je U={s}), posle čega se koriguje pri dodavanju novog
elementa u skup U. Na početku je dužina puta jednaka:
dužini ivice između čvora s i odgovarajućeg čvora ako ivica postoji;
+∞, tj. put ne postoji, ako ivica od čvora s do tog čvora ne postoji.
Po dodavanju novog čvora (u) u skup U, računati put se može promeniti. Jasno, taj put se menja samo
ako se na njemu nalazi i čvor u. Novi put vodi od čvora s do čvora u, a nakon toga duž ivice od čvora u do
čvora v (ako postoji ivica (u,v)). Tako novi put ima dužinu jednaku zbiru dužine puta od čvora s do u i
dužinu ivice od čvora u do čvora v (ako ta ivica postoji). Najkraći put je jednak minimumu dosadašnje
dužine puta i gore pomenutog zbira.
#include <stdio.h>
#include <stdlib.h>
#define MAXV 20
#define MAXEDGES 190
#define NEPOZNATO 1000000
void buildGraph(int adj[][MAXV], int nver, int edges[3][MAXEDGES], int nedges ) {
/*
* popunjavamo matricu susedstva
*/
int i,j;
for(i=0;i<nver;i++)
for(j=0;j<nver;j++)
adj[i][j]=0;
for( i=0; i<nedges; ++i ) {
adj[edges[0][i]][edges[1][i]]=edges[2][i];//graf je orijentisan
}
}
void dijkstra(int vn, int vs, int e[][MAXV], int d[]){
int i,j,vm;
int id[MAXV];
for(i=0;i<vn;i++)
d[i]=e[vs][i]?e[vs][i]:NEPOZNATO;
d[vs]=0;
for(i=0;i<vn;i++) id[i]=0;
id[vs]=1;
for(i=0;i<vn;i++){
j=0;
while((j<vn) && (id[j] || (d[j] == NEPOZNATO))) j++;
if(j>=vn) break;
vm=j;
while(j<vn){
if(!id[j] && (d[j]!= NEPOZNATO) && (d[j]<d[vm])) vm=j;
j++;
}
id[vm]=1;
for(j=0;j<vn;j++)
if(!id[j] && (e[vm][j] != 0))
if((d[j] == NEPOZNATO) || (d[vm]+e[vm][j]<d[j]))
84
d[j]=d[vm]+e[vm][j];
}
}
int main() {
FILE *f;
int edges[3][MAXEDGES],i,nvert,nedges,adj[MAXV][MAXV],d[MAXV],vs;
f=fopen("graph.txt","r");
fscanf(f,"%d %d",&nvert,&nedges);
for(i=0;i<nedges;i++)
fscanf(f,"%d %d %d",&edges[0][i],&edges[1][i],&edges[2][i]);
fclose(f);
buildGraph(adj,nvert,edges,nedges);
printf("\n************* ALGORITAM DIJKSTRA ********************\n");
printf("\nUnesi startni cvor (0-%d):",nvert-1);
scanf("%d",&vs);
dijkstra(nvert,vs,adj,d);
for(i=0;i<nvert;i++)
printf("\nRastojanje od cvora %d do cvora %d iznosi: %d",vs,i,d[i]);
printf("\n*************** kraj ****************\n");
return 0;
}
85
4.2.9. Najkraće rastojanje između svih parova čvorova (Floyd-Warshall)
Alogoritam Floyd-Warshall – a podrazumeva iterativni postupak za određivanje najkraćih rastojanja
između svih parova čvorova.
Na početku čvorove numerišemo brojevima od 0 do n-1. Neka je d(k)i,j najkraći put između čvorova i i j
takav da su svi čvorovi na tom putu, osim krajnjih, manji ili jednaki čvoru k. Jasno, tada je d(-1)i,j jednako
dužini ivice između čvorova i i j, ako postoji. Takođe je d(n-1)i,j jednako upravo najkraćem putu između
čvorova i i j.
Računanje vrednosti d(k+1)i,j je prilično jednostavno. Može se pokazati da je:
d(k+1)i,j = min(d(k)
i,j , d(k)
i,k+1 + d(k)k+1,j)
Program za računanje najkraćih rastojanja izgleda ovako:
#include <stdio.h>
#include <stdlib.h>
#define MAXV 20
#define MAXEDGES 190
#define NEPOZNATO 1000000
void buildGraph(int adj[][MAXV], int nver, int edges[3][MAXEDGES], int nedges ) {
/*
* popunjavamo matricu susedstva
*/
int i,j;
for(i=0;i<nver;i++)
for(j=0;j<nver;j++)
adj[i][j]=0;
for( i=0; i<nedges; ++i ) {
adj[edges[0][i]][edges[1][i]]=edges[2][i];//graf je orijentisan
}
}
void floyd_warshall(int vn, int ve[][MAXV], int me[][MAXV]){
int vi, vj, vk;
for(vi=0;vi<vn;vi++)
for(vj=0;vj<vn;vj++)
if(vi==vj)
me[vi][vj]=0;
else if(ve[vi][vj] != 0)
me[vi][vj] = ve[vi][vj];
else
me[vi][vj] = NEPOZNATO;
for(vk=0;vk<vn;vk++)
for(vi=0;vi<vn;vi++){
for(vj=0;vj<vn;vj++){
if((me[vi][vk] != NEPOZNATO) && (me[vk][vj] != NEPOZNATO))
if((me[vi][vj] == NEPOZNATO) ||(me[vi][vk]+me[vk][vj] < me[vi][vj]))
me[vi][vj] = me[vi][vk] + me[vk][vj];
}
}
}
int main() {
FILE *f;
86
int edges[3][MAXEDGES],i,j,nvert,nedges,adj[MAXV][MAXV],shortest[MAXV][MAXV];
f=fopen("graph.txt","r");
fscanf(f,"%d %d",&nvert,&nedges);
for(i=0;i<nedges;i++)
fscanf(f,"%d %d %d",&edges[0][i],&edges[1][i],&edges[2][i]);
fclose(f);
buildGraph(adj,nvert,edges,nedges);
printf("\n******** ALGORITAM FLOYD - WARSHALL *****************\n");
floyd_warshall(nvert,adj,shortest);
for(i=0;i<nvert;i++)
for(j=0;j<nvert;j++)
printf("\nRastojanje od cvora %d do cvora %d iznosi: %d",i,j,shortest[i][j]);
printf("\n*************** kraj ****************\n");
return 0;
}
87
5. Zadaci za vežbu
1. Napisati program koji čvorove binarnog stabla štampa u redosledu koji odgovara nivoima (prvo
element koji se nalazi u prvom nivou, pa elemente drugog nivoa i tako redom). Za ispis
elemenata stabla po nivoima koristiti red.
/* Struktura reda u kojoj cemo cuvati pokazivace na elemente stabla */
typedef struct red{
cvor *el;
struct red * sl;
} red;
/* Struktura binarnog stabla*/
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
2. Napisati metodu koja ce vratiti broj cvorova binarnog stabla kod kojih je zbir elemenata levog podstabla veći
od zbira elemenata desnog podstabla.
/* Struktura binarnog stabla*/
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
3. Napisati metodu koja će vratiti broj čvorova stabla koji su roditelji barem jednog lista (tj. koji imaju barem
jedan list kao direktnog potomka).
/* Struktura binarnog stabla*/
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
4. Napisati metodu koja vraća labelu onog lista binarnog stabla koji ima najmanji nivo. Ukoliko postoji više
listova na najmanjem nivou, treba vratiti onaj sa najmanjom labelom. Koren stabla se nalazi na nivou 0.
/* Struktura binarnog stabla*/
typedef struct cvor { char c; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
5. Dva binarna stabla su „slična kao u ogledalu“ ako su oba prazna ili ako nisu prazna, ako je levo stablo svakog stabla „slično kao u ogledalu“ desnom stablu onog drugog. Na sledećoj slici su prikazana dva „slična kao u ogledalu“ stabla:
Napišite funkciju koja će proveriti da li su dva binarna stabla „slična kao u ogledalu“. /* Struktura binarnog stabla*/
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
6. Rekonstruišite binarno stablo čiji čvorovi imaju imena A, B, . . ., J ako je poznato da INORDER obilazak ispisuje čvorove u redosledu GDJEAICHBF, a POSTORDER obilazak u redosledu
88
DJGIABHFCE. Detaljno obrazložite svaki korak. Nakon rekonstrukcije ispišite i PREORDER obilazak dobijenog stabla. Nacrtajte još neko stablo koje ima iste PREORDER i POSTORDER obilaske kao ovo.
/* Struktura binarnog stabla*/
typedef struct cvor { int broj; struct cvor *levo, *desno; } Cvor;
typedef Cvor *Stablo;
7. Kažemo da je čvor p binarnog stabla zajednički predak čvorova u i v ako je p istovremeno predak čvora u i predak čvora v. Čvor np je najbliži predak od u i v ako od svih njihovih zajedničkih predaka upravo np ima najveću visinu. Napišite funkciju node np(BTREE T, node u, node v) koja vraća ime najbližeg pretka čvorova u i v. U primeru desno, čvorovi a i c su zajednički pretci čvorova f i e - ali kako c ima veću visinu, on je najbliži predak.
8. Udaljenost čvorova u i v računamo kao broj grana koji treba preći
na putu koji spaja u i v. Napišite funkciju int udalj(BTREE T,
node u, node v) koja vraća udaljenost čvorova u i v u stablu T. Možete koristiti pozive funkcije iz (a). U primeru desno, dužina puta koji spaja f i e je jednaka 3.
9. Kažemo da je čvor v binarnog stabla T k-potomak čvora u ako se v
nalazi u podstablu od T kojem je u koren i pri tome je nivo čvora v
za k veći od nivoa čvora u. Tako su npr. deca nekog čvora njegovi 1-potomci, deca od dece 2-potomci, itd. Napišite funkciju sa prototipom labeltype potomak(BTREE T, int k) koja vraća label onog ćvora bin. stabla T koji ima najviše k-potomaka. Ako ima više takvih čvorova, vratite labelu bilo kojeg. Funkcija treba biti neovisna o implementaciji atp-a BTREE; ne smete koristiti pomoćne atp-ove. Možete definisati pomoćne funkcije i globalne varijable. U primeru desno, uzmimo da je k = 2. Čvor a ima dvoje 2-potomaka, a čvor c jednog; kako ostali čvorovi nemaju 2-potomaka, funkcija treba vratiti a.
10. Napišite funkciju sa prototipom labeltype najvisi_list(BTREE T) koja vraća labelu
onog lista binarnog stabla T koji ima najmanji nivo. Ako ima više listova na najmanjem nivou, treba vratiti onaj sa najmanjim label. U primeru desno, listovi su b, e i f, najmanji nivo od njih ima b i taj nivo je 1; dakle funkcija za ovaj primer treba vratiti b.
11. Rekonstruišite binarno stablo ćiji čvorovi imaju imena A, B, . . ., J ako je poznato da INORDER obilazak ispisuje čvorove u redosledu GEAFDBHICJ, a POSTORDER obilazak u redosledu EFAGIHJCBD. Detaljno obrazložite svaki korak. Nakon rekonstrukcije ispišite i PREORDER obilazak dobivenog stabla.
12. Date su dve datoteke koje u svakoj liniji sadrže po jednu nisku sa ne više od 80 karaktera. Napisati program koji na standardni izlaz ispisuje sve niske prve datoteke koje nisu sadržane u drugoj datoteci. Zadatak realizovati korišćenjem binarnog stabla pretrage.
13. U binarno stablo smeštaju se celobrojni podaci (int) u intervalu [1, X] (gdje X prestavlja zbir cifara vašeg matičnog broja - JMBAG). Napisati funkciju koja će u stablo dodati novi element (ali samo ako
89
on u stablu već ne postoji). Napisati drugu funkciju koja će elemente zadanog stabla ispisati na ekran od najmanjeg prema najvećem. Napisati glavni program u kojem slučajno generirati 20 brojeva u intervalu [1, X]. Koristeći prvu napisanu funkciju, tako dobivene brojeve upisati u binarno stablo. Pomoću druge napisane funkcije ispisati sve elemente stabla. Odrediti apriornu složenost za obje funkcije i glavni program.
14. U binarno stablo smeštaju se celobrojni podaci (int) u intervalu [1, X] (gde X prestavlja zbir cifara vašeg matičnog broja - JMBG). Napisati funkciju koja će u stablo dodati novi element (ali samo ako on u stablu već ne postoji). Napisati drugu funkciju koja će za zadato stablo izračunati najveću dubinu. Napisati glavni program u kojem slučajno generisati 20 brojeva u intervalu [1, X]. Koristeći prvu napisanu funkciju, tako dobijene brojeve upisati u binarno stablo. Pomoću druge napisane funkcije izračunati i ispisati najveću dubinu stabla.
15. U binarno stablo smeštaju se celobrojni podaci (int) u intervalu [1, X] (gdje X prestavlja zbroj cifara vašeg matičnog broja - JMBAG). Napisati funkciju koja će u stablo dodati novi element (ali samo ako on u stablu već ne postoji). Napisati drugu funkciju koja će za zadato stablo izračunati prosek svih elemenata. Napisati glavni program u kojem slučajno generisati 20 brojeva u intervalu [1, X]. Koristeći prvu napisanu funkciju, tako dobijene brojeve upisati u binarno stablo. Pomoću druge napisane funkcije izračunati i ispisati prosek elemenata stabla.
16. U binarno stablo smeštaju se celobrojni podaci (int) u intervalu [1, X] (gdje X prestavlja zbir cifara vašeg matičnog broja - JMBAG). Napisati funkciju koja će u stablo dodati novi element (ali samo ako on u stablu već ne postoji). Napisati drugu funkciju koja će za zadato stablo ispisati sve elemente koji se nalaze na zadatom nivou (dubini). Napisati glavni program u kojem slučajno generisati 20 brojeva u intervalu [1, X]. Koristeći prvu napisanu funkciju, tako dobijene brojeve upisati u binarno stablo. Pomoću druge napisane funkcije za prvih 10 nivoa stabla (od korena prema listovima) ispisati elemente na svakom nivou.
17. U binarno stablo upisuju se cjelobrojni podaci (int) u intervalu [1, X] (gdje X prestavlja zbir cifara vašeg matičnog broja - JMBAG). Napisati funkciju koja će u stablo dodati novi element (ali samo ako on u stablu već ne postoji). Napisati drugu funkciju koja će za zadano stablo ispisati sve listove tog stabla. Napisati glavni program u kojem slučajno generirati 20 brojeva u intervalu [1, X]. Koristeći prvu napisanu funkciju, tako dobijene brojeve upisati u binarno stablo. Pomoću druge napisane funkcije ispisati sve listove dobijenog stabla.
6.
