PROGRAMARE S˘I STRUCTURI DE DATEmarianzsu/Postuniv/Curs/Curs05.pdfPROGRAMARE S˘I STRUCTURI DE DATE...

PROGRAMARE SI STRUCTURI DE DATECURS 5

Lect. dr. Onet - Marian Zsuzsanna

Facultatea de Matematica si Informatica UBBın colaborare cu NTT Data

Lect. dr. Onet - Marian Zsuzsanna PROGRAMARE SI STRUCTURI DE DATE

Cuprins

Ansamblu binar

Lista ınlantuita


Ansamblu

Ansamblul este o structura de date care este un fel de hibridıntre

Vector DinamicArbore Binar

Ansamblul este folosit ca reprezentare doar pentru Coada cuprioritati

Algoritmul de sortare Heap-sort este bazat pe un ansamblu.


Arbore binar

Vectorul este o structura liniara: pentru fiecare element existaun element anterior si unul urmator (exceptand primul siultimul element).

Un arbore binar este o structura neliniara, alcatuita din noduri,fiecare nod are un parinte si 0, 1 sau 2 fii sau descendenti.

Nodul care nu are parinte se numeste radacina arborelui, iarnodurile care nu au descendenti se numesc frunze.


Arbore binar

Un exemplu de arborebinar.

Radacina: 54

Frunze: 49, 28, 74

Fii lui 54: 11, 30

Fii lui 30: 59, 74

Parintele lui 49: 11

etc.

Vom vorbi mai mult despre arbori ın cursul 7, deocamdata eimportant doar sa ıntelegeti ce este un arbore binar.


Ansamblu

Un ansamblu este de fapt un vector dinamic (elementeleansamblului sunt stocate ıntr-un vector dinamic) care esteprivit/interpretat ca un arbore binar:

Radacina arborelui este primul element din vector.Teoretic, pentru orice element de pe pozitia i , descendentiielementului se gasesc ın vector pe pozitiile 2 ∗ i , 2 ∗ i + 1In practica, din moment ce prima pozitie ıntr-un vectordinamic e 0, descendentii pentru pozitia i se gasesc pe pozitiile2 ∗ i + 1 si 2 ∗ i + 2Parintele unui element de pe pozitia i este pe pozitia(i − 1)/2.

Radacina: pozitia 0.Descendentii radacinei: pozitiile 2*0+1 = 1, 2*0+2 = 2Descendentii elementului pe pozitia 1: 2*1+1 = 3, 2*1+2 = 4Descendetii elementului pe pozitia 2: 2*2+1 = 5, 2* 2+ 2 =6etc.


Ansamblu Exemplu


Ansamblu

Pentru a avea un ansamblu valid (nu orice arbore binar esteun ansamblu) trebuie sa respectam structura de ansamblu siproprietatea de ansamblu.

Structura de ansamblu: nu exista “gauri” ın arbore: fiecarenod are exact 2 descendenti, exceptand ultimele 2 niveluri. Peultimul nivel, descendentii sunt completati din stanga spredreapta.


Exemple de arbori binari care nu au structura de ansamblu

Evident, sunt mult mai multe exemple de arbori binari care nuau structura de ansamblu.


Exemple de arbori binari care au structura de ansamblu


Proprietarea de ansamblu

Proprietarea de ansamblu cere ca pentru orice element

Elementul sa fie mai mare (sau egal) decat cei doi descendenti(daca exista descendenti) - MAXHEAPElementul sa fie mai mic (sau egal) decat cei doi descendenti(daca exista descendenti) - MINHEAP

Mai formal: presupunand ca elementele ansamblului suntretinute ıntr-un vector dinamic v cu n elemente, proprietateade ansamblu cere ca pentru fiecare pozitie i , 0 ≤ i < n:

v [i ] ≥ v [2 ∗ i + 1] daca 2 ∗ i + 1 < n siv [i ] ≥ v [2 ∗ i + 2], daca 2 ∗ i + 2 < n

SAU

v [i ] ≤ v [2 ∗ i + 1] daca 2 ∗ i + 1 < n siv [i ] ≤ v [2 ∗ i + 2], daca 2 ∗ i + 2 < n


Exemple

Are proprietate de ansamblu?

NU are proprietate de ansamblu (54 este mai mare ca 11 simai mic ca 59)


Exemplu


NU are proprietatea de ansamblu (54 este mai mare cadescendentii, dar 11 nu este mai mare ca descendentii)


Exemplu


DA, are proprietarea de ansamblu (54 mai mare ca 11 si 30,11 mai mare ca 9 si 5, 30 mai mare ca 7). Pentru ca relatiadintre un nod si descendentii este ≥, spunem ca avem unMAXHEAP. Oare de ce se numeste MAXHEAP?

Intr-un MAXHEAP radacina contine elementul maxim dinansamblu.


Ansamblu

Elementele ansamblului sunt stocate ıntr-un vector dinamic,care este interpretat ca un arbore. In acest caz, vectorulcontine elementele (ın aceasta ordine): 54, 11, 30, 9, 5, 7.Desi avem un MAXHEAP valid, vectorul nu e ordonat (nici nutrebuie sa fie).


Exemplu


DA, are proprietarea de ansamblu (4 mai mic ca 41 si 30, 41mai mic ca 59 si 54). Pentru ca relatia dintre un nod sidescendentii este ≤, spunem ca avem un MINHEAP. Oare dece se numeste MINHEAP?

Intr-un MINHEAP radacina contine elementul minim dinansamblu.


Ansamblu

Elementele ansamblului sunt stocate ıntr-un vector dinamic,care este interpretat ca un arbore. In acest caz, vectorulcontine elementele (ın aceasta ordine): 4, 41, 30, 59, 54. Desiavem un MINHEAP valid, vectorul nu e ordonat.


Exemplu 2

Vectorii de mai jos reprezinta ansamblu valid? Daca nu,transformati vectorul ın ansamblu interschimband 2 elemente.

1 [70, 10, 50, 7, 1, 33, 3, 8]2 [1, 2, 4, 8, 16, 32, 64, 65, 10]3 [10, 12, 100, 60, 13, 102, 101, 80, 90, 14, 15, 16]


