Colegiul Naional Mihail Koglniceanu Galai

Proiect pentru susinerea atestatului n

informatica

Tema: Structuri de date

Profesor ndrumator:
Novetschi Musunoiu Iuliana Monica
Elev:
Hahue Madalina
Georgiana
Cls a XII a E

Sesiunea mai 2012

Cuprins:
2

Structuri de date__________________________________________________________4
Conceptul de dat______________________________________________________________4
Conceptul

de structur de date_____________________________________________5

Clasificarea structurilor de date :_____________________________________________7

Structuri dinamice de date_______________________________________________7

Structura de tip list liniar___________________________________________________7

Liste alocate secvential__________________________________________________8

Implementarea listelor liniare folosind tipul tablou_________________________8

Liste alocate inlantuit____________________________________________________9

Stive si cozi. Operatii specifice.________________________________________10
Prezentare general__________________________________________________________11
Stiva___________________________________________________________________________11
Eficiena utilizrii stivelor____________________________________________________12
Coada:_________________________________________________________________________13
Eficiena utilizrii cozilor:____________________________________________________13

De Retinut!_______________________________________________________________14
Lista liniara simplu inlantuita__________________________________________15
Lista liniara dublu inlantuita___________________________________________16
Functii de inserare(adaugare)__________________________________________17
Aplicatii__________________________________________________________________18
Structura de date de tip coada________________________________________________________32
Structura de tip Stiva__________________________________________________________________35
Liste circulare_________________________________________________________________________40

Bibliografie______________________________________________________________88

Structuri de date

Conceptul de dat
n informatic, prin dat, se desemneaz un model de reprezentare a
informaiei, model cu care se poate opera pentru a obine noi informaii
despre fenomenele, procesele i obiectele lumii reale.
O dat care apare ca o entitate indivizibil att din punct de vedere al
informaiei pe care o reprezint ct i din punct de vedere al procesorului
care o prelucreaz se numete dat elementar sau scalar.
O dat elementar, ca model de reprezentare a informaiei, poate fi
privit la nivel logic sau la nivelul calculatorului, din punct de vedere fizic.
Exemplu de dat elementar: x=8
Datele pot fi private din punct de vedere:
- logic, o dat poate fi definit ca un triplet de forma
(identificator, atribute, valori)
- fizic, ca o zon de memorie de o anumit lungime situat la o
anumit adres absolut n care sunt memorate n timp i ntr-o
form specific valorile date.
O dat care pstreaz aceeasi valoare pe tot parcursul procesului de
prelucrare se numete simplu constant, n caz contrar se numete variabil.
O dat constant este identificat prin nsui valoarea ei, altfel spus, o dat
se identific prin formas textual a valorii. Tipul unei date, utilizate n cadrul
unui program, este precizat n cadrul programului de prelucrare printr-o
declaraie de tip ce precede utilizarea respectivei constante, variabile sau
funcii. n afara atributului de tip, unei date i se pot asocia i alte atribute. De
exemplu: precizia reprezentrii interne; ncadrarea datei n zona afectat;
modul de alocare al memoriei (static sau dinamic), valoarea iniial.
Valorile datei pot fi precizate prin enumerare (tipul de enumerare n Pascal)
sau printr-o proprietate comun. Valorile datei pot fi numere sau valori de
adevr sau iruri, de bii, etc.

Conceptul

de structur de date

De foarte multe ori n realitate, datele apar sub forma unor colecii de date
asupra unor mulimi de date pe care ns s-a definit o anumit organizare
menit s faciliteze prelucrarea.
O colecie de date pe care s-a definit o anumit organizare, o numit
structur i creia i este specific un anumit mod de selecie i identificare,
poart denumirea de structur de date.

Structurile interne au un caracter de date temporare, ele dispar

odat cu oprirea programului, ncetarea activitii de prelucrare, iar cele
externe au un caracter de date permanente, care nu se pierd odat cu
ntreruperea tensiunii de alimentare.
Structura de date de tip tablou este o structur implicit; listele
liniare simplu nlnuite sunt structuri explicite de date.
Cele mai frecvente operaii pot fi:
operaia de creare care const n memorarea pe suportul de
memorie a structurii de date n forma sa iniial
operaia de consultare care const n accesul la elementele
structurii n vederea prelucrrii valorilor acestora
operaia de actualizare care const n adugarea de noi
elemente, tergerea elementelor care nu mai sunt necesare i
modificarea valorilor unor componente ale structurii
operaia de actualizare const n modificarea structurii de date
operaia de sortare care presupune aranjarea, ordonarea
elementelor unei structuri ntr-o anumit ordine precizat de
valorile date
operaia de descompunere care const n descompunerea unei
structuri de date n dou sau mai multe structuri
operaia de fuzionare combinarea a dou sau mai multe
structuri la fel ordonate n una singur

 operaia de copiere realizarea unei copii a structurii de date,

de regul pe un alt suport de memorie.

Prin structur de date vom nelege un asamblu de date caracterizat

prin relaiile existente ntre ele i a operaiilor care pot fi efectuate
cu datele respective.
Vom numi nod o variabil de un tip oarecare. De obicei, acest tip
este structurat. Dup caz, termenul nod poate fi nlocuit cu articol,
nregistrare sau entitate.
n cele mai multe cazuri, "ansamblul de date" care alctuiete
structura e alctuit dintr-o mulime cu un numr variabil de noduri.

Clasificarea structurilor de date :

I. Structuri de date elementare :
tablouri (vectori, matrici, iruri de caractere)
nregistrare
fiiere
II. Structuri de date dinamice:
structura de tip list (list simplu nlnuit, dublu nlnuit,
circular, stiv, coad)
structura de tip arbore: arbori binari, arbori binari de
cautare, arbori oarecare
III. Structuri de tip graf :
grafuri neorientate
arbori
grafuri orientate

Structuri dinamice de date

Structura de tip list liniar
Lista liniar este o colecie de n0 elemente de acelai tip
denumite noduri ale cror proprieti structurale se refer la
poziiile relative liniare unidimensionale.
Principalele operaii care se pot efectua asupra
elementelor unei liste liniare sunt urmatoarele:
1. inserarea unui nou element n faa elementului de pe poziia
i
2. suprimarea elementului de pe poziia i
3. consultarea elementului de pe poziia i
4. sortarea elementelor listei n ordinea valorilor unui anumit
cmp cmp cheie precizat de utilizator
5. descompunerea unei liste liniare n dou sau mai multe liste
6. compunerea a dou sau mai multe liste la fel ordonate ntruna singur
7. determinarea numrului de elemente a unei liste
8. cutarea unui element cu o valoare particular a unui cmp
dat

9. copierea unei liste liniare, de regul, pe un alt suport

Liste alocate secvential

Implementarea listelor liniare folosind tipul
tablou
La acest mod de implementare nodurile listei ocup poziii succesive n
memorie. Acest tip de alocare a fost utilizat frecvent, ori de cte ori s-au
utilizat vectori.
n reprezentarea listelor prin intermediul tipului tablou, tipul list se
asimileaz cu un articol cu 2 componente:
o component fiind un tablou ale crui elemente vor fi elementele listei
de dimensiune aleas astfel nct s poat s conin cea mai mare
list posibil care poate s apar n respectiva aplicaie
a doua component (cmp) este un ntreg care va preciza poziia n
tablou a ultimului element al listei liniare.
Structura de date care va descrie o astfel de implementare a listelor
liniare va fi:

n limbajul C++:
# define lungime_max
typedef nod;
typedef struct
8

{nod elem[lung_max];
int ultim;}
lista;

Liste alocate inlantuit

Listele nlnuite sunt cele mai frecvent utilizate structuri de date dup
tablouri. Ele ofer un mecanism extrem de eficient care poate fi utilizat n
multe tipuri de baze de date. Listele pot nlocui structuri de baz pentru
implementarea altor structuri cum sunt stivele sau cozile. De fapt se pot
utiliza listele nlnuite aproape peste tot unde se utilizeaz tablourile (cu
excepia cazului n care avem frecvent nevoie de accesul la elementele
individuale ale listei prin intermediul unui indice).
Exist dou feluri de alocare nlnuit: alocare simplu nlnuit i
alocare dublu nlnuit.
1. O list liniar simplu nlnuit este o structur de forma:
in1
p
ri
madr2

inn
a
d
rn nil

in
a 2
d
3
radr
2

2. Alocarea dublu nlnuit. Alocarea simplu nlnuit permite

parcurgerea listei ntr-un singur sens (de la stnga la dreapta) n cazul n
care se dorete ca lista s poat fi parcurs n ambele sensuri se utilizeaz
alocarea dublu nlnuit. Aici fiecare nod reine adresele predecesorului i
succesorului su, aa cum se vede n figura urmtoare:
nil

adr

adr

a in
1
d adr2
r

a in 1
2
d adr
3
r

a in n-1
d niln
r

Liste circulare alocate dinamic

Listele circulare sunt un caz particular de liste liniare nlnuite (simplu
sau dublu). Deosebirea fa de acestea const n aceea c adresa urmtoare
a ultimului nod (i adresa precedent a primului nod la cele dublu nlnuite)
nu mai este nil ci este primul nod (respectiv ultimul nod ). n rest listele
circulare se comport la fel ca i celelalte liste. Un exemplu de astfel de list
este prezentat n continuare:
9
7

10

Stive si cozi. Operatii specifice.

Listele implementate dinamic sunt foarte utile atunci cnd se lucreaz cu
multe informaii pe care vectorii se dovedesc incapabili a le stoca, sau
ineficieni.
Cazuri particulare de liste simplu nlnuite sunt stivele i cozile.
Acestea implementeaz dou mecanisme diferite de intrare i ieire a
elementelor din list. La ambele feluri de liste, un nod al listei este o
nregistrare ce conine o informaie (info), precum i un pointer (indicator)
ctre precedentul (urmtorul) element al listei (prec sau urm).

