MINISTERUL EDUCAIEI NAIONALE

LICEUL TEORETIC DUNREA GALAI

PROFESOR NDRUMTOR:
BIBICU DORIN

NUME:
Moraru Florin
CLASA A XII-A D

Pagina 1

CUPRINS

INTRODUCERE N LISTE............................................................................................................4
LISTE CIRCULARE.......................................................................................................................7
Introducere...................................................................................................................................7
Clasificarea listelor circulare.......................................................................................................8
Operaii n liste circulare............................................................................................................11
APLICAII....................................................................................................................................14
Reinei coordonatele unui poligon i calculai perimetrul acestuia..........................................14
Concatenarea a dou liste circulare............................................................................................16
Se citesc mai multe numere memorate ntr-o list circular.Sfritul listei este marcat prin
citirea unei valori egal cu suma ultimelor dou numere introduse.S se realizeze un
subprogram recursiv pentru afiarea elementelor n ordinea invers introducerii.....................19
BIBLIOGRAFIE............................................................................................................................23

Pagina 2

MOTIVAIA ALEGERII TEMEI

Am ales aceast tem datorit faptului c voi susine examenul de bacalaureat la
disciplina informatic, iar capitolul Liste circulare este parte component a programei pentru
examenul de bacalaureat.
Pe de alta parte, am considerat c modul de abordare dinamic al listelor este destul de
dificil i cred c poate fi folosit ca baz in stiudiul informaticii pentru orice elev de nivelul
claselor X XI.

Pagina 3

INTRODUCERE N LISTE
Lista este o structur de date logic, liniar, cu date omogene, n care fiecare element are
un succesor i un predecesor, exceptnd primul element, care nu are dect un succesor, i ultimul
element, care nu are dect predecesor.

a1

a2

ai-1

ai

ai+1

an

Unde:
a1 este primul element ( nu are predecesor );
ai este elementul care l are ca succesor pe ai+1 i ca predecesor pe ai-1;
an este ultimul element ( nu are succesor );
Operaiile care se pot executa asupra listelor sunt:

iniializarea listei: se creeaz lista vid;

crearea listei: se adaug repetat elemente la list, pornind de la lista vid;
inserarea unui element n list: la nceput, la sfrit, n interior;
tergerea unui element din list: la nceput, la sfrit, n interior;
parcurgerea listei: se viziteaz elementele listei pentru a obine informaii;
cutarea n list a unui element care ndeplinete anumite condiii;
concatenarea a dou liste;
divizarea n dou liste;

n funcie de modul n care se aloc memoria intern, listele pot fi implementate prin
dou metode:
metoda static: folosind vectori;
metoda dinamic: folosind pointeri;
n funcie de modul n care sunt aranjate elementele n list, acestea pot fi implementate
prin:
metoda secvenial;
metoda nlnuit;

n implementarea prin alocare secvenial nodurile listei sunt stocate ntr-un bloc
contiguu de locaii de memorie cu adrese consecutive.De exemplu, dac avem o list
format din cuvinte de maximum 4 caractere, acestea vor fi scrise ntr-un bloc contiguu
Pagina 4

de locaii de 5 octei.Aceast implementare este cea mai simpl i se face folosind un

vector de iruri de caractere:
typedef char nod[5];
nod lista[100];

n implementarea prin alocare nlnuit nodurile listei nu mai sunt stocate succesiv
n memorie.Aceast implementare se poate face att static, ct i dinamic, ntre cele dou
implementri existnd urmtoarele diferene:
n implementarea static, nodurile listei ocup un bloc contiguu de locaii de memorie
( zona de memorie alocat vectorului );
n implementarea dinamic, nodurile listei ocup locaii dispersate din memorie ( a cror
adres poate fi pstrat cu ajutorul pointerilor );
Clasificarea listelor:
Listele liniare se clasific n:

Liste generale: Nu exist restricii pentru operaiile de inserare i tergere a elementelor