Ansamblu - Operatii

Pentru un ansamblu avem doar 2 operatii posibile:

AdaugareStergere radacina

Am discutat ca ansamblu este folosit ca reprezentare pentrucoada cu prioritati (imediat vom vedea cum exact) deci nicinu ne trebuie mai multe operatii.

Vom vedea cum sunt implementate aceste 2 operatii si cumputem implementa o Coada cu prioritati folosind un ansambluca reprezentare. In exemplu vom discuta despre unMAXHEAP, MINHEAP-ul este implementat in mod similar.


Adaugare ın ansamblu

La adaugare, elementul de adaugat vine neaparat pe primapozitie libera din vector (altfel am strica structura deansamblu).

Daca dupa adaugare, nu mai este respectata proprietatea deansamblu, vom urca nodul adaugat: ıl vom interschimba cuparintele lui, pana parintele este mai mare, sau nodul ajungeradacina.


Adaugare ın ansamblu - exemplu

Sa adaugam elementul 93 ın ansamblu.



Noul element a venit pe pozitia 11 ın vector. Parintele lui (cucare ıl comparam) este pe pozitia 11 - 1 ımpartita la 2, adica5.



Dupa interschimbare, elementul nou este pe pozitia 5. Ilcomparam cu parinte, care este pe pozitia 2.



Dupa interschimbare, elementul nou este pe pozitia 2. Ilcomparam cu parinte, care este pe pozitia 0. Elementul de pepozitia 0 fiind mai mare, nu mai trebuie sa faceminterschimbare, am terminat adaugarea.


Adaugare ın ansamblu - implementare

Sa vedem cum se implementeaza operatia de adaugare.

Cum reprezentam ansamblul? Ce campuri ar trebui sa aibastructura ansamblu?

Pentru simplitate, presupunem ca elementele din ansamblusunt numere. Putem avea si alt tip de date ın ansamblu,trebuie numai sa definim cum sunt elementele comparate.

Ansamblu:cap: Intreglen: Intregelem: Intreg[]



subalgorithm adauga(e: Integer) is:if this.len == this.cap then//vectorul dinamic folosit pentru ansamblu este plin

@ alocam un vector mai mare si copiem elementeleend ifthis.elem[this.len] = e //punem elementul la finalthis.len = this.len + 1//ıncepem procesul de urcarepozE, pozP, temp: IntegerpozE = this.len-1 //pozitia elementuluipozP = (pozE-1) / 2 //pozitia parintelui

//continuam pe pagina urmatoare



while pozE > 0 AND this.elem[pozP] < this.elem[pozE] executetemp = this.elem[pozP]this.elem[pozP] = this.elem[pozE]this.elem[pozE] = temppozE = pozP //resetam pozitia elementuluipozP = (pozE-1) / 2 //recalculam pozitia parintelui

end whileend subalgorithm

Complexitate:

O(log2n) - unde n este numarul de elementedin ansamblu.



while pozE > 0 AND this.elem[pozP] < this.elem[pozE] executetemp = this.elem[pozP]this.elem[pozP] = this.elem[pozE]this.elem[pozE] = temppozE = pozP //resetam pozitia elementuluipozP = (pozE-1) / 2 //recalculam pozitia parintelui

end whileend subalgorithm

Complexitate: O(log2n) - unde n este numarul de elementedin ansamblu.


Stergere din ansamblu

Dintr-un ansamblu putem sterge un singur element: radacina.

Nu exista stergere de pe o pozitie, nu exista stergerea unuielement dat, doar radacina poate fi stearsa.

Cand se sterge radacina, ın primul pas se copiaza ultimulelement din vector ın locul radacinii. Aceasta mutarepastreaza structura de ansamblu, dar poate strica proprietateade ansamblu (radacina poate nu mai este mai mare ca fii).

Pentru a restabili proprietatea de ansamblu, folosim un procesde coborare. Elementul curent (care initial este radacina) secompara cu maximul dintre fii, daca maximul este mai mare,elementul curent coboara (schimba locul cu fiu). Procesul serepeta pana elementul curent este mai mare ca fii sau ajungesa fie frunza.


Stergere din ansamblu - Exemplu

Doar radacina poate fi stearsa.



Mutam 38 ın locul lui 94. Comparam elementul 38 cumaximul dintre fii si daca trebuie ıl coboram.



Am schimbat 93 cu 38. In continuare comparam elementul 38cu maximul dintre fii si daca trebuie ıl coboram.



38 e frunza. Nu mai avem cu ce sa comparam, a terminatstergerea (mai trebuie doar sa returnam elementul sters, 94).


Stergere din ansamblu - Implementare

function sterge() is://presupunem ca ansamblul are macar un element

elemSters, pozE, fiuS, fiuD, fiuMax, temp: IntegerelemSters = this.elem[0] //elementul care va fi stersthis.elem[0] = this.elem[this.len-1] //mutam ultimul elementthis.len = this.len - 1pozE = 0while pozE < this.len execute

fiuS = pozE * 2 + 1fiuD = pozE * 2 + 2fiuMax = fiuS //presupunem ca fiu stang e mai mare

//continuam pe pagina urmatoare


if fiuD < this.len then //are 2 fiiif this.elem[fiuD] > this.elem[fiuS] then

fiuMax = fiuDend if

end ifif fiuS < this.len AND this.elem[fiuMax] > this.elem[pozE] then

temp = this.elem[fiuMax]this.elem[fiuMax] = this.elem[pozE]this.elem[pozE] = temppozE = fiuMax

else //fiuMax este mai mic sau nu are fii. Ne oprimpozE = this.len

end ifend whilereturn elemSters

end function



Complexitate:

O(log2n)



Complexitate: O(log2n)


Coada cu Prioritati pe ansamblu

Ansamblu poate fi folosit ca reprezentare pentru o coada cuprioritati, unde radacina ansamblului este elementul cuprioritate maxima.

Operatii si complexitati:

adauga - adaugam elementul cu prioritate ın ansamblu.O(log2n)sterge - stergem un element din ansamblu (care va fi cel cuprioritate maxima). O(log2n)element - returneaza elementul cu prioritate maxima (de pepozitia 0). Θ(1)vida - verificam daca vectorul e vid. Θ(1)