Prezentare general
Stivele i cozile reprezint entiti mai abstracte dect tablourile i multe
alte structuri de date. Ele sunt definite n primul rnd prin interfa, adic
prin operaiile care se pot executa asupra lor. Mecanismul intern utilizat la
implementarea lor nu este de regul vizibil pentru utilizator. De exemplu, la
baza implementrii unei stive poate sta un tablou sau o list.

Stiva
Stiva este o structur dinamic de date reprezentat de o list simplu
nlnuit n care mecanismul de intrare-ieire a elementelor este de tip LIFO
ultimul intrat este primul ieit (Last In, First Out).

10

O stiv permite accesul la un singur element: cel care a fost inserat ultimul.
Dac eliminm acest element atunci vom avea acces la elementul de sub el
.a.m.d. Aceast caracteristic se dovedete util n multe situaii din
programare.
Stiva este, de asemenea, un alement ajuttor pentru algoritmii care
utilizeaz anumite structuri mai complexe de date.
Majoritatea microprocesoarelor au o arhitectur bazat pe conceptul de
stiv. La apelul unei funcii, adresa de revenire din aceasta i parametrii
funciei se introduc ntr-o stiv, n timp ce, la revenire, aceste informaii sunt
extrase din stiv.

Push
7

Pop

Vrf

3
4
8
5
2

Stiva va fi afiat astfel :

nil
>7,3,4,8,5,2
Stiva o structur dinamic de date de
tip LIFO

11

n C++:
struct Stiva { int info;
Stiva * urm;
stiva
}
*S;

// informatia
// precedentul element din

Eficiena utilizrii stivelor

Elementele pot fi att inserate ct i extrase dintr-o stiv n timp constant
O(1). Aceasta nseamn c timpul nu depinde de numrul elementelor din
stiv, fiind deci foarte scurt. Nu sunt necesare comparaii sau deplasri.

Coada:
Coada este o structur dinamic de date reprezentat de o list
simplu nlnuit n care mecanismul de intrare-ieire a elementelor
este de tip FIFO primul intrat este primul ieit (First In, First Out).
Un sinonim cu termenul coad este rnd. A sta la coad nseamn,
a sta la rnd. n programare, o coad este o structur de date
similar stivei, exceptnd faptul c ntr-o coad primul element
inserat este i primul care va fi ters.
Ca i stivele, cozile sunt utilizate ca instrumente ale programatorilor.
Ele se utilizeaz, spre exemplu n implementarea algoritmilor de
parcurgere a grafurilor. Cozile se mai pot utiliza la modelarea unor
situaii din viaa cotidian. Exist diferite cozi care funcioneaz
neobservate n cadrul sistemului de operare al calculatorului. Exist
o coad asociat unei imprimante, n care aplicaiile care au ceva
de tiprit ateapt ca imprimanta s devin disponibil. Tot ntr-o
coad sunt pstrate apsrile tastelor. De asemenea, n structura
intern a unui microprocesor, instruciunile care urmeaz s fie
procesate de acesta sunt pstrate tot ntr-o coad de ateptare.
12

 Vom memora o coad n felul urmtor:

n C++:
struct Celula { int info;
Celula* urm;
}*prim;
struct Coada { Celula prim, ultim;} C;
Aadar n cazul cozii, avem nevoie de doi pointeri, unul ctre primul
element al cozii (capul cozii), iar altul ctre ultimul su element (coada cozii),
deoarece introducerea n list se face prin spate, iar eliminarea prin fa.
n
coa
ca
Coada
va
fi
i
7
1 o structur
2
9
5
Coada
da
pul
0afiat
dinamic
de astfel
date de tip l
cozii
coz
FIFO
ii
7,10,2,9,5

Eficiena utilizrii cozilor:

Ca i n cazul stivelor, elementele pot fi inserate i terse dintr-o coad ntrun timp constant.

13

De Retinut!

Un pointer este o variabila care retine adresa de memorie a unei alte

variabile.
In alocarea statica, fiecare variabila are alocata o zona de memorie de
la inceputul programului pana la sfarsit , chiar daca variabila este sau
nu folosita in interiorul programului.
Structurile dinamice de date sunt structuri de date ale caror
dimensiuni se schimba pe parcursul executiei programului. Ele sunt
mai flexibile decat cele statice si din aceasta cauza sunt mai
avantajoase.
Elementele structurii dinamice trebuie sa fie inlantuite.
Fiecare mod/element cuprinde pe langa informatia propriu-zisa si una
de legatura prin care se realizeaza inlantuirea.
structura dinamica poate avea toate elementele structurate:
-pe un singur nivel=>lista liniara;
-pe mai multe nivele=> arbore;
-poate cuprinde elemente ce nu pot fi structurate pe nivel
existand legaturi intre oricare 2 moduri=> retea.

Structura a fost introdusa ca fiind o colectie ordonata de date ce pot fi

de tipuri diferite si care au anumite legaturi logice intre ele.
Structura formeaza un tip nou de data diferit de toate tipurile de data
predefinite.

14

Un alt mod de a organiza o multime de structuri cu acelasi tip este

structura recursiva, introducand in tipul structurat unul sau mai multi
pointeri spre tipul respectiv.
Se poate stabili o relatie de ordine( mai multe) intre elementele
multimii de structuri. Multimea se poate organiza in mod dinamic
adaugand elemente noi sau suprimandu-le pe cele care nu sunt
necesare.
Operatorii folositi pentru aceste procedee sunt:
-new=alocarea zonei de memorie
-delete=eliminarea zonei de memorie

Sintaxa sub care se folosesc: new p,delete p.

O multime dinamica de structuri recursive de acelasi tip care satisfac
una sau mai multe relatii de ordine introduse prin p(pointer) se
numeste LISTA INLANTUITA.

Lista liniara simplu inlantuita

(L.S.I)

Este o structura dinamica de date in care intre elementele sale exista o

singura legatura( relatie de ordine).
Intr-o lista liniara simplu inlantuita exista doua noduri semnificative:
primul si ultimul nod din lista.
Primul pentru ca adresa sa va fi memorata intr-un pointer a carui
adresa o retine programul principal si ultimul mod care nu retine
adresa niciunui alt mod si pointeaza catre un NULL sau VID.
Fiecare va avea 2 compartimente:
-Primul compartiment retine informatia modului( poate fi
de orice legatura de date predefinit in C++ dau definit de
utilizator).
-Al doilea compartiment :retine adresa nodului urmator si
identificatorul poate fi urm, adr, next.

15

Structura unui nod din L.S.I este:

typedef struct nod
{tip_de_data_inf;
struct nod*urm;
};

Nod=element al listei liniare simple inlantuite.

Informatia din structura poate fi din orice tip de data definit sau
predefinit in C++ iar pointerul urm este declarat catre structura
nodului listei noastre.
Observatie!!

Pentru a parcurge o lista liniara simpla inlantuita ne vom folosi de un

nod(pointer) care este nodul current din lista si va avea ca identificator unul
din urmatoarele caractere: p,q,p1,q1,g.

Lista liniara dublu inlantuita

( L.D.I)

Este o lista in care elementele au legaturi atat catre elemental anterior

cat si catre cel urmator( cu dubla legatura). Astfel, primul nod va avea
legatura catre anterior nula si ultimul nod al listei va avea legatura
catre urmatorul tot de tipul nul.
Structura unui nod intr-o L.D.I:
struct nod
{int inf;
nod*ant, *urm;
};
Listele circulare sunt de 2 tipuri:
-liste circulare simplu inlantuite care reprezinta liste liniare
simplu inlantuite in care ultimul nod este legat de primul nod al
16

listei noastre prin legatura( ! Nu se poate preciza cu exactitate

care este primul nod si care este ultimul nod).
-liste circulare dublu inlantuite care reprezinta liste liniare dublu
inlantuite in care primul si ultimul element sunt legate prin
legaturi duble.
Stiva este o lista simplu inlantuita care functioneaza dupa principiul
LIFO( last in, first out).
Coada este o lista simplu inlantuita care funcdtioneaza dupa principiul
FIFO( first in, first out).

Functii de inserare(adaugare)
1. Inserare inaintea primului nod din lista
p=new nod;
citeste inf din p;
P=>urm=prim;
prim=p;
2. Inserare dupa primul nod
P=>urm=prim=>urm;
prim=>urm=p;
leg dintre prim si p
3. Inserare inaintea unui nod cheie(informatie)
p1=>urm=p;
P=>urm=p1;
4. Inserare dupa un nod dat prin cheie
q=>urm=p=>urm;
17

P=>urm=q;
5. Inserarea inaintea ultimului nod
q=>urm=ultim;
P=>urm=q;
6. Inserare dupa ultimul nod
ultim=>urm=q;
q=>urm=NULL;
ultim=q;

Aplicatii
18

1. URMATORUL

PROGRAM OFERA O MODALITATE DE CREARE, ADAUGARE SI AFISARE

A UNEI LISTE LINIARE SIMPLU INLANTUITE CARE PRELUCREAZA NUMERE INTREGI :

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod *next;};
nod *p,*u ;
// acceseaza primul respective ultimul nod
int n;
//numarul de noduri
void cre_ad()
//functia de creare si adaugare a unui nou element
{nod *c;
if(!p)
//daca lista este vida (p==0) se aloca primul nod
{p=new nod;
cout<<"valoare primului nod ";
cin>>p->info;
u=p;
//la creare primul si ultimul nod vor fi identici
}
else
//altfel se adauga un nou element la sfarsit
{ c=new nod; //se aloca un nou nod
cout<<"informatia utila :";
cin>>c->info; //se completeaza campul informatie utila
u->next=c;
//se adauga dupa ultimul nod
u=c;
//se stabileste noul nod c ca fiind ultimul
}
19

u->next=0;
}