din list ( se pot face n orice poziie a listei );
Liste restrictive: Exist restricii pentru operaiile de inserare i stergere a elementelor
din list ( se pot face numai la extremiti );

Liste generale
Stiva
Lista simplu
Lista dublu
Operaiile de
nlnuit:
introducere i extragere nlnuit:

Coada
Lista circular:

Operaia de introducere
Pagina
5
a elementelor
se face
Este o list
nlnuit
n
a elementelor se pot
pe la o extremitate,
iar ultim se
care elementul
Fiecare element
Fiecare element
face numai printr-una
extragerea prin
leagacealalta
de cel prim
pstreaz legtura cu
pstreaz
legtura cu
Liste
restrictive
din extremiti
extremitate

LISTE CIRCULARE
Introducere
O list circular simplu nlntuit este o list liniar simplu nlntuit modificat astfel
nct ultimul element pointeaz ( direcioneaz ) spre primul element din list.
Pagina 6

O list circular dublu nlntuit este o list liniar dublu nlntuit modificat astfel
nct ultimele elemente pointeaz respectiv spre primele elemente din list.
n continuare ne vom referi la liste circulare simplu nlntuite pe care le vom numi simplu:
liste circulare.
Deci fiecare element din lista circular are urmtoarea structur:

a1

a2

ai-1

ai

ai+1

an

a1

Forma general a unui element dintr-o list circular este:

struct nume_structura {
nume_tip1 nume_var1;
//...................
nume_tipN nume_varN;
nume_structura *nume_pointer; // pointer de tip nume_structura care va indica spre urmatorul
element };

Exemplu de element dintr-o list circular este:

struct record
{
int number;
record *next;
Pagina 7

};
La listele circulare, pe baza informatiei de nlntuire trebuie s poat fi identificat
urmtorul element din list.

Clasificarea listelor circulare

Liste circulare alocate static:

Dac implementarea structurii de list circular se face prin tablouri, o list circular este
numit list circular alocat static sau simplu o list circular static.
Considerm urmtoarele declaratii:

struct element {
char* data;
int leg;
};
element v[8];

Pentru elementele vectorului V exist o ordine natural dat de aranjarea n memorie a

elemetelor sale: v[0], v[1], ...v[7]. Vom reperezenta memoria ocupat de vectorul V astfel nct
fiecare element s fie reprezentat vertical, n felul urmtor:

v[1
]

v[2
]

v[3
]

v[4
]

v[6
]

v[7
]

v[1
]

reprezint pentru fiecare element al vectorului legtura catre urmtorul element , iar
pentru ca lista s fie circular de la ultimul element se face legatura catre primul.
Pagina 8

Observaie: Nu mai exist un ultim element n list ca la listele liniare! Este necesar s
cunoastem care este primul element din nlntuire, pentru aceasta retinem ntr-o variabil:
int cap;
Indexul primului element
cap=3;

Parcurgerea n ordine a elementelor listei circulare se face n felul urmtor:

int crt;
.................
if (cap!=null){
crt = cap;
Prelucreaz V[crt]

while (V[crt].leg!=cap) {
crt = V[crt].leg;
Prelucreaza V[crt]
}
}

Liste circulare alocate dinamic:

Dac implementarea structurii de list circular se face prin tehnici de alocare dinamic
se obtine o list circular alocat dinamic sau simplu o list circular dinamic.
Considerm urmtoarele declaraii:

struct Element

Pagina 9

{
TipOarecare data; // informatia util
Element* leg; // legtura
};
Avnd declaratiile de mai sus (una din forme):
Element* p; // un pointer la Element
n urma unei operatii:
p = (Element*) malloc( sizeof(Element) )

Operaii n liste circulare

Parcurgerea listei:

Considerm: cap - contine adresa primului element din list.

Pagina 10

O parcurgere nseamn prelucrarea pe rnd a tuturor elementelor listei, n ordinea n care