Folosind un ansamblu, o secventa de n adaugari ın coada cuprioritati, urmat de n stergeri are complexitate O(nlog2n)


Exercitii

Subiectul 2017Randul 1:

Problemele 1, 2, 3.4

Randul 2:

Problemele 1, 2, 3.2, 3.4

Subiectul 2018Randul 1:

Problemele 1, 2, 3.3

Randul 2:

Problemele 1, 2, 3.1, 5


Pointeri

Orice variabila definita are o adresa de memorie, care aratalocul unde variabila respectiva este stocata ın memorie.

Un pointer este un tip de date care retine o adresa dememorie. O variabila de tip pointer poate sa retina o adresade memorie (probabil adresa unei alte variabile).

In pseudocod, o variabila de tip pointer este reprezentata de osageata ın sus: ↑

a: ↑ Intreg - a este o variabila care retine adresa unei altevariabile de tip Intregc: ↑ Colectie - c este o variabila care retine adresa uneivariabile de tip Colectieetc.


Pointeri II

Daca am un pointer, prin el pot accesa variabila adresa careiao am ın pointer (se numeste dereferentiere).

In pseudocod pentru dereferentiere folosim notatia [ ].

Daca a este un pointer la un Intreg, [a] reprezinta numarul dela adresa aDaca c este un pointer la o Colectie, [c] reprezinta colectia dela adresa c .


Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar

//va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199

O variabila de tip pointer care nu retine (ınca) o adresa valida,ın general este setat la valoarea NIL. NIL reprezinta o adresainvalida.


Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa

//va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa]

//va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar

//va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa

//va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa]

//va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri III

numar: Intreg //definim o variabila de tip Intregadresa: ↑Intreg //definim o variabila de tip pointer la un Intregnumar = 99adresa = @adresa variabilei numar //retinem adresa variabilei numarprint numar //va afisa 99print adresa //va afisa o adresa - de ex 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 99[adresa] = 199print numar //va afisa 199print adresa //va afisa aceeasi adresa ca ınainte, 12A961print [adresa] //va afisa valoarea variabilei de la adresa adresa, adica 199



Pointeri IV

Anumite limbaje de programare permit accesare adreselor dememorie (deci pot fi definite variabile de tip pointer), altelimbaje de programare nu permit acest lucru.

De exemplu ın C++, programatorul poate sa decida daca vreao variabila de tip Colectie sau o variabila de tip pointer laColectie.

In Java, nu putem accesa adresa de memorie unei variabile, sinici nu putem defini variabile de tip pointer.


Pointeri V

In Java nu putem accesa adresa de memorie a unei variabile.Astfel nu exista nici dereferentiere.

In schimb, orice variabila de tip clasa este retinuta prin adresaei.

Am discutat ca la tablouri se retine intern adresa primuluielement din tablou. La obiecte (variabile de tip clasa) internse retine adresa obiectului. Deci practic nu avem pointeri ınJava, pentru ca (aproape) tot e pointer (cu exceptia tipurilorprimitive: int, boolean, double, etc.).


Pointeri VI

Colectie col = new Colectie()//col este adresa unde e retinuta colectia, chiar daca nu ıl vedem asaSystem.out.println(col.dimensiune()) //va afisa 0Colecie col2 = col //col2 retine aceeasi adresa.col2.adauga(45)System.out.println(col.dimensiune()) //va afisa 1

In Java o variabila care nu retine nici-o adresa (ınca) seinitializeaza cu null


Lista ınlantuita

Am discutat ca Vectorul Dinamic rezolva dezavantajulprincipal al unui tablou simplu: necesitatea de a stabili de laınceput numarul de elemente.

Dar mai ramane un dezavantaj: de multe ori, vectorul ocupazona de memorie chiar daca nu sunt elemente acolo. Operatiacare mareste Vectorul Dinamic ın general dubleaza marimeatabloului (si capacitatea), si majoritatea pozitiilor nu suntocupate. Evident, ele pot fi ocupate pe parcurs, daca se totadauga elemente, dar daca nu sunt alte adaugari, atunciramane zona ocupata degeaba.

O alta problema la Vector Dinamic (si la tablou simplu) aparedaca trebuie sa adaugam elemente la ınceput, sau sa stergemelemente de la ınceput. In ambele situatii toate elementeletrebuie mutate.


Lista ınlantuita II

Lista ınlantuita este o structura de date care rezolva primaproblema, ea ocupa tot timpul doar atat spatiu cat estenecesar pentru elementele existente. Nu exista spatiu extra,pentru elementele care poate vor fi adaugate ın viitor.

Lista ınlantuita este alcatuita de fapt din noduri, fiecare nodcontine cate un element.

Aceste noduri care compun lista ınlantuita nu trebuie sa fie ınzone consecutive de memorie, ele pot fi oriunde ın memorie.


Lista ınlantuita III

Sa prespunem ca avem o lista ınlantuita cu urmatoarele 7noduri (ın fiecare nod vedem elementul retinut ın nod):

Care este problema cu acesta lista?

Nu stim care e primul elementNu stim care e ultimul elementNu stim ın ce ordine vin elementele


Lista ınlantuita IV

Pentru a putea retine ordinea elementelor, fiecare nod continepe langa elementul retinut si adresa nodului urmator (unpointer spre nodul urmator).

Ultimul nod din lista retine ca adresa nodului urmatorvaloarea NIL.


Lista ınlantuita V

Chiar daca nodurile nu sunt ın zone de memorie consecutive,ın general, pe desen, vom pune nodurile unul dupa altul:


Lista ınlantuita V

Lista din figura anterioara se numeste lista simplu ınlantuita,pentru ca fiecare nod are legatura spre nodul urmator. Existasi lista dublu ınlantuita ın care fiecare nod are legatura sprenodul anterior si urmator.

Deocamdata vom vorbi de lista simplu ınlantuita.

Am vazut ca prin legaturi (pointeri spre nodul urmator) putemstabili ordinea nodurilor. Ceea ce trebuie sa retinem pentru olista simplu ınlantuita, este adresa primului nod. Daca amadresa primului nod, de acolo pot ajunge la orice element.