//campul adresa urmatoare a ultimului nod este 0

void afis() //functia de afisare parcurge elementele cu afisare

{nod *c;
c=p;
//se porneste de la primul nod din lista
while(c)
//cat timp c retine o adresa nenula
{cout<<c->info<<" ";//se afiseza campul informatie utila
c=c->next;}
//se avanseaza la urmatoarea adresa, la urmatorul
nod
cout<<endl;
}
void main()
{clrscr();
int b;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
cre_ad( );
cout<<endl;
afis();
getch();
}

20

2. INSERAREA SI STERGEREA UNUI ELEMENT DIN LISTA.

#include<conio.h>
#include<fstream.h>
struct Nod
{int info;
Nod *adr_urm;
};
Nod *prim, *ultim;
/*************************************************************************
functiile de creare si adaugare se pot comprima intr-o singura functie
care poate testa daca exista un prim nod si in functie de rezultatul testului
va realiza alocarea primului nod sau se va adauga un nou nod la sfarsit
*************************************************************************/
void creare_adaugare()
{if(prim==NULL)
{prim=new Nod;
cout<<"introduceti valoarea retinuta in primul nod:";
cin>>prim->info;
prim->adr_urm=0; //la crearea listei va exista un singur nod, primul si
prin urmare adresa urmatoare lui este 0
ultim=prim; //evident, avand un singur element acesta va fi si primul si
ultimul
}
else
{Nod *c;
c=new Nod;
cout<<"valoarea de adaugat in lista ";
cin>>c->info;
ultim->adr_urm=c; //se "agata" noul nod c, dupa ultimul din lista
ultim=c; //evident noul nod e ultimul...
ultim->adr_urm=0;//...si dupa ultimul nu e nimic, deci nici o adresa
}
}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->adr_urm;//avansez in lista trecand la urmatoarea adresa
21

}
cout<<endl;
}
/**************************************************************************
functia inserare_dupa() va insera dupa o valoare val transmisa din main()
***************************************************************************/
void inserare_dupa(int val)
{Nod *c,*a;
//Nod *a retine adresa nodului ce se va insera in lista
//cu *c se face avansarea in lista pana la nodul ce contine valoarea dupa
//care se face inserarea; evident se porneste de la primul;
c=prim;
while(c->info!=val &&c)
c=c->adr_urm;
a=new Nod;
cout<<"valoarea de inserat ";
cin>>a->info;
a->adr_urm=c->adr_urm;
c->adr_urm=a;
if(c==ultim) ultim=a;//pentru ca exista si posibilitatea ca valoarea
//dupa care se face inserarea sa fie retinuta de ultimul element
}
/**************************************************************************
functia inserare_inainte() va insera inainte de o valoare val transmisa din
main()
***************************************************************************/
void inserare_inainte(int val)
{Nod *c,*a;
//Nod *a retine adresa nodului ce se va insera in lista
//cu *c se face avansarea in lista pana la nodul ce contine valoarea inainte
//care se face inserarea; evident se porneste de la primul;
c=prim;
//pentru ca exista si posibilitatea ca valoarea inainte de care se face inserarea
// sa fie retinuta de primul nod se va face un test si in caz afirmativ se va
//stabili un nou prim element
if(prim->info==val)
{c=new Nod;
cout<<"valoare de inserat ";
cin>>c->info;
c->adr_urm=prim;
prim=c;}
else
{while(c->adr_urm->info!=val &&c) //c se pozitioneaza inainte de elementul
cautat
c=c->adr_urm;
a=new Nod;
cout<<"valoarea de inserat ";
cin>>a->info;
22

a->adr_urm=c->adr_urm;
c->adr_urm=a;}
}
/
******************************************************************************
functia realizeaza stergerea unui element dupa continutul transmis ca
parametru
******************************************************************************
/
void stergere(int val)
{Nod *c,*a; //a se sterge, c este precedentul sau.Se va genera o noua
legatura intre c si a->next
c=prim;
if(prim->info==val) //daca primul nod retine val se sterge primul
{a=prim;
//se retine in a
prim=prim->adr_urm; //primul va deveni urmatorul element
delete a;}
//se elibereaza memoria
else
{while(c->adr_urm->info!=val &&c)//se pozitioneaza pe urmatorul
elementului ce urmeaza a fi sters
c=c->adr_urm;
a=c->adr_urm;
c->adr_urm=a->adr_urm;
if(a==ultim) ultim=c;
delete a;}
}
void main()
{int i,n,val_info;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
creare_adaugare();
listare();
cout<<"dupa ce valoare din lista se realizeaza inserarea ";
cin>>val_info;
inserare_dupa(val_info);
listare();
creare_adaugare();
listare();
cout<<"valoarea inainte de care se face inserarea ";
cin>>val_info;
inserare_inainte(val_info);
listare();
cout<<endl<<"valoarea ce urmeaza a fi stearsa: ";
cin>>val_info;
stergere(val_info);
listare();
}
23

3. ORDONAREA

UNEI LISTE

Principiul acestei operatii este acelasi ca si la vectori. Ordonarea se poate face prin
aceleasi metode. In exemplul urmator este prezentata ordonarea prin metoda
Bubble Sort:
#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *next;
};
Nod *prim, *ultim;
void creare()
24

{prim=new Nod;
cout<<"introduceti valoarea retinuta in primul nod:";
cin>>prim->info;
prim->next=0; //la crearea listei va exista un singur nod, primul si prin
urmare adresa urmatoare lui este 0
ultim=prim; //evident, avand un singur element acesta va fi si primul si
ultimul
}
void adaugare()
{Nod *c;
c=new Nod;
cout<<"valoarea de adaugat in lista ";
cin>>c->info;
ultim->next=c; //se "agata" noul nod c, dupa ultimul din lista
ultim=c; //evident noul nod e ultimul...
ultim->next=0;//...si dupa ultimul nu e nimic, deci nici o adresa
}
void ordonare()
{Nod *c;int ord,aux;
do
{c=prim;
ord=0;
while(c->next)
{if(c->info>c->next->info)
{aux=c->info;
c->info=c->next->info;
c->next->info=aux;
ord=1;
}
c=c->next;}
}
while(ord);}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->next;//avansez in lista trecand la urmatoarea adresa
}
cout<<endl;
}
void main()
{int n,i;int val,nr;
clrscr();
cout<<"cate elemente va avea lista?";
cin>>n;
creare();
for(i=2;i<=n;i++)
adaugare();
cout<<"Elementele listei sunt:";
25

listare();
ordonare();
cout<<endl<<"elementele listei dupa ordonare;"<<endl;
listare();
getch();
}

4. ESTE

PREFERABIL IN UNELE SITUATII SA SE GENEREZE O LISTA ORDONATA

(CRESCATOR DE EXEMPLU), IN FUNCTIA DE CREARE A LISTEI AVAND

URMATOARELE SITUATII :
-INSERAREA SE FACE INAINTE DE PRIMUL NOD (INFORMATIA MAI MICA DECAT P>INFO )
-INSERAREA SE FACE DUPA ULTIMUL NOD (INFORMATIA MAI MARE DECAT U>INFO )
-INSERAREA SE FACE IN INTERIOR
#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *adr_urm;
};
Nod *prim, *ultim;
void creare_lista_ordonata(int val)
{Nod *c,*a;
if(!prim)
{prim=new Nod;
prim->info=val;
ultim=prim;
ultim->adr_urm=0;}
else
{c=prim;
if(val<prim->info)
{a=new Nod;
26

a->info=val;
a->adr_urm=prim;
prim=a;}
else
{if(val>ultim->info)
{a=new Nod;
a->info=val;
ultim->adr_urm=a;
ultim=a;
ultim->adr_urm=0;}
else
{ while(c->adr_urm->info<=val)
c=c->adr_urm;
a=new Nod;
a->info=val;
a->adr_urm=c->adr_urm;
c->adr_urm=a;
}
}
}
}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->adr_urm;//avansez in lista trecand la urmatoarea adresa
}
cout<<endl;
}
void main()
{int n,i;int val,nr;
cout<<"cate elemente va avea lista?";
cin>>n;
for(i=1;i<=n;i++)
{cout<<"elementul de adaugat in lista ";
cin>>val;
creare_lista_ordonata(val);
}
cout<<"Elementele listei sunt:";
listare();
getch();
}

27

5. ALGORITMUL DE STERGERE AL UNUI ELEMENT.

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod* next;
};
nod *p,*u;
void cre_ord(int x) //creare lista ordonata
{nod *c,*a;
c=new nod;
c->info=x;
if(!p)//test lista vida
{p=new nod;
p->info=x;
u=p;
u->next=0;
}
else
if(x<=p->info)//inserare inainte de primul
{c->next=p;
p=c;}
else
if(x>u->info)//dupa ultimul
{u->next=c;
u=c;
u->next=0;}
else //in interior
{
a=p;
while(x>a->next->info)
a=a->next;
c->next=a->next;
a->next=c;
}
}
void afisare()
28

{nod *c;
c=p;
cout<<endl<<"continutul listei "<<endl;
while(c)
{cout<<c->info<<" ";
c=c->next;}
}
void sterge(nod *a)
{nod *c,*x;
if(p==a)
{x=p;
p=p->next;
delete x;
}
else
{c=p;
while(c->next!=a)
c=c->next;
x=c->next;
c->next=x->next;
if(x==u)
{u=c;
u->next=0;}
delete x;}
}
void main()
{int n,y;
clrscr();
cout<<"nr de noduri ";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"informatia ";
cin>>y;
cre_ord(y);
}
afisare();
cout<<"ce valoare se sterge ?";
int k;
cin>>k;
nod *c,*a;
c=p;
while(c)
{if(c->info==k)
{a=c;
c=c->next;
sterge(a);}
else
c=c->next;}
afisare();
getch();
29