acestea apar n list. Vom avea o variabil pointer p care va indica pe rnd fiecare element al
listei:
if (cap!=0){
p = cap;
Prelucreaz p->data
while (p->leg!=cap){
p = p->leg;
Prelucreaz p->data
}
}
Un caz special apare atunci cnd dorim s facem o parcurgere care s se opreasc n fata
unui element care s ndeplineasc o conditie (ca n cazul cnd inserm un element ntr-o pozitie
dat printr-o conditie, sau stergem un element care ndeplineste o conditie). Presupunem c lista
are cel putin un element.

p = cap;
while (p->leg!=cap && !conditie(p->leg))
p = p->leg;
Bucla while se poate opri pe condiia "p->leg==cap", ceea ce nsemn c nici un element
din list nu ndeplineste conditia iar pointerul p indic ultimul element din list, sau pe conditia
"conditie(p->leg)" , ceea ce nsemn c pointerul p va contine adresa elementului din fata
primului element care ndeplineste condiia.
Inserarea unui nod n list:

Se pun urmtoarele probleme:

inserarea naintea unui nod de cheie dat;
inserarea dup un nod de cheie dat;
n ambele cazuri se caut nodul de cheie dat avnd adresa q; dac exist un astfel de
nod, se creeaz nodul de inserat de adres p i se fac legturile corespunztoare.
Pagina 11

Inserarea naintea unui nod de cheie dat:

TIP_NOD *p,*q,*q1;
q = ptr_nod;
do
{
q1 = q; q = q -> urm;
if (q -> cheie = =key ) breaak;
}
while (q! = ptr_nod);
if (q -> cheie == key) {
q1 -> urm = p; p -> urm = q;
}
Inserarea dup un nod de cheie dat:
TIP_NOD *p,*q;
q = ptr_nod;
do
{
if (q -> cheie == key ) break;
q = q -> urm;
}
while(q!=ptr_nod);
if (q -> cheie == key)
{
p -> urm =q -> urm;
q -> urm = p;
}
tergerea unui nod din list:

q = ptr_nod;
do
{
q1 = q; q = q -> urm;
if (q -> cheie == key ) break;
Pagina 12

}
while (q! = ptr_nod);
if (q-> cheie == key)
{
if (q==q -> urm) ptr_nod==0;
else
{
q1 -> urm = q -> urm;
if (q == ptr_nod) ptr_nod = q1;
}
elib_nod(q);
}
tergerea listei:
p = ptr_nod;
do
{
p1 =p; p = p -> urm;
elib_nod(p1);
}
while (p! = ptr_nod);
ptr_nod = 0;

APLICAII
Reinei coordonatele unui poligon i
calculai perimetrul acestuia
#include<stdio.h>
Pagina 13

#include<conio.h>
#include<alloc.h>
#include<math.h>
struct nod
{ int x,y;
struct nod *next;
}*l,*q;
int n,i;
float p;
struct nod* creare()
{ struct nod* aux;int x,y;
l=NULL;
for(i=n;i>=1;i--)
{ aux= (struct nod* )malloc(sizeof(struct nod));
printf("coordonatele vfului %d",i);
printf("x=" );
scanf("%d",&x);
printf("y=" );
scanf("%d",&y);
aux->x=x;
aux->y=y;
aux->next=l;
if (i==n) q=aux;
l=aux;
}
q->next=l;
return l;
}
void afisare()
{ struct nod* c;
c=l;
Pagina 14

printf("(%d,%d)",c->x,c->y);
c=l->next;
while(c!=l)
{ printf("(%d,%d)",c->x,c->y);
c=c->next;
}
}
void perimetru()
{ struct nod*c;
c=l;
p=0;
for(i=1;i<=n;i++)
{ p+=pow(pow(c->x-c->next->x,2)+pow(c->y-c->next->y,2),0.5);
c=c->next;
}
}
void main(void)
{ clrscr();
printf("nr de varfuri este " );
scanf("%d",&n);
l=creare();
afisare();
perimetru();
printf("p=%f",p);
getch();
}

Pagina 15

Concatenarea a dou liste circulare