Lista ınlantuita V


Lista simplu ınlantuita - reprezentare

Daca vrem sa implementam o lista simplu ınlantuita, avemnevoie de 2 structuri:

Nod:elem: TElemurm: ↑ Nod

ListaSimpluInlantuita:prim: ↑ Nod



Sa presupunem ca lst este o variabila de tipListaSimpluInlantuita care contine exact 3 elemente:

lst.prim -

adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem

- elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm -

adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem -

elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm -

adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem -

elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm -

adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem -

teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.




lst.prim - adresa primului nod din lista (pointer la nodul cu 52)[lst.prim].elem - elementul din primul nod (valoarea 52)[list.prim].urm - adresa celui de-al doilea nod (pointer la nodul cu 101)[[lst.prim].urm].elem - elementul din al 2-lea nod (valoarea 101)[[lst.prim].urm].urm - adresa celui de-al treilea nod (pointer la nodul cu 99)[[[lst.prim].urm].urm].elem - elementul din al 3-lea nod (valoarea 99)[[[lst.prim].urm].urm].urm - adresa celui de-al patrulea nod. Din moment ce nuexista decat 3 noduri, aceasta adresa este NIL[[[[lst.prim].urm].urm].urm].elem - teoretic al 4-lea element. Daca sunt doar 3elemente, eroare.


LSI - parcurgere

Evident, pentru a parcurge o lista ıntreaga ne trebuie ometoda mai generala decat .urm.urm.urm...

Vom considera o variabila de tip pointer la nod, si cu aceastavariabila vom parcurge lista.

//presupunem ca suntem ın clasa ListanodC: ↑ Nod //nodC va retine adresa unui nodnodC = this.prim //nodC retine primul nod din lstwhile nodC 6= NULL execute

elem = [nodC].elem //elementul din nodul curent@facem ceva cu elemnodC = [nodC].urm //trecem cu variabila nodC la nodul urmator

end while


LSI - parcurgere II

Initial, variabila nodC retine adresa primului nod din lista


LSI - parcurgere III

Dupa prima executie a instructiunii: nodC = [nodC].urm


LSI - parcurgere IV

Dupa a doua executie a instructiunii: nodC = [nodC].urm

Si tot asa mai departe, pana ajungem la ultimul element, careare ca urm valoarea NIL. Cand facem nodC = [nodC].urm,nodC devine NIL. Acum am terminat de parcurs toateelementele.


LSI - adaugare la ınceput

Sa presupunem ca vrem sa inseram un element nou laınceputul unei liste simplu ınlantuite.

De fiecare data cand inseram un element nou, trebuie sacream un nod nou ın care sa punem elementul, dupa caretrebuie sa setam niste legaturi ca nodurile sa vina ın ordineaın care vrem.

La lista ınlantuita adagarea sau stergerea unui element tottimpul implica doar setarea unor legaturi, niciodata nu vommuta elementele dintr-un nod ın altul (sau nu vom muta unnod la o alta adresa).



Daca pun element la ınceputul listei, atunci urmatorulelementului nou va fi prim-ul de pana acum, iar prim-ul listeiva fi elementul nou.

Trebuie sa consideram si cazul cand lista nu contine nici-unelement. In acest caz lst.prim are valoarea NIL si nodul deinserat va fi primul nod.



Adaugarea elementului 33 la ınceputul listei simple ınlantuite

Vom crea un nod nou (numit nodNou) ın care punemvaloarea 33.

Cu rosu sunt marcate legaturile noi care trebuie create laadaugare, iar cu fulger galben este marcata legatura care va fidesfacuta.



subalgorithm adaugaInceput( el: TElem) isnodNou: ↑ Nod //cream un nod nou...[nodNou].elem = el //...si ıi setam campurile[nodNou].urm = NILif this.prim == NIL then //lista e vida

this.prim = nodNouelse

[nodNou].urm = this.primthis.prim = nodNou

end ifend subalgorithm

Complexitate:

Θ(1)



subalgorithm adaugaInceput( el: TElem) isnodNou: ↑ Nod //cream un nod nou...[nodNou].elem = el //...si ıi setam campurile[nodNou].urm = NILif this.prim == NIL then //lista e vida




Complexitate: Θ(1)


LSI - adaugare la sfarsit I

Sa adaugam un element la sfarsitul unei liste simplu ınlantuite.

Trebuie sa parcurgem lista, nod cu nod, pana ajungem laultimul nod (cel care are campul urm egal cu NIL). Dacasuntem la ultimul nod, legam campul urm de nodul pe carevrem sa ıl inseram.


LSI - adaugare la sfarsit II

Adaugarea elementului 33 la sfarsitul listei simple ınlantuite

Vom crea un nod nou (numit nodNou) ın care punemvaloarea 33.

Avem nevoie de nodCurent cu care parcurgem nodurile panaajungem la ultimul nod.

Linia punctata arata parcurgerea cu nodCurent, iar cu rosusunt marcate legaturile noi care trebuie create.


LSI - adaugare la sfarsit III

subalgorithm adaugaSfarsit(el: TElem) isnodNou: ↑ Nod //cream un nod nou...[nodNou].elem = el //...si ıi setam campurile[nodNou].urm = NILif this.prim == NIL then //lista e vida


nodCurent: ↑ Nod //o variabila cu care vom parcurge listanodCurent = this.prim

while [nodCurent].urm 6= NIL executenodCurent = [nodCurent].urm

end while //nodCurent acum e ultimul nod[nodCurent].urm = nodNou



LSI -adaugare la sfarsit IV

Complexitate:

Θ(n) - unde n este numarul de elemente


LSI -adaugare la sfarsit IV

Complexitate: Θ(n) - unde n este numarul de elemente


LSI -adaugare pe pozitie I

Sa adaugam un element pe o anumita pozitie ın lista simpluınlantuita.

Prima data trebuie sa gasim pozitia. Plecand de la primulelement, parcurgem lista pana ajungem la pozitia ceruta. Neoprim cand gasim nodul dupa care trebuie sa inseram, altfelnu vom putea seta legaturile ın mod corect. Tratam separatcazul cand elementul trebuie inserat pe prima pozitie (ın acestcaz nu exista nod dupa care sa inseram). (cazul cand vrem sainseram dupa ultimul nod va fi acoperit de cazul general -exista nod dupa care inserez).


