Линеарно поврзани листи

и купови (stack)
Поврзани листи

● Поврзаната листа е најчесто користената структура на податоци што

може да собере неопределено количество на артикли која се состои од
група на јазли во низа.
● Секој јазол има свои податоци и адреса на следниот јазол, со што
формира структура како синџир.
● Поврзаните листи се користат за создавање дрва и графови.
Што е јазол?
Секој елемент, односно јазол од листата се состои од два артикли - податок и
покажувач кон следниот јазол. Последниот јазол има референца (покажувач)
кон NULL. Влезната точка во поврзаните листи се нарекува глава на листата.
Треба да се напомене дека главата не е посебен јазол, туку покажувач на
првиот јазол.
Податок (data)

next
Предности на поврзаните листи:

● Тие се динамични по природа што ја расподелуваат меморијата кога е

потребно.
● Операциите вметнување и бришење може лесно да се спроведат.
● Купови и редици лесно може да се извршат.
● Поврзаната листа го намалува времето за пристап.
Видови врзани листи

Достапни се 3 различни имплементации на поврзаната листа, тие се:

● Листа со единечно поврзување
● Двојно поврзана листа
● Кружна поврзана листа
Листа со единечно поврзување
Единечно поврзаните листи содржат јазли кои имаат дел за податоци, како и
адресен дел т.е. следно (next), што укажува на следниот јазол во низата на
јазли. Операциите што можеме да ги извршиме на единечно поврзаните
листи се вметнување, бришење и вкрстување.
Двојно поврзана листа Кружно поврзана листа

Во двојно поврзана листа, секој јазол Во кружно поврзаната листа,

содржи дел за податоци и две адреси, последниот јазол на листата ја содржи
една за претходниот јазол и една за адресата на првиот јазол, со што се
следниот јазол. формира кружен ланец.
 Креирање јазол Креирање покажувачи

struct node { node *n; // покажува кон одреден

јазол
int data; // дел за податоци
node *next; // покажувач node *t; // temporary (привремен
покажувач)
};
node *h; // head (глава - почеток
на листата)
data

next n t h
 Креирање на прв јазол
n = new node; // дава наредба на
покажувачот n да покаже кон нов
креиран јазол n

n -> data = 1; // со помош на n -> 1

пристапуваме до data членот од јазолот
и даваме вредност 1
next
t = n; // дава наредба на покажувачот t
да покажува каде што покажува n
t h
h = n; // дава наредба на покажувачот
h да покажува каде што покажува n
 Креирање на втор јазол

n = new node; // дава наредба n

на покажувачот n да покаже кон
нов креиран јазол
2
n -> data = 2; // со помош на n
-> пристапуваме до data членот од next
јазолот и даваме вредност 2
 Поврзување на првиот и вториот јазол

t -> next = n; // дава наредба на покажувачот t да пристапи кон next делот

од јазолот и дава наредба да покажува каде што покажува n

t = t -> next; // го преместува покажувачот t на следниот јазол, може да се

запише и едноставно како t = n;

n
1 2
h next next
t
 Креирање на последен јазол
n = new node; // дава наредба на покажувачот n да покаже кон нов креиран јазол

n -> data = 3; // со помош на n -> пристапуваме до data членот од јазолот и даваме

вредност 3

t -> next = n; // дава наредба на покажувачот t да пристапи кон next делот од јазолот и
дава наредба да покажува каде што покажува n

n -> next = NULL; // дава наредба next да “покажува“ кон NULL, т.е. да го заврши
синџирот

n
1 2 3
h next next next
t
 Целосен код
#include <iostream> t=n;
using namespace std; h=n;
int main (){ n= new node;
struct node { n->data=2;
int data; t->next=n;
node *next; t = t ->next;
}; n= new node;
node *n; n->data=3;
node *t; t->next=n;
node *h; n->next=NULL;
n = new node;
n->data=1; return 0;
}
Куп (stack)
Куп е апстрактен тип на податоци со ограничен (предефиниран) капацитет.
Тоа е едноставна структура на податоци која овозможува додавање и
отстранување на елементи во одреден редослед. Секој пат кога ќе се додаде
елемент, тој оди на врвот на купот и елементот што може да се отстрани е
елементот што е на врвот на купот.
Top
4 Покажувач на купот (stack pointer) -
секогаш покажува кон врвот
3
2
1
Bottom
Функции на купот
Купот работи според LIFO (Last In First Out) т.е. кој последен влегува прв
излегува, односно секој пат кога ќе се додаде елемент, тој оди на врвот на
купот и елементот што може да се отстрани е елементот што е на врвот на
купот.

Функциите поврзани со куповите се:

● empty() - враќа дали купот е празен

● size() - ја враќа големината на купот
● top() - го враќа горниот елемент од купот
● push(n) - додава елемент ‘n’ на врвот од купот
● pop() - го брише горниот елемент од купот
 Визуелен пример

Push(1) 1

3
Push(3) 1

5
Push(5) 3
1

3
Pop()
1
За да креираме куп (stack) мора прво да ја вклучиме библиотеката stack

● #include <stack>

Купот се креира со командата stack <TYPE> name; каде што на местото на

TYPE го дефинираме типот на купот (int, char, float, double итн.), а на местото
на name го ставаме името на купот што сакаме да го има.

●  stack <int> s1; // креира куп со име s1 и тип на купот е int (integer)

За имплементирање на функциите користиме команда name.command(); каде

што на местото на name го пишуваме името на купот, а на местото на
command функцијата што сакаме да ја искористиме

● s1.push(3);
 Пример
#include <iostream> while ( !mystack.empty() ) // се додека На екран печати:
купот не е празен: ... Stack size: 3
#include <stack> // библиотека stack 5
{ 3
using namespace std; 0
cout<<mystack.top()<<endl; // го печати
int main (){ горниот елемент од купот

stack <int> mystack; // креирање куп mystack.pop(); // го брише горниот

елемент од купот
mystack.push(0); 5
}
mystack.push(3); 3
return 0;
0
mystack.push(5);
}
cout<<”Stack size: ”mystack.size()<<endl;
// ја печати големината на купот
 Пр. Корисникот внесува колку елемнти сака да има купот и потоа тој ги внесува податоците

#include <iostream> for(i=0; i<n; i++){ На екран печати:

Vnesi kolku elementi

#include <stack> cout<<"Vnesi element za kupot "; sakas da ima kupot 5

using namespace std; cin>>a;

Vnesi element za kupot 2
int main (){ mystack.push(a);

int n, a=0, i; } Vnesi element za kupot 1

cout<<"Vnesi kolku elementi sakas da ima while(!mystack.empty()){

kupot "; Vnesi element za kupot 6
cout<<mystack.top()<<" ";
cin>>n;
Vnesi element za kupot 8
mystack.pop();
stack <int> mystack;
}
Vnesi element za kupot 4

return 0; }
Пр. Корисникот внесува колку елементи да бидат избришани
#include <iostream> cout<<"Vnesi kolku elementi sakas da izbrises "; На екран печати:

#include <stack> cin>>n; Vnesi kolku elementi

sakas da izbrises 2

using namespace std; for(i=0; i<n; i++){

int main (){ mystack.pop(); 704

int n, i; }

stack<int>mystack; while(!mystack.empty()){

mystack.push(4); cout<<mystack.top()<<" ";

mystack.push(0); mystack.pop();

mystack.push(7); }

mystack.push(4); return 0; }

mystack.push(3);