Binarno pretraivanje

Uvjet da bi se primijenio algoritam za binarno pretraivanje:

- Lista treba biti sortirana
Ukratko, binarno pretraivanje moemo opisati na slijedei nain:
- Pronalazimo centralni element
- Odbacimo polovicu liste
- Pretraujemo drugu polovicu
- Nastavljamo dok se traeni element ne pronane...
- ...ili dok ne ostane niti jedan element za pretraivanje

nt main(){
const int arraySize = 10;
int target;
int Element[arraySize] = {1, 4, 6, 9, 13, 17, 20, 28, 32, 41};
int bottom, middle, top;
cout << "Unesite cilj koji trazite: ";
cin >> target;
//binarno pretrazivanje
bottom = 0;
top = 9;
while(top > bottom){
middle = (top+bottom)/2;
if (Element[middle] < target)
bottom = middle+1;
else
top = middle;
}
if (Element[top] == target)
cout << "Cilj je pronadjen na lokaciji " << top+1 <<"."<< endl;
else
cout << "Cilj nije pronadjen." << endl;
return 0;
}

Stek (Stack) - LIFO

Stek je urenena grupa homogenih elemenata kod koje se
izbacivanje i dodavanje novih elemenata moe obaviti jedino na
vrhu grupe. Prema tome, stek je struktura podataka koja namee neka
ogranienja.
//stek struktura
typedefstruct
{
intv[20];
inttop;
}Stack;
//funkcije steka
void push(Stack *S, int val){
if (!full(S)){
S->v[ S->top ] = val;
(S->top)++; }
else
cout<<"Stek je pun."<<endl;
}
int pop(Stack *S){
if (S->top!=0){
(S->top)--;
return (S->v[S->top]);}
else
cout<<"Stek je prazan."<<endl;
}
void init(Stack *S){
S->top = 0;
}
bool full(Stack *S){
return (S->top == 20);
}
void StackPrint(Stack *S){
int i;
if (S->top == 0)
cout << "Stek je prazan."<<endl;
else{
cout <<"Sadrzaj steka: ";
for (i=0;i<S->top;i++){
cout<<S->v[i]<<" ";
}
cout<<endl;
}
}

void main()
{
Stack S;
init(&S);
cout<<"STANJE NA STEKU:";
StackPrint(&S);
cout<<"Ubacujemo na stek 7,2,4,8,3"<<endl;
push(&S, 7);
push(&S, 2);
StackPrint(&S);
cout<<"Uzimamo sa steka dva broja"<<endl;
pop(&S);
pop(&S);
StackPrint(&S);
cout<<"Stavljamo na stek 6"<<endl;
push(&S, 6);
StackPrint(&S);
cout<<"Uzimamo sa steka dva broja, sabiremo ih i rezultat stavljamo na
stek"<<endl;
push(&S, pop(&S) + pop(&S));
StackPrint(&S);
}

Red (Queue)- LIFO

Red (eng. queue) je podatkovna struktura kod koje je pristup dozvoljen
samo elementu koji se nalazi na kraju strukture. Prema tome, stek je
struktura podataka koja namee neka ogranienja.
Trebat e nam slijedei markeri:
- marker head da pokazuje na glavu reda;
- marker tail da pokazuju na lokaciju neposredno iza repa reda gdje bi
se trebao smjestiti slijedei element koji se dodaje u red
- QSIZE broj elemenata u redu
Prazan red:
head == tail?
Pun red:
(tail + 1) % QSIZE == head
Novi element dodajemo u red na slijedei nain:
Ako red nije prazan dodati element na lokaciju s indeksom tail, te postaviti
novu
vrijednost za marker tail na slijedei nain
tail = (tail + 1) % QSIZE.
Element uklanjamo iz reda na slijedei nain:
Ako red nije prazan ukloniti element s lokacije s indeksom head, te
postaviti novu
vrijednost za marker head na slijedei nain:
head = (head + 1) % QSIZE
constintQSize=5;
//struktura Red
typedefstruct
{
intv[QSize];
intHead;
intTail;
}Red;
//funkcije reda
boolIsEmpty(Red*R){
returnR>Head==R>Tail?true:false;
}
boolIsFull(Red*R){
return(R>Tail+1)%QSize==R>Head?true:false;
}
boolPop(Red*R,int&TopElem){
if(!IsEmpty(R)){
TopElem=R>v[R>Head];
R>Head=(R>Head+1)%QSize;
returntrue;

}
else{
cout << "Element nije izbacen iz reda jer je red prazan.\n";
returnfalse;
}
}
boolPush(Red*R,intNewElem){
if(!IsFull(R)){
R>v[R>Tail]=NewElem;
R>Tail=(R>Tail+1)%QSize;
returntrue;
}
else{
cout<<"Elementnijestavljenuredjerjeredpun.\n";
returnfalse;
}
}