LSI - adaugare pe pozitie II

La acele operatii care lucreaza cu pozitii, trebuie sa verificamsi daca pozitia e corecta.

La Vector Dinamic aveam campul len, pe care l-am folosit saverificam daca o pozitie este valida.

Pentru a simplifica lucrurile, putem introduce si laListaSimpluInlantuita campul lungime.

Daca nu avem camp lungime, ın timp ce parcurgem listatrebuie sa verificam si daca am iesit din lista.

Deocamdata presupunem reprezentare fara campul lungime.


LSI - adaugare pe pozitie III

Adaugarea elementului 33 pe pozitia 4 (indexam de la 0).

Vom crea un nod nou (numit nodNou) ın care punem valoarea 33.

Avem nevoie de nodCurent cu care parcurgem nodurile pana ajungem laelementul dupa care inseram (elementul de pe pozitia 3).

Linia punctata arata parcurgerea cu nodCurent, cu rosu sunt marcatelegaturile noi care trebuie create, iar fulgerul galben marcheaza legaturacare va fi desfacuta.


subalgorithm adaugaPozitie(el: TElem, poz: integer) isif poz < 0 then

@arunca exceptie, pozitia nu poate fi negativaend ifnodNou: ↑ Nod //cream un nod nou...[nodNou].elem = el //...si ıi setam campurile[nodNou].urm = NILif poz == 0 then //vrem sa inseram pe prima pozitie


elsenodCurent: ↑ Nod //o variabila cu care vom parcurge listapozCurent : Intreg //pentru a numara pozitiilepozCurent = 0nodCurent = this.prim

while pozCurent < poz-1 AND nodCurent 6= NIL executenodCurent = [nodCurent].urmpozCurent = pozCurent + 1

end while //continuam pe pagina urmatoare


if pozCurent == poz - 1 AND nodCurent 6= NIL then//pozitia e valida

//nodCurent este nodul dupa care inseram//prima data setam legatura noului nod[nodNou].urm = [nodCurent].urm[nodCurent].urm = nodNou

end ifend if

end subalgorithm


LSI - adaugare pe pozitie IV

Complexitate:

O(n)


LSI - adaugare pe pozitie IV

Complexitate: O(n)


LSI - adaugare pe pozitie V

Ce se modifica daca am campul lungime ın reprezentarealistei?

Putem verifica la ınceput direct daca pozitia primita caparametru e o pozitie valida

Daca stim ca pozitia este valida, nu ne mai trebuie conditia ınciclu while cu nodCurent diferit de NIL.

De fapt, putem folosi un ciclu for ın loc de ciclu while.


subalgorithm adaugaPozitie(el:TElem, poz:Integer) isif poz < 0 OR poz > this.lungime then

@arunca exceptie, pozitie invalidaend ifnodNou: ↑ Nod //cream un nod nou...[nodNou].elem = el //...si ıi setam campurile[nodNou].urm = NILif poz == 0 then //vrem sa inseram pe prima pozitie

[nodNou].urm = this.primthis.prim = nodNouthis.lungime = this.lungime+ 1

elsenodCurent: ↑ Nod //o variabila cu care vom parcurge listanodCurent = this.prim

for i = 0, i < poz-1, 1 executenodCurent = [nodCurent].urm

end for //continuam pe pagina urmatoare


//nodCurent este nodul dupa care inseram//prima data setam legatura noului nod[nodNou].urm = [nodCurent].urm[nodCurent].urm = nodNou

this.lungime = this.lungime + 1end if

end subalgorithm


LSI - stergere de la ınceput I

Sa vedem cum putem sterge primul element dintr-o listasimplu ınlantiuta.

Daca vrem sa stergem primul element, pur si simplumodificam valoarea prim-ului, sa fie nodul urmator.

Evident, trebuie sa verificam sa nu avem lista vida (ın acestcaz nu putem sterge nimic).

Presupunem reprezentare fara campul lungime.


LSI - stergere de la ınceput II

Stergem primul element din lista (elementul 65).

Modificam valoarea prim-ului, sa arate spre al 2-lea nod.

Cu rosu este marcata legatura noua si fulgerul galben aratalegaturile sterse.


LSI - stergere de la ınceput III

subalgorithm stergeInceput() is:if this.prim != NIL then

this.prim = [this.prim].urmend if

end subalgorithm

Complexitate:

Θ(1)


LSI - stergere de la ınceput III

subalgorithm stergeInceput() is:if this.prim != NIL then

this.prim = [this.prim].urmend if

end subalgorithm

Complexitate: Θ(1)


LSI - stergere de la sfarsit I

Pentru a sterge ultimul element, trebuie sa parcurgem lista,pana ajungem la penultimul element. Legatura urm alpenultimul element este spre ultimul element, cel pe care vremsa stergem. Vom seta aceasta legatura la NIL pentru a rupelegatura cu ultimul element.

Ultimul element este cel care are urm egal cu NIL, penultimulelement este cel care are urm-ul urm-ului egal cu NIL.

Trebuie sa verificam ca lista sa nu fie vida (nu avem ce sterge)si sa nu aiba un singur element (nu avem penultim element).Daca lista are un singur element, acesta va fi sters.

Presupunem reprezentare fara campul lungime


LSI - stergere de la sfarsit II

Stergem ultimul element din lista (elementul 99)

Cu nodCurent ne deplasam pana la penultimul element (liniilepunctate)

Cu fulger galben este marcata legatura care este stearsa.


LSI - stergere de la sfarsit III

subalgorithm stergeSfarsit () is:if this.prim != NIL then

if [this.prim].urm == NIL then //avem un singur elementthis.prim = NIL

elsenodCurent: ↑ Nod //variabila cu care parcurgem listanodCurent = this.primwhile [[nodCurent].urm].urm != NIL execute

nodCurent = [nodCurent].urmend while //acum [[nodCurent].urm].urm este NIL[nodCurent].urm = NIL

end ifend if

end subalgorithm

Complexitate:

Θ(n) - unde n este numarul de elemente dinlista