Structura de date de tip coada

Aceasta structura de date este un caz particular de lista care functioneaza pe
principiul FIFO (first in first out, primul intrat este primul servit). Prin urmare
principalele prelucrari care se refera la aceasta structura de date vor fi:
30

creare coada

listare coada (parcurgere)

adaugare la sfarsit

stergere prim element

prelucrare prim element

Specific acestei structuri de date este faptul ca adaugarea se va face intotdeauna la

ultim in timp ce prelucrarea (stergerea) se va face la celalat capat. Pentru a
prelucra o coada vor fi necesari doi pointeri: unul il vom numi varful cozii (primul
nod creat) in timp ce la capatul opus ne vom referi la ultimul element.

Functia pune( ) , creaza coada cand aceasta este vida sau adauga un nou element
la sfarsit in caz contrar.
Functia scoate( ), elimina elementul din varful cozii.

6. PRELUCRARI - COADA
#include<iostream.h>
#include<conio.h>
struct nod{int info;
nod *next;};
nod *varf,*sfarsit;//varful si sfarsitul cozii
void pune(nod* &v,nod* &sf,int x)
{nod *c;
31

if(!v)
{v=new nod;
v->info=x;
v->next=0;
sf=v;}
else
{c=new nod;
sf->next=c;
c->info=x;
sf=c;
sf->next=0;}
}
void afisare(nod *v)
{nod *c;
c=v;
while(c)
{cout<<c->info<<" ";
c=c->next;}
}
void scoate(nod* &v)
{nod* c;
if(!v)
cout<<"coada este vida si nu mai ai ce elimina!!!";
else
{c=v;
v=v->next;
delete c;}
}
void main()
{int n,a;
cout<<"numarul initial de noduri ";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"valoarea de adaugat in coada ";
cin>>a;
pune(varf,sfarsit,a);
}
cout<<endl;
afisare(varf);
int nre,nra;
cout<<endl<<"cate adaugari ?";
cin>>nra;
for(i=1;i<=nra;i++)
{cout<<"valoarea de adaugat ";
cin>>a;
pune(varf,sfarsit,a);}
cout<<endl<<"dupa adaugare"<<endl;
n=n+nra;
cout<<"coada are "<<n<<" elemente"<<endl;
afisare(varf);
32

cout<<endl<<"cate eliminari ?";

cin>>nre;
for(i=1;i<=nre;i++)
scoate(varf);
cout<<endl<<"dupa eliminare"<<endl;
n=n-nre;
cout<<"coada are "<<n<<" elemente"<<endl;
afisare(varf);
//prelucrez varful cozii: de exemplu se poate dubla continutul:
varf->info=2*varf->info;
cout<<endl<<"dupa dublarea valorii varfului "<<endl;
afisare(varf);
getch();
}

Structura de tip Stiva

Aceasta structura de date este un caz particular de lista care functioneaza pe
principiul LIFO (last in first out, ultimul intrat este primul servit, puteti sa va ganditi
la o stiva de materiale pentru care un nou material se va adauga intotdeauna
deasupra si se va extrage tot de deasupra). Prin urmare principalele prelucrari care
se refera la aceasta structura de date vor fi:
-

creare stiva

listare stiva (parcurgere in ordine inversa creerii)

adaugare la sfarsit ( peste varful stivei, operatie numita push ( ) )

stergere element din varful stivei (operatie numita pop( ) )

prelucrarea varfului stivei

Specific acestei structuri de date este faptul ca prelucrarile se fac intotdeauna la

elementul de la acelasi capat, element pe care il vom numi varf.
33

Functia push( ) , creaza stiva cand aceasta este vida sau adauga un nou element in
caz contrar.
Functia pop( ), elimina elementul din varful stivei.

7. *CREAREA

UNEI STIVE

* STERGERTEA VARFULUI
#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod* back;
};
nod *varf,*c;
int nr_elem;
void creare(nod *&c)
{int val;
c=new nod;
cout<<endl<<"prima valoare din stiva:";
cin>>val;
c->info=val;
c->back=NULL;
varf=c;
34

nr_elem=1;
}
void Push(int val) //adauga un nou nod in varful stivei
{nod *c;
c=new nod;
c->info=val;
c->back=varf;
varf=c;
nr_elem++;
}
void Pop()
{nod *c;
if(!varf)
cout<<endl<<"Stiva este vida!";
else
{c=varf;
varf=varf->back;
delete c;
}
nr_elem--;
}
void afisare(nod *c)
{c=varf;
while(c!=NULL)
{cout<<c->info<<" ";
c=c->back;
}
}
Void main()
{int val,i,nr,val_l;
Pop();
cout<<endl<<"Se va crea o structura de date de tip stiva";
creare(varf);
cout<<endl<<"elementele stivei sunt:"<<endl;
afisare(varf);
cout<<endl<<"Cate valori mai adaugi in stiva? ";
cin>>nr;
for(i=1;i<=nr;i++)
{cout<<"valoarea de adaugat:";
cin>>val;
Push(val);
}
cout<<endl<<"in stiva sunt "<<nr_elem<<" elemente:"<<endl;
afisare(varf);
cout<<"varf="<<varf->info<<" nr_elem="<<nr_elem;
cout<<endl<<"se va sterge varful din stiva, caz in care stiva
devine:"<<endl;
Pop();
afisare(varf);
cout<<"varf="<<varf->info<<" nr_elem="<<nr_elem;
35

getch();
}

8. PRELUCRARI

STIVA

: (LIFO)

-ADAUGAREA DE ELEM IN STIVA;

-ELIMINAREA UNOR ELEM
-DUBLAREA VALORII VARFULUI
#include<iostream.h>
#include<conio.h>
struct nod{int info;
nod *back;};
nod *varf;//intereseaza doar varful stivei: ultimul nod din stiva
void push(nod* &v,int x)
{nod *c;
if(!v)
{v=new nod;
v->info=x;
v->back=0;}
else
{c=new nod;
c->back=v;
c->info=x;
v=c;}}
void afisare(nod *v)
{nod *c;
c=v;
while(c)
{cout<<c->info<<" ";
c=c->back;}
}
void pop(nod* &v)
{nod* c;
36

if(!v)
cout<<"stiva este vida si nu mai ai ce elimina!!!";
else
{c=v;
v=v->back;
delete c;}
}
void main()
{int n,a;
cout<<"numarul initial de noduri ";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"valoarea de adaugat in stiva ";
cin>>a;
push(varf,a);
}
cout<<endl;
afisare(varf);
int nre,nra;
cout<<endl<<"cate adaugari ?";
cin>>nra;
for(i=1;i<=nra;i++)
{cout<<"valoarea de adaugat ";
cin>>a;
push(varf,a);}
cout<<endl<<"dupa adaugare"<<endl;
n=n+nra;
cout<<"stiva are "<<n<<" elemente"<<endl;
afisare(varf);
cout<<endl<<"cate eliminari ?";
cin>>nre;
for(i=1;i<=nre;i++)
pop(varf);
cout<<endl<<"dupa eliminare"<<endl;
n=n-nre;
cout<<"stiva are "<<n<<" elemente"<<endl;
afisare(varf);
//prelucrez varful stivei: de exemplu se poate dubla continutul:
varf->info=2*varf->info;
cout<<endl<<"dupa dublarea valorii varfului "<<endl;
afisare(varf);
getch();
}

37

Liste circulare
In unele aplicatii este necesar sa se prelucreze structuri de date inlantuite simple
sau duble circulare. Acestea se obtin din liste liniare printr-o singura operatie daca
lista este simpla sau prin doua operatii daca lista este dubla.
Lista devine circulara prin operatiile:

ultim->next=prim; //urmatorul ultimului devine primul

prim->back=ultim; //precedentul primului devine ultimul

Prin urmare nici un nod nu va mai contine pentru campurile *next sau *back
valoarea 0 (ultimul si primul in cazul listelor liniare) ceea ce va determina
modificarea functiei de parcurgere in scopul prelucrarilor .

38

9. SA

SE VERIFICE DACA O LISTA ESTE SAU NU CIRCULARA .

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod *next;};
nod *p,*u,*p1,*p2;
int n;
void cre_ad()
{nod *c;
if(!p)
{p=new nod;
cout<<"valoare primului nod ";
cin>>p->info;
u=p;
u->next=0;}
else
{ c=new nod;
cout<<"informatia utila :";
cin>>c->info;
u->next=c;
u=c;
u->next=0;
}
}
void afis(nod *p)
{nod *c;
c=p;
while(c)
{cout<<c->info<<" ";
c=c->next;}
cout<<endl;
}
int e_circulara(nod *x)
{nod *c=x;
c=c->next;
while(c&&c!=x)
c=c->next;
if(c==x)
return 1;
else
return 0;
}
void main()
{int b;
clrscr();
cout<<"n=";
cin>>n;
39

for(int i=1;i<=n;i++)
{ cre_ad();}
cout<<endl;
afis(p);
if(e_circulara(p))
cout<<"e circulara ";
else
cout<<"nu este circulara";
u->next=p;
cout<<endl;
if(e_circulara(p))
cout<<"acum e circulara ";
else
cout<<"nu este circulara";
getch();
}

10.

IATA O SOLUTIE DE GENERARE A UNEI LISTE DUBLE CIRCULARE DE INTREGI

PORNIND DE LA O LISTA LINIARA DUBLA SI O MODALITATE DE PARCURGERE A
LISTEI CIRCULARE ASTFEL OBTINUTE :

#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *next,*back;};
Nod *prim, *ultim;
int n;

40

