Stog

Tipovi:

typedef ? stack_element_t;

typedef struct stack_tag *stack_t;

Operacije:

stack_t stack_new(); stvara novi (prazni) stog

void stack_delete(stack_t s); unitava stog

void stack_push(stack_t s, stack_element_t e); ubacuje element na vrh stoga

stack_element_t stack_pop(stack_t s); uklanja element sa vrha stoga

stack_element_t stack_top(stack_t s); vraa element sa vrha stoga

int stack_is_empty(stack_t s); vraa 1 ako je stog prazan, a 0 inae

int stack_size(stack_t s); vraa broj elemenata u stogu

Red

Tipovi:

typedef ? queue_element_t;

typedef struct queue_tag *queue_t;

Operacije:

queue_t queue_new(); stvara novi (prazni) red

void queue_delete(queue_t q); unitava red

void queue_enqueue(queue_t q, queue_element_t e); ubacuje element na kraj reda

queue_element_t queue_dequeue(queue_t q); uklanja element s poetka reda

queue_element_t queue_front(queue_t q); vraa element na poetku reda

int queue_is_empty(queue_t q); vraa 1 ako je red prazan, a 0 inae

int queue_size(queue_t q); vraa broj elemenata u redu

Lista

Tipovi:

typedef ? list_element_t;

typedef struct list_tag *list_t;

typedef struct list_iterator_tag *list_iterator_t;

Operacije nad listom:

list_t list_new(); stvara novu (praznu) listu

void list_delete(list_t l); unitava listu

int list_is_empty(list_t l); vraa 1 ako je lista prazna, a 0 inae

int list_size(list_t l); vraa broj lanova u listi

void list_add(list_t l, list_element_t e); dodaje element na kraj liste

list_iterator_t list_iterator(list_t l); vraa prvu poziciju u listi

list_iterator_t list_reverse_iterator(list_t l); vraa zadnju poziciju u listi

Operacije nad iteratorom liste:

list_element_t list_get(list_iterator_t i); vraa element na danoj poziciji u listi

void list_insert(list_iterator_t i, list_element_t e); ubacuje element na danu poziciju u listi

void list_replace(list_iterator_t i, list_element_t e); zamjenjuje element na danoj poziciji u listi novom

vrijednou

void list_remove(list_iterator_t i); uklanja element sa dane pozicije u listi

void list_iterator_next(list_iterator_t i); postavlja iterator na sljedeu poziciju u listi

void list_iterator_previous(list_iterator_t i); postavlja iterator na prethodnu poziciju u listi

void list_iterator_seek(list_iterator_t i, int n); postavlja iterator na n-tu poziciju u listi

int list_iterator_is_valid(list_iterator_t i); vraa 1 ukoliko iterator pokazuje na ispravnu poziciju

u listi, a 0 inae

int list_iterator_is_equal(list_iterator_t i1,

list_iterator_t i2);

vraa 1 ukoliko oba iteratora pokazuju na istu poziciju

u listi, a 0 inae

void list_iterator_set(list_iterator_t i1,

list_iterator_t i2);

postavlja iterator i1 na istu poziciju kao i i2

void list_iterator_delete(list_iterator_t i); unitava iterator

Skup

Tipovi:

typedef ? set_element_t;

typedef struct set_tag *set_t;

typedef struct set_iterator_tag *set_iterator_t;

Operacije nad skupom:

set_t set_new(); stvara novi (prazni) skup, elementi se usporeuju

sa , ==, hash se rauna sa %

set_t set_new_advanced(

int (*compare)(const set_element_t, const set_element_t),

size_t (*hash)(const set_element_t));

stvara novi (prazni) skup, elementi se usporeuju

funkcijom compare, a hash rauna funkcijom hash

void set_delete(set_t s); unitava skup

int set_is_empty(set_t s); vraa 1 ako je skup prazan, a 0 inae

int set_size(set_t s) vraa broj elemenata u skupu

void set_add(set_t s, set_element_t e); ubacuje element u skup

void set_remove(set_t s, set_element_t e); uklanja element iz skupa

int set_is_member(set_t s, set_element_t e); vraa 1 ako skup sadri dani element, a 0 inae

int set_is_subset(set_t s1, set_t s2); vraa 1 ako je skup s1 podskup skupa s2, a 0 inae

set_t set_union(set_t s1, set_t s2); vraa uniju skupova s1 i s2

set_t set_intersection(set_t s1, set_t s2); vraa presjek skupova s1 i s2

set_t set_difference(set_t s1, set_t s2); vraa razliku skupova s1 i s2

set_iterator_t set_iterator(set_t s); vraa iterator na prvi element skupa

Operacije nad iteratorom skupa:

set_element_t set_get(set_iterator_t i); vraa element na danoj poziciji u skupu

set_element_t set_iremove(set_iterator_t i); uklanja zadani element iz skupa

void set_iterator_next(set_iterator_t i); postavlja iterator na sljedeu poziciju u skupu

int set_iterator_is_valid(set_iterator_t i); vraa 1 ukoliko iterator pokazuje na ispravnu poziciju u

skupu, a 0 inae

int set_iterator_is_equal(set_iterator_t i1,

set_iterator_t i2);

vraa 1 ukoliko oba iteratora pokazuju na istu poziciju

u skupu, a 0 inae

void set_iterator_set(set_iterator_t i1,

set_iterator_t i2);

postavlja iterator i1 na istu poziciju kao i i2

void set_iterator_delete(set_iterator_t i); unitava iterator

Mapa

Tipovi:

typedef ? map_key_t;

typedef ? map_value_t;

typedef struct map_tag *map_t;

typedef struct map_iterator_tag *map_iterator_t;

typedef struct map_element_tag {

map_key_t key;

map_value_t value;

} map_element_t;

Operacije:

map_t map_new(); stvara novu (praznu) mapu, elementi se usporeuju sa , ==, hash se rauna sa %

map_t map_new_advanced(

int (*compare)(const map_key_t, const map_key_t),

size_t (*hash)(const map_key_t));

stvara novu (praznu) mapu, elementi se usporeuju

funkcijom compare, a hash rauna funkcijom hash

void map_delete(map_t m); unitava mapu

int map_is_empty(map_t m); vraa 1 ako je mapa prazna, a 0 inae

int map_size(map_t m); vraa broj elemenata u mapi

int map_has_key(map_t m, map_key_t k); vraa 1 ukoliko u mapi postoji element s kljuem k, a 0

inae

map_value_t map_get(map_t m, map_key_t k); vraa vrijednost pridjeljenu kljuu k

void map_put(map_t m, map_key_t k, map_value_t v); ubacuje element sa kljuem k i vrijednou v

void map_put_element(map_t m, map_element_t e); ubacuje element sa kljuem e.key i vrijednou e.value

void map_remove(map_t m, map_key_t k); uklanja element sa kljuem k

map_iterator_t map_iterator(map_t m); vraa prvu poziciju u mapi

Operacije nad iteratorom mape:

map_element_t map_iget(map_iterator_t i); vraa element na danoj poziciji u mapi

void map_iput(map_iterator_t i, map_value_t v); zamjenjuje vrijednost na danoj poziciji u mapi novom

vrijednou

void map_iremove(map_iterator_t i); uklanja element sa dane pozicije u mapi

void map_iterator_next(map_iterator_t i); postavlja iterator na sljedeu poziciju u mapi

void map_iterator_set(map_iterator_t i1,

map_iterator_t i2);

postavlja iterator i1 na istu poziciju kao i i2

int map_iterator_is_valid(map_iterator_t i); vraa 1 ukoliko iterator pokazuje na ispravnu poziciju

u mapi, a 0 inae

int map_iterator_is_equal(map_iterator_t i1,

map_iterator_t i2);

vraa 1 ukoliko oba iteratora pokazuju na istu poziciju

u mapi, a 0 inae

void map_iterator_delete(map_iterator_t i); unitava iterator

Prioritetni red

Tipovi:

typedef ? prioq_key_t;

typedef ? prioq_value_t;

typedef struct prioq_tag *prioq_t;

typedef struct prioq_element_tag {

prioq_key_t key;

prioq_value_t value;

} prioq_element_t;

Operacije:

prioq_t prioq_new(); stvara novi (prazni) red, elementi se usporedjuju

sa , ==, hash se rauna sa %

prioq_t prioq_new_advanced(

int (*compare)(const prioq_key_t, const prioq_key_t),

size_t (*hash)(const prioq_key_t));

stvara novi (prazni) red, elementi se usporeuju

funkcijom compare, a hash rauna funkcijom hash

void prioq_delete(prioq_t pq); unitava red

void prioq_enqueue(prioq_t pq, prioq_key_t k,

prioq_value_t v);

ubacuje element sa prioritetom k i vrijednou v

void prioq_enqueue_element(prioq_t pq, prioq_element_t e); ubacuje element sa prioritetom e.key i vrijednou

e.value

prioq_element_t prioq_dequeue(prioq_t pq); uklanja element s najveim prioritetom

prioq_element_t prioq_front(prioq_t pq); vraa element sa najveim prioritetom

int prioq_is_empty(prioq_t pq); vraa 1 ako je red prazan, a 0 inae

int prioq_size(prioq_t pq); vraa broj elemenata u prioritetnom redu