LSI - stergere de la sfarsit III


if [this.prim].urm == NIL then //avem un singur elementthis.prim = NIL

elsenodCurent: ↑ Nod //variabila cu care parcurgem listanodCurent = this.primwhile [[nodCurent].urm].urm != NIL execute

nodCurent = [nodCurent].urmend while //acum [[nodCurent].urm].urm este NIL[nodCurent].urm = NIL

end ifend if

end subalgorithm

Complexitate: Θ(n) - unde n este numarul de elemente dinlista


LSI - stergere de la sfarsit IV

Exista o alta varianta de a parcurge lista, pentru a evita safolosim [[nodCurent].urm].urm.

Putem folosi pentru parcurgere 2 variabile de tip nod (de ex.nodCurent si nodAnterior), care vor retine adresele pentru 2noduri consecutive.

nodCurent este primul nod, nodAnterior este NILnodCurent este al 2-lea nod, nodAnterior este primul nodnodCurent este al 3-lea nod, nodAnterior este al 2-lea nod...nodCurent este ultimul nod, nodAnterior este penultimul nod


LSI - stergere de la sfarsit V

Dupa o iteratie (din parcurgere):

Dupa a 2-a iteratie (din parcurgere):


LSI - stergere de la sfarsit VI

Dupa a 3-a iteratie (din parcurgere):

Dupa ultima iteratie (din parcurgere):


LSI - stergere de la sfarsit VII


if [this.prim].urm = NIL then //avem un singur elementthis.prim = NIL

elsenodCurent: ↑ NodnodCurent = this.primnodAnterior: ↑ NodnodAnterior = NILwhile [nodCurent].urm != NIL execute

nodAnterior = nodCurentnodCurent = [nodCurent].urm

end while //acum nodCurent trebuie sters[nodAnterior].urm = NIL

end ifend if

end subalgorithm


LSI - stergere de pe pozitie I

Pentru a sterge un element de pe o pozitie, trebuie saparcurgem lista pana cand gasim nodul de dupa care stergem.

Daca am gasit nodul de dupa care stergem, pur si simplusetam campul urm al acestui nod, la urm-ul nodului urmator(care este nodul sters).

Trebuie sa verificam daca stergem elementul de pe primapozitie (este caz special, aici nu exista nod de dupa carestergem) si daca lista e vida (nu avem ce sterge).


LSI - stergere de pe pozitie II

Sa stergem elementul de pe pozitia 3 (numarul 73)

Folosim un nodCurent sa ne deplasam pe pozitia 2.

Setam legatura nodului de pe pozitia 2 la nodul de pe pozitia4.


LSI - stergere de pe pozitie III

subalgorithm stergePozitie(poz:integer) is:if this.prim != NIL then

if poz == 0 thenthis.prim = [this.prim].urm

elsenodCurent: ↑ NodnodCurent = this.primpozCurent: integerpozCurent = 0//continuam pe pagina urmatoare


LSI - stergere de pe pozitie IV

while pozCurent < poz - 1 AND nodCurent != NIL exec.nodCurent = [nodCurent].urmpozCurent = pozCurent + 1

end whileif pozCurent==poz-1AND nodCurent!=NILAND[nodCurent].urm!=NIL

th.[nodCurent].urm = [[nodCurent].urm].urm

end ifend if


Complexitate:

O(n) - unde n este numarul de elemente dinlista


LSI - stergere de pe pozitie IV

while pozCurent < poz - 1 AND nodCurent != NIL exec.nodCurent = [nodCurent].urmpozCurent = pozCurent + 1

end whileif pozCurent==poz-1AND nodCurent!=NILAND[nodCurent].urm!=NIL

th.[nodCurent].urm = [[nodCurent].urm].urm

end ifend if


Complexitate: O(n) - unde n este numarul de elemente dinlista


LSI - stergere de pe pozitie V

Exista si la acest algoritm varianta ın care folosim 2 variabilede tip nod: nodCurent si nodAnterior. Ne deplasam panacand nodCurent este nodul de sters, iar nodAnterior estenodul de dinaintea lui.

In acest caz, pentru a sterge elementul nodCurent, vom setaurm-ul lui nodAnterior la urm-ul lui nodCurent.


LSI - stergere de pe pozitie VI

subalgorithm stergePozitie(poz: integer) is://poz - pozitia de unde stergem. Presupunem ca poz >= 0

if this.prim != NIL thenif poz == 0 then

this.prim = [this.prim].urmelse

nodCurent: ↑ NodnodCurent = this.primnodAnterior: ↑ NodnodAnterior = NILpozCurent: integerpozCurent = 0//continuam pe pagina urmatoare


LSI - stergere de pe pozitie VII

while pozCurent < poz and nodCurent != NIL exec.nodAnterior = nodCurentnodCurent = [nodCurent].urmpozCurent = pozCurent + 1

end whileif pozCurent == poz AND nodCurent != NIL th.

[nodAnterior].urm = [nodCurent].urmend if

end ifend if

end subalgorithm

Complexitate:

O(n) - unde n este numarul de elemente dinlista


LSI - stergere de pe pozitie VII

while pozCurent < poz and nodCurent != NIL exec.nodAnterior = nodCurentnodCurent = [nodCurent].urmpozCurent = pozCurent + 1

end whileif pozCurent == poz AND nodCurent != NIL th.

[nodAnterior].urm = [nodCurent].urmend if

end ifend if

end subalgorithm

Complexitate: O(n) - unde n este numarul de elemente dinlista


LSI - Returnarea unui element de pe o pozitie

Pentru a returna un element de pe o pozitie, trebuie saparcurgem lista pana ajungem la pozitia respectiva.

Asemenea parcurgeri am facut si la adaugare pe pozitie, si lastergere de pe pozitie, numai atunci ne-am deplasat doar panala nodul de dinaintea pozitiei cerute. Acum ne vom deplasapana la pozitia ceruta.

Evident, trebuie sa verificam sa existe pozitia (daca nu existapozitia, nodul folosit pentru parcurgere - nodCurent - vadeveni NIL).


LSI - Returnarea unui element de pe o pozitie II

Vrem elementul de pe pozitia 4.

Folosim nodCurent care initial e pe pozitia 0, si ne deplasampana ajungem la pozitia 4.


LSI - Returnarea unui element de pe o pozitie III

function element (poz:Integer) is:if poz >= 0 then

nodCurent: ↑ NodnodCurent = this.primpozCurent: IntegerpozCurent = 0while pozCurent < poz AND nodCurent != NIL execute

pozCurent = pozCurent + 1nodCurent = [nodCurent].urm

end while//continuam pe pagina urmatoare


LSI - Returnarea unui element de pe o pozitie IV

if nodCurent != NIL thenreturn [nodCurent].elem

end ifend if//aruncam exceptie sau returnam NIL, pozitia nu exista

end function

Complexitate:

O(n)


LSI - Returnarea unui element de pe o pozitie IV

if nodCurent != NIL thenreturn [nodCurent].elem

end ifend if//aruncam exceptie sau returnam NIL, pozitia nu exista

end function

Complexitate: O(n)


LSI - Iterator

Cum putem defini un iterator pentru o lista simplu ınlantuita?

Un iterator este folosit pentru a parcurge o structura de date,element - cu - element. Orice iterator trebuie sa retina unelement curent (care difera de la o structura la alta)

Cum putem retine un element curent pentru o lista simpluınlantuita?


LST - Iterator II

La VectorDinamic am discutat ca elementul curent diniterator este un index, o pozitie din cadrul vectorului.

La lista ınlantuita nu e o idee buna sa retinem un index. Ooperatie al iteratorului este element, operatia care returneazaelementul curent. Daca iteratorul retine pozitia elementuluicurent (cum facem la Vector Dinamic), pentru a returnaelementul curent trebuie sa parcurgem toata lista de laınceput pana la pozitia respectiva.

La o lista ınlantuita, elementul curent din iterator este un nod.


LST - Iterator - Reprezentare

Un Iterator pentru o lista simplu ınlantuita poate fireprezentata ın modul urmator (structura Nod este ceafolosita si la lista) :

IteratorLSI:list: LSIcurent: ↑ Nod


LSI - Iterator - creeaza

Operatia creeaza trebuie sa initializeze campurile pentruiterator.

subalgorithm creeaza(lst) is://lst - este lista pentru care vrem sa cream iteratorul.

this.list = lstthis.curent = lst.prim

end subalgorithm

Complexitate: Θ(1)






end subalgorithm

Complexitate:

Θ(1)






end subalgorithm

Complexitate: Θ(1)


LSI - Iterator - element

Cum returnam elementul curent din iterator?

function element() is:returneaza [this.curent].elem

end function

Complexitate: Θ(1)





end function

Complexitate:

Θ(1)





end function

Complexitate: Θ(1)


LSI - Iterator - urmator

Cum trecem la elementul urmator?

subalgorithm urmator() is:this.curent = [this.curent].urm

end subalgorithm

Complexitate: Θ(1)





end subalgorithm

Complexitate:

Θ(1)





end subalgorithm

Complexitate: Θ(1)


LSI - Iterator - valid

Cum verificam daca elementul curent din iterator este valid?

function valid() is:if this.curent == NIL then

return falseelse

return trueend function

Complexitate: Θ(1)





return falseelse


Complexitate:

Θ(1)





return falseelse


Complexitate: Θ(1)


Lista dublu ınlantuita

Pana acum am discutat de lista simplu ınlantuita, ın carefiecare nod retine adresa nodului urmator.

Exista si lista dublu ınlantuita ın care fiecare nod retine adresanodului urmator si adresa nodului anterior.

Lista simplu ınlantuita poate fi parcursa ıntr-o singura directie(ınainte), lista dublu ınlantuita poate fi parcursa ın ambeledirectii (pot sa parcurg lista de la capat spre ınceput).


LDI - Exemplu

Fiecare nod are legatura pentru nodul urmator si anterior.

Legatura pentru urmator la ultimul nod este NIL

Legatura pentru anteriorul la primul nod este NIL

Nu retinem doar primul nod, ci si ultimul.


LDI - Reprezentare

Avem nevoie de 2 structuri si la LDI: Nod siListaDubluInlantuita

Nod:elem: TElemurm: ↑ Nodant: ↑ Nod

LDI:prim: ↑ Nodultim: ↑ Nod


LDI - Operatii

Operatiile sunt similare cu operatiile de la lista simpluınlantuita, trebuie doar sa setam mai multe legaturi si sa nuuitam ca retinem si ultimul nod (de exemplu cand adaug sausterg de la sfarsitul listei, se modifica valoarea ultimului nod).

Acele operatii care nu modifica structura listei (element,cauta, lungime, toate operatiile iteratorului) raman la fel ca lalista simplu ınlantuita.

Vom implementa cateva dintre operatiile pe lista dubluınlantuita ca sa vedem diferenta.


LDI - Creeaza

Operatia creeaza trebuie sa initializeze campurile listei.

subalgorithm creeaza() is:this.prim = NILthis.ultim = NIL

end subalgorithm

Complexitate:

Θ(1)


LDI - Creeaza

Operatia creeaza trebuie sa initializeze campurile listei.

subalgorithm creeaza() is:this.prim = NILthis.ultim = NIL

end subalgorithm

Complexitate: Θ(1)


LDI - AdaugaInceput I

Trebuie sa cream un nod nou, si sa-l punem la ınceputul listei.

Se va modifica prim-ul listei, dar daca lista era vida, atunci siultim-ul (daca lista este vida, adaugand un element nou, acelelement va fi si primul si ultimul element)

Trebuie sa setam si legatura pentru ant, nu doar urm.


LDI - AdaugaInceput II

Sa adaugam la ınceputul listei elementul 52.

Vom crea un nod nou, ın care punem elementul si care vadeveni primul nod.

Cu rosu sunt marcate legaturile noi, iar cu fulger galbenlegatura care va fi desfacuta.

Comparati figura cu cel de la adaugare ınceput la LSI.


LDI - Adauga Inceput III

subalgorithm adaugaInceput(el:TElem) is:nodNou: ↑ Nod //nodul nou[nodNou].urm = NIL[nodNou].ant = NIL[nodNou].elem = elif this.prim == NIL then

this.prim = nodNouthis.ultim = nodNou

else//ıncepem cu legaturile nodului nou[nodNou].urm = this.prim[this.prim].ant = nodNouthis.prim = nodNou


Complexitate:

Θ(1)


LDI - Adauga Inceput III

subalgorithm adaugaInceput(el:TElem) is:nodNou: ↑ Nod //nodul nou[nodNou].urm = NIL[nodNou].ant = NIL[nodNou].elem = elif this.prim == NIL then

this.prim = nodNouthis.ultim = nodNou

else//ıncepem cu legaturile nodului nou[nodNou].urm = this.prim[this.prim].ant = nodNouthis.prim = nodNou


Complexitate: Θ(1)


LDI - Adauga Sfarsit

La adaugare la sfarsit facem similar ca la adaugarea laınceput.

Nu trebuie sa parcurgem lista ca sa ajungem la ultimulelement (cum am facut la lista simplu ınlantuita) pentru caavem ultimul nod retinut.


LDI - Adaugare pe pozitie I

La adaugare pe pozitie trebuie sa parcurgem lista, pana candajungem la pozitia unde vrem sa adaugam.

Nu trebuie sa ne oprim neaparat la nodul dupa care inseram(cum am facut la lista simplu ınlantuita), pentru ca putem sane deplasam ın ambele directii. Dar, ınainte de implementaretrebuie sa ne decidem daca ne oprim la nodul ınainte saudupa care adaugam. Noi vom implementa varianta candcautam nodul dupa care adaugam.

Trebuie sa verificam daca inseram pe prima sau ultima pozitie(ın acest caz se modifica valoarea prim sau ultim)


LDI - Adaugare pe pozitie II

Sa adaugam elementul 52 pe pozitia 3.


LDI - Adaugare pe pozitie III

subalgorithm adaugaPozitie(el:TElem, poz: Integer) is://poz - pozitia pe care adaugam. Presupunem ca poz >= 0

nodNou: ↑ Nod[nodNou].urm = NIL[nodNou].ant = NIL[nodNou].elem = elif poz == 0 then //adaugam pe prima pozitie

if this.prim == NIL then //si lista e vidathis.prim = nodNouthis.ultim = nodNou

else //adaugam pe prima poz, dar lista nu e vida//continuam pe pagina urmatoare


LDI - Adaugare pe pozitie IV

[nodNou].urm = this.prim[this.prim].ant = nodNouthis.prim = nodNou

end ifelse//trebuie sa cautam nodul dupa care inseram

nodCurent: ↑ NodnodCurent = this.primpozCurent: IntegerpozCurent = 0while pozCurent < poz - 1 AND nodCurent != NIL execute

pozCurent = pozCurent + 1nodCurent = [nodCurent].urm

end while//continuam pe pagina urmatoare



//inseram dupa nodCurent, daca existaif pozCurent == poz - 1 AND nodCurent 6= NIL then

if nodCurent == this.ultim then //adaugam dupa ultimul[nodNou].ant = nodCurent[nodCurent].urm = nodNouthis.ultim = nodNou

else[nodNou].ant = nodCurent[nodNou].urm = [nodCurent].urm[[nodCurent].urm].ant = nodNou[nodCurent].urm = nodNou

end ifend if


Complexitate:

O(n)



//inseram dupa nodCurent, daca existaif pozCurent == poz - 1 AND nodCurent 6= NIL then

if nodCurent == this.ultim then //adaugam dupa ultimul[nodNou].ant = nodCurent[nodCurent].urm = nodNouthis.ultim = nodNou

else[nodNou].ant = nodCurent[nodNou].urm = [nodCurent].urm[[nodCurent].urm].ant = nodNou[nodCurent].urm = nodNou

end ifend if


Complexitate: O(n)


LDI - Stergere ınceput

Cand vrem sa stergem primul element, pur si simplu setamprim-ul listei sa arate spre nodul urmator.

Trebuie sa verificam ca lista sa nu fie vida (nu avem ce sterge)sau sa nu aiba un singur element (ın acest caz lista devinevida si se modifica si prim si ultim).


LDI - Stergere sfarsit I

Cand vrem sa stergem ultimul element, nu trebuie saparcurgem lista, folosim campul ultim.

Setam ultim la ant-ul ultimului nod.

Trebuie sa verificam ca lista sa nu fie vida (nu avem ce sterge)sau sa nu aiba un singur element (ın acest caz lista devinevida si se modifica si prim si ultim).


LDI - Stergere sfarsit II

subalgorithm stergeSfarsit() is:if this.prim != NIL then

if this.prim == this.ultim then //lista are un singur elementthis.prim = NILthis.ultim = NIL

elsethis.ultim = [this.ultim].ant[this.ultim].urm = NIL

end ifend if

end subalgorithm

Complexitate:

Θ(1)


LDI - Stergere sfarsit II

subalgorithm stergeSfarsit() is:if this.prim != NIL then

if this.prim == this.ultim then //lista are un singur elementthis.prim = NILthis.ultim = NIL

elsethis.ultim = [this.ultim].ant[this.ultim].urm = NIL

end ifend if

end subalgorithm

Complexitate: Θ(1)


LDI - Stergere de pe pozitie I

Pentru a sterge un element de pe o pozitie, trebuie sa luamun nod curent si sa ne deplasam cu acel nod pana la pozitiade unde stergem.

Putem sa ne deplasam pana la elementul sters, nu trebuie sane oprim ınainte de pozitie (ca la lista simplu ınlantuita).

Pentru a sterge elementul trebuie sa setam 2 legaturi(urmatorul anteriorului si anteriorul urmatorului).

Trebuie sa verificam daca stergem primul sau ultimul element(se modifica prim sau ultim).


LDI - Stergere de pe pozitie II

Sa stergem elementul de pe pozitia 2.


PROGRAMARE S˘I STRUCTURI DE DATEmarianzsu/Postuniv/Curs/Curs05.pdfPROGRAMARE S˘I STRUCTURI DE DATE...

Documents

Transcript of PROGRAMARE S˘I STRUCTURI DE DATEmarianzsu/Postuniv/Curs/Curs05.pdfPROGRAMARE S˘I STRUCTURI DE DATE...