voidPrint(Red*R){
if(IsEmpty(R))
cout<<"Redjeprazan.\n";
else
for(intmarker=R>Head;marker!=R>Tail;marker=(marker+1)%QSize)
cout<<marker<<''<<
R>v[marker]<<endl;
}
voidinit(Red*R){
R>Head=0;
R>Tail=0;
}
voidmain()
{
RedR;
intItem;
init(&R);
cout<<"Unesitecijelibroj:";
cin>>Item;
Push(&R,Item);
if(Pop(&R,Item))
cout<<"Element"<<Item<<"jeuklonjen.\n";
cout<<"Sadrzajredaje:\n";
Print(&R);
return0;
}

Liste
U najkraem listu moemo definirati kao konani niz podataka istog tipa.
Lista se obino formalno zapisuje na slijedei nain:
(a1, a2, a3, ..., an),
gdje je n duljina liste. Ako je n=0 kaemo da je lista prazna.
Broj elemenata u listi nije fiksiran to znai da se elementi mogu ubacivati ili
izbacivati na bilo kojem mjestu.
Lista, kao i neke druge strukture podataka, se sastoje od manjih cjelina koje se
integriraju u vee i meusobno se povezuju vezama. Osnovni element od kojih se
grade povezane liste je vor.
vor predstavlja komponentu koju promatramo kao zasebnu cjelinu.
Svaki vor sadri dio koji nazivamo informacioni dio. Informacioni sadraj moe
biti bilo kojeg strukturiranog tipa.
Svaki vor liste pored informacionog sadraja sadri i pokaziva na slijednika,
odnosno, na slijedei vor.
Pokaziva je druga vana komponenta (pored informacionog sadraja)
sadrana u vorovima liste. Pokaziva slui za uspostavljanje veze izmeu
pojedinih dijelova liste. Prema tome, pokaziva je dio vora koja pokazuje na neki
drugi vor u listi. Sadraj pokazivaa je zapravo adresa vora na koju taj
pokaziva pokazuje.
Listi se pristupa preko posebnog pokazivaa koji pokazuje na prvi vor
koji se obino naziva glava (eng. head). Ako je lista prazna, onda pokaziva
glava ima vrijednost 0 (glava=0), to znai da taj pokaziva ne pokazuje niti na
jedan vor (lista je prazna).

LIFO Lista
struct Cvor
{
int v;
Cvor *slijed;
};
Cvor *glava=0;
void ubaci_novi_cvor(int broj)
{
Cvor *priv=glava;
glava=new Cvor;
glava->v=broj;
glava->slijed=priv;
}
void print_list()
{
Cvor *ptr = glava;
int i=1;
cout<<"Sadrzaj LIFO liste pocevsi od glave:"<<endl;
cout<<"-------------------------------------"<<endl;
while (ptr != 0)
{
cout << "Informacioni dio cvora "<<i<<":" << ptr->v << " " <<endl;
ptr = ptr->slijed;
i++;
}
}
void main()
{
int x;
x=7;
ubaci_novi_cvor(x);
x=8;
ubaci_novi_cvor(x);
x=9;
ubaci_novi_cvor(x);
x=14;
ubaci_novi_cvor(x);
x=12;
ubaci_novi_cvor(x);
print_list();
}

system ("pause>null");