void creare_lista()
{Nod *c;
c=new Nod;
cout<<"info ";
cin>>c->info;
if(!prim)
{prim=c;
prim->next=0;
prim->back=0;
ultim=prim;
}
else
{ultim->next=c;
c->back=ultim;
ultim=c;
ultim->next=0;
}
}
void listare_stanga_dreapta()
{Nod *c;
c=prim;
while(c)
{cout<<c->info<<" ";
c=c->next;}
}
void creaza_lista_circulara()
{ultim->next=prim;
prim->back=ultim;
}
void afiseaza_lista_circulara(Nod *c) //se parcurge lista pornind de la o adresa
transmisa
{for(int i=1;i<=n;i++)
{cout<<c->info<<" ";
c=c->next;}
}
void main()
{int i;
clrscr();
cout<<"cate elemente va avea lista?";
cin>>n;
for(i=1;i<=n;i++)
creare_lista();
cout<<endl<<"Elementele listei de la stanga la dreapta sunt:"<<endl;
listare_stanga_dreapta();
creaza_lista_circulara();
cout<<endl<<"afiseaza lista circulara incepand de la primul :"<<endl;
afiseaza_lista_circulara(prim);
41

cout<<endl<<"afiseaza lista circulara incepand de la al doilea :"<<endl;

afiseaza_lista_circulara(prim->next);
cout<<endl<<"afiseaza lista circulara incepand de la ultimul :"<<endl;
afiseaza_lista_circulara(ultim);
getch();
}

11.

SA SE DESCOMPUNA O LISTA CIRCULARA IN DOUA LISTE CIRCULARE.

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod *next;};
nod *p,*u;
void creare(int x)
{nod *q;
if(!p)
{p=new nod;
p->info=x;
u=p;}
else
{q=new nod;
q->info=x;
u->next=q;
u=q;}
u->next=0;
}
void afisare()
{nod *q;
q=p;
while(q)
42

{cout<<q->info<<" ";
q=q->next;}
}
void afisare_circ(nod *p)
{nod *q;
q=p;
cout<<q->info<<" ";
q=q->next;
while(q!=p)
{cout<<q->info<<" ";
q=q->next;}
}
int e_circ(nod *a)
{nod *q=a->next;
while(q&&q!=a)
q=q->next;
if(q==0)
return 1;
else
return 2;
}
void desc(nod *a, nod *&p1,nod *&p2,int n)
{p1=a;
nod *q=a;
for(int i=1;i<=n/2-1;i++)
q=q->next;
p2=q->next;
q->next=p1;
q=p2;
while(q->next!=p1)
q=q->next;
q->next=p2;
}
void main()
{clrscr();
int n,x;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"x=";
cin>>x;
creare(x);
}
afisare();
u->next=p;
nod *p1,*p2;
desc(p,p1,p2,n);
cout<<endl;
cout<<endl<<"prima lista circulara"<<endl;
afisare_circ(p1);
43

cout<<endl<<"a doua lista circulara"<<endl;

afisare_circ(p2);
getch();
}

12.

SA SE AFISEZE ELEMENTELE UNEI LISTE PARCURSE ATAT DE LA STANGA LA

DREAPTA , CAT SI DE LA DREAPTA LA STANGA . A POI, DUPA CE LISTA A DEVENIT
CIRCULARA SA SE AFISEZE NUMARUL DE NUMERE EGALE ALATURATE .
#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *adr_urm,*adr_prec;
};
Nod *prim, *ultim;
void creare_lista()
{Nod *c;
c=new Nod;
cout<<"info ";
cin>>c->info;
if(!prim)
{prim=c;
prim->adr_urm=0;
prim->adr_prec=0;
ultim=prim;
}
else
{ultim->adr_urm=c;
c->adr_prec=ultim;
ultim=c;
ultim->adr_urm=0;
}
}
int calcul(Nod *a)
{int x=0;
Nod *c=a,*aux=a;
while(c!=a->adr_prec)
{if(c->info==c->adr_urm->info)
x++;
c=c->adr_urm;}
if(a->info==a->adr_prec->info)
x++;
return x;
}
void listare_stanga_dreapta()
44

{Nod *c;
c=prim;
while(c)
{cout<<c->info<<" ";
c=c->adr_urm;}
}
void listare_dreapta_stanga()
{Nod *c;
c=ultim;
while(c)
{cout<<c->info<<" ";
c=c->adr_prec;}
}
void main()
{int n,i;int val,nr;
cout<<"cate elemente va avea lista?";
cin>>n;
for(i=1;i<=n;i++)
creare_lista();
cout<<"Elementele listei de la stanga la dreapta sunt:";
listare_stanga_dreapta();
cout<<"Elementele listei de la dreapta la stanga sunt:";
cout<<endl;
listare_dreapta_stanga();
ultim->adr_urm=prim;
prim->adr_prec=ultim;
cout<<endl<<"lista devine circulara"<<endl;
cout<<endl<<"Numarul de numere egale alaturate ";
cout<<calcul(prim);
getch();
}

13.

SA SE RETURNEZE ADRESA DIN MEMORIE DE LA FIECARE VALOARE DATA

DE LA TASTATURA .
#include<iostream.h>
#include<conio.h>
45

struct nod
{int info;
nod *next;};
nod *p,*u;
void creare(int x)
{nod *q;
if(!p)
{p=new nod;
p->info=x;
u=p;}
else
{q=new nod;
q->info=x;
u->next=q;
u=q;}
u->next=0;
}
void afisare()
{nod *q;
q=p;
while(q)
{cout<<q->info<<" la adresa "<<q<<endl;
q=q->next;}
}
void cauta_adresa(nod *p,int n,nod*&b)
{nod *q;
q=p;
int i=1;
while(q&&i<n)
{
q=q->next;
i++;
}
if(q)
b=q;
else
b=0;
}
void main()
{clrscr();
int n,x;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"x=";
cin>>x;
creare(x);
}
afisare();
nod *b;
46

cauta_adresa(p,7,b);
cout<<endl<<b;
getch();
}

14.

SA SE AFISEZE NUMERELE COMPLEXE DUPA CE SE INTRODUC DE LA

TASTATURA PARTEA REALA SI CEA IMAGINARA SI APOI SA SE CALCULEZE
MODULUI FIECARUIA .

#include<iostream.h>
#include<conio.h>
#include<math.h>
struct complex
{float re,im,m;};
struct nod
{complex info;
nod *next;};
nod *p,*u;
void cre_ad()
{nod *c;
if(!p)
{p=new nod;
cout<<"valoare primului nod ";
47

cout<<"partea reala ";

cin>>p->info.re;
cout<<"partea imaginara ";
cin>>p->info.im;
p->info.m=sqrt(pow(p->info.re,2)+ pow(p->info.im,2));
u=p;
u->next=0;}
else
{ c=new nod;
cout<<"informatia utila :";
cout<<"partea reala ";
cin>>c->info.re;
cout<<"partea imaginara ";
cin>>c->info.im;
c->info.m=sqrt(pow(c->info.re,2)+ pow(c->info.im,2));
u->next=c;
u=c;
u->next=0;
}
}
void afisare()
{nod *c;
c=p;
while(c)
{cout<<c->info.re<<"+"<<c->info.im<<"i modulul: "<<c>info.m<<endl;
c=c->next;}
}
void main()
{int n;
clrscr();
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
cre_ad();
afisare();
getch();
}

48

15.

SE DA O LISTA CU N ELEMENTE INTRODUSE DE LA TASTATURA .

-SA SE AFISEZE ELEMENTELE LISTEI;
-SA SE AFISEZE VALOAREA MINIMA DIN LISTA;
-SA SE ORDONEZE LISTA;
-SA SE CAUTE UN ELEMENT IN LISTA SI SA SE INLOCUIASCA CU UN ALTUL. DUPA,
SE VA AFISA FORMA FINALA A LISTEI .
#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *adr_urm;
};
Nod *prim, *ultim;
void creare()
{prim=new Nod;
cout<<"introduceti valoarea retinuta in primul nod:";
cin>>prim->info;
prim->adr_urm=0; //la crearea listei va exista un singur nod, primul si
prin urmare adresa urmatoare lui este 0
ultim=prim; //evident, avand un singur element acesta va fi si primul si
ultimul
}
void adaugare()
{Nod *c;
c=new Nod;
cout<<"valoarea de adaugat in lista ";
49

cin>>c->info;
ultim->adr_urm=c; //se "agata" noul nod c, dupa ultimul din lista
ultim=c; //evident noul nod e ultimul...
ultim->adr_urm=0;//...si dupa ultimul nu e nimic, deci nici o adresa
}
void ordonare()
{Nod *c;int ord,aux;
do
{c=prim;
ord=0;
while(c->adr_urm)
{if(c->info>c->adr_urm->info)
{aux=c->info;
c->info=c->adr_urm->info;
c->adr_urm->info=aux;
ord=1;
}
c=c->adr_urm;}
}
while(ord);
}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->adr_urm;//avansez in lista trecand la urmatoarea adresa
}
cout<<endl;
}
void minim()
{int min;
Nod *c;
c=prim;
min=c->info;
c=c->adr_urm;
while(c!=0)
{if(min>c->info)
min=c->info;
c=c->adr_urm;
};
cout<<endl<<"valoarea minima din lista este "<<min;
};
int cautare(int val,int nr)
{Nod *c; int gasit;
50

c=prim; gasit=0;
while(c)
{if(c->info==val)
{gasit=1;
c->info=nr;
}
c=c->adr_urm;
};
return gasit;
}
void main()
{int n,i;int val,nr;
cout<<"cate elemente va avea lista?";
cin>>n;
creare();
for(i=2;i<=n;i++)
adaugare();
cout<<"Elementele listei sunt:";
listare();
minim();
ordonare();
cout<<endl<<"elementele listei dupa ordonare;"<<endl;
listare();
cout<<endl<<"valoarea de cautat in lista...";
cin>>val;
cout<<endl<<"valoarea de schimb in lista...";
cin>>nr;
if(cautare(val,nr)==1)
{cout<<endl<<"s-a gasit "<<val<<" in lista si s-a schimbat cu "<<nr;
cout<<endl;
listare();}
else cout<<endl<<"nu s-a gasit "<<val<<" in lista";
getch();
}

