1.2.4.

Stiva
Stiva este un tip particular de listă simplu înlănţuită în care adăugarea sau excluderea unui element se
face la un singur capăt al listei, numit vârf . Elementul introdus primul în stivă,
Vârf poartă numele de bază a stivei (vezi figura alăturată).

Prim Observaţii:
 singurul element din stivă, la care avem acces direct, este cel de la vârful
stivei;
 trebuie cunoscut în permanenţă vârful stivei (pointerul Prim);
 stiva este utilizată atunci când programul trebuie să amâne execuţia unor
Baza NULL operaţii, pentru a le executa ulterior, în ordinea inversă apariţiei lor;
 stiva funcţionează după principiul: Ultimul sosit este primul servit.

Crearea unei stive

Aşa cum ştim, stiva suportă două operaţii: inserarea unui nod la începutul listei şi ştergerea primului
nod din listă. În varianta de implementare dinamică, crearea unei stive cu informaţii ( n –numere
întregi) citite de la tastatură se realizează astfel:
int n, x, i;
Prim=NULL;
cin>>n; //n-numarul de elemente
for (int i=1; i<=n; i++)
{ cin>>x;
Adaug(Prim, NULL, x); } // Inserarea unui nou element la începutul listei

1.2.5. Coada
Coada reprezintă o altă categorie specială de listă simplu înlănţuită, în care elementele se adaugă la un
capăt (sfârşit) şi se suprimă la celălalt capăt (început). Despre primul element pus în coadă se spune că
este capul cozii, despre ultimul că este sfârșitul cozii. Modelul intuitiv al acestei structuri este coada
care se formează la un magazin: lumea se aranjează la sfârşitul cozii, cei care se găsesc la începutul cozii
sunt serviţi şi părăsesc apoi coada.
Elementele unei cozi se structurează ca în următoarea figură:

NULL Coada

Prim Ultim
Observaţii:
 trebuie cunoscut în permanenţă începutul cozii şi sfârşitul cozii (pointerii Prim şi Ultim);
 capul cozii se modifică de fiecare dată când eliminăm un element din coadă, iar sfârșitul cozii se
modifică de fiecare dată când adăugăm un element în coadă;
 accesul este permis astfel:
 un element se poate pune în coadă numai după elementul aflat la sfârșitul cozii şi după
această operație el devine sfârșit al cozii;
 se poate scoate din coadă numai elementul aflat în capul cozii şi după această operație în
capul cozii rămâne elementul care a fost pus în coadă după el.
 coada este utilizată atunci când informaţiile trebuie prelucrate exact în ordinea în care ”au sosit”, ele
sunt reţinute în coadă până când pot fi prelucrate;
 coada funcţionează după principiul “Primul venit –primul servit”.

Crearea unei cozi

După cum ştim, coada este o structură de date abstractă care suportă două operaţii: inserarea unui
element după ultimul nod din coadă şi ştergerea primului nod din coadă.
Pentru a realiza eficient cele două operaţii este bine să reţinem pe lângă adresa primului nod şi adresa
ultimului din coadă (de exemplu, în variabila Ultim).
 În varianta de implementare dinamică, crearea unei cozi cu informaţii ( n –numere întregi) citite de
la tastatură se realizează astfel:
Prim=Ultim=NULL;
cin>>n;
for (i=1; i<=n; i++)
{ cin>>x;
if(Prim) //coada nu este vida
{ Adaug(Prim, Ultim,x); Ultim=Ultim->urm;}
else //coada este vida
{Adaug (prim, NULL, x); Ultim=Prim; }
}

// Programul complet de creare si afisare a datelor unei cozi

#include<iostream>
#include<conio.h>
using namespace std;
struct nod
{ int inf;
nod *urm; };

typedef struct nod *Lista;