#include <conio.h>
#include <stdio.h>
#include <alloc.h>
struct nod
{ int x;
struct nod *next;
}*l,*l1,*u,*u1,*ultim;
int i,n;
struct nod* creare(struct nod *l, int k)
{struct nod*aux;
int v;
printf("nr de noduri=" );
scanf("%d",&n);
l=NULL;
ultim=NULL;
for (i=n;i>=1;i--)
{
aux= (struct nod*)malloc(sizeof(struct nod));
printf("\nInfo. nodului %d = ",i);
scanf("%d",&v);
aux->x=v;
aux->next=l;
if (i==n) ultim=aux;
Pagina 16

l=aux;
}
u->next=l;
if(k==0) u=ultim;
else u1=ultim;
return l;
}
void afisare(struct nod*l)
{ struct nod*c;
c=l;
printf("\n" );
printf("%d ",l->x);
c=l->next;
while (c!=l)
{
printf("%d ",c->x);
c=c->next;
}
}
struct nod* concat(struct nod* l,struct nod* l1)
{ struct nod* c,*aux;
u->next=l1;
u1->next=l;
return l;
}
Pagina 17

void main()
{ clrscr();
l=creare(l,0);
afisare(l);
l1=creare(l1,1);
afisare(l1);
printf("\nListele concatenate\n" );
l=concat(l,l1);
afisare(l);
getch();
}

Se citesc mai multe numere

memorate ntr-o list circular.Sfritul
listei este marcat prin citirea unei valori
egal cu suma ultimelor dou numere
introduse.S se realizeze un subprogram
recursiv pentru afiarea elementelor n
ordinea invers introducerii
#include <conio.h>
#include <stdio.h>
Pagina 18

#include <alloc.h>
struct nod
{ int x;
struct nod *next;
}*l,*q,*linv,*qinv;
int i,n,start,stop;
struct nod* insert(int x){
struct nod*aux;
aux= (struct nod*) malloc (sizeof(struct nod));
aux->x=x;
aux->next=l;
if (start) q=aux;
l=aux;
return l;
}
struct nod* creare()
{ int v1,v2,v3;
l=NULL;start=1;
printf("Info.= " );
scanf("%d",&v1);
l=insert(v1);
start=0;
stop=0;
printf("Info.= ") ;
scanf("%d",&v2);
Pagina 19

l=insert(v2);
printf("Info.= " );
scanf("%d",&v3);
while(stop==0){
if(v3==v1+v2) stop=1;
l=insert(v3);
v1=v2;
v2=v3;
printf("Info.= " );
scanf("%d",&v3);
}
q->next=l;
return l;
}
void afisare(struct nod*l)
{ struct nod*c;
c=l;
printf("%d ",c->x);
c=l->next;
while (c!=l)
{ printf("%d ",c->x);
c=c->next;
}
printf("\n" );
}
Pagina 20

struct nod* inversa(struct nod* l)

{ struct nod*aux,*q,*c;
int v;
if(l==NULL) linv=NULL;
else{
linv=insert(l->x);
qinv=linv;
for(c=l->next;c!=l;c=c->next)
linv=insert(c->x);
qinv->next=linv;
}
return linv;
}

0void main()
{ l=creare();
afisare(l);
linv=inversa(l);
afisare(linv);
getch();
}

Pagina 21

BIBLIOGRAFIE

Manual informatic clasa a XI-a.Editura LS Soft.Autori: Vlad Huanu, Tudor Sorin;

Programarea modern n C++.Editura Teora.Autor: Andrei Alexandrescu;

http://www.cs.uregina.ca/Dept/manuals/Manuals/7Language/7_18C++/c++.htm

Secrete de programare in Windows 98.Editura ZY.Autor: Clayton Walnum;

file://localhost/D:/download/Liste%20dublu%20inlantuite,%20liste%20circulare.htm

http://www.skullbox.info/board/-curs-c-lectia-12-liste-p31092.html
Pagina 22

http://cppcorner.3x.ro/circularlist.html

Pagina 23