51

16.

O DACTILOGRAFA A TASTAT GRESIT UN TEXT PT CA O TASTA ERA GRESITA :

SE VA AFISA
PRIMUL CUVANT CU 3 VOCALE ALATURATE ATFEL INCAT SA SE DEPISTEZE L
SE STIE CA IN LOC DE O CONSOANA S-A TASTAT O VOCALA .

ITERA GRESITA URMAND SA SE INLOCUIASCA IN TEXT TOATE

CUVINTELE GRESITE .

#include<iostream.h>
#include<fstream.h>
#include<string.h>
#include<conio.h>
typedef char sir[30];
struct nod
{char info[20];
nod *adr_urm,*adr_prec;
};
nod *prim,*ultim,*c,*d;
void creare()
{fstream f;
char copil[20];
f.open("textg.txt",ios::in);
while(f>>copil)
{if(!prim)
{prim=new nod;
strcpy(prim->info,copil);
prim->adr_urm=0;
prim->adr_prec=0;
ultim=prim;
}
else
{c=new nod;
strcpy(c->info,copil);
ultim->adr_urm=c;
c->adr_urm=0;
c->adr_prec=ultim;
ultim->adr_urm=c;
ultim=c;}
f.clear();
}
}
void listare()
{c=prim;
while(c)
{cout<<c->info<<endl;
52

c=c->adr_urm;
}
}
int cauta_voc(char ch)
{char voc[30]="aeiouAEIOU";
for(int i=0;i<=9;i++)
if(ch==voc[i])
return 1;
return 0;
}
void caut_cuv(sir cv)
{sir s;
int n,k,g=0;
nod *c=prim;
while(c&&!g)
{strcpy(s,c->info);
n=strlen(s);
k=0;
for(int i=0;i<=n-1;i++)
if(cauta_voc(s[i]))
k++;
cout<<endl<<"nr de voc "<<k;
if(k>=3)
{g=1;
strcpy(cv,s);
}
c=c->adr_urm;
}
}
void main()
{int n,nr,i,j;
clrscr();
creare();
cout<<"Textul "<<endl<<endl;
listare();
sir cv;
caut_cuv(cv);
cout<<"cuvantul "<<cv;
getch();
}

53

17.

SA SE AFISEZE FRECVENTA DE APARITIE A FIECARUI NOD INTRODUS DE LA

TASTATURA .
#include<iostream.h>
#include<conio.h>
struct nod
{int info,fr;
nod *next;};
nod *p,*u,*p1,*u1 ;
// acceseaza primul respective ultimul nod
int n;
//numarul de noduri
void cre_ad()
//functia de creare si adaugare a unui nou element
{nod *c;
if(!p)
//daca lista este vida (p==0) se aloca primul nod
{p=new nod;
cout<<"valoare primului nod ";
cin>>p->info;
u=p;
//la creare primul si ultimul nod vor fi identici
}
else
//altfel se adauga un nou element la sfarsit
{ c=new nod; //se aloca un nou nod
cout<<"informatia utila :";
54

cin>>c->info; //se completeaza campul informatie utila

u->next=c;
//se adauga dupa ultimul nod
u=c;
//se stabileste noul nod c ca fiind ultimul
}
u->next=0;
//campul adresa urmatoare a ultimului nod este 0
}
void afis() //functia de afisare parcurge elementele cu afisare
{nod *c;
c=p;
//se porneste de la primul nod din lista
while(c)
//cat timp c retine o adresa nenula
{cout<<c->info<<" ";//se afiseza campul informatie utila
c=c->next;}
//se avanseaza la urmatoarea adresa, la urmatorul
nod
cout<<endl;
}
int cauta(int x)
{nod *q;
q=p1;
while(q)
{if(q->info==x)
{q->fr=q->fr+1;
return 1;}
q=q->next;}
return 0;}
void adauga(int x)
{if(!p1)
{p1=new nod;
p1->info=x;
p1->fr=1;
u1=p1;
u1->next=0;
}
else
{nod *c;
c=new nod;
c->info=x;
c->fr=1;
u1->next=c;
u1=c;
u1->next=0;}
}
void modific_frecventa(int x)
{nod *q=p1;
while(q)
{if(q->info==x)
q->fr=1+q->fr;
q=q->next;}
}
void main()
55

{clrscr();
int b;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
cre_ad( );
cout<<endl;
afis();
nod *q;
q=p;
while(q)
{if(cauta(q->info)==0)
adauga(q->info);
// else
//modific_frecventa(q->info);
q=q->next;}
q=p1;
while(q)
{cout<<q->info<<" de "<<q->fr<<" ori "<<endl;
q=q->next;}
getch();
}

56

18.

SA SE CREEZE O LISTA. SA SE DETERMINE :

-NUMARUL DE ELEM SI SA SE AFISEZE

-SA SE INSEREZE IN LISTA O VALOARE DUPA UN ELEMENT SI SA SE AFISEZE LISTA

-SA SE INSEREZE IN LISTA O VALOARE INAINTEA UNUI ELEMENT SI SA SE AFISEZE
-SA SE STEARGA DIN LISTA O VALOARE SI SA SE AFISEZE LISTA DUPA STERGERE
-SA SE DENUMEASCA PRIMUL NOD, ULTIMUL NOD SI NUMARUL ELEM

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod* adr_urm;
};
nod *prim,*ultim,*c;
int nr_elem;
void creare(nod *&p)
{int val;
p=new nod;
cout<<endl<<"prima valoare din lista:";
cin>>val;
p->info=val;
p->adr_urm=NULL;
ultim=p;
nr_elem=1;
}
void afisare(nod *p)
{p=prim;
while(p!=NULL)
{cout<<p->info<<" ";
p=p->adr_urm;
}
}
void adaugare(int val)
{nod *c;
c=new nod;
c->info=val;
ultim->adr_urm=c;
ultim=c;
ultim->adr_urm=NULL;
nr_elem=nr_elem+1;
}
57

void inserare_dupa(int val,int val_l)//se adauga valoarea val dupa val_l din
lista
{nod *c,*d;
c=prim;
while(c->info!=val_l)
c=c->adr_urm;
d=new nod;
d->info=val;
d->adr_urm=c->adr_urm;
c->adr_urm=d;
nr_elem=nr_elem+1;
}
void inserare_inainte(int val,int val_l)//se adauga valoarea val inainte de val_l
din lista
{nod *c,*d;
c=prim;
while(c->adr_urm->info!=val_l)
c=c->adr_urm;
d=new nod;
d->info=val;
d->adr_urm=c->adr_urm;
c->adr_urm=d;
nr_elem=nr_elem+1;
}
void stergere(int val)
{nod *c,*aux;
c=prim;
if (c->info==val)
{aux=c;
prim=prim->adr_urm;
}
else
{while(c->adr_urm->info!=val)
c=c->adr_urm;
aux=c->adr_urm;
c->adr_urm=aux->adr_urm;
}
if (aux==ultim) ultim=c;
delete aux;
nr_elem=nr_elem-1;
}
int main()
{int val,i,nr,val_l;
cout<<endl<<"Se va crea lista";
creare(prim);
cout<<endl<<"elementele listei sunt:"<<endl;
afisare(prim);
cout<<endl<<"Cate valori mai adaugi in lista? ";
cin>>nr;
for(i=1;i<=nr;i++)
58

{cout<<"valoarea de adaugat:";
cin>>val;
adaugare(val);
}
cout<<endl<<"in lista sunt "<<nr_elem<<" elemente:"<<endl;
afisare(prim);
cout<<endl<<"dupa ce valoare din lista faceti inserarea? ";
cin>>val_l;
cout<<endl<<"Ce valoare inserati in lista? ";
cin>>val;
inserare_dupa(val,val_l);
cout<<endl<<"dupa inserare:";
afisare(prim);
cout<<endl<<"inainte de ce valoare din lista faceti inserarea? ";
cin>>val_l;
cout<<endl<<"Ce valoare inserati in lista? ";
cin>>val;
inserare_inainte(val,val_l);
cout<<endl<<"dupa inserare:";
afisare(prim);
cout<<endl<<"Ce valoare stergeti din lista? ";
cin>>val;
stergere(val);
cout<<endl<<"dupa stergere:";
afisare(prim);
cout<<"prim="<<prim->info<<" ultim="<<ultim->info<<"
nr_elem="<<nr_elem;
getch();
}

19.
SA SE INSEREZE INTRE FIECARE 2 NODURI MEDIA LOR ARITMETICA.
#include<iostream.h>
#include<conio.h>
struct nod
{float info;
nod *next;};
nod *p,*u ;
int n;

// acceseaza primul respective ultimul nod

//numarul de noduri

void cre_ad()
//functia de creare si adaugare a unui nou element
{nod *c;
if(!p)
//daca lista este vida (p==0) se aloca primul nod
59

{p=new nod;
cout<<"valoare primului nod ";
cin>>p->info;
u=p;
//la creare primul si ultimul nod vor fi identici
}
else
//altfel se adauga un nou element la sfarsit
{ c=new nod; //se aloca un nou nod
cout<<"informatia utila :";
cin>>c->info; //se completeaza campul informatie utila
u->next=c;
//se adauga dupa ultimul nod
u=c;
//se stabileste noul nod c ca fiind ultimul
}
u->next=0;
//campul adresa urmatoare a ultimului nod este 0
}
void afis() //functia de afisare parcurge elementele cu afisare
{nod *c;
c=p;
//se porneste de la primul nod din lista
while(c)
//cat timp c retine o adresa nenula
{cout<<c->info<<" ";//se afiseza campul informatie utila
c=c->next;}
//se avanseaza la urmatoarea adresa, la urmatorul
nod
cout<<endl;
}
void inserare(nod *p)
{nod *q,*a;
q=p;
while(q->next)
{a=new nod;
a->info=(q->info+q->next->info)/2;
a->next=q->next;
q->next=a;
q=q->next->next;
}
}
void main()
{clrscr();
int b;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
cre_ad( );
cout<<endl;
afis();
inserare(p);
afis();
getch();
}
60

20.

SE DAU 2 LISTE. SA SE REUNEASCA SI SA SE ORDONEZE CRESCATOR

ELEMENTELE .
#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod *next;};
nod *p1,*u1,*p2,*u2,*p3,*u3;
void creare(nod *&p,nod *&u,int x)
{nod *q;
if(!p)
{p=new nod;
p->info=x;
u=p;}
else
{q=new nod;
q->info=x;
u->next=q;
u=q;}
u->next=0;
}
void afisare(nod *p)
61

{nod *q;
q=p;
while(q)
{cout<<q->info<<" ";
q=q->next;}
}

void main()
{clrscr();
int n,x;
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
{cout<<"x=";
cin>>x;
creare(p1,u1,x);
}
cout<<"n=";
cin>>n;
for(i=1;i<=n;i++)
{cout<<"x=";
cin>>x;
creare(p2,u2,x);
}
afisare(p1);
cout<<endl;
afisare(p2);
nod *q1=p1,*q2=p2;
while(q1&&q2)
{if(q1->info<q2->info)
{creare(p3,u3,q1->info);
q1=q1->next;}
else
{creare(p3,u3,q2->info);
q2=q2->next;}
}
if(q1!=0)
while(q1)
{creare(p3,u3,q1->info);
q1=q1->next;
}
else
while(q2)
{creare(p3,u3,q2->info);
62

q2=q2->next;
}
cout<<endl;
afisare(p3);
getch();
}

21.

SA SE INVERSEZE O LISTA.

#include<iostream.h>
#include<conio.h>
struct nod
{int info;
nod *next;};
nod *p,*u,*p1,*p2;
int n;

void cre_ad()
{nod *c;
if(!p)
{p=new nod;
cout<<"valoare primului nod ";
cin>>p->info;
u=p;
u->next=0;}
else
{ c=new nod;
cout<<"informatia utila :";
cin>>c->info;
u->next=c;
u=c;
u->next=0;
}
}
void afis(nod *p)
{nod *c;
c=p;
while(c)
{cout<<c->info<<" ";
c=c->next;}
cout<<endl;
}
void invers()
{nod *c,*c2;
63

c=p;
p1=new nod;
p1->info=c->info;
nod *u1=p1;
u1->next=0;
c=c->next;
while(c)
{c2=new nod;
c2->info=c->info;
c2->next=p1;
p1=c2;
c=c->next;
}
}
void main()
{int b;
clrscr();
cout<<"n=";
cin>>n;
for(int i=1;i<=n;i++)
{
cre_ad();}
cout<<endl;
afis(p);
invers();
cout<<endl<<"cea de a doua lista in ordine inversa"<<endl;
afis(p1);
getch();
}

22.

SE DA O LISTA. SA SE AFISEZE :
-ELEMENTELE LISTEI;
-VALOAREA MINIMA DIN LISTA;

-ELEMENTELE LISTEI DUPA ORDONARE

-SA SE INLOCUIASCA O VALOARE DIN LISTA CU UNA CITITA DE LA TASTATURA .
64

#include<iostream.h>
#include<conio.h>
struct Nod
{int info;
Nod *next;
};
Nod *prim, *ultim;
void creare()
{prim=new Nod;
cout<<"introduceti valoarea retinuta in primul nod:";
cin>>prim->info;
prim->next=0; //la crearea listei va exista un singur nod, primul si prin
urmare adresa urmatoare lui este 0
ultim=prim; //evident, avand un singur element acesta va fi si primul si
ultimul
}
void adaugare()
{Nod *c;
c=new Nod;
cout<<"valoarea de adaugat in lista ";
cin>>c->info;
ultim->next=c; //se "agata" noul nod c, dupa ultimul din lista
ultim=c; //evident noul nod e ultimul...
ultim->next=0;//...si dupa ultimul nu e nimic, deci nici o adresa
}
void ordonare()
{Nod *c;int ord,aux;
do
{c=prim;
ord=0;
while(c->next)
{if(c->info>c->next->info)
{aux=c->info;
c->info=c->next->info;
c->next->info=aux;
ord=1;
}
c=c->next;}
}
while(ord);
}
void creare_lista_ordonata(int val)
{Nod *c,*a;
if(!prim)
65

{prim=new Nod;
prim->info=val;
ultim=prim;
ultim->next=0;}
else
{c=prim;
if(val<prim->info)
{a=new Nod;
a->info=val;
a->next=prim;
prim=a;}
else
{if(val>ultim->info)
{a=new Nod;
a->info=val;
ultim->next=a;
ultim=a;
ultim->next=0;}
while((c->next->info<=val)&&c)
c=c->next;
a=new Nod;
a->info=val;
a->next=c->next;
c->next=a;
}
}
}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->next;//avansez in lista trecand la urmatoarea adresa
}
cout<<endl;
}
void minim()
{int min;
Nod *c;
c=prim;
min=c->info;
c=c->next;
while(c!=0)
{if(min>c->info)
min=c->info;
c=c->next;
};
cout<<endl<<"valoarea minima din lista este "<<min;
66

};
int cautare(int val,int nr)
{Nod *c; int gasit;
c=prim; gasit=0;
while(c)
{if(c->info==val)
{gasit=1;
c->info=nr;
}
c=c->next;
};
return gasit;
}
void main()
{int n,i;int val,nr;
cout<<"cate elemente va avea lista?";
cin>>n;
creare();
for(i=2;i<=n;i++)
adaugare();
cout<<"Elementele listei sunt:";
listare();
minim();
ordonare();
cout<<endl<<"elementele listei dupa ordonare;"<<endl;
listare();
cout<<endl<<"valoarea de cautat in lista...";
cin>>val;
cout<<endl<<"valoarea de schimb in lista...";
cin>>nr;
if(cautare(val,nr)==1)
{cout<<endl<<"s-a gasit "<<val<<" in lista si s-a schimbat cu "<<nr;
cout<<endl;
listare();}
else cout<<endl<<"nu s-a gasit "<<val<<" in lista";
getch();
}

67

23.

SE INTRODUC DE LA TASTATURA GRADUL SI COEFICIENTII A 2 POLINOAME.

SA SE AFISEZE POLINOMUL SUMA SI POLINOMUL PRODUS.
#include<iostream.h>
#include<conio.h>
struct monom
{int c,gr;
};
struct nod
{monom info;
nod *next;};
nod *p1,*u1;
nod *p2,*u2;
nod *ps,*us;
void creare(int co,int grd,nod*&p,nod *&u )
{nod *q;
if(!p)
{p=new nod;
p->info.c=co;
p->info.gr=grd;
u=p;}
else
{q=new nod;
q->info.c=co;
q->info.gr=grd;
u->next=q;
u=q;}
u->next=0;
}
void afisare(nod *p)
{nod *q;
q=p;
while(q)
{cout<<q->info.c<<"X^"<<q->info.gr<<" ";
q=q->next;}
}
int cauta(nod *p,int exp)
{nod *q;
68

q=p;
while (q)
{if(q->info.gr==exp)
return q->info.c;
q=q->next;
}
return 0;
}
int main()
{clrscr();
int n,x;
cout<<"Gradul primului polinom =";
cin>>n;
int coef;
for(int i=0;i<=n;i++)
{cout<<"coeficientul monomului de grad ="<<i<<":";
cin>>coef;
if(coef!=0)
creare(coef,i,p1,u1);
}
int m;
cout<<"Gradul celui de al doilea polinom =";
cin>>m;
for(i=0;i<=m;i++)
{cout<<"coeficientul monomului de grad ="<<i<<":";
cin>>coef;
if(coef!=0)
creare(coef,i,p2,u2);
}
afisare(p1);
cout<<endl;
afisare(p2);
nod *q=p1;
int z;
while(q)
{z=cauta(p2,q->info.gr);
creare(z+q->info.c,q->info.gr,ps,us);
q=q->next;}
cout<<endl<<"polinomul suma "<<endl;
afisare(ps);
//produsul
nod *pp=0,*up;
int y;
for(i=0;i<=n+m;i++)
{int s=0;
for(int j=0;j<=i;j++)
{x=cauta(p1,j);
y=cauta(p2,i-j);
s=s+x*y;}
69

creare(s,i,pp,up);
}
cout<<endl;
cout<<endl<<"polinomul produs "<<endl;
afisare(pp);
getch();
return 0;
}

24.
SA SE STEARGA ELEMENTELE NEPRIME DINTR-O LISTA.
#include<conio.h>
#include<fstream.h>
struct Nod
{int info;
Nod *adr_urm;
};
Nod *prim, *ultim;
int gasit;
70

/*************************************************************************
functiile de creare si adaugare se pot comprima intr-o singura functie
care poate testa daca exista un prim nod si in functie de rezultatul testului
va realiza alocarea primului nod sau se va adauga un nou nod la sfarsit
*************************************************************************/
void creare_adaugare()
{if(prim==NULL)
{prim=new Nod;
cout<<"introduceti valoarea retinuta in primul nod:";
cin>>prim->info;
prim->adr_urm=0; //la crearea listei va exista un singur nod, primul si
prin urmare adresa urmatoare lui este 0
ultim=prim; //evident, avand un singur element acesta va fi si primul si
ultimul
}
else
{Nod *c;
c=new Nod;
cout<<"valoarea de adaugat in lista ";
cin>>c->info;
ultim->adr_urm=c; //se "agata" noul nod c, dupa ultimul din lista
ultim=c; //evident noul nod e ultimul...
ultim->adr_urm=0;//...si dupa ultimul nu e nimic, deci nici o adresa
}
}
void listare()
{Nod *c;
c=prim;
while(c!=0)//cat timp mai sunt in lista
{cout<<c->info<<" ";
c=c->adr_urm;//avansez in lista trecand la urmatoarea adresa
}
cout<<endl;
}
int e_prim(int x)
{int i;
for(i=2;i<=x/2;i++)
if(x%i==0)
return 0;
return 1;
}
/
******************************************************************************
functia realizeaza stergerea unui element dupa continutul transmis ca
parametru
71