Lista Prim, Ultim, p;
int x,n;
void Adaug(Lista & Prim, Lista p, int x) // Inserarea unui nou nod in coada
{ Lista q=new nod; q->inf=x;
if(!p) {q->urm=Prim; Prim=q;}
else {q->urm=p->urm; p->urm=q;}
}
void Afisare(Lista Prim) // Parcurgerea listei cu începutul indicat de pointerul Prim
{ Lista v;
for (v=Prim; v; v=v->urm) cout<<v->inf<<" ";
cout<<endl;
}
int main ()
{cout<<"crearea unei liste pana la citirea valorii 0"<<endl;
Prim=Ultim=NULL;
cout<<"n="; cin>>n;
for (int i=1; i<=n; i++)
{ cout<<”x=”; cin>>x;

if(Prim) //coada nu este vida

{ Adaug(Prim, Ultim, x); Ultim=Ultim->urm;}
else //coada este vida
{Adaug (Prim, NULL, x); Ultim=Prim; }
}
cout<<endl<<"Lista creata:"<<endl;
Afisare(Prim); // Afişarea datelor din coada creata
cout<<endl; getch();
return 0; }

1.2.6. Crearea unei liste ordonate

Pentru a crea o listă ordonată va trebui ca înainte de a insera o nouă valoare în listă să căutăm poziţia
sa corectă, apoi să inserăm valoarea pe această poziţie, astfel încât la fiecare moment lista să fie sortată.
Dacă lista este vidă sau valoarea care trebuie să fie inserată este mai mică decât informaţia primului
nod din listă, atunci inserarea se realizează la începutul listei.
 Astfel, vom folosi un pointer p pe care îl deplasăm de la începutul listei până când nodul cel indicat de
p are o informaţie mai mare decât valoarea de inserat sau p indică ultimul nod din listă. Inserarea noii
valori se va realiza după nodul indicat de p.
Prim=NULL;
cin>>n;
for(i=1; i<=n; i++)
{ cin>>x;
if (!Prim || Prim->inf>x)
Adaug(Prim, NULL, x);
else { for ( p=Prim; p->urm && p->urm->inf<x; p=p->urm);
Adaug(Prim, p, x);
}
}

Observaţie
Elaborarea programului complet (pentru crearea unei liste ordonate) rămâne în sarcina
programatorului.

1.2.7. Exerciţii propuse (referitoare la liste simplu înlănţuite)

1. Scrieţi o funcţie care să primească ca parametru adresa primului nod al unei liste simplu înlănţuite şi
care să returneze numărul de noduri ale listei.
2. Scrieţi o funcţie cu un singur parametru (adresa primului nod dintr-o listă simplu înlănţuită) care să
şteargă din lista specificată toate nodurile care au ca informaţie valoarea 100.
3. De la tastatură se introduce un număr natural n. Creaţi o stivă ce va conţine divizorii acestui număr.
4. De la tastatură se introduce un număr natural n, apoi n numere întregi. Creaţi două cozi, astfel încât
una să conţină numerele negative, iar cealaltă –numerele nenegative dintre cele n numere introduse de la
tastatură.
5. Se consideră o listă simplu înlănţuită ce conţine elemente care au ca informaţie utilă: cod produs,
cantitate şi preţ. Scrieţi o funcţia care calculează preţul total al materialelor înregistrate în listă.
6. Să se scrie o funcţie care ordona crescator elementele unei liste inlanţuite.
7. Interclasarea a două liste ordonate. Se consideră două liste simplu înlănţuite ordonate crescător
cu adresele de început L1 şi respectiv L2. Să se scrie o funcţie care să creize o a treia listă, cu adresa de
început L3, care să conţină informaţiile din ambele liste în ordine crescătoare
Indicaţii. O primă variantă de rezolvare a problemei este de a construi o nouă listă, copiind succesiv
elemente. Se parcurg simultan cele două liste cu ajutorul a doi pointeri. La fiecare pas se compară
elementele curente şi se copiază în lista rezultat elementul cu informaţie mai mică, trecând mai departe
doar în lista din care s-a făcut copierea. Când una dintre liste s-a terminat, se copiază în lista rezultat
nodurile rămase în cealaltă listă.
O altă abordare (mai interesantă) este de a contopi cele două liste, prin modificarea legăturilor dintre
noduri astfel încât să se obţină o singură listă cu informaţiile ordonate crescător. Evident, în acest mod
cele două liste iniţiale se distrug.
.