Sunteți pe pagina 1din 5

Laborator Nr.

5:
Structuri de date 2

Intocmit de: Dobrinas Alexandra


Indrumator: Asist. Drd. Danciu Gabriel
November 3, 2011

I.

NOT
IUNI TEORETICE
A.

Liste

Lista reprezint
a cea mai simpl
a structura de date nlantuita. Se folosesc doua tipuri de liste:
liste simplu nl
antuite;
liste dublu nl
antuite;

B.

Liste simplu nl
antuite

Pot fi definite ca fiind o secvent


a de obiecte alocate dinamic, n fiecare obiect se pastranduse atat informatia
util
a c
at si o referint
a c
atre succesorul sau din lista. Exista o multitudine de moduri prin care se poate
implementa aceast
a structur
a de date,ns
a cel mai utilizat mod este prin definirea unei clase cu doi membri,
unul n care se retine informaia util
a si unul In care se retine adresa urmatorului element din lista.
1
2
3
4
5
6
7
8
9
10
11
12

public

class

public

LinkedList

int data ;
LinkedList

next ;

LinkedList ()

data = 0 ;
next = null ;
}
}

Se observ
a c
a membrul next este de acelasi tip de date ca si clasa, acesta pentru ca urmatorul element din
list
a este tot de acest tip de date. Pe l
ang
a acesti membri se mai pot adauga si altii care sa contina diverse
informatii, n functie de aplicatia care cere utilizarea unei astfel de structuri.
Urm
atorul exemplu ilustreaz
a crearea si afisarea unei liste simplu nlantuite. Initial a fost creat un element cu ajutorul constructorului, informaatia din acest element a primit valoarea 23, iar pentru crearea
urm
atorului element s-a instantiat membrul next, s.a.m.d. Aceasta operatie poate fi numita ,,alipirea
urm
atorului element de elementul curent. Pentru a parcurge lista se foloseste un iterator.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

c l a s s LinkedListDemo {
p u b l i c s t a t i c void main ( S t r i n g a r g s [ ] )
{
L i n k e d L i s t l i s t = new L i n k e d L i s t ( ) ;
l i s t . d a t a =23;
l i s t . n e x t = new L i n k e d L i s t ( ) ;
l i s t . next . data = 1 0 ;
l i s t . n e x t . n e x t = new L i n k e d L i s t ( ) ;
l i s t . next . next . data = 4 9 ;
// p a r c u r g e r e a

listei

de

la

primul

element

LinkedList i t e r a t o r = l i s t ;
do
{
System . o u t . p r i n t l n ( i t e r a t o r . d a t a ) ;
}
w h i l e ( ( i t e r a t o r = i t e r a t o r . n e x t ) != n u l l ) ;
}
}

Un alt mod de folosire al listelor nl


antuite este prin declararea si retinerea primului element din list
a:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class

LinkedList2

int data ;
LinkedList2
LinkedList2
public

next ;
head ;

LinkedList2 ()

head = t h i s ;
next = null ;
d a t a =0;
}
public

LinkedList2 ( LinkedList2

head ) {

t h i s . head = head ;

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

next = null ;
d a t a =0;
}
}

// / / / / / / / / / / / / / / / / / / / / / / / / / / / /

class

LinkedList2Demo {

public

static

void main ( S t r i n g

args [ ] )

L i n k e d L i s t 2 l i s t = new L i n k e d L i s t 2 ( ) ;
l i s t . head = l i s t ;
l i s t . d a t a =23;
l i s t . n e x t = new L i n k e d L i s t 2 ( l i s t ) ;
l i s t . next . data = 1 0 ;
l i s t . n e x t . n e x t = new L i n k e d L i s t 2 ( l i s t ) ;
l i s t . next . next . data = 4 9 ;
// p a r c u r g e r e a l i s t e i de l a p r i m u l
w h i l e ( l i s t . n e x t != n u l l )
{

element

System . o u t . p r i n t l n ( l i s t . d a t a ) ;
l i s t = l i s t . next ;
}
System . o u t . p r i n t l n ( l i s t . d a t a ) ;
l i s t = l i s t . head ;
while

( l i s t . next

!= n u l l ) {

System . o u t . p r i n t l n ( l i s t . d a t a ) ;
l i s t = l i s t . next ;
}
System . o u t . p r i n t l n ( l i s t . d a t a ) ;
}
}

Se observ
a c
a prin retinerea primunul element al listei se poate ajunge mult mai repede si mai usor la
primul element din list
a. De asemenea, se poate observa ca acest mod de construire al unei liste nu este
eficient, deoarece, n cazul unei liste cu sute sau chiar mii de elemente adaugarea noilor elemente va fi
imposibil de realizat. De aceea, ad
augarea unui element nou precum si stergerea unui element sunt operatii
specifice pentru lucrul cu liste al
aturi de modificarea informatiei utile, modificarea legaturii dintre elemente,
c
autarea unui element n liste, aflarea pozitiei unui element.
C.

Liste dublu nl
antuite

In cazul n care se doreste parcurgerea listei si n celalalt sens (si nu doar de la predecesor la succesor),
avem lista dublu nl
antuit
a. Aceasta p
astreaz conceptele listei simplu nlantuite, cu specificarea ca fiecare
element al listei mai contine o referint
a si catre elementul precedent. Un mod de declararea al unei astfel de
liste este urm
atorul:
1
2
3
4
5
6
7
8
9
10
11
12
13

public

c l a s s Nod {

p r i v a t e Nod n e x t ;
p r i v a t e Nod p r e v ;
private int data ;
p u b l i c Nod ( i n t
{
this . data =
this . next =
this . prev =
}

data ,

Nod n e x t , Nod p r e v )

data ;
next ;
prev ;

Operatile specifice lister simplu nl


antuite se mentin si pentru listele dublu, doar ca trebuie sa se tin
a cont
si de leg
atura prev.
D.

Framework -ul Java pentru Colectii

Java pune la dispozitia utilizatorilor o serie de interfete si clase ce pot fi folosite pentru crearea si utilizarea
diferitelor colectii de date. Printre acestea amintim:
interfata Collection - are definite metode pentru o serie de operatii ce se aplica unei colectii (detalii
aici)
3

interfata Iterator - iteratorul este acel obiect ce permite parcurgerea colectiilor (detalii aici)
interfata List - interfat
a ce implementeaza Collection. Exista doua clase ce implementeaza aceast
a
interfat
a: ArrayList si LinkedList. Interfata List ofera posibilitatea de a lucra ordonat, deci permite
p
astrarea secvential
a a elementelor dintr-o colectie (detalii aici)
clasa ArrayList - clasa este echivalentul clasei Vector, dar sub forma unei colectii. Un ArrayList este
o colectie de elemente indexate ntr-o anumita ordine, dar nu neaparat sortate. (detalii)
clasa LinkedList - aceasta este implementarea listei dublu nlantuite. (detalii)

E.

Multimi - Interfata Set

Interfata Set reprezint


a un grup de elemente fara duplicate. Nu exista o conditie anume ce impune acest
lucru, ci implement
arile din clasele Set, sunt cele care impun aceasta conditie. Interfata Set deriv
a din
Collections, deci va implementa aceleasi metode ca si aceasta interfata. Un element, aflat deja n multime,
nu mai poate fi modificat. API-ul interfetei se poate gasii aici

F.

Clasa HashSet

Face parte din interfata Set si are ca operatii specifice urmatoarele:


ad
augarea elementelor;
stergerea elementelor;
verificare dac
a lista este goal
a;
verificare daca un anumit obiect este continut tn lista;
Un exemplu de utilizare al clasei HashSet este urmatorul:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import j a v a . u t i l . A r r a y L i s t ;
class Point {
public
public

int
int

x;
y;

public

Point

( int x ,

int

y) {

this . x = x ;
this . y = y ;
}
public

boolean

equ als ( Object

o) {

if

( ! ( o instanceof Point ) )
return f a l s e ;
Point pt = ( Point ) o ;
return ( ( p t . x == t h i s . x ) &&

( p t . y==t h i s . y ) ) ;

}
public

int

return

hashCode ( )

17 t h i s . x +23 t h i s . y +43;

}
public S t r i n g t o S t r i n g ( ) {
return x = +x+ y = +y +

i d = + hashCode ( )+ \n ;

}
}
// / / / / / / / / / / / / / / / / / / /
public
{
public
Set

class
static

Multimi
void main ( S t r i n g

args [ ] )

s e t = new H a s h S e t ( ) ;

// Adaug i n m u l t i m e
s e t . add (new P o i n t ( 1 , 2 ) ) ;
s e t . add (new P o i n t ( 2 , 1 ) ) ;
s e t . add ( c ) ;

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// S t e r g un e l e m e n t
s e t . remove ( c ) ;

din

multime

// Marimea u n e i m u l t i m i
int s i z e = set . s i z e () ;
System . o u t . p r i n t l n ( s i z e ) ;
// Adaug un e l e m e n t c e e x i s t a
s e t . add (new P o i n t ( 1 , 2 ) ) ;

deja

// f a r a a a v e a i n s a e f e c t
size = set . size () ;
System . o u t . p r i n t l n ( s i z e ) ;
// V e r i f i c a m d a c a un e l e m e n t e s t e d e j a i n m u l t i m e
boolean b = s e t . c o n t a i n s (new P o i n t ( 2 , 1 ) ) ; // t r u e
System . o u t . p r i n t l n ( b ) ;
b = set . contains (c) ;
System . o u t . p r i n t l n ( b ) ;

//

false

// Parcurgem m u l t i m e a
Iterator it = set . iterator () ;
while ( i t . hasNext ( ) ) {
// s i a f i s a m e l e m e n t e l e
Object element = i t . next ( ) ;
System . o u t . p r i n t l n ( e l e m e n t ) ;
}
}
}

II.

TEME DE LABORATOR

1. Editati, compilati si lansati n executie aplicatile prezentate la I B.


2. Creati o list
a dublu nl
antuit
a si afisati-o.
3. Editati, compilati si lansati n executie aplicatile prezentate la I F.
4. Se d
a o clas
a de numere complexe. Folosind clasa HashSet creati o lista n care sa se retina numere
complexe. Ad
augati minim 5 astfel de numere si realizati un meniu prin care sa se rezolve urmatoarele
cerinte:
Afisati dimensiunea listei.
Verificati daca un num
ar citit exista n lista. Daca nu exista, adaugati-l si afisati noua lungime a
listei.
Eliminati un num
ar din list
a.
Afisati suma numerelor din list
a.
Afisati elementele listei.