******************************************************************************
/
void stergere()
{Nod *c,*a; //a se sterge, c este precedentul sau.Se va genera o noua
legatura intre c si a->next
c=prim;
gasit=0;
if(e_prim(prim->info)==0) //daca primul nod retine val se sterge primul
{a=prim;
//se retine in a
prim=prim->adr_urm; //primul va deveni urmatorul element
delete a;
gasit=1;
}
//se elibereaza memoria
else
{while(e_prim(c->adr_urm->info)==1 && c)
c=c->adr_urm;
if(c)
gasit=1;
a=c->adr_urm;
c->adr_urm=a->adr_urm;
if(a==ultim)
ultim=c;
delete a;
}
}
/*void ste(int x)
{Nod *c=prim;
int avans;
if(prim->info==x)
{Nod *a=prim;
prim=prim->adr_urm;
delete a;
}
while(c)
{avans=0;
if(c->adr_urm->info==x)
{Nod *a;
a=c->adr_urm;
c->adr_urm=a->adr_urm;
c=c->adr_urm;
avans=1;
delete a;
}
if(avans==0)
c=c->adr_urm;
}
}
72

*/
void main()
{int i,n,val_info;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++)
creare_adaugare();
listare();
gasit=1;
int x;
cout<<"x=";
cin>>x;
while(gasit)
{stergere();
//cout<<endl<<"dupa stergerea lui "<<x<<endl;
listare();
getch();}
//ste(x);
//listare();
getch();
}
25.
SE INTRODUC N BILE DE LA TASTATURA DE DIFERITA CULORI , SA SE
SORTEZE BILELE IN ODINE DESCRESCATOARE SI APOI SA SE IDENTIFICE PE
CULORI DE LA INCEPUT LA SFARSIT .

#include<iostream.h>
#include<conio.h>
#include<string.h>
struct nod
{int nr;
char cul[20];
nod *back;};
typedef char string[20];
string w[20];
nod *v[100];
void push(nod *&vf, int x, char y[20])
{nod *q;
q=new nod;
q->nr=x;
strcpy(q->cul,y);
if(!vf)
{vf=q;
vf->back=0;}
else
{q->back=vf;
vf=q;
}
}
void afisare(nod *p)
{nod *c;
73

c=p;
while(c)
{cout<<c->nr<<" "<<c->cul<<" ";
c=c->back;}
cout<<endl;
}
void main()
{int n;
cout<<"n=";
cin>>n;
char cc[20];
nod*vf;
int k;
for(int i=1;i<=n;i++)
{cout<<"ce culoare are bila "<<i<<" ";
cin>>cc;
push(vf,i,cc);
}
afisare(vf);
int gasit;
nod*q=vf;
for(i=1;i<=n;i++)
{k=1;gasit=0;
while(v[k]!=0)
{if(strcmp(v[k]->cul,q->cul)==0)
{gasit=1;
push(v[k],q->nr,q->cul);}
k++;}
if(gasit==0)
push(v[k],q->nr,q->cul);
q=q->back;
}
i=1;
while(i<=k)
{afisare(v[i]);
cout<<endl;
i++;}
getch();
}

74

26.

LISTA UNOR ANGAJATI

-AFISAREA LOR INCEPAND CU ULTIMUL

-AFISAREA LOR DACA SE VOR CONCEDIA UN NUMAR INTRODUS DE LA TASTATURA
#include<iostream.h>
struct angajat
{char nume[20];
int salariu;};
struct Nod
{angajat info;
Nod *adr_prec;};
Nod *varf,*c;
int n;
void push()
{if(!varf)
{varf=new Nod;
cout<<"numele angajatului ";
cin>>varf->info.nume;
cout<<"salariul ";
cin>>varf->info.salariu;
varf->adr_prec=0;}
else
{c=new Nod;
cout<<"numele angajatului ";
cin>>c->info.nume;
cout<<"salariul ";
cin>>c->info.salariu;
c->adr_prec=varf;
varf=c;}
}
void listare()
{cout<<"afisarea angajatilor incepand cu ultimul "<<endl;
c=varf;
while(c)
{cout<<c->info.nume<<" "<<c->info.salariu<<endl;
c=c->adr_prec;}
}
void pop()
75

{if(!varf) cout<<"lista este vada!";

else
{c=varf;
varf=varf->adr_prec;
delete c;}
}
void main()
{cout<<"numarul de angajati ";
cin>>n;
for(int i=1;i<=n;i++)
push();
listare();
cout<<endl<<"cati angajati se vor concedia ";
cin>>n;
for(i=1;i<=n;i++)
pop();
cout<<endl<<"ultimii "<<n<<" angajati au fost concediati ";
listare();
}

27.

SA SE CONSTRUIASCA O LISTA LINIARA SIMPLU INLANTUITA CARE SA

CONTINA NUMERE NATURALE . S A SE SCRIE O FUNCTIE CARE SA SEPARE
ELEMENTELE PARE DE CELE IMPARE IN 2 LISTE SEPARATE .

#include<fstream.h>
fstream f("nr.in",ios::in);
struct nod{int info;
76

nod *leg;
};
nod *prim,*pare,*impare;
void adaugf(nod *&prim,int x)
{nod *nou=new nod;
nou->info=x;
nou->leg=prim;
prim=nou;
}
void citire()
{int x;
while(f>>x)adaugf(prim,x);
}
void separ(nod *prim,nod *&pare,nod *&impare)
{nod *p=prim;
while(p){if(p->info%2==0)adaugf(pare,p->info);
else adaugf(impare,p->info);
p=p->leg;
}
}
void afis(nod *prim)
{nod *p=prim;
while(p){cout<<p->info<<" ";
p=p->leg;
}
cout<<endl;
}
void main()
{citire();
separ(prim,pare,impare);
afis(pare);
afis(impare);
getch();
}

28.

A)

SA SE CREEZE O LLDI CARE SA MEMOREZE NUMERE INTREGI CITITE DINTR-UN

FISIER TEXT .

B)

SA SE SCRIE O FUNCTIE CARE PRIMESTE CA PARAMETRU ADRESA PRIMULUI NOD AL

LISTEI SI O AFISEAZA IN AMBELE SENSURI .
C) S A SE SCRIE O FUNCTIE CARE PRIMESTE CA PARAMETRU ADRESA P A UNUI NOD SI
UN NUMAR NATURAL X SI ADAUGA DUPA NODUL INDICAT DE P UN NOD CARE SA
CONTINA VALOAREA X .

77

D)

SA SE SCRIE O FUNCTIE CARE PRIMESTE CA PARAMETRU ADRESA P A UNUI NOD SI

STERGE NODUL INDICAT DE P.
E) F OLOSIND FUNCTIILE DE PUNCTELE B ), C) SI D ) SA SE ADAUGE DUPA NODUL AL
DOILEA UN NOD CU INFORMATIA 7, SA SE STEARGA AL TREILEA NOD SI APOI PRIMUL
NOD SI SA SE AFISEZE LISTA IN AMBELE SENSURI DUPA FIECARE DINTRE ACESTE
OPERATII .

#include<fstream.h>
ifstream f("date.in");
ofstream g("date.out");
struct nodd{int info;
nodd *prec,*urm;
};
nodd *prim;
void adaugs(nodd *&prim,int x)
{nodd *u=prim;
if(prim)
{while(u->urm) u=u->urm;
nodd *nou=new nodd;
nou->info=x;
u->urm=nou;
nou->prec=u;
nou->urm=0;
}
else {prim=new nodd;
prim->info=x;
prim->urm=0;
prim->prec=0;
}
}
void creare(nodd *&prim)
{int x;
while(f>>x) adaugs(prim,x);
}
void afis(nodd *prim)
{nodd *p=prim;
while(p->urm) {g<<p->info<<" ";
p=p->urm;
}
g<<p->info<<" ";
g<<endl;
while(p) {g<<p->info<<" ";
p=p->prec;
}
g<<endl;
78

}
void inseraredupa(nodd *p,int x)
{nodd *nou=new nodd;
nou->info=x;
nodd*q=p->urm;
nou->prec=p;
p->urm=nou;
nou->urm=q;
if(q) q->prec=nou;
}
void sterg(nodd *&p)
{nodd *q,*r;
q=p->prec;
r=p->urm;
if(r) r->prec=q;
if(q) q->urm=r;
else {nodd *x=p;
p=p->urm;
p->prec=0;
delete x;
}
if(p!=r) delete p;
}
void main()
{creare(prim);
afis(prim);
inseraredupa(prim->urm,7);
afis(prim);
sterg(prim->urm->urm);
afis(prim);
sterg(prim);
afis(prim);
}

Bibliografie
o

Mariana Milosescu, Informatica Intensiv: C++, manual pentru clasa a XI-a/

Mariana Milosescu- Bucuresti, Editura Didactica si Pedagogica 2009
79

o
o
o
o

Tudor Sorin, Vlad Tudor; Manual de INFORMATIC, clasa a XI-a, profilul real
(neintensiv)
Carmen Popescu, Informatica: culegere de problem pentru clasa a IX-XI,
Bucuresti, Editura L&S Infomat, 2008
http://infoscience.3x.ro
http://infomcip.ro

80