Curs, Lab, Quiz - SD 2020

Universitatea
Politehnica
Bucureşti
"States of Matter", by D.L. Goodstein
Structuri de Date:
Introducere
alexandru.olteanu@upb.ro
STRUCTURI DE DATE – CURSUL 1 – Introducere
De ce aceasta facultate?
Ce face aceasta facultate? Ce NU face aceasta facultate?
?? ??!?!?!
2
Februarie 2020
People profile
Gasiti cat mai multe modalitati Ce urmeaza in urmatoarea secventa?

de a folosi un pantof 1, 2, 5, 10, 17, 26, ?
3
Februarie 2020
Sistemele de calcul au nevoie de structură
The Matrix
4
Februarie 2020
De ce acest curs?
5
Februarie 2020
Situarea cursului
6
Februarie 2020
C vs C++
C C++
Object-Oriented no yes
Learning curve quick recap PC min. 3 weeks
mai simplu: de ce nu imi mai complex: de ce nu imi
iese structura de date  compileaza programul 
Clean code void*  data structures as classes 
char arrays  string 
Libraries several: link STL and many more
Aplicatii Embedded Gaming
7
Februarie 2020
Despre cursul de SD
8
Februarie 2020
Cum obținem aceste competente?
9
Februarie 2020
Lessons Learned - Team Work
10
Februarie 2020
Lessons Learned – Work Ethics
11
Februarie 2020
Lessons Learned – Teorie vs Cod
Teorie Cod
12
Februarie 2020
Universitatea
Politehnica
Bucureşti
C Programming
C Programming
• Inclusion of headers
• Definition of types
• Declaration of global variables #include <stdio.h>
• Definition of functions // global variables should be avoided
• The main function char* name = "Joe";
void sayHello(char* name) {

printf("Hello %s\n",name);
}
int main() {
char* name = "Joe";
sayHello(name);
return 0;
}
Global variables should be avoided when unnecessary

http://c2.com/cgi/wiki?GlobalVariablesAreBad
14
Februarie 2020
C Compiling process
https://www.geeksforgeeks.org/compiling-a-c-program-behind-the-scenes/
15
Februarie 2020
Universitatea
Politehnica
Bucureşti
Alocarea Memoriei
Alocare statica si dinamica
Alocare statica Alocare dinamica

Tipuri de baza
Date omogene
Struct
• Alocare statica:
• memoria este alocata de compilator, nu se mai poate modifica la runtime
• pe Stack
• Alocare dinamica:
• memoria este alocata la runtime
• pe Heap
17
Februarie 2020
Tipuri de baza – alocare statica

Tipuri de baza
Struct
Date omogene
int a;
a = 10;
sizeof(a)
sizeof(int)
18
Februarie 2020
Tipuri de baza – alocare dinamica

Tipuri de baza
Struct
Date omogene
int *ptr = malloc(sizeof (int));

*ptr = 10;
free(ptr);
memory leaks; no garbage collector

19
Februarie 2020
Struct – alocare statica

Tipuri de baza
Struct
Date omogene
struct Masina {
char* culoare;
int cai_putere;
long pret;
};
struct Masina o_masina;

o_masina.pret;
20
Februarie 2020
Struct – alocare dinamica

Tipuri de baza
Struct
Date omogene
struct Masina {
char* culoare;
int cai_putere;
long pret;
};
struct Masina* o_masina = malloc(sizeof(struct Masina));

o_masina->pret = 15;
free(o_masina);
21
Februarie 2020
Array – alocare statica

Tipuri de baza
Struct
Date omogene
char name[10] = “Mike";

char name[] = “Mike";
22
Februarie 2020
Array – alocare dinamica

Tipuri de baza
Struct
Date omogene
int *ptr = malloc(10 * sizeof (int));

int *ptr = calloc(10,sizeof (int));
free(ptr);
23
Februarie 2020
Metode de alocare dinamica
24
Februarie 2020
Alocarea dinamica a matricelor

Care este diferenta intre array1 si array2? 
int **array1 = malloc(nrows * sizeof(int *));

for(i = 0; i < nrows; i++)
array1[i] = malloc(ncolumns * sizeof(int));

array2[0] = malloc(nrows * ncolumns * sizeof(int));
array2[i] = array2[0] + i * ncolumns;
25
Februarie 2020
Alocarea dinamica a matricelor

Care este diferenta intre array1 si array2? 

array1[i] = malloc(ncolumns * sizeof(int));

array2[0] = malloc(nrows * ncolumns * sizeof(int));
Dar ce parere aveti de array3 si array4? 
int *array3 = malloc(nrows * ncolumns * sizeof(int));
int (*array4)[NCOLUMNS] = malloc(nrows * sizeof(*array4));
http://c-faq.com/aryptr/dynmuldimary.html
26
Februarie 2020
Bibliografie
• Cap 3 din Cormen, Thomas H. Introduction to algorithms.

MIT press, 2009.
• Cap 3 din Kleinberg, Jon, and Eva Tardos. Algorithm design.
Pearson Addison-Wesley, 2006, disponibil la acest link
• Cap 4 din Manber, Udi. Introduction to algorithms: a
creative approach. Addison-Wesley Longman Publishing Co.,
Inc., 1989, disponibil la acest link
• The C Programming Language, Kernighan, Brian; Ritchie,
Dennis
• https://www.learn-c.org/
27
Februarie 2020
Start with the Why
Simon Sinek, “Start with the Why” TED Talk
28
Februarie 2020
Red Team – student vs professional
Michael Seibel on advice and bias
29
Februarie 2020
The pressure on college students
Sir Ken Robinson, “Bring on the learning revolution” TED Talk
30
Februarie 2020
Universitatea
Politehnica
Bucureşti
ArrayList vs LinkedList
Universitatea
Politehnica
Bucureşti
Abstract Data Types

STRUCTURI DE DATE – CURSUL 2 - ArrList vs LnkList
Abstract Data Type
Abstract Data Type A set of data values and associated

operations that are precisely specified
(ADT) independent of any particular
implementation.
https://xlinux.nist.gov/dads//HTML/abstractDataType.html
http://aroma.vn/web/wp-content/uploads/2016/11/code-co
mplete-2nd-edition-v413hav.pdf
- Section 6.1
3
Februarie 2020
Liste
Valori:
• Orice tip, dar toate de acelasi tip
Operatii:
• Operatii cu elemente (modifiers)
• Operatii cu lista in ansamblu (operations)
4
Februarie 2020
Ce operatii ati vrea sa faceti cu liste?
• adaugare element la sfarsit

• parcurgere / traversare (iterate)
• pozitia unui element
• eliminarea unui element cu valoarea X
• eliminarea elementului pe pozitia i
• sortare
ToDo List
5
Februarie 2020
Operatiile unei liste

Operatii cu elemente:
• adaugare: add / push / insert
• citire: get / read
• extragere: pop / extract
• pozitia unui element: index / find
• stergere: remove / erase
• modificare: update
6
Februarie 2020

Adaugare in L la inceput la sfarsit pozitie arbitrara
elementul X push_front(X) push_back(X) insert(i,X)
N elemente (X[N] Xn sau List Xn) insert(0,Xn) insert(len(L),Xn) insert(i,Xn)
concat(Xn,L) concat(L,Xn)
7
Februarie 2020

Citire din L la inceput la sfarsit poz. arbitrara
elementul X X=get_front() X=get_back() X=get(i)
N elemente (X[N] sau List Xn) Xn=get(0,N-1) Xn=get(len(L)-N,len(L)-1) Xn=get(i,i+N)
Extragere din L la inceput la sfarsit pozitie arbitrara

elementul X X=pop_front() X=pop_back() X=extract(i)
N elemente (X[N] sau List Xn) Xn=extract(0,N-1) Xn=extract(len(L)-N, Xn=extract(i,i+N)
len(L))
Pozitie element prima aparitie ultima aparitie

elementul X i=findFirst(X) i=findLast(X)
N elemente (X[N] sau List Xn) i=findFirst(Xn) i=findLast(Xn)
8
Februarie 2020

Stergere din L la inceput la sfarsit pozitie arbitrara
elementul X erase(0) erase(len(L)-1) erase(i)
N elemente (X[N] sau List Xn) erase(0,N-1) erase(len(L)-N,len(L)-1) erase(i,i+N-1)
Modificare in L la inceput la sfarsit pozitie arbitrara

elementul X update(0,X) update(len(L)-1,X) update(i,X)
9
Februarie 2020

Operatii cu liste in ansamblu:
• iterate: perform action for each element
• sort: arrange elements in specified order
• reverse: put elements in exactly reversed order
• merge: combine two lists with given order
• unique: keep only unique values
• concat: append one list at the end of another
• swap: exchange content with the content of other list (same type)
• assign: replace content with the content of other list
• Shuffle, rotate, compare, count de elemente, umplere (random, paddin

• slice, repozitionare, swap elem, filtrare, agregare de elemente, frecvent
• Stergere lista, operatii except element
10
Februarie 2020
Alte structuri de date se bazeaza pe liste
11
Februarie 2020
Blockchain
https://blockgeeks.com/guides/bitcoin-developer/
12
Februarie 2020
Infinite lists
13
Februarie 2020
Universitatea
Politehnica
Bucureşti
ArrayList vs LinkedList
Comparatie ArrayList vs LinkedList
ArrayList LinkedList
15
Februarie 2020
acces la element
stocare in memorie
inserare element
• la inceput
• la sfarsit
• arbitrar
stergere element
• la inceput
• la sfarsit
• arbitrar
redimensionare
16
Februarie 2020
acces la element direct parcurgere
stocare in memorie 2
contigua aleator
inserare element
1 • la inceput shift si eventual realloc direct 3
• la sfarsit eventual realloc direct
• arbitrar shift si eventual realloc parcurgere si direct
stergere element
• la inceput shift si eventual realloc direct
• la sfarsit eventual realloc direct
• arbitrar shift si eventual realloc parcurgere si direct
redimensionare realocare nu e necesar
17
Februarie 2020 La punctul 3, explicati in 2-3 propozitii cine este mai bun si de ce
Variante de implementare
ArrayList with dynamic array
struct ArrayList {
size_t size;
size_t reallocSize;
size_t
void count;
add_elem(struct ArrayList* list, int X){
int* data;
if (list->count==list->size) {
}; // realloc
list->size += list->reallocSize;
structlist->data
ArrayList*= create(int dim) {
realloc(list->data, list->size * sizeof(int));
struct
} ArrayList *list =
...malloc(sizeof(struct ArrayList));
} list->size = dim;
list->reallocSize = dim;
list->count = 0;
list->data = calloc(list->size, sizeof(int));
}
18
Februarie 2020
LinkedList: Lista Simplu Inlantuita (LSI)
struct Node {
int info;
struct Node *next;
};
struct LinkedList {
struct Node *head;
int size;
};
struct LinkedList* create() {

struct LinkedList* list = malloc(sizeof(struct LinkedList));
list->head = NULL;
list->size = 0;
}
19
Februarie 2020
LinkedList add_first
void add_first(struct LinkedList* list, int X) {

struct Node* new;
if (list==NULL) {
return
}
new = (struct Node*)malloc(sizeof(struct Node));

new->info = X;
new->next = list->head; // ce se intampla
list->head = new; // daca lista este goala?
list->size++;
}
20
Februarie 2020
LinkedList add_last
void add_last(struct LinkedList* list, int X) {

struct Node *new, *curr;
if (list==NULL) {
return
}
new = (struct Node*)malloc(sizeof(struct Node));

new->info = X;
new->next = NULL;
curr = list->head;
while (curr->next != NULL) {
curr = curr->next;
}
curr->next = new;
list->size++;
Februarie 2020 21
LinkedList remove_first
void remove_first(struct LinkedList* list) {

struct Node* first;
if (list==NULL || list->head==NULL) {
return
}
first = list->head;
list->head = first->next; // ce se intampla daca lista are 1 elem?
free(first);
list->size--;
}
22
Februarie 2020
LinkedList remove_last
void remove_first(struct LinkedList* list) {

struct Node *last, *prev;
if (list==NULL || list->head==NULL) {
return
if (list->head->next==NULL) {
}
free(list->head);
list->head = NULL;
last = list->head->next;
}
prev = list->head;
while (last->next != NULL) {
prev = last;
last = last->next;
}
prev->next = NULL;
free(last);
list->size--;
Februarie 2020 23
LinkedList print
void print(struct LinkedList* list) {

struct Node *curr;
if (list==NULL) {
return
}
curr = list->head;
while (curr != NULL) {
printf("%d ", curr->info));
curr = curr->next;
}
printf(“\n”);
}
24
Februarie 2020
Al k-lea element de la sfarsit
Se da o lista simplu-inlantuita.
De cate avansari in lista este nevoie
pentru a accesa al k-lea element de la sfarsit?
25
Februarie 2020
26
Februarie 2020
27
Februarie 2020
k
a
28
Februarie 2020
k
b a
29
Februarie 2020
k
b a
30
Februarie 2020
Universitatea
Politehnica
Bucureşti
LinkedList part 2
STRUCTURI DE DATE – CURSUL 3 - LinkedList part2
struct Node {
int info;
struct Node *next;
};
+ last->next = NULL
struct LinkedList {
struct Node *L;
...
}
2
Martie 2020
LinkedList: Lista Dublu Inlantuita (LDI)
struct Node {
int info;
struct Node *next, *prev;
};
+ last->next = NULL
struct LinkedList { L->prev = NULL
struct Node *L;
...
}
3
Martie 2020
LinkedList: Lista Simplu-Inlantuita Circulara (LSC)
struct Node {
int info;
struct Node *next;
};
+ last->next = L
struct LinkedList {
struct Node *L;
...
}
4
Martie 2020
LinkedList: Lista Dublu-Inlantuita Circulara (LDC)
struct Node {
int info;
struct Node *next, *prev;
};
+ last->next = L
struct LinkedList { L->prev = last
struct Node *L;
...
}
5
Martie 2020
Folosirea pointerilor
first last
De ce ar fi util sa tinem doi pointeri?
Node* last = L;
last = last->next;
}
6
Martie 2020
first last
Node* last = L;
last = last->next;
}
7
Martie 2020
first last
Node* first = last->next;
8
Martie 2020
first last
Node* last = L->prev;
9
Martie 2020
Adaugare element la sfarsit

first last
void add_last(int X) {
struct Node *aux = malloc(sizeof(struct Node));
aux->info = X;
aux->next = NULL;
if (L.is_empty()) {
first = last = aux;
} else {
last->next = aux;
last = aux;
}
} 10
Martie 2020

first last
aux->info = X;
aux->next = NULL;
aux->prev = last; // works if list is empty too
if (L.is_empty()) {
first = last = aux;
} else {
last->next = aux;
last = aux;
}
Martie 2020} 11

first last
aux->info = X;
aux->next = first; // works if list is empty too
if (L.is_empty()) {
first = last = aux;
} else {
last->next = aux;
last = aux;
}
}
12
Martie 2020

first last
aux->info = X;
aux->next = first; // works if list is empty too
aux->prev = last; // works if list is empty too
if (L.is_empty()) {
first = last = aux;
} else {
last->next = aux;
first->prev = aux;
last = aux;
} 13
Martie 2020}
Mentinerea listelor sortate (pt LSI)

Special type of add:
Node* p = L;
while (p != NULL && p->info < x)
p = p->next;
if (p == NULL)
add_last(x);
else {
Legatura de la prev la paux
paux = malloc(sizeof(struct Node));
paux->info = x;
paux->next = p;
}
also note insertion sort 14

Martie 2020
Mentinerea listelor sortate (pt LDI)

Special type of add:
Node* p = L;
while (p != NULL && p->info < x)
p = p->next;
if (p == NULL)
add_last(x);
else {
paux = malloc(sizeof(struct Node));
paux->info = x;
paux->next = p;
paux->prev = p->prev;
if (p->prev != NULL) p->prev->next = paux;

else pfirst = paux;
p->prev = paux;
}
also note insertion sort 15

Martie 2020
Iterare si iteratori
first last
Node* p = first;
while (p->next != NULL) {
printf(“%d”,p->info);
p = p->next;
}
16
Martie 2020
first last
Node* p = first;
while (p->next != NULL) {
p = p->next; Reverse
}
Node* p = last;
while (p->prev != NULL) {
p = p->prev;
} 17
Martie 2020
first last
Node* p = first; Node* p = first;

do { if (!L.isempty()) {
printf(“%d”,p->info); do {
p = p->next; printf(“%d”,p->info);
} while (p!= first);
p = p->next;
} while (p!= first);
}
18
Martie 2020
first
Node* p = first->prev; Node* p = first;

if (!L.isempty()) { if (!L.isempty()) {
do { do {
printf(“%d”,p->info); printf(“%d”,p->info);
p = p->prev; p = p->next;
} while (p!= first->prev); } while (p!= first);
} }
19
Martie 2020
Liste Dublu Inlantuite in practica
https://kernelnewbies.org/FAQ/LinkedLists
20
Martie 2020
Universitatea
Politehnica
Bucureşti
Dictionar
STRUCTURI DE DATE – CURSUL 4 - Dictionar
Dictionare in viata de zi cu zi
2
Martie 2020
Folosirea Dictionarelor
Dictionary / Map / Associative Array
.Net, Python JavaScript, PHP
Java, C++
3
Martie 2020
• cheie
• valoare
4
Martie 2020
• cheie
• valoare
PHP
5
Martie 2020
Folosirea Dictionarelor pentru a cauta

Operatia principala este de a gasi un element pentru care stim cheia (lookup)
6
Martie 2020
Folosirea Dictionarelor pentru a cauta

Dar pentru a cauta, trebuie populat Dictionarul sau creat un index (indexing)
7
Martie 2020 http://www.tomshardware.co.uk/forum/2054-63-should-disable-disk-indexing
Retelistica: routing table
8
Martie 2020
Abstract Data Type

Dictionary ADT
Operatii:
• put(key,value)
• remove(key)
• get(key)
• has_key(key)
9
Martie 2020
Cum functioneaza un Dictionar
put(key, value):
adaugă în dicționar o nouă valoare și o asociază unei anumite chei
dacă perechea există deja, valorea este înlocuită cu cea nouă
remove(key):
elimina din dictionar cheia (si valoarea asociata acesteia) key
get(key):
întoarce valoarea asociată cheii
dacă perechea nu există, întoarce corespunzător o eroare pentru
a semnala acest lucru
has_key(key):
întoarce TRUE dacă există cheia respectivă în dicționar
întoarce FALSE dacă nu există cheia respectivă în dicționar
10
Martie 2020
Problema stocarii unui dictionar
Cum reprezint in memorie un Dictionar cu key int si value int?

dict.put(2,15); int container[10];
dict.put(7,3); container[key] = value;
15 3
0 1 2 3 4 5 6 7 8 9
Dar in aceste cazuri?

dict.put(10001234,1);
dict.put(”zece”,10);
11
Martie 2020
HashTable (tabel de dispersie)
http://www.eecs.wsu.edu/~ananth/CptS223/Lectures/hashing.pdf 12
Martie 2020
Necesitatea unui Hash
Hash function:
• maps data of arbitrary length
to data of a fixed length
• needs to be quick
• reduce collisions
13
Martie 2020
Coliziuni
Many items are mapped to fewer items
14
Martie 2020
Tratarea coliziunilor
Metode pentru tratarea coliziunilor:

- înlănțuire directă (direct chaining):
valorile care au aceeasi cheie se pun intr-o lista
- linear probing:
cand o valoare are aceeasi cheie ca alta, se cauta prima pozitie libera
https://en.wikipedia.org/wiki/Hash_table
15
Martie 2020
Alte functii ale unui Hash
• Index data (lookup)

• Compare large amounts of data (download integrity)
• Cryptographic apps (storing passwords)
• Generate (seemingly) random strings
16
Martie 2020
Alte functii ale unui Hash
17
Martie 2020
Universitatea
Politehnica
Bucureşti
Implementare
Universitatea
Politehnica
Bucureşti
Implementarea din scheletul de laborator

https://ocw.cs.pub.ro/courses/sd-ca/laboratoare/lab-04
Universitatea
Politehnica
Bucureşti
Performanta unui
HashTable
Numere prime in Hash functions
Hashtable cu N buckets, adica index intre [0 , N-1]
hash(key) = f(key) % N
Daca se intampla doua lucruri:

1. f(key) are predispozitia de a da numere multiplu de D
2. N este un divizor al lui D
atunci un anumit bucket va fi favorizat ducand la dezechilibru
Pentru a minimiza 1 sau 2 se pot folosi numere prime
21
Martie 2020
Functii Hash bune pentru strings
%N %N
(Weiss)
a b c d 394 2987074
d c b a 394 3077374
a a d d 394 2986144
A b c d 394 61079524
a = 31
22
Martie 2020
Hash functions – ongoing discussion
• Hash functions are continuously improving

• Further reading:
• https://blogs.msdn.microsoft.com/dcook/2007/09/10/hash-func
tions-tables-and-primes-oh-my/
• http://www.cs.columbia.edu/~allen/S14/NOTES/hash.pdf
23
Martie 2020
Universitatea
Politehnica
Bucureşti
Stiva si Coada
alexandru.olteanu@cs.pub.ro
Universitatea
Politehnica
Bucureşti
Quiz
STRUCTURI DE DATE – CURSUL 5 - Stiva si Coada
Quiz 1
struct item
{
int data;
struct item * next;
};
int f(struct item *p)

{
return ( (p == NULL) || (p->next == NULL) ||
(( p->data <= p->next->data) && f(p-
>next)) );
}
For a given linked list p, the function f returns 1 if and only if:
A. the list is empty or has exactly one element
B. the elements in the list are sorted in non-decreasing order of data value
C. the elements in the list are sorted in non-increasing order of data value
D. not all elements in the list have the same data value.
3
Martie 2020
Quiz 2
Given pointer to a node X in a singly linked list. Only one pointer is given,
pointer to head node is not given, can we delete the node X from given
linked list?
• Yes
• No
struct node *temp = X->next;

X->data = temp->data;
X->next = temp->next;
free(temp);
4
Martie 2020
Quiz 3
void traverse(struct Node *head)

{
while (head->next != NULL)
{
printf("%d ", head->data);
head = head->next;
}
}
Which of the following is FALSE about above function?

1. The function may crash when the linked list is empty
2. The function doesn't print the last node when the linked list is not empty
3. The function is implemented incorrectly because it changes head
5
Martie 2020
Quiz 4
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* head_ref is a double pointer which points to head (or start) pointer

of linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
/*ADD A STATEMENT HERE*/
6
Martie
} 2020
Universitatea
Politehnica
Bucureşti
Stiva si Coada
cazuri de utilizare
Modelarea unor situatii reale
8
Martie 2020
Stive in functionarea calculatoarelor

Call Stack
void DrawSquare (int[] coords) {

…
void DrawLine (…);
void DrawLine (…);
…
}
int main(){
…
DrawSquare (coords);
…
}
9
Martie 2020
Stack Trace
10
Martie 2020
Recursivitate si stive
#include <iostream>
using namespace std;
int fib(int x) {
if (x <= 1) {
return 1;
} else {
return fib(x-1)+fib(x-2);
}
}
int main() {
cout << fib(5) << endl;
}
11
Martie 2020
Stack Overflow
• Too many calls (infinite recursion)
• Very large stack variables
• Attacks
12
Martie 2020

Memory Stack
• Static vs Dynamic
• Thread vs Process
• Growing direction
13
Martie 2020

Software Stack
14
Martie 2020

Protocol Stack
15
Martie 2020
Cozi in functionarea calculatoarelor
Modelul Client-Server
16
Martie 2020

Batch System
17
Martie 2020
Problema Producator-Consumator
19
Martie 2020
Job Scheduler
20
Martie 2020

Queing Theory
Little's Law: the average number of customers

in the store L, is the effective arrival rate λ,
times the average time that a customer spends
in the store W
Store: 400 visitors/h x 0.75h = 300 visitors capacity

Batch system: 50 jobs in queue / 5 jobs/h = 10h average job wait in queue
21
Martie 2020
Universitatea
Politehnica
Bucureşti
Stiva si Coada
tipuri abstracte de date
Cum functioneaza o stiva

peek
(top)
isEmpty
push(x)
Adds the element x at the top of the stack
pop()
Removes the element from the top of the stack and returns it
Returns an error if the stack is empty
peek()
Returns (but does not remove) the element at the top of the stack
isEmpty()
Returns 1 if the stack is empty and 0 otherwise
The axioms are given implicitly – they determine the expected

behavior of the stack for a given sequence of operations
23
Februarie 2017
Cum functioneaza o stiva peek

(top)
isEmpty
1
2 while (!a.isEmpty()){
a.pop();
3
}
4
a a
b.push(a.pop())
c.push(a.peek())
1 1 a.push(b.peek())
2 2 1 2
a b c a b c
24
Martie 2020

(top)
isEmpty
b.push(a.pop())
c.push(a.pop())
1 1 c.push(b.pop())
2 2
a b c a b c
1 1
2 2
3 3
a b c a b c
25
Martie 2020

(top)
isEmpty
b.push(a.pop())
c.push(a.pop())
1 1 c.push(b.pop())
2 2
a b c a b c
1 1
2 1 2
3 3 2 3
a b c a b c a b c
26
Martie 2020
Implementarea unei stive cu o lista
push push_front
pop pop_front
peek get_front / *first
is_empty is_empty / size == 0 / first == last
27
Martie 2020
STRUCTURI DE DATE – CURSUL 5 – Stiva si Coada
Cum functioneaza o coada
enqueue(x)
Adds the element x at the tail of the queue
dequeue()
Removes the element from the head of the queue and returns it
Returns an error if the queue is empty
front()
Returns (but does not remove) the element at the head of the queue
isEmpty()
Returns 1 if the queue is empty and 0 otherwise

behavior of the queue for a given sequence of operations
28
Februarie 2017
front front
3 2 1 4 3 2
a a.dequeue()
a
a.enqueue(4)
a.enqueue(4)
a.dequeue()
29
Martie 2020
enqueue(1);
enqueue(2);
for (int i = 0; i < 3; i++) front
{
int a = dequeue(); 192 24
int b = front();
enqueue( ( a + 2 ) * b );
}
30
Martie 2020
Implementare cu LinkedList
enqueue push_back
dequeue pop_front
peek get_front / *first
is_empty is_empty / size == 0 / first == last
31
Martie 2020
Implementare cu ArrayList si circular
32
Martie 2020
Universitatea
Politehnica
Bucureşti
Stiva si Coada
aplicatii
Turnurile din Hanoi
1 1
2 1 2
3 3 2 3
a b c a b c a b c
1 1
… 1 …
N-1 … N-1
N N N-1 N
a b c a b c a b c34
Martie 2020
Paranthesis Checking
Given a string S composed of the characters ‘(‘, ‘)’, ‘[‘, ‘]’, ‘{‘, ‘}’
(round bracket, square bracket and curly bracket),
determine if the parantheses are correctly balanced
S=“([()[{([]()){}}[[]]]{}])[]({})” is correctly balanced
S1=“([]({)})”, S2=“[{{}(())([]{“, S3=“[(){}]]” are not correctly balanced
Algorithm
We use a stack
We traverse the string from left to right
• We push on the stack every open bracket
• For every closed bracket, the bracket at the top of the stack
must be an open bracket of the same type (and the stack
must not be empty) => then we pop the open bracket from the stack
In the end, the stack must be empty
35
Martie 2020
#include <stdio.h>
#include <string.h>
#include “stack.h”
char s[200]="([{()[]}(()[{}()])])(){}[{{()[]}()}]";
int error = 0;
int main() {
Stack<char> stk;
return 0;
}
36
Martie 2020
#include <stdio.h>
#include <string.h>
char s[200]="([{()[]}(()[{}()])])(){}[{{()[]}()}]";
int error = 0;
int main() {
Stack<char> stk;
for (int i = 0; i < strlen(s); i++) {

…
}
…
return 0;
}
37
Martie 2020
#include <stdio.h>
#include <string.h>
char s[200]="([{()[]}(()[{}()])])(){}[{{()[]}()}]";
int error = 0;
int main() {
Stack<char> stk;

if (s[i] == '(' || s[i] == '[' || s[i] == '{')
stk.push(s[i]);
else if (stk.isEmpty()) {
error = 1; break; // Empty stack
} else {
…
}
}
…
return 0;
}
38
Martie 2020
#include <stdio.h>
#include <string.h>
char s[200]="([{()[]}(()[{}()])])(){}[{{()[]}()}]";
int error = 0;
int main() {
Stack<char> stk;

if (s[i] == '(' || s[i] == '[' || s[i] == '{')
stk.push(s[i]);
} else {
if ((s[i] == ')' && stk.peek() != '(') ||
(s[i] == ']' && stk.peek() != '[') ||
(s[i] == '}' && stk.peek() != '{')) {
error = 1; break; // Wrong paranthesis
}
stk.pop();
}
}
…
return 0;
}
39
Martie 2020
#include <stdio.h>
#include <string.h>
char s[200]="([{()[]}(()[{}()])])(){}[{{()[]}()}]";
int error = 0;
int main() {
Stack<char> stk;

if (s[i] == '(' || s[i] == '[' || s[i] == '{')
stk.push(s[i]);
} else {
if ((s[i] == ')' && stk.peek() != '(') ||
(s[i] == ']' && stk.peek() != '[') ||
(s[i] == '}' && stk.peek() != '{')) {
error = 1; break; // Wrong paranthesis
}
stk.pop();
}
}
if (!error && !stk.isEmpty())
break; // Stack not empty at the end
else if (!error)
printf("OK\n");
return 0;
40
Martie
} 2020
Notatii matematice pentru expresii

Forma prefixata Forma infixata Forma postfixata
(Forma poloneza) (Forma poloneza inversa)
+34 3+4 34+
3 4
41
Martie 2020

+34 3+4 34+
2+4-5
+ 5
2 4
42
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+ 5
2 4
43
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
2 + (4 - 5)
2 -
4 5
44
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
2 -
4 5
45
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
!((A + B) * A)
+ A
A B
46
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
!*+ABA !((A + B) * A) AB+A*!
+ A
A B
47
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
!*+ABA !((A + B) * A) AB+A*!
(A + B) * C * (B + A)
* +
+ C B A
A B
48
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
!*+ABA !((A + B) * A) AB+A*!
**+ABC+BA (A + B) * C * (B + A) AB+C*BA+*
* +
+ C B A
A B
49
Martie 2020

+34 3+4 34+
-+245 2+4-5 24+5-
+2-45 2 + (4 - 5) 245-+
!*+ABA !((A + B) * A) AB+A*!
**+ABC+BA (A + B) * C * (B + A) AB+C*BA+*
Transformare
Evaluare
50
Martie 2020
Transformare forma infixata -> postfixata
51
Martie 2020
Evaluare forma postfixata Pentru operatori binari

(la operatori unari 1 operand)
52
Martie 2020
Radix Sort
non-comparative integer sorting algorithm
53
Martie 2020
Radix Sort - LSD

MSD?
54
Martie 2020
Universitatea
Politehnica
Bucureşti
Stiva și Coada
structuri de date
înrudite
Priority Queue
56
Martie 2020
Cum functioneaza o coada cu prioritati
enqueue(x)
Adds the element x to the priority queue
dequeue()
Removes the element with the highest priority in the queue and returns it
Returns an error if the queue is empty
front()
Returns (but does not remove) the element with the highest priority
in the queue
isEmpty()
Returns 1 if the queue is empty and 0 otherwise

57
Februarie 2017
Priority Queue vs Queue and Stack
In ce ordine trebuie adaugate elementele

2 intr-o coada si intr-o coada cu prioritati
1
a
b ca scoaterea lor sa se faca la fel pentru
cele doua structuri de date?
3
c 4 3 2 1
4 d c b a
d
58
Martie 2020
Priority Queue vs Queue and Stack
In ce ordine trebuie adaugate elementele

2 intr-o stiva si intr-o coada cu prioritati
1
a
b ca scoaterea lor sa se faca la fel pentru
cele doua structuri de date?
3
c 4 3 2 1
4 d c b a
d
59
Martie 2020
Dequeue (coada cu dublu acces)

(or Double Ended Queue, or Deque)
60
Martie 2020
Dequeue (coada cu dublu acces)

(or Double Ended Queue, or Deque)
61
Martie 2020
Cum functioneaza o coada cu dublu acces
add_to_front(x)
Adds the element x to the front of deque
add_to_rear(x)
Adds the element x to the rear of deque
remove_from_front()
Removes the element from the front of the deque and returns it
remove_from_rear(x)
Removes the element from the rear of the deque and returns it

62
Martie 2020
Deque vs Queue and Stack
63
Martie 2020
Deque vs Queue and Stack
64
Martie 2020
Stack vs Queue
out in
enqueue = in.push
if out.isEmpty refill out from in refill out from in:

dequeue = out.pop
while !in.isEmpty
out.push(in.pop)
if out.isEmpty refill out from in
front = out.peek
isEmpty = in.isEmpty && out.isEmpty

65
Martie 2020
Stack vs Queue
stack made with two queues
push = A.enqueue
pop =
while !A.isEmpty pop efficient form?
elem = A.dequeue
if !A.isEmpty
B.enqueue(elem)
switch names of A and B
return elem http://stackoverflow.com/questions/688276/implement-stack-using-two-queues 66
Martie 2020
Universitatea
Politehnica
Bucureşti
Grafuri – Reprezentare si Parcurgeri

STRUCTURI DE DATE – Grafuri - Reprezentare si Parcurgeri
Grafuri in viata de zi cu zi
2
Martie 2020
Grafuri in viata de zi cu zi
3
Martie 2020
Graful ca tip abstract de date
4
Martie 2020
G = (V, E) G = (X,U)
• a set V of vertices or nodes • X este o mulțime finită și nevidă de

• a set E of edges or lines elemente numite noduri sau vârfuri
• U este o mulțime de perechi (ordonate sau
neordonate) de elemente din X numite
muchii (dacă sunt perechi neordonate) sau
arce (dacă sunt perechi ordonate)
Both vertices and edges can have extra

edges
information associated to them (e.g. name,
cost)
5
Martie 2020
Operatii:
• Gestiunea elementelor (adaugare / stergere nod sau muchie)
• Parcurgeri
• Complement / Inversare
• Join / Union
• Edge Contraction
edges
6
Martie 2020
Graf neorientat Graf orientat

G(X,U) X – noduri X – varfuri
U – muchii (perechi neorientate de noduri) U – arce (perechi orientate de noduri)
Undirected graph Directed graph

G(V,E) V – vertices or nodes X – vertices or nodes
U – edges (pairs of undirected vertices) U – arcs (pairs of directed vertices)
7
Martie 2020
Universitatea
Politehnica
Bucureşti
Reprezentarea
Grafurilor
Reprezentarea Grafurilor
Adjacency matrix
A = an NxN matrix
A[i][j] = 1 if the edge (i,j) occurs in the graph (i.e. the vertices i
and j are connected by an edge), and 0 otherwise for undirected
graphs
A[i][j] = 1 if there is a directed arc from i to j for directed graphs
A is symmetrical (A[i][j] == A[j][i]) for undirected graphs
9
Martie 2020
Reprezentarea Grafurilor
Lists of neighbors
An array of N linked-lists
The list L[i] contains all the neighbors of the vertex i
In the case of directed graphs, the neighbors of a vertex are
considered to be those nodes j such that the arch i->j exists
10
Martie 2020
Recapitulare Grafuri
Spuneti despre graful reprezentat de

matricea de adiacenta din fig. daca
(a)este orientat sau neorientat;
(b)este ciclic sau aciclic (in cazul in care
este ciclic mentionati ciclul);
(c)contine drum de la nodul B la nodul F
sau nu (daca da, mentionati drumul).
11
Martie 2020
Spuneti despre graful reprezentat de lista de vecini din fig. daca

(a) este orientat sau neorientat;
(b) contine sau nu ciclu Hamiltonian (trece exact o data prin
fiecare nod); daca da, precizati ciclul;
(c) contine sau nu drum de la nodul 0 la nodul 2 (daca da,
mentionati drumul);
(d) mentionati nodurile conform unei parcurgeri in latime
pornind din nodul 0.
12
Martie 2020
Implementarea Grafurilor - container

Which is better? (adjacency matrix or list of neighbours)
Depinde de densitate
13
Martie 2020
Implementarea Grafurilor
14
Martie 2020
Universitatea
Politehnica
Bucureşti
Parcurgerea Grafurilor
Parcurgerea Grafurilor (Traversals)
Breadth-First Search (BFS)

Mark all the vertices as not visited and initialize an empty queue Q
Starting vertex S => insert S into a queue Q (Q.enqueue(S)) and mark S
as visited
While Q is not empty:
x = Q.dequeue()
For y in Neighbors(X):
If (y has not been marked as visited) then
Mark y as visited
Q.enqueue(y)
BFS can be used for computing shortest paths in the graph

http://ocw.cs.pub.ro/courses/sd-ca/resurse/visualization
16
Martie 2020

BFS can be used for computing shortest paths in the graph
(with uniform weights)
17
Martie 2020
Depth-First Search (DFS)

Mark all the vertices as not visited
Starting vertex S => call dfs(S)
dfs(x)
Mark x as visited
For y in Neighbors(X):
If (y has not been marked as visited) then call dfs(y)
DFS is the building block for many more advanced algorithms

A simple application: check if a graph is connected
http://ocw.cs.pub.ro/courses/sd-ca/resurse/visualization
18
Martie 2020
STRUCTURI DE DATE – Grafuri - Reprezentare si parcurgeri
BFS/DFS folosind 3 stari pentru noduri

colorarea nodurilor: pe parcurs ce algoritmul avansează, se colorează
nodurile în felul următor:
• alb - nodul este nedescoperit încă
(aka nu a fost inca pus in coada / stiva)
• gri - nodul a fost descoperit dar nu toti vecinii lui au fost descoperiti
(aka inca este in coada / stiva)
• negru - toti vecinii nodului au fost descoperiti
(aka a fost scos din coada / stiva)
Utilitate in explicatie si in algoritmi:

• Detectarea ciclurilor in grafuri orientate
19
Martie 2020
STRUCTURI DE DATE – Grafuri - Reprezentare si parcurgeri
DFS cu timpi de descoperire si finalizare
Asocierea unui “timestamp” (0..2N-1 pt un graf cu N noduri) pentru

descoperirea si finalizarea fiecarui nod:
• Detectarea muchiilor inapoi (si a punctelor de articulatie)
20
Martie 2020
STRUCTURI DE DATE – Grafuri – Reprezentare si parcurgeri
Comparatie parcurgeri
BFS DFS
Cicluri
Componente conexe
Aplicatii
Complexitate:
- Iteratii
- Spatiu
21
Martie 2020
STRUCTURI DE DATE – Grafuri – Reprezentare si parcurgeri
Comparatie parcurgeri
BFS DFS
Cicluri DA DA
Componente conexe DA DA
Aplicatii Cel mai scurt drum Sortare topologica
Complexitate:
- Iteratii |E| |E|
- Spatiu ≤|V| ≤|V| La fel!
22
Martie 2020
Universitatea
Politehnica
Bucureşti
Structuri de Date – CURSUL 7 –

Grafuri: proprietati si aplicatii
alexandru.olteanu@cs.pub.ro
STRUCTURI DE DATE – CURSUL 7 - Grafuri: proprietati si aplicatii
Notiuni de data trecuta

G(X,U) X – noduri X – varfuri
U – muchii (perechi neorientate de noduri) U – arce (perechi orientate de noduri)

G(V,E) V – vertices or nodes X – vertices or nodes
U – edges (pairs of undirected vertices) U – arcs (pairs of directed vertices)
2
Aprilie 2020
Which of the following is an advantage of adjacency list

representation over adjacency matrix representation of a graph?
a) In adjacency list representation, space is saved for sparse

graphs.
b) DFS and BSF can be done in O(V + E) time for adjacency list
representation. These operations take O(V^2) time in
adjacency matrix representation. Here V and E are number of
vertices and edges respectively.
c) Adding a vertex in adjacency list representation is easier than
adjacency matrix representation.
3
Aprilie 2020
Pentru graful de mai sus:

- Dati o parcurgere in adancime din nodul 0
- Dati o parcurgere in latime din nodul 0
4
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Tipuri speciale de
Grafuri
Graf complet
un graf complet este un graf neorientat simplu în care fiecare pereche
de noduri distincte este conectată printr-o muchie unică.
un digraf complet este un graf orientat în care fiecare pereche de

noduri distincte este conectată printr-o pereche de muchii unice (una în
fiecare direcție).
KN: N(N-1) / 2 muchii
7
Aprilie 2020
https://en.wikipedia.org/wiki/Complete_graph
Clique
A clique is a subset of vertices of an undirected graph such that its induced subgraph is
complete
A maximal clique is a clique that cannot be extended by including one more adjacent
vertex (some authors define cliques in a way that requires them to be maximal)
• 23 × 1-vertex cliques (the vertices),

• 42 × 2-vertex cliques (the edges),
• 19 × 3-vertex cliques (light and dark
blue triangles), and
• 2 × 4-vertex cliques (dark blue areas).
https://en.wikipedia.org/wiki/Clique_(graph_theory) 8
Aprilie 2020
Alte grafuri cu nume
Cycles:
https://en.wikipedia.org/wiki/Gallery_of_named_graphs
9
Aprilie 2020
Grafuri bipartite
a bipartite graph (or bigraph) is a graph whose

vertices can be divided into two disjoint sets U
and V (that is, U and V are each
independent sets) such that every edge connects
a vertex in U to one in V
studenti si materii
10
Aprilie 2020
DAG (Directed Acyclical Graph)

Util pentru a modela relatii intre entitati care se pot
aseza pe o axa liniara:
• Timp: relatii intre evenimente istorice
• Inaltime: scurgerea apei
• Gestionarea codului: repositories and branches
• Executia unui program: apeluri de functii
source sink
11
Aprilie 2020
Isomorphic Graphs
Two graphs are isomorphic if a bijection exists between the vertex sets
of G and H such that edges are preserved
https://en.wikipedia.org/wiki/Graph_isomorphism
12
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Proprietati ale
Grafurilor
Gradele nodurilor
Gradul nodului = Grad interior = numarul de
numarul de muchii arce care intra intr-un varf
incidente unui nod
(buclele se numara de Grad exterior = numarul de
doua ori) arce care ies dintr-un varf
Degree = number of In-Degree = number of arcs

edges incident to the going into a node
vertex, with loops
counted twice Out-Degree = number of
arcs coming out of a node
14
Aprilie 2020
Gradele nodurilor
Doua noduri sunt Doua varfuri sunt adiacente
adiacente daca sunt daca sunt unite de un arc.
unite de o muchie
Intre varfurile de la capetele
unui arc se stabileste o
relatie de predecesor –
succesor.

Un nod si o muchie Un varf si un arc sunt
sunt incidente daca incidente daca varful se afla
nodul se afla la unul la unul din capetele arcului.
din capetele muchiei
15
Aprilie 2020
Puncte de articulatie si muchii critice

Nod Muchie
Punct de articulatie = Punte sau muchie critica =
nod (varf) a cărui muchie (arc) a(l) unui graf a
eliminare duce la cărui eliminare duce la
creşterea numărului de creşterea numărului de
componente (tare) componente (tare) conexe
conexe
Vertex Edge
Cut vertex = vertex Bridge = edge (arc) that,

that, when eliminated, when eliminated, generates
generates more more (strongly) connected
(strongly) connected components
components
16
Aprilie 2020
Componente conexe
connected components
(componente conexe) strongly connected components
(componente tare conexe)
O componentă tare conexă a grafului orientat G este o mulţime maximală de

vârfuri U inclusă în V, astfel încât, pentru fiecare pereche de
vârfuri u şi v din U avem atât drum de la u la v cât şi drum de la v la u
17
Aprilie 2020
Cicluri in grafuri
ciclu = drum care are drept capete un același vârf

ciclu simplu = fara repetitii
18
Aprilie 2020
Cicluri in grafuri
ciclu eulerian dacă trece prin toate muchiile

grafului G, exact o dată.
19
Aprilie 2020
Cicluri in grafuri
ciclu hamiltonian dacă este simplu și trece prin

toate nodurile grafului G, exact o dată
Fara repetitii
puzzle in which such a path along the

polyhedron edges of an dodecahedron was
sought (the Icosian game).
20
Aprilie 2020
Raza si Diametru
• The distance between two nodes is defined as the number of
edges on the shortest path between the vertices
• The eccentricity ecc(v) of v in G is the greatest distance
from v to any other node.
• The radius rad(G) of G is the value of the smallest eccentricity.
• The diameter diam(G) of GG is the value of the greatest
eccentricity.
• The center of G is the set of nodes v such that ecc(v)=rad(G)
Aprilie 2020 ? 21
Chromatic Number
The chromatic number of a graph G is the smallest number of colors
needed to color the vertices of G so that no two adjacent vertices share
the same color.
http://mathworld.wolfram.com/ChromaticNumber.html
22
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Aplicatii pe Grafuri
Complementare
The complement or inverse of a graph G is a graph H on the same
vertices such that two distinct vertices of H are adjacent if and only
if they are not adjacent in G. That is, to generate the complement of a
graph, one fills in all the missing edges required to form a complete
graph, and removes all the edges that were previously there.
https://en.wikipedia.org/wiki/Complement_graph
24
Aprilie 2020
Transpunere
The transpose[2] or reverse[3] of a directed graph G is another directed
graph on the same set of vertices with all of the edges reversed
compared to the orientation of the corresponding edges in G
https://en.wikipedia.org/wiki/Transpose_graph
25
Aprilie 2020
Sortare topologica
Aplicatii:
• Ordinea cursurilor
• Make: dependente intre targeturi
26
Aprilie 2020 • etc.
Sortare topologica
Kahn
27
Aprilie 2020
Sortare topologica
DFS
28
Aprilie 2020
Sortare topologica
Care dintre urmatoarele nu este rezultatul unei sortari topologice:

a) 1 2 3 4 5 6
b) 1 3 2 4 5 6
c) 1 3 2 4 6 5
d) 3 2 4 1 6 5
29
Aprilie 2020
Verificare graf bipartit
30
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Structuri de Date – Arbori si Arbori

Binari
STRUCTURI DE DATE – Arbori si Arbori Binari
Drawing time
1. Desenati graful
2. Daca numele de familie incepe cu o litera dintre:

A-M: parcurgere latime (BFS)
N-Z: parcurgere adancime (DFS)
a) Ce structura de date se foloseste in algoritm?

b) Desenati aplicarea algoritmului pe graful alaturat
pornind din nodul 0:
• evolutia datelor in structura
• in ce ordine sunt vizitate nodurile
3. Alegeti unul dintre algoritmii de sortare topologica:

a) Mentionati cum se numeste algoritmul ales
b) Explicati cum se aplica pe graful alaturat
2
APRILIE 2020
Grafuri vs Arbori
un arbore este un graf neorientat conex aciclic
3
APRILIE 2020
Aplicatii ale arborilor
http://www.wikiwand.com/ro/Dinastia_Basarabilor
4
APRILIE 2020
5
APRILIE 2020
6
APRILIE 2020
Computer Network Topology

7
APRILIE 2020
Wireless Sensor Network Topology

8
APRILIE 2020
Spatiul starilor
9
APRILIE 2020
Binary Space Partitioning

10
APRILIE 2020
• Cautarea unui element

Search Trees:
• Cautarea unui interval de elemente
11
APRILIE 2020
Heap: • Extragerea celui mai mare element

• Extragerea top K cele mai mari elemente
12
APRILIE 2020
Grafuri vs Arbori
13
APRILIE 2020
Grafuri vs Arbori vs Arbori Binari
Un arbore binar este

un arbore în care fiecare nod are cel mult doi succesori (fii)
(de obicei, succesorii se numesc „nodul stânga” și „nodul dreapta”)
14
APRILIE 2020
Grafuri vs Arbori vs Arbori Binari
15
APRILIE 2020
Exercitii Arbori Binari
In a complete k-ary tree, every node has exactly k children

or no child. The number of leaves in such a tree with n
internal nodes is:
a) nk
b) (n – 1) k+ 1
c) n( k – 1) + 1
d) n(k – 1)
16
APRILIE 2020
The number of leaf nodes in a rooted tree of N nodes, with

each node having 0 or 3 children is:
a) N/2
b) (N-1)/3
c) (N-1)/2
d) (2N+1)/3
17
APRILIE 2020
Arborele ca tip abstract de date
Operatii:
• Gestiunea elementelor (adaugare / stergere nod sau muchie)
• Parcurgeri
18
APRILIE 2020
Parcurgeri Arbori Binari
• Latime (BFS)
• Adancime (DFS)
• Preordine (RSD)
• Postordine (SDR)
• Inordine (SRD)
19
APRILIE 2020
Parcurgere in adancime: preordine
Radacina – Stanga – Dreapta
F, B, A, D, C, E, G, I, H
20
APRILIE 2020
Parcurgere in adancime: inordine
Stanga – Radacina – Dreapta

A, B, C, D, E, F, G, H, I
21
APRILIE 2020
Parcurgere in adancime: postordine
Stanga – Dreapta – Radacina

A, C, E, D, B, H, I, G, F
22
APRILIE 2020
Parcurgere in latime
F, B, G, A, D, I, C, E , H
23
APRILIE 2020
Consider a node X in a Binary Tree. Given that X has two

children, let Y be Inorder successor of X. Which of the
following is true about Y?
a) Y has no right child

b) Y has no left child
c) Y has both children
d) None of the above
24
APRILIE 2020
Reprezentarea Arborilor
26
APRILIE 2020
Lowest Common Ancestor
https://www.infoarena.ro/problema/lca
27
APRILIE 2020
Universitatea
Politehnica
Bucureşti
Arbori Binari de Cautare si

Heap
STRUCTURI DE DATE – Cursul 9: ABC si Heap
Reprezentarea Arborilor Binari
2
Aprilie 2020
O posibila implementare
struct BinaryTreeNode {
void *pinfo;
struct BinaryTreeNode *left_son, *right_son, *parent, *root;
}
struct BinaryTreeNode* create_BinaryTreeNode(void* info) {

struct BinaryTreeNode* node
= malloc(sizeof(struct BinaryTreeNode));
node->pinfo = NULL;
node->left_son = node->right_son = node->parent = NULL;
node->root = node;
return node;
}
3
Aprilie 2020
Operatii pe Arbori Binari

void insert(struct BinaryTreeNode* node, void* info) {
int next_son = rand() % 2;
if (next_son == 0) { // left son
node->left_son = create_BinaryTreeNode(info);
//node->left_son->pinfo = info;
node->left_son->parent = node;
node->left_son->root = node->root;
}
else // right son
{
node->right_son = create_BinaryTreeNode(info);
//node->right_son->pinfo = info;
node->right_son->parent = node;
node->right_son->root = node->root;
}
}
4
Aprilie 2020

void insert(struct BinaryTreeNode* node, void* info) {
int next_son = rand() % 2;
if (node->left_son == NULL) {
node->left_son = create_BinaryTreeNode();
node->left_son->pinfo = info;
node->left_son->root = node->root;
}
else
insert(node->left_son, info);
}
else // right son
{
if (node->right_son == NULL) {
node->right_son = create_BinaryTreeNode();
node->right_son->pinfo = info;
node->right_son->root = node->root;
}
else
insert(node->right_son);
}
}
5
Aprilie 2020

void remove(struct BinaryTreeNode* node) {
struct BinaryTreeNode* leaf = findLeaf(node);
if (leaf->parent->left_son == leaf) {
leaf->parent->left_son = NULL;
} else {
leaf->parent->right_son = NULL;
}
node->pinfo = leaf->pinfo;
free(leaf);
}
struct BinaryTreeNode* findLeaf(struct BinaryTreeNode* node) {

if (node->left_son == NULL && node->right_son == NULL) {
return node;
} else {
if (node->left_son != NULL) {
return findLeaf(node->left_son);
} else {
return findLeaf(node->right_son);
}
}
}
6
Aprilie 2020

void remove(struct BinaryTreeNode* node) {
struct BinaryTreeNode* leaf = findLeaf(node);
if (leaf->parent != NULL) { // leaf is root when only node
if (leaf->parent->left_son == leaf) {
leaf->parent->left_son = NULL;
} else {
leaf->parent->right_son = NULL;
}
node->pinfo = leaf->pinfo;
}
free(leaf);
}
struct BinaryTreeNode* findLeaf(struct BinaryTreeNode* node) {

return node;
} else {
return findLeaf(node->left_son);
} else {
return findLeaf(node->right_son);
}
}
}
7
Aprilie 2020
Structuri de Date studiate
Arbori Binari
de Cautare
Grafuri Arbori Arbori Binari
Heap
8
Aprilie 2020
Cautarea Binara
9
Aprilie 2020
Cautarea Binara
use gdb
10
Aprilie 2020
Arbori Binari de Cautare (BST)
BST = Arbore Binar in care:
cheile stocate în noduri (informația utilă) aparțin

unei mulțimi peste care există o relație de ordine
cheia din oricare nod este mai mare decât cheile

tuturor nodurilor din subarborele stâng
cheia din oricare nod este mai mică decât cheile

nodurilor ce compun subarborele drept
11
Aprilie 2020
Proprietati BST:
parcurgerea în inordine produce o secventa

ordonată crescător
Valoarea maximă dintr-un arbore binar de

căutare se află în nodul din extremitatea dreaptă
Valoarea minimă se află în nodul din extremitatea

stângă
12
Aprilie 2020
Reprezentarea Arborilor Binari de Cautare
13
Aprilie 2020
struct BSTNode {
struct BSTNode *left_son, *right_son, *parent;
void* info;
// Functie ce compara 2 elemente

// si intoarce < 0, = 0, > 0, daca primul
// element este mai mic ca, egal cu, mai mare
// ca al doilea element.
int (*compare)(void*, void*);
}
// Functie pentru compararea a doua int-uri.

int compare_int(void* a, void* b) {
return ((*(int*)a) – (*(int*)b));
}
14
Aprilie 2020
struct BSTNode* create_BSTNode(int (*compare) (void*, void*), void* info) {

struct BSTNode* node = malloc(sizeof(struct BSTNode));
node->compare = compare;
node->info = info;
}
15
Aprilie 2020
// Insereaza informatia in subarborele cu radacina node
void insert_info(struct BSTNode* node, void* info) {
int next_son;
if (compare(info, node->info) <= 0) next_son = 0;
else next_son = 1;

node->left_son = create_BSTNode(compare, info);
} else
insert_info(node->left_son, info);
} else { // right son
node->right_son = create_BSTNode(compare, info);
} else
insert_info(node->right_son, info);
}
}
. . .
16
Aprilie 2020
. . .
// Intoarce un pointer catre nodul ce contine informatia si NULL altfel
// cautand in subarborele cu radacina node
struct BSTNode* find_info(struct BSTNode* node, void* info) {
if (compare(info, node->info) == 0)
return node;
info == node->info
if (compare(info, node->info) < 0) {
if (node->left_son != NULL)
return find_info(node->left_son, info);
else
return NULL;
} else {
if (node->right_son != NULL)
return find_info(node->right_son, info);
else
return NULL;
}
}
. . .
17
Aprilie 2020
. . .
// Sterge elementul node
// Intoarce 1 daca e stearsa radacina arborelui si 0 altfel.
int remove(struct BSTNode* node) {
struct BSTNode *p;
if (node->parent == NULL) { // node == root
free(node);
return 1;
} else {
if (node->parent->left_son == node)
node->parent->left_son = NULL;
else
node->parent->right_son = NULL;
free(node);
return 0;
}
} else {
. . .
18
Aprilie 2020
. . .
} else {
// Gaseste nodul cu cea mai mare valoare din subarborele stang.
p = node->left_son;
while (p->right_son != NULL)
p = p->right_son;
} else { // right_son != NULL
// Gaseste nodul cu cea mai mica valoare din subarborele drept.
p = right_son;
while (p->left_son != NULL)
p = p->left_son;
}
node->info = p->info;
return remove(p);
}
}
. . .
19
Aprilie 2020
. . .
// Sterge un element din subarborele cu radacina node care are info.
// Intoarce 1 daca e stearsa radacina arborelui si 0 altfel.
int remove_info(struct BSTNode* node, void* info) {
struct BSTNode *t = find_info(node, info);
if (t != NULL)
return remove(t);
else
return 0;
}
. . .
20
Aprilie 2020
struct BST {
struct BSTNode* root;
int (*compare) (void*, void*);
}
struct BST* create_BST(int (*compare) (void*, void*)) {

struct BST* tree = malloc(sizeof(struct BST));
tree->root = NULL;
tree->compare = compare;
return tree;
}
// Insereaza un element nou in arbore.

void insert_info(struct BST* tree, void* x) {
if (tree->root == NULL) {
tree->root = create_BSTNode(x);
} else
insert_info(tree->root, x);
}
}
. . .
21
Aprilie 2020
. . .
// Cauta un element in arbore.
struct BSTNode* find_info(struct BST* tree, void* x) {
if (tree->root == NULL)
return NULL;
else
return find_info(tree->root,x);
}
}
// Sterge un element din arbore.

void remove_info(struct BST* tree, void* x) {
if (tree->root != NULL) {
if (remove_info(tree->root, x)) {
tree->root = NULL;
}
}
}
22
Aprilie 2020
Operatii BST:
• cautare
• inserare
• stergere
Performanta vs echilibrare (balance)
23
Aprilie 2020
Comparatie
Punem N elemente in structurile de date de mai jos.

Cate iteratii sunt necesare in cazul cel mai defavorabil pentru fiecare operatie?
Sorted BinarySearchTree Balanced

LinkedList BinarySearchTree
Cautare
Inserare
Stergere
24
Aprilie 2020
Comparatie


Cautare N h, log N ≤ h ≤ N log N
Inserare
Stergere
25
Aprilie 2020
Comparatie


Inserare N h, log N ≤ h ≤ N log N
Stergere
26
Aprilie 2020
Comparatie


Inserare N h, log N ≤ h ≤ N log N
Stergere N h, log N ≤ h ≤ N log N
27
Aprilie 2020
Echilibrarea arborilor binari
• Global Rebuilding = BST operation to extract and insert again all nodes
• Scapegoat Tree = self-balancing BST; scapegoat subtree undergoes
rebuilding
• Treap = BST and Heap in the same time
• AVL Tree = self-balancing BST, heights of left and right subtree cannot differ
with more than one (balance factor)
• Red-Black Tree = self-balancing BST, using a color label
• B-Tree = self-balancing tree (not BST) used in databases and file systems
(also good for order statistics)
28
Aprilie 2020
Heap
Min-Heap Binar = Arbore Binar in care:
fiecare nod are proprietatea că valoarea sa este

mai mică sau egală decât cea a tuturor
descendenților săi
sau, echivalent:
fiecare nod are proprietatea că valoarea sa este

mai mare sau egală decât cea a părintelui său
H[Parinte(x)] <= H[x]
(analog Max-Heap Binar)
29
Aprilie 2020
Heap
putem defini şi recursiv proprietatea de heap

pentru orice (sub)arbore:
• nodul rădăcină trebuie să respecte

proprietatea de heap (inegalitatea);
• cei doi subarbori descendenţi sa fie heap-uri.
30
Aprilie 2020
Heap
Operaţii Min-Heap Binar:
• push: inserare
• peek: extrage rădăcina, fără extragere
• pop : extrage rădăcina, cu extragere
• pushUp: propagarea unui nod catre radacina până heap-ul e valid
• pushDown: cernerea unui nod catre nivelurile de jos până heap-ul e valid
31
Aprilie 2020
Reprezentarea Arborilor Binari
Dacă lăsăm deliberat poziția 0 liberă și punem rădăcina în vector

pe poziția 1, atunci pentru fiecare nod în parte, părintele şi
descendenţii se pot calcula după formulele:
Parinte(i) = i / 2, unde i este indicele nodului curent

IndexStanga(i) = 2 * i, unde i este indicele nodului curent
IndexDreapta(i) = 2 * i + 1, unde i este indicele nodului curent
32
Aprilie 2020
struct Heap {
void **H;
int currentDim, maxDim;
int compare(void*, void*);
}
struct Heap* create_Heap(int (*compare) (void*, void*), int maxDim) {

struct Heap* heap = malloc(sizeof(struct Heap));
heap->maxDim = maxDim;
heap->H = // we leave the first element empty
malloc((maxDim+1) * sizeof(void*));
heap->currentDim = 0;
heap->compare = compare;
return heap;
}
. . .
33
Aprilie 2020
34
Aprilie 2020
. . .
void insert(struct Heap* h, int x) {
if (h->currentDim == h->maxDim) { // no more room
fprintf(stderr, "Error!\n");
return;
}
h->currentDim++;
h->H[currentDim] = x;
pushUp(h, currentDim); // this does most of the work
}
. . .
35
Aprilie 2020
. . .
void pushUp(struct Heap* h, int pos) {
int parent;
void* vaux;
parent = pos / 2;
while (pos > 1 && h->H[parent] > h->H[pos]) {
// if not top of heap and if H[parent] and
// H[l] do not respect the heap’s order
vaux = h->H[parent];
h->H[parent] = h->H[pos];// interchange H[parent] and H[pos]
h->H[pos] = vaux;
pos = parent; // move pos to point to the parent

parent = pos / 2;
}
}
. . .
36
Aprilie 2020
37
Aprilie 2020
. . .
void* peek(struct Heap* h) {
if (h->currentDim == 0) {
T x;
return x;
}
return h->H[1];
}
. . .
38
Aprilie 2020
. . .
void* extractMin(struct Heap* h) {
if (h->currentDim == 0) {
return NULL;
}
void* minValue = h->H[1];// min will always be the top of the heap
h->H[1] = h->H[h->currentDim]; // bring last element to top
h->currentDim--;
if (h->currentDim > 0)
pushDown(h); // this does most of the work
return minValue;
}
. . .
39
Aprilie 2020
. . .
void pushDown(struct Heap* h) {
int pos = 1;
void* vaux;
while (1) {
if (2 * pos + 1 > h->currentDim) { // if there isn’t a right son
if (2 * pos > h->currentDim)// if there isn’t a left son
break;
else if (H[2 * pos] < H[pos]) { // if there is a left son and
// it’s not heap proper order
vaux = h->H[2 * pos]; // interchange the node and
h->H[2 * pos] = h->H[pos];// it’s left son
h->H[pos] = vaux;
pos = 2 * pos; // and move to the left son
}
else // there is a left son but
break; // it’s heap proper order
}
. . .
40
Aprilie 2020
. . .
else { // there are both a left son and a right son
if (h->H[2*pos] <= h->H[2*pos + 1] && h->H[2*pos] < h->H[pos]) {
// if left son is smaller and it’s not in heap proper order
vaux = h->H[2 * pos];
h->H[2 * pos] = H[pos];// interchange the node and it’s left
son
h->H[pos] = vaux;
pos = 2 * pos; // move on the left son
}
else if (h->H[2*pos+1] <= h->H[2*pos] && h->H[2*pos+1] < h->H[pos])
{
// if right son is smaller than right and it’s not in heap order
vaux = h->H[2*pos + 1];
h->H[2*pos+1] = h->H[pos];// interchange the node and right son
h->H[pos] = vaux;
pos = 2 * pos + 1; // move to the right son
}
else // all nodes in proper order
break;
}
}
}
};
41
Aprilie 2020
Aplicatii: HeapSort
HeapSort()
{
ConstruiesteMaxHeap();
for (i=dimHeap-1; i>=1; i--)
{
// Punem maximul la sfarsitul vectorului
interschimba(heap[0], heap[i]);
// 'Desprindem' maximul de heap

//(valoarea ramanand astfel in pozitia finala in array)
dimHeap--;
// Reconstituim heap-ul ramas

pushDown(0);
}
}
42
Aprilie 2020
Aplicatii: HeapSort
http://www.c-sharpcorner.com/UploadFile/fd0172/heap-sort-in-java/
43
Aprilie 2020
Aplicatii: PriorityQueue
44
Aprilie 2020
Aplicatii: Order Statistics
k largest(or smallest) elements in an array
1) Build a MaxHeap tree in O(n)

2) Use ExtractMax k times to get k maximum elements
from the MaxHeap in O(k logn)
45
Aprilie 2020
Aplicatii: Graph Algorithms

Algorithms that work on minimum edges, like:
• Prim’s algorithm: minimum spanning tree
• Dijkstra’s algorithm: single source shortest path
46
Aprilie 2020
Binomial Heap
A binomial heap supports quick merging of two heaps:
• A binomial tree of order 0 is a single node

• A binomial tree of order k has a root node whose children are roots of
binomial trees of orders k−1, k−2, ..., 2, 1, 0 (in this order).
• A binomial tree of order k can be constructed from two trees of order k−1
47
Aprilie 2020
Fibonacci Heap
A Fibonacci heap is a collection of trees satisfying the minimum-
heap property, similar to binomial heaps, but less rigid structure:
• Binomial heap: eagerly consolidate trees after each insert

• Fibonacci heap: lazily defer consolidation until next delete-min
• the size of a subtree rooted in a node of

degree k is at least Fk + 2, where Fk is
the kth Fibonacci number
• a node is marked if at least one of its

children was cut since this node was made a
child of another node
some operations can take a long time while others are done very
quickly
48
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Structuri de Date – Treap

STRUCTURI DE DATE – CURSUL 10 - Treap
Test
Nr Subiect
1 Inserati intr-un ABC valorile:
10, 5, 20, 2, 18, 1, 2, 6, 7, 8, 7
Extrageti din ABC de mai sus valoarea: 5
2 Inserati intr-un MinHeap valorile:
10, 5, 20, 2, 1, 4, 7, 11
Faceti o extragere din MinHeap de mai
sus
Exercitii Heap
Care dintre acestea este un Max-Heap?
3
Aprilie 2020
Exercitii Heap
Creati un Heap pe baza acestor chei:
10, 12, 1, 14, 8, 6, 5
4
Aprilie 2020
Exercitii Heap
Eliminati cheia 14 din Heap-ul obtinut in exercitiul precedent
5
Aprilie 2020
Exercitii Heap
Scrieti o functie care verifica un Heap daca este organizat corect
6
Aprilie 2020
Exercitii Heap
Care dintre urmatoarele este un Max-Heap valid?

a) 25,12,16,13,10,8,14
b) 25,12,16,13,10,8,14
c) 25,14,16,13,10,8,12
d) 25,14,12,13,10,8,16
e) Toate cele de mai sus
7
Aprilie 2020
Exercitii Heap
Cum va arata vectorul de la exercitiul precedent dupa doua operatii pop?
8
Aprilie 2020
Exercitii Heap
Se da un heap binar reprezentat cu un array, folosit incepand cu pozitia 1.

Pentru un element de indice i, indicele parintelui sau va fi:
a) i-1
b) floor(i/2)
c) ceil(i/2)
d) (i+1)/2
Daca array-yl ar fi folosit incepand cu pozitia 0, care ar fi raspunsul?
9
Aprilie 2020
Aplicatii: Order Statistics
k largest(or smallest) elements in an array
1) Build a MaxHeap tree in O(n)

2) Use ExtractMax k times to get k maximum elements
from the MaxHeap in O(k logn)
10
Aprilie 2020
Exercitii Arbori Binari de Cautare
Postorder traversal of a given binary search tree, T

produces the following sequence of keys 10, 9, 23, 22, 27,
25, 15, 50, 95, 60, 40, 29 Which one of the following
sequences of keys can be the result of an in-order traversal
of the tree T?
a) 9, 10, 15, 22, 23, 25, 27, 29, 40, 50, 60, 95
b) 9, 10, 15, 22, 40, 50, 60, 95, 23, 25, 27, 29
c) 29, 15, 9, 10, 25, 22, 23, 27, 40, 60, 50, 95
d) 95, 50, 60, 40, 27, 23, 22, 25, 10, 9, 15, 29
11
Aprilie 2020
Suppose that we have numbers between 1 and 1000 in a

binary search tree and want to search for the number 363.
Which of the following sequences could NOT be the
sequence of nodes examined?
a) 2, 252, 401, 398, 330, 344, 397, 363.

b) 924, 220, 911, 244, 898, 258, 362, 363.
c) 925, 202, 911, 240, 912, 245, 363.
12
Aprilie 2020
Consider the following Binary Search Tree:
If we randomly search one of the keys present in above

BST, what would be the expected number of comparisons?
a) 2.75
b) 2.25
c) 2.57
d) 3.25
13
Aprilie 2020
Recapitulare BST
• Chei stocate în noduri

• Cheia unui nod este:
– mai mare decât cheile nodurilor din subarborele stâng
– mai mică decât cheile nodurilor din subarborele drept
• Operații
– inserare, ștergere, găsire maxim, găsire minim
– O(adâncime_arbore)
14
Aprilie 2020
Probleme BST
• Comportament bun pe chei random, dar prost pe input

particular
• Exemplu: chei sortate
15
Aprilie 2020
Probleme BST
16
Aprilie 2020
Probleme BST
• Standard Template Library nu ajută întotdeauna

• Deși există set, multiset, priority_queue, nu pot obține a k-a
cheie dintr-o mulțime de chei
17
Aprilie 2020
Cum rezolvam? Echilibrare...
• Global Rebuilding = BST operation to extract and insert again all nodes
• Scapegoat Tree = self-balancing BST; scapegoat subtree undergoes rebuilding
• Treap = BST and Heap in the same time
• AVL Tree = self-balancing BST, heights of left and right subtree cannot differ
with more than one (balance factor)
• Red-Black Tree = self-balancing BST, using a color label
• B-Tree = self-balancing tree (not BST) used in databases and file systems (also
good for order statistics)
18
Aprilie 2020
Rotatii
• Facem rotații în arbore (mețin proprietatea de arbore de

căutare)
19
Aprilie 2020
Rotatii
• Rotație dreapta:
– Z->left = B; W->right = Z
• Rotație stânga:
– W->right = B; Z->left = W;
• În practică:
– valori auxiliare pentru interschimbare
– grijă la părinte
– noduri nil pentru nodurile care nu au 2 fii
20
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Treap
Treap
• Îi vom asigna fiecărui nod, la inserare, o prioritate

random
• Prioritatea unui nod trebuie să fie mai mare ca
prioritatea fiilor săi (invariantul de heap)
• Vom folosi rotații ca să asigurăm păstrarea acestui
invariant
22
Aprilie 2020
Echilibrare
23
Aprilie 2020
Treap
• Un treap este un arbore binar care respectă doi

invarianți
– Invariantul arborelui de căutare pentru chei (tree)
– Invariantul de heap pentru priorități (heap)
• => treap
24
Aprilie 2020
Treap
Operatii Treap:
• cautare
• inserare
• stergere
25
Aprilie 2020
Treap
struct TreapNode {
struct TreapNode *left_son, *right_son, *parent;
void* info;
int prio;
int (*compare)(void*, void*);
...
}
// Functie pentru compararea a doua int-uri.

int compare_int(void* a, void* b) {
return ((*(int*)a) – (*(int*)b));
}
26
Aprilie 2020
Treap
struct TreapNode* create_TreapNode(int (*compare) (void*, void*), void* info) {

struct TreapNode * node = malloc(sizeof(struct TreapNode));
node->compare = compare;
node->info = info;
// Choose a random priority.
node->prio = rand();
}
27
Aprilie 2020
Treap
// cauta nodul cu informatia x in subarborele cu radacina node

struct TreapNode* find_info(struct TreapNode* node, void* x) {
if (compare(x, node->info) == 0)
return node;
if (compare(x, node->info) <= 0) {

if (node->left_son != NULL)
return find_info(node->left_son, x);
else
return NULL;
} else {
if (node->right_son != NULL)
return find_info(node->right_son, x);
else
return NULL;
}
}
28
Aprilie 2020
Treap – exemplu inserare
29
Aprilie 2020
30
Aprilie 2020
31
Aprilie 2020
Treap
// insereaza nodul cu informatia x in subarborele cu radacina node

void insert_info(struct TreapNode* node, void* x) {
if (compare(x, node->info) <= 0) { // left son

node->left_son = create_TreapNode(compare, x);
push_up(node->left_son);
} else
insert_info(node->left_son, x);
} else { // right son
node->right_son = create_TreapNode(compare, x);
push_up(node->right_son);
} else
insert_info(node->right_son, x);
}
32
Aprilie 2020
Treap
void rotate_right(struct TreapNode* w) {

struct TreapNode* gparent = w->parent->parent;
struct TreapNode* rson = w->right_son;

w->parent->left_son = rson;
if (rson != NULL)
rson->parent = w->parent;
w->right_son = w->parent;
w->parent->parent = w;
if (gparent != NULL) {
if (gparent->left_son == w->parent)
gparent->left_son = w;
else
gparent->right_son = w;
}
w->parent = gparent;
}
33
Aprilie 2020
Treap
void rotate_left(struct TreapNode* z) {

struct TreapNode* gparent = z->parent->parent;
struct TreapNode* lson = z->left_son;

z->parent->right_son = lson;
if (lson != NULL)
lson->parent = z->parent;
z->left_son = z->parent;
z->parent->parent = z;
if (gparent != NULL) {
if (gparent->left_son == z->parent)
gparent->left_son = z;
else
gparent->right_son = z;
}
z->parent = gparent;
}
34
Aprilie 2020
Treap
// impinge node in sus pana la locul care ii corespunde conform

// invariantului de heap, folosind rotatii pentru a pastra
// invariantul de arbore binar de cautare
void push_up(struct TreapNode* node) {
while (node->parent != NULL) {
if (node->prio > node->parent->prio) {
struct TreapNode* gparent = node->parent->parent;
if (node->parent->left_son == node) {
rotate_right(node);
} else {
rotate_left(node);
}
} else
break;
}
}
35
Aprilie 2020
Treap – exemplu stergere
36
Aprilie 2020
37
Aprilie 2020
38
Aprilie 2020
Treap
void remove(struct TreapNode* node) {
struct TreapNode *p;
if (node->parent != NULL) { // node is not root
else
}
free(node);
} else {
// Gaseste nodul cu cea mai mare val din subarb stang.
p = node->left_son;
p = p->right_son;
// Gaseste nodul cu cea mai mica val din subarb drept.
p = node->right_son;
p = p->left_son;
}
remove(p);
// si putem sa ne oprim aici sau...
}
39
Aprilie 2020
}
Treap
void remove(struct TreapNode* node) {
struct TreapNode *p;
if (node->parent != NULL) { // node is not root
else
}
free(node);
} else {
// Gaseste nodul cu cea mai mare val din subarb stang.
p = node->left_son;
p = p->right_son;
// Gaseste nodul cu cea mai mica val din subarb drept.
p = node->right_son;
p = p->left_son;
}
remove(p);
push_down(node);
}
40
Aprilie 2020
}
Treap
void push_down(struct TreapNode* node) {

while ( (node->left_son!=NULL && node->left_son->prio > node->prio) ||
(node->right_son!=NULL && node->right_son->prio > node->prio) {
if (node->left_son==NULL)
rotate_left(node->right_son);
else if (node->right_son==NULL)
rotate_right(node->left_son);
else // avem ambii fii
// rotim in directia fiului cu prioritate mai mare pt ca avem un max-heap
if (node->left_son->prio < node->right_son->prio)
rotate_left(node->right_son);
else
rotate_right(node->left_son);
}
41
Aprilie 2020
Treap
// elimina din subarborele cu radacina node, nodul care

// are informatia x
void remove_info(struct TreapNode *node, void* x) {
struct TreapNode *t = find_info(node, x);
if (t != NULL)
remove(t);
}
42
Aprilie 2020
Analiza
• Existență:
– O rotație menține proprietatea de BST, se folosește pentru
respectarea celei de heap
• Unicitate:
– Nodul cu prioritatea cea mai mare va fi radacină
– Împarte în mod unic (după invariantul de BST) în doi
subarbori
– Se aplică recursiv
43
Aprilie 2020
Complexitate
• Datorită alegerii random a priorităților, inserarea și

stergerea au loc in O(logN), N – numărul de noduri
din arbore
– Se poate demonstra totusi ca numarul asteptat de rotatii
care se fac la o inserare este de fapt O(1), vezi ex. 7.5:
https://opendatastructures.org/ods-java/7_3_Discussion_
Exercises.html#exc:treap-rotates
44
Aprilie 2020
Alte posibile operatii
• Găsire element cheie minima

• Găsire element cheie maximă
• Găsirea celei de-a k-a cheie, în ordine sortată
• Split
• Join
45
Aprilie 2020
Reading material
1. http://www.cs.cmu.edu/afs/cs.cmu.edu/project/scandal/pub
lic/papers/treaps-spaa98.pdf
2. http://compgeom.cs.uiuc.edu/~jeffe/teaching/algorithms/no
tes/10-treaps.pdf
3. http://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/154
51-s07/www/lecture_notes/lect0208.pdf
46
Aprilie 2020
Universitatea
Politehnica
Bucureşti
Structuri de Date – Arbori

Echilibrati
(AVL, Red-Black, B-Tree)
Universitatea
Politehnica
Bucureşti
AVL Trees
STRUCTURI DE DATE – CURSUL 11 - Arbori Echilibrati
AVL Trees
AVL tree is a self-balancing Binary Search Tree (BST)

where the difference between heights of left and right
subtrees cannot be more than one for all nodes
http://www.geeksforgeeks.org/avl-tree-set-1-insertion/
3
Mai 2020
Functionare AVL Trees
4
Mai 2020 Click for animation
AVL Trees
- Height vs depth
- Balance factor
- Rotations
https://www.geeksforgeeks.
org/avl-tree-set-1-insertion/
5
Mai 2020
Functionare AVL Trees
• Cautare si Parcurgere: la fel ca la ABC obisnuiti

• Inserare:
– Inserare ca la ABC obisnuit
– Rotatii pentru a respecta invariantul de AVL
– http://www.geeksforgeeks.org/avl-tree-set-1-insertion/
• Stergere:
– Stergere ca la ABC obisnuit
– Rotatii pentru a respecta invariantul de AVL
– https://www.geeksforgeeks.org/avl-tree-set-2-deletion/
6
Mai 2020
Analiza
Avantaj:
• arbore perfect echilibrat, timp cautare minim
Dezavantaj:
• Potential multe rotatii
7
Mai 2020
Universitatea
Politehnica
Bucureşti
Red Black Trees

Red-Black Trees
Red-Black tree is a self-balancing BST where:

1. Every node has a color either red or black.
2. Root of tree is always black.
3. A red node cannot have a red parent or red child).
4. Every path from root to a NULL node has same number of black nodes.
http://www.geeksforgeeks.org/red-black-tree-set-1-introduction-2/
9
Mai 2020
Functionare Red-Black Trees
10
Functionare Red-Black Trees
• Cautare si Parcurgere: la fel ca la ABC obisnuiti

• Inserare:
– Inserare ca la ABC obisnuit, nod rosu
– Daca unchiul nodului inserat este:
• Rosu: recolorare recursiva
• Negru: rotatii similar cu AVL
https://www.geeksforgeeks.org/red-black-tree-set-2-insert/
• Stergere:
– Stergere ca la ABC obisnuit
– Recolorare si rotatii pentru a rezulta Red-Black Tree
https://www.geeksforgeeks.org/red-black-tree-set-3-delete-2/
11
Mai 2020
Analiza
Avantaj:
• Arbore aproximativ echilibrat: cea mai lunga cale de la
radacina la frunza este de maxim doua ori mai lunga decat cea
mai scurta
– Cea mai scurta cale are doar noduri negre (k noduri)
– Cea mai lunga cale are alternate noduri rosii si negre (2k noduri)
• Timp de cautare bun: O(k) = O(2k) = O(log n)
Dezavantaj:
• Implementare mai complexa decat la AVL
12
Mai 2020
Universitatea
Politehnica
Bucureşti
B-Trees
B-Trees
B-Tree is a self-balancing tree (not BST) of order m:
• All leaves are at the same level
• Each node contains between m/2-1 and m-1 keys
• Root contains between 1 and m-1 keys
• Number of children = number of keys + 1
• All keys of a node are sorted, child between k1 and k2 contains all keys
in range from k1 to k2
14
Mai 2020 http://www.geeksforgeeks.org/b-tree-set-1-introduction-2/
B-Trees
15
Functionare B-Trees
• Cautare si Parcurgere: analog cu ABC obisnuiti

– Mergem pe copilul care e imediat inaintea primei chei mai
mari decat cheia cautata
• Inserare:
– Nodurile se completeaza pana la umplere, moment in care
se face split (eventual cu mutarea mijlocului in parinte)
– http://www.geeksforgeeks.org/b-tree-set-1-insert-2/
• Stergere:
– Stergerea unei frunze (majoritatea nodurilor) se face direct
– Celelalte cazuri sunt definite individual
– http://www.geeksforgeeks.org/b-tree-set-3delete/
16
Mai 2020
B+Trees
https://stackoverflow.com/questions/870218/what-are-the-differences-between-b-trees-and-b-trees
17
Mai 2020
De ce B-Trees si B+Trees?
BTRFS: The linux B-tree filesystem

https://www.researchgate.net/publication/262177144_BTRFS_The_linux_B-tree_filesystem
Using B+Tree to index databases (e.g. SQLite):

https://cstack.github.io/db_tutorial/parts/part7.html
How to decide the order of a B-Tree:

https://stackoverflow.com/questions/28677734/how-to-decide-order-of-b-tree
18
Mai 2020
Analiza
Avantaj
• Creat pentru a imparti populatia de chei in blocuri
stocate separat (e.g. baze de date)
• Dimensiunea blocului (i.e. ordinul arborelui B-Tree)
este ales in functie de marimea discului
Dezavantaj
• Schimbarea ordinului implica reconstruirea completa
a arborelui
19
Mai 2020
ReadingViewing materials
• MIT 6.006 Introduction to Algorithms, Fall 2011

https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61O
q3tWYp6V_F-5jb5L2iHb
20
Mai 2020
Universitatea
Politehnica
Bucureşti
xkcd
Structuri de Date – van Emde

Boas
STRUCTURI DE DATE – Cursul 12: van Emde Boas
Operatii ale SD in practica

Ganditi-va ce complexitate (timp si memorie) au urmatoarele SD:
HashTable Balanced Binary

(cu bucket lista Search Tree
inlantuita)* (AVL, Red-Black)
Insert / Delete
Find
Min/Max
(*)
Exista si structuri de date hibride, gen HashTable cu bucket Binary Tree
2
Mai 2020

Ganditi-va ce complexitate (timp si memorie) au urmatoarele SD:

(cu bucket lista Search Tree
inlantuita)* (AVL, Red-Black)
Insert / Delete
Find
Min/Max
(*)
Exista si structuri de date hibride, gen HashTable cu bucket Binary Tree
3
Mai 2020

Search Tree
(AVL, Red-Black)
Successor/Predecessor
4
Mai 2020

Search Tree
(AVL, Red-Black)
Successor/Predecessor
Posibile aplicatii: routere care mentin tabele de lookup pe intervale de

adrese IP: pentru un IP dat, afla in ce range te aflii
5
Mai 2020
Despre complexitate
6
Mai 2020
Despre complexitate
• constant
• logarithmic
• square root
• linear
• log-linear
• polynomial
(quadratic, cubic etc.)
• exponential
• factorial
7
Mai 2020
Complexitate si notatii asimptotice
Ce sunt O, Ɵ si Ω? pentru n suficient de mare:

• f(n) ∈ O(g(n)) adica f nu creste mai repede decat g O(g(n)) adica f nu creste mai repede decat g
• f(n) ∈ O(g(n)) adica f nu creste mai repede decat g Ω(g(n)) adica f nu creste mai incet decat g
• f(n) ∈ O(g(n)) adica f nu creste mai repede decat g Ɵ(g(n)) adica f creste ca g(n)
http://andrei.clubcisco.ro/cursuri/2aa/notatii%20de%20complexitate.pdf
Mai 2020
Vor fi studiate la Analiza Algoritmilor 8
Universitatea
Politehnica
Bucureşti
vEB Tree
(van Emde Boas)
The van Emde Boas Tree
Stocheaza n valori dintr-o multime de u valori posibile

Fixed universe: {0, 1, … , u-1}
10
Mai 2020
Stocheaza n valori dintr-o multime de u valori posibile

Fixed universe: {0, 1, … , u-1}
Ofera complexitate O(log2 log2 u) pentru toate operatiile!

adrese IPV4: u = 232 => log2 u = 32, log2 log2 u = 5
adrese IPV6: u = 264 => log2 u = 64, log2 log2 u = 6
11
Mai 2020
1. bit vector – array of size u

- insert O(1)
- successor O(n)
12
Mai 2020
2. split universe into clusters

- insert O(1)
- successor … how big the cluster?
- look for x in cluster
- look for 1 in summary to get next cluster
- look for first 1 in next cluster
13
Mai 2020
A word about complexity
Teorema Master pe care o veti studia la analiza algoritmilor:
T(k) = T(k/2) + O(1) = O (log2 k)
T(log2 u) = T((log2 u)/2) + O(1) = O (log2 log2 u)
T’(u) = T’(u1/2) + O(1) = O(log2 log2 u)
14
Mai 2020
2. split universe into clusters

- insert O(1)
- successor O(√u)
- look for x in cluster
- look for 1 in summary to get next cluster
- look for first 1 in next cluster
15
Mai 2020

3. recursive structure
V : vEB(u)
- V.cluster[i] : vEB(√u), i = 0..√u
- V.summary : vEB(√u)
V : vEB(2)
- A[0,1]
16
Mai 2020 Cormen, Thomas H., et al. Introduction to algorithms. MIT press, 2009
3. recursive structure
- insert (v, x) T(log2 u) = 2 T(log2 u / 2) + O(1)
insert (v.cluster[high(x)], low(x))
insert (v.summary, high(x))
- successor (v, x) T(log2 u) = 3 T(log2 u / 2) + O(1)
i = high(x)
j = successor(v.cluster[i], low(x))
if j == ∞:
i = successor (v.summary, i)
j = successor (v.cluster[i], -∞)
17
Mai 2020
4. Store min and max for each cluster

- insert (V, x) T(log2 u) = 2 T(log2 u / 2) + O(1)
if x<V.min: V.min = x
if x>V.max: V.max = x
insert (V.cluster[high(x)], low(x))
insert (V.summary, high(x))
- successor (V, x) T(log2 u) = T(log2 u / 2) + O(1) = O(log2 log2 u)
i = high(x)
if low(x) < V.cluster[i].max:
j = successor(V.cluster[i], low(x))
else:
i = successor (V.summary, high(x))
j = V.cluster[i].min
18
Mai 2020
5. Lazy propagation of x in empty clusters

- insert (V, x) T(log2 u) = T(log2 u / 2) + O(1) = O (log2 log2 u)
if V.min == None:
V.min = V.max = x
return
if x<V.min: swap x <-> V.min
if x>V.max: V.max = x
if V.cluster[high(x)].min = None:
insert (V.summary, high(x))
insert (V.cluster[high(x)], low(x))
19
Mai 2020
Avantaj:
- Performanta imbunatatita - O(log2 log2 u)
Dezavantaj:
- spatiu ocupat foarte mare (u – toate valorile posibile
din universul de valori, structura recursiva)
Structuri de date care rezolva acest dezavantaj:

- x-fast tries
- y-fast tries
20
Mai 2020
vEB References
Cormen, Thomas H., et al. Introduction to algorithms. MIT press, 2009 (prima editie in
care apare), Chapter 20. van Emde Boas Trees
Stanford lecture slides:

http://web.stanford.edu/class/archive/cs/cs166/cs166.1146/lectures/14/Small14.pdf
MIT video:
https://www.youtube.com/watch?v=hmReJCupbNU
IIT Kharagpur:
https://www.youtube.com/watch?v=_KgllZVMshg
vEB implementation in C++:

https://github.com/PetarV-/Algorithms/blob/master/Data%20Structures/van%20Emde
%20Boas%20Tree.cpp
21
Mai 2020
6/11/2020 Laborator 1 - Recapitulare PC. Vectori si matrice. Alocare dinamica [CS Open CourseWare]
Laborator 1 - Recapitulare PC. Vectori si matrice. Alocare

dinamica
Responsabili
Andrei Dinu [mailto:mailto:dinuaadrian@gmail.com]

Rares Cheseli [mailto:mailto:rares96cheseli@gmail.com]
În cadrul acestui laborator ne propunem să recapitulam cateva dintre conceptele de C invatate la cursul de
Programarea Calculatoarelor.
Obiective
Ne dorim să:
Recapitulam alocarea dinamica a memoriei si pointerii

Recapitulam lucrul cu structuri
Recapitulam directivele de preprocesare
Invatam sa ne asiguram ca nu avem memory leaks in programul nostru
Pass by value vs Pass by address

C este un limbaj pass-by-value. Asta inseamna ca functiile isi vor creea copii ale parametrilor si vor lucra cu ele. Daca
vrem sa lucram direct pe variabilele trimise ca parametru, va trebui sa trimitem adresa lor catre functie.
main.c
#include <stdio.h>
// Se va face cate o copie a variabilelor a si b. Aceste copii se vor distruge

// dupa ce functia isi va incheia executia
void swap(int a, int b) {
int temp = a;
a = b;
b = a;
}
// Se va face cate o copie a pointerilor dar vor pointa tot catre variabilele
// a si b
void swap2(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int a = 5;
int b = 10;
printf("Before swap: %d %d\n", a, b); // 5 10

swap(a, b);
printf("After swap: %d %d\n", a, b); // 5 10
printf("Before swap: %d %d\n", a, b); // 5 10

swap2(&a, &b);
printf("After swap: %d %d\n", a, b); // 10 5
return 0;
}
Void pointer (void*)

Un pointer de tipul void* este un pointer care nu este asociat cu niciun tip de date, ceea ce ii permite sa pointeze la
adrese de memorie de orice tip. De asemenea, el poate fi castat la orice tip de date.
https://ocw.cs.pub.ro/courses/sd-ca/laboratoare/lab-01 1/8
Exemplu de folosire in contextul genericitatii

main.c
#include <stdio.h>
enum types {
INT,
DOUBLE,
STRING
};
void print(void* var, enum types type) {

if (type == INT) {
printf("%d\n", *((int*)var));
}
if (type == DOUBLE) {
printf("%lf\n", *((double*)var));
}
if (type == STRING) {
printf("%s\n", (char*)var);
}
}
int main() {
int a = 123;
double b = 2.67;
char* c = "wubba lubba dub dub";
print(&a, INT);
print(&b, DOUBLE);
print(c, STRING);
return 0;
}
Alocarea dinamica
Vectori
Printr-un vector se înţelege o colecţie liniară şi omogenă de date. Un vector este liniar pentru că datele(elementele)
pot fi accesate în mod unic printr-un index. Un vector este, de asemenea, omogen, pentru că toate elementele sunt
de acelaşi tip. În limbajul C, indexul este un număr întreg pozitiv şi indexarea se face începând cu 0.
Declarare vector static:
int a[100]; // structură statică: dimensiunea acestuia trebuie să fie o constantă la compilare şi nu poate fi modificată în cursul
// execuţiei programului.
Declarare vector alocat dinamic:
int *a = malloc(n * sizeof(int));

…
free(a);
În limbajul C nu există practic nici o diferenţă între utilizarea unui vector cu dimensiune fixă şi utilizarea unui vector
alocat dinamic.
Matrice
Matricea este o colecţie omogenă şi bidimensională de elemente. Acestea pot fi accesate prin intermediul a doi indici,
numerotaţi, ca şi în cazul vectorilor, începand de la 0.
Declarare matrice statica:
int mat[5][10];
Declarare matrice dinamica:
int **a;
...
a = malloc(nl * sizeof(int *)); // Alocare pentru vector de pointeri
for (i = 0; i < nl; ++i) {
a[i] = malloc(nc * sizeof(int)); // Alocare pentru o linie
}
...
for (i = 0; i < nl; ++i) {
free(a[i]);
}
free(a);
Daca se cunoaste la compilare prima dimensiune a matricei (numarul de linii), un alt mod de a declara o matrice
dinamic este urmatorul:
int (*mat)[10] = (int (*)[10])malloc(sizeof(*mat) * 5);

...
free(mat);
In acest caz, toata matricea va fi alocata intr-o zona continua de memorie.
Pentru a aloca dinamic un vector putem folosi si functia calloc. Exista doua mari diferente intre calloc si malloc:
Semnatura functiei: calloc() primeşte două argumente, o lungime de vector şi o dimensiune a fiecărui element.
calloc initializeaza elementele cu 0, malloc nu face niciun fel de initializare.
Realocarea
Redimensionarea unui vector care creste (sau scade) fata de dimensiunea alocata initial se poate face cu funcţia
realloc, care primeşte adresa veche şi noua dimensiune şi întoarce noua adresă. In cazul in care realocarea a esuat,
la fel ca celelalte functii de alocare, realloc va intoarce NULL.
Static
Variabile statice
Variabilele statice reprezinta un tip special de variabile care isi pastreaza valoarea in program pana la terminarea
executiei lui. Ele sunt stocate intr-o parte separata a memoriei, astfel incat dupa iesirea din scope sau stack frame ele
nu se distrug.
#include <stdio.h>
void f() {
static int i = 0;
++i;
printf("%d ", i);
}
int main() {
for (int i = 0; i < 3; ++i) {
f();
}
return 0;
}
Functii statice
Declarerea unei functii statice ii va restrictiona acesteia accesul la fisierul in care este declarata. Astfel, daca fisierul
sursa al acesteia este inclus in altul si iar functia este apelata din el, vom primi o eroare de compilare, functia statica
nefiind inclusa.
f1.c
static void f() {

printf(“imported”);
}
f2.c
#include “f1.c”;
int main() {
f(); // Se va genera o eroare de tip “undefinied reference to f” deoarece functia statica nu a fost importata.
return 0;
}
Const
Keyword-ul const desemneaza o variabila constanta, read-only, a carei valoare nu se va mai schimba dupa initializare.
Daca se incearca schimbarea valorii se va genera o eroare de compilare. In cazul pointerilor fiti atenti daca adresa de
memorie este constanta sau valorea spre care pointeaza!
Deducerea acestor declaratii se poate face prin clockwise/spiral rule [http://c-faq.com/decl/spiral.anderson.html].
Exemple:
int* a; // pointer de tip int

int* const a; // pointer constant catre un int variabil
int const *a; // pointer variabil catre un int constant
int const * const a; // pointer constant catre un int constant
Pentru syntactic sugar putem muta primul const la inceputul declaratiei:
const int* a == int const* a (veti vedea de multe ori acest tip de declaratie)
Directive de preprocesor
Definirea de macro-uri
#define MAX 50
Putem defini constante ce vor fi inlocuite peste tot in program in etapa de procesare. Este recomandat sa folosim
aceasta optiune in defavoarea scrierii efective a constantei deoarece suntem mai predispusi la bug-uri putand uita sa
modificam constanta in unele parti ale programului.
Garzi
Folosim garzi de preprocesare pentru a evita incluziunea multipla si redefinirea de variabile. Astfel, chiar daca
includem de mai multe ori acelasi header, textual, vom avea o singura inlocuire a variabilelor/functiilor.
engine.h
struct A{};
car.h
car.h
#include “engine.h” // se va inlocui cu struct A la preprocesare
main.c
#include “engine.h”
#include “car.h”
...// Vom avea inclusa de doua ori struct A, ceea ce va duce la o eroare de compilare
// deoarece se incearca redefinirea lui A.
Solutie: Adaugam garzi in fiecare fisier
engine.h
#ifndef __ENGINE_H__
#define __ENGINE_H__
struct A {};
#endif
car.h
#ifndef __CAR_H__
#define __CAR_H__
#include "engine.h"
#endif
main.c
#include "engine.h"
#include "car.h"
int main() {
return 0;
}
Dupa expandare vom avea:
main.c
#ifndef __ENGINE_H__ // Adaugam o intrare pentru "engine" in tabela de simboluri

struct A {};
#endif
#ifndef __CAR_H__ // Adaugam o intrare pentru "car" in tabela de simboluri

#define __CAR_H__
#ifndef __ENGINE_H__ // "engine" este definit deci sarim peste acest branch si nu includem struct A din nou
struct A {};
#endif
#endif
int main() {
return 0;
}
Exerciții
Fiecare laborator va avea unul sau doua exerciții publice si un pool de subiecte ascunse, din care asistentul poate
alege cum se formeaza celelalte puncte ale laboratorului.
[4p] Se citesc de la tastatura N cercuri definite prin coordonatele centrului si raza (toate, numere intregi). Sa se
numere cate perechi de cercuri se intersecteaza.
Ex:
6
25 25 15
10 10 12
25 20 7
40 40 5
48 40 5
0 30 5
Output: 4 (se intersecteaza perechile de cercuri: (1, 2), (1, 3), (2, 3), (4, 5))
311CAa 2) [6p] Un robot pleacă de la coordonatele (0, 0) ale unei matrice de dimensiune n x m. El primește
dimensiunile matricei si o serie de comenzi codificate astfel ‘U’ → up (merge o casuță în sus), ‘D’ → down (merge o
casuță în jos), ‘R’ → right (merge o casuță la dreapta), ‘L’ → left (merge o casuță la stânga). Robotul primește
comenzile ca un șir de caractere (ex: “DDURLLR”). Întoarceți true dacă robotul ajunge înapoi în bază după aceste
comenzi (coordonatele (0, 0)) sau false în caz contrar. Afisati matricea dupa fiecare miscare, marcand pozitia
robotului cu un caracter distinct.
[2p] Alocați dinamic matricea

[2p] Implementați logica problemei
[2p] Verificați cu Valgrind că nu aveți memory leaks
313CAb 2) [6p] Se citește o matrice de dimensiune n x m. Se poate efectua operația XOR de-a lungul unei linii sau a
unei coloane. Să se afișeze rezultatul maxim.

311CAb 2) [6p] Se citește o matrice de dimensiune n x m. Se primesc alte două dimensiuni n’ si m’. Se va face
conversia de la matricea de n x m la matricea n’ x m’ și se va întoarce noua matrice (dacă este posibil). În caz contrar
se va afișa vechea matrice.

Ex:
n = 2
m = 2
[[1, 2], [3, 4]]
n’ = 1
m’ = 4
[1, 2, 3, 4]
314CAa 2) [6p] Se citește o matrice de dimensiune n x m. Fiecare linie va forma un număr. Exemplu: linia [3, 0, 2]
va forma numărul 302. Afișați suma liniilor.

312CAb 2) [6p] Se citește o matrice de dimensiune n x m. Să se rețină în memorie și să se afișeze transpusa ei.

313CAa 2) [6p] Se citește o matrice de dimensiune n x m cu toate elementele 0 și un șir de operații formate din
perechi de câte două numere a și b. La fiecare operatie, se incrementeaza toate elementele matricei aflate in
dreptunghiul cu coltul stanga-sus in [0,0] si dreapta-jos in [a,b].

Exemplu:
m=3n=3
Operații: [2, 2], [3, 3]
Inițial, M va fi
000
000
000
După [2, 2], M va fi
110
110
000
După [3, 3], M va fi
221
221
111
Afișați matricea finală.
314CAb 2) [6p] Se citește o matrice de dimensiune n x m. Se va popula cu caracterele ‘B’ → bomb, ‘E’ → enemy si
‘X’ → zona neutră. Fiecare bombă va exploda și va afecta întrega linie și întreaga coloană din care face parte,
transforând-o în zonă neutră. Întoarceți true dacă mai există inamici pe hartă și false în caz contrar.

Exemplu: Matrice inițială: [ [X, X, E, X], [X, B, X, X], [X, E, X, X], [X, X, B, X]]
După explozia bombelor: [ [X, X, X, X], [X, X, X, X], [X, X, X, X], [X, X, X, X]] → false
315CAa 2) [6p] Se citește o matrice de dimensiune n x m. Elementul ei minim va fi 1. Verificați că matricea conține
doar numere consecutive (suma tuturor elementelor == n * (n + 1) / 2)

315CAb 2) [6] Se citește o matrice de dimensiune n x m sortată crescător pe linii. Elementele ei vor fi doar 0 și 1. Să
se afișeze index-ul liniei cu cei mai multi de 1.

Interviu
Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți
întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului.
Care este diferenta dintre pass by value si pass by address?

Ce intoarce functia malloc? De ce?
Care sunt diferentele dintre alocarea dinamica si alocarea statica?
Ce se intampla daca un header este inclus de doua ori?
Și multe altele…
Bibliografie obligatorie
1. Cum scriem cod C corect? [https://www.csd.uoc.gr/~zakkak/hy255/reading/c_coding_style.pdf]

2. Valgrind quick start [http://valgrind.org/docs/manual/quick-start.html]
Bibliografie recomandată
1. Tutorial C pentru incepatori [https://www.learn-c.org/]

2. The C Programming Language by K&R
[http://www2.cs.uregina.ca/~hilder/cs833/Other%20Reference%20Materials/The%20C%20Programming%20Language.pdf]
sd-ca/laboratoare/lab-01.txt · Last modified: 2020/03/11 12:19 by andrei.vasiliu2211
6/11/2020 Laborator 2 - Liste înlănțuite [CS Open CourseWare]
Laborator 2 - Liste înlănțuite

Responsabili
Adrian Mirea [mailto:mailto:amirea99@gmail.com]

Alexandru Mihai [mailto:mailto:alexcosmin.mihai@gmail.com]
Obiective
În urma parcugerii acestui laborator, studentul va:
avea cunoștințele de baza despre ArrayList și LinkedList

putea implementa propria listă simplu înlănțuită
putea compara o listă înlănțuită cu un vector
Despre vectori
Cum ați învățat la PC și în laboratorul anterior, un vector este o colecție liniară și omogenă de date. În
cazul alocării dinamice (care va fi și modul predominant în care vom lucra cu structurile de
date), această zonă are o capacitate care se poate modifica (mări sau micșora) în funcție de diferite
criterii de redimensionare (de exemplu: putem dubla capacitatea vectorului dacă ajungem la 75% din
capacitatea sa curentă și putem înjumătăți capacitatea dacă vectorul esti plin în proporție mai mică de
25%). Obținem astfel mai multă memorie liberă, însă, trebuie să plătim prețul overhead-ului dat de
realocarea array-ului.
Această implementare (folosind vectorul) are avantajul vitezei de acces sporite (elementele sunt în locaţii
succesive de memorie), dar este limitată de cantitatea de memorie contiguă accesibilă programului.
LinkedList
O listă înlănțuită (LinkedList) reprezintă o structură de date liniară și omogenă. Spre deosebire de vector,
lista înlănțuită nu își are elementele într-o zonă contiguă de memorie ci fiecare element (nod al listei) va
conține pe langă informația utilă și legătură către nodul următor (listă simplu înlănțuită), sau legături către
nodurile vecine (listă dublu înlănțuită). Alocând dinamic nodurile pe măsură ce este nevoie de ele, practic
se pot obține liste de lungime limitată doar de cantitatea de memorie accesibilă programului.
Această implementare (folosind lista) are avantajul unei mai bune folosiri a memoriei, putând fi ocupată
toată memoria liberă disponibilă, indiferent de dispunerea ei. Dezavantajul constă în timpul de acces la
elementele listei, deoarece pentru a ajunge într-un element aleator, lista trebuie parcursă (în general) de la
primul element pană la cel dorit.
O listă înlănțuită are întotdeauna cel puțin un pointer: head. După cum spune și numele, el reprezintă
capul listei, începutul ei. head va indica mereu către primul element al listei. Un alt pointer ce poate fi
folosit pentru a facilita lucrul cu lista este tail, care, după cum spune și numele, reprezintă coada listei,
sfârșitul ei, el indicând către ultimul element al listei. Pe lângă cei doi pointeri precizați, este recomandat
să avem salvată și lungimea listei.
În concluzie, putem defini o listă în cod astfel:
struct Node {
void* data; // pointer void pentru a utiliza orice tip de date
...
};
struct LinkedList {
struct Node* head;
...
};
Asupra unei liste înlănțuite ar trebui să putem executa urmatoarele operații:
void add_nth_node(struct LinkedList* list, int n, void* new_data); adaugă pe

poziția n în listă elementul new_data. Adăugarea presupune modificarea câmpului next al nodului
în urma căruia se va adăuga noul nod, cât și a câmpului next al nodului adăugat pentru a face
legăturile necesare ca lista sa funcționeze corect. Dacă nodul este adăugat pe prima poziție, atunci
el va devenihead-ul listei, iar dacă este adăugat pe ultima poziție, el va deveni tail-ul listei.
Complexitate: O(n). Dacă se adaugă elementul în capul sau coada listei, se obține o complexitate
mai buna: O(1).
struct Node* remove_nth_node(struct LinkedList* list, int n); șterge și întoarce al

n-lea element al listei. Operația presupune modificarea listei astfel încât între nodurile vecine celui
eliminat să se refacă legaturile pentru a permite listei sa funcționeze în continuare. Daca nu există
un nod următor, head va deveni NULL, iar lista va fi goală. Dacă nodul eliminat era head-ul listei,
atunci succesorul său îi va lua locul. Analog pentru ultimul nod, însă în această situație, nodul
precedent devine tail. Complexitate: O(n). Dacă se șterge primul nod, se obține o complexitate
mai buna: O(1). Aceeași complexitate se obține și dacă lista este dublu înlănțuită și se șterge
ultimul nod.
int get_size(struct LinkedList* list); întoarce numărul curent de elemente stocate în

listă. Complexitate: O(1)
Pentru metodele de adăugare sau ștergere vor trebui, în funcție de caz, efectuate verificări speciale pentru
cazul unei liste vide, o listă cu un singur element, etc.
Tipuri de LinkedList
Există doua mari tipuri de liste înlănțuite: liniare și circulare.
Liste liniare
Listele liniare se numesc astfel deoarece ele au un caracter liniar: încep undeva și se termină altundeva,
fără a fi o legatură înapoi la începutul listei. Așadar, într-o listă liniară, câmpul next al ultimului element va
indica spre NULL. Dacă nodurile au legatură și spre elementul anterior, atunci câmpul prev al primului
element va indica tot spre NULL.
Listă liniară simplu înlănțuită
În acest laborator vom discuta doar despre listele simplu înlănțuite. Cum am aflat anterior, un nod al unei
liste simplu înlănțuite conține informația utilă și o legătură către nodul următor.
Putem reprezenta în cod acest nod astfel:
struct Node {
void* data;
struct Node* next;
};
Îmbinând informațiile despre listele liniare și particularitățile listei simplu înlănțuite, putem reprezenta
grafic o lista simplu înlănțuită astfel:
Schelet
schelet_lab02_linkedlist.zip
Exerciții
Fiecare laborator va avea unul sau doua exerciții publice și un pool de subiecte ascunse, din care asistentul
poate alege cum se formeaza celelalte puncte ale laboratorului.
[5p] Implementaţi, plecând de la scheletul de cod, lista liniară simplu înlănțuită.
311CAa
[2p] Implementați o funcție care primește ca parametru un pointer la începutul unei liste simplu înlănțuite
și inversează ordinea nodurilor din listă (fără alocare de memorie auxiliară pentru o nouă listă).
Exemplu: pentru lista 1 → 2 → 3 rezultă lista 3 → 2 → 1.
311CAb
[2p] Implementați o funcție care primește ca parametri doi pointeri la începuturile a două liste simplu
înlănțuite sortate și întoarce o listă simplu înlănțuită sortată ce conține toate elementele din cele două liste.
Exemplu: pentru listele 1 → 2 → 5 → 9 și 2 → 3 → 7 → 8 → 10 rezultă lista 1 → 2 → 2 → 3 → 5 → 7 → 8

→ 9 → 10.
312CAa
[2p] Implementați o funcție care primește ca parametri un pointer la începutul unei liste simplu înlănțuite
și șterge elementul aflat în mijlocul listei. Ștergerea trebuie să se facă printr-o singură parcurgere a listei.
Exemple:
pentru lista vidă, rezultă lista vidă;

pentru lista 1, rezultă lista vidă;
pentru lista 1 → 2, rezultă lista 2;
pentru lista 1 → 2 → 3, rezultă lista 1 → 3;
pentru lista 1 → 2 → 3 → 4, rezultă lista 1 → 3 → 4;
pentru lista 1 → 2 → 3 → 4 → 5, rezultă lista 1 → 2 → 4 → 5.
312CAb
[2p] Implementați o funcție care primește ca parametri un pointer la începutul unei liste simplu înlănțuite
și un element și adaugă elementul în mijlocul listei. Adăugarea trebuie să se facă printr-o singură
parcurgere a listei.
Exemple (elementul adăugat este X):
pentru lista vidă, rezultă lista X;

pentru lista 1, rezultă lista X → 1;
pentru lista 1 → 2, rezultă lista 1 → X → 2;
pentru lista 1 → 2 → 3, rezultă lista 1 → X → 2 → 3;
pentru lista 1 → 2 → 3 → 4, rezultă lista 1 → 2 → X → 3 → 4;
pentru lista 1 → 2 → 3 → 4 → 5, rezultă lista 1 → 2 → X → 3 → 4 → 5.
313CAa
[2p] Implementați o funcție care primește ca parametru un pointer la începutul unei liste simplu înlănțuite
și construiește două liste în care se vor afla toate elementele de pe poziții pare, respectiv impare, în
aceeași ordine.
Exemplu: pentru lista 1 → 2 → 2 → 3 → 5 → 7 → 8 → 9, rezultă listele 1 → 2 → 5 → 8 și 2 → 3 → 7 → 9.
313CAb
[2p] Fiind date două liste simplu înlănțuite cu numar egal de elemente, contopiți-le astfel încât după
fiecare nod provenit dintr-o listă să urmeze un nod din cealaltă listă. Nu alocați noduri noi!
Exemplu: pentru listele 1 → 3 → 5 și 2 → 4 → 6, rezultă lista 1 → 2 → 3 → 4 → 5 → 6.
314CAa
[2p] Se dă o listă simplu înlănțuită ale cărei noduri rețin valori de tip int și, se dă de asemenea, un integer
X. Reordonați nodurile din listă astfel încât toate nodurile cu valori mai mici sau egale decât X să apară
înaintea nodurilor cu valori mai mari decât X. Nu alocați noduri noi!
Exemplu: pentru lista 3 → 6 → 5 → 4 → 2 și integer-ul 3, o posibilă listă rezultat este 2 → 4 → 3 → 6 → 5.
314CAb
[2p] Fiind date două liste simplu înlănțuite, A și B, ale căror noduri stochează valori integer, construiți o
nouă listă simplu înlănțuită, C, pentru care fiecare nod i este suma nodurilor asociate din A și B. Mai exact,
nodul i din C reține suma dintre valoarea nodului i din A și valoarea nodului i din B. Dacă una dintre listele
primite este mai lungă decât cealaltă, se consideră că nodurile asociate lipsă din cealaltă listă conțin
valoarea 0, adică se păstrează valorile din lista mai lungă.
Exemplu: pentru listele A: 3 → 7 → 29 → 4 și B: 2 → 4 → 3, va rezulta lista C: 5 → 11 → 32 → 4.
315CAa
[2p] Se dau două liste simplu înlănțuite, A și B, ale căror noduri stochează în ordine inversă cifrele câte
unui număr natural reprezentat în baza 10 (primul nod al unei liste stochează cea mai puțin semnificativă
cifră). Creați o nouă listă simplu înlănțuită, C, care stochează suma celor două numere. Lista C trebuie
construită în timp ce se parcurg listele A și B!
Exemplu: pentru listele A: 4 → 3 → 2 → 9 și B: 6 → 6 → 7, rezultă lista C: 0 → 0 → 0 → 0 → 1.
315CAb
[2p] Se dă o listă simplu înlănțuită ale cărei noduri stochează câte un caracter. Verificați dacă șirul de
caractere stocat de lista simplu înlănțuită reprezintă un palindrom. Puteți folosi o nouă listă auxiliară sau
puteți modifica lista primită, dar nu puteți să rețineți șirul în afara unei liste (de ex. nu aveți voie să
parcurgeți lista și să stocați șirul la o adresă la care pointează un char*).
Exemplu: pentru lista l → u → p → u → l, rezultă ca este palindrom.
Interviu
Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le
puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul
laboratorului.
1. Implementați o funcție de ștergere a duplicatelor dintr-o listă simplu înlănțuită sortată.

2. Implementați o funcție de detectare (+ înlăturare) a unui ciclu într-o listă simplu înlănțuită.
3. Găsirea celui de-al k-lea nod de la sfârșit spre început într-o listă simplu înlănțuită.
Și multe altele…
Bibliografie
1. Linked list visualization [https://visualgo.net/en/list]

2. CLRS - Introduction to Algorithms, 3rd edition, capitol 10.2 - Linked lists
6/11/2020 Laborator 3 - Liste înlănțuite (continuare) [CS Open CourseWare]
Laborator 3 - Liste înlănțuite (continuare)

Responsabili

Alexandru Mihai [mailto:mailto:alexcosmin.mihai@gmail.com]
Obiective
În urma parcugerii acestui laborator, studentul va:
putea implementa propria listă dublu înlănțuită

putea implementa propria listă circulară
LinkedList (conținut din laboratorul precedent)

O listă înlănțuită (LinkedList) reprezintă o structură de date liniară și omogenă. Spre deosebire de vector,
lista înlănțuită nu își are elementele într-o zonă contiguă de memorie, ci fiecare element (nod al listei) va
conține, pe langă informația utilă, și legătură către nodul următor (listă simplu înlănțuită), sau legături
către nodurile vecine (listă dublu înlănțuită). Alocând dinamic nodurile pe măsură ce este nevoie de ele,
practic se pot obține liste de lungime limitată doar de cantitatea de memorie accesibilă programului.
Această implementare (folosind lista) are avantajul unei mai bune folosiri a memoriei, putând fi ocupată
toată memoria liberă disponibilă, indiferent de dispunerea ei. Dezavantajul constă în timpul de acces la
elementele listei, deoarece pentru a ajunge într-un element aleator, lista trebuie parcursă (în general) de la
primul element pană la cel dorit.
O listă înlănțuită are întotdeauna cel puțin un pointer: head. După cum spune și numele, el reprezintă
capul listei, începutul ei. head va indica mereu către primul element al listei. Un alt pointer ce poate fi
folosit pentru a facilita lucrul cu lista este tail, care, după cum spune și numele, reprezintă coada listei,
sfârșitul ei, el indicând către ultimul element al listei. Pe lângă cei doi pointeri precizați, este recomandat
să avem salvată și lungimea listei.
În concluzie, putem defini o listă în cod astfel:
struct Node {
void* data; // pointer void pentru a utiliza orice tip de date
...
};
struct LinkedList {
struct Node* head;
struct Node* tail;
int size;
};
Asupra unei liste înlănțuite ar trebui să putem executa urmatoarele operații:
void add_nth_node(struct LinkedList* list, int n, void* new_data); adaugă pe

poziția n în listă elementul new_data. Adăugarea presupune modificarea câmpului next al nodului
în urma căruia se va adăuga noul nod, cât și a câmpului next al nodului adăugat pentru a face
legăturile necesare ca lista sa funcționeze corect. Dacă nodul este adăugat pe prima poziție, atunci
el va devenihead-ul listei, iar dacă este adăugat pe ultima poziție, el va deveni tail-ul listei.
Complexitate: O(n). Dacă se adaugă elementul în capul sau coada listei, se obține o complexitate
mai buna: O(1).
struct Node* remove_nth_node(struct LinkedList* list, int n); șterge și întoarce al

n-lea element al listei. Operația presupune modificarea listei astfel încât între nodurile vecine celui
eliminat să se refacă legaturile pentru a permite listei sa funcționeze în continuare. Daca nu există
un nod următor, head va deveni NULL, iar lista va fi goală. Dacă nodul eliminat era head-ul listei,
atunci succesorul său îi va lua locul. Analog pentru ultimul nod, însă în această situație, nodul
precedent devine tail. Complexitate: O(n). Dacă se șterge primul nod, se obține o complexitate
mai buna: O(1). Aceeași complexitate se obține și dacă lista este dublu înlănțuită și se șterge
ultimul nod.
int get_size(struct LinkedList* list); întoarce numărul curent de elemente stocate în

listă. Complexitate: O(1)
Pentru metodele de adăugare sau ștergere vor trebui, în funcție de caz, efectuate verificări speciale pentru
cazul unei liste vide, o listă cu un singur element, etc.
Tipuri de LinkedList
Există doua mari tipuri de liste înlănțuite: liniare și circulare.
Liste liniare
Listele liniare se numesc astfel deoarece ele au un caracter liniar: încep undeva și se termină altundeva,
fără a fi o legatură înapoi la începutul listei. Așadar, într-o listă liniară, câmpul next al ultimului element va
indica spre NULL. Dacă nodurile au legatură și spre elementul anterior, atunci câmpul prev al primului
element va indica tot spre NULL.
Listă liniară simplu înlănțuită

Prezentată în laboratorul precedent.
Listă liniară dublu înlănțuită
Spre deosebire de o listă simplu înlănțuită, un nod al unei liste dublu înlănțuite conține informația utilă și
două legături: una către nodul anterior și alta către nodul următor.
Putem reprezenta în cod acest nod astfel:
struct Node {
void* data;
struct Node* prev;
struct Node* next;
};
Îmbinând informațiile despre listele liniare și particularitățile listei dublu înlănțuite, putem reprezenta grafic
o lista dublu înlănțuită astfel:
Liste circulare
Listele circulare se numesc astfel datorită caracterului lor circular: primul și ultimul nod al listei sunt
conectate. Așadar, într-o listă circulară, câmpul next al ultimului element va indica spre primul element.
Dacă nodurile au legătură și spre elementul anterior, atunci câmpul prev al primului element va indica spre
ultimul element.
Listă circulară simplu înlănțuită

Pentru acest tip de listă, un nod este reprezentat la fel ca într-o listă liniară simplu înlănțuită:
struct Node {
void* data;
struct Node* next;
};
Îmbinând informațiile despre listele circulare și particularitățile listei circulare simplu înlănțuite, putem
reprezenta grafic o listă simplu înlănțuită astfel:
Listă circulară dublu înlănțuită
Pentru acest tip de listă, un nod este reprezentat la fel ca într-o listă liniară dublu înlănțuită:
struct Node {
void* data;
struct Node* prev;
struct Node* next;
};
Îmbinând informațiile despre listele circulare și particularitățile listei circulare dublu înlănțuite, putem
reprezenta grafic o listă simplu înlănțuită astfel:
Schelet
schelet_laborator03_circulardoublylinkedlist.zip
Exerciții
[7p] Implementaţi, plecând de la scheletul de cod, lista circulară dublu înlănțuită.
311CAb
[2p] Implementați o funcție care primește ca parametru un pointer la începutul unei liste dublu înlănțuite
și inversează ordinea nodurilor din listă (fără alocare de memorie auxiliară pentru o nouă listă).
Exemplu: pentru lista 1 ⇔ 2 ⇔ 3 rezultă lista 3 ⇔ 2 ⇔ 1.

312CAb
[2p] Fiind date două liste dublu înlănţuite, A şi B, ale căror noduri stochează valori integer, construiţi o
nouă listă dublu înlănţuită, C, pentru care fiecare nod i este suma nodurilor asociate din A şi B. Mai exact,
nodul i din C reţine suma dintre valoarea nodului i din A şi valoarea nodului i din B. Dacă una dintre listele
primite este mai lungă decât cealaltă, se consideră că nodurile asociate lipsă din cealaltă listă conţin
valoarea 0, adică se păstrează valorile din lista mai lungă.
Exemplu: pentru listele A: 3 ⇔ 7 ⇔ 29 ⇔ 4 și B: 2 ⇔ 4 ⇔ 3, va rezulta lista C: 5 ⇔ 11 ⇔ 32 ⇔ 4.

313CAa
[2p] Implementați o funcție care primește ca parametri doi pointeri la începuturile a două liste dublu
înlănțuite sortate și întoarce o listă dublu înlănțuită sortată ce conține toate elementele din cele două liste.
Exemplu: pentru listele 1 ⇔ 2 ⇔ 5 ⇔ 9 și 2 ⇔ 3 ⇔ 7 ⇔ 8 ⇔ 10 rezultă lista 1 ⇔ 2 ⇔ 2 ⇔ 3 ⇔ 5 ⇔ 7 ⇔ 8 ⇔

9 ⇔ 10.
314CAb
[2p] Implementați o funcție care primește ca parametri un pointer la începutul unei liste dublu înlănțuite și
șterge elementul aflat în mijlocul listei. Ștergerea trebuie să se facă printr-o singură parcurgere a listei.
Exemple:
pentru lista vidă, rezultă lista vidă;

pentru lista 1, rezultă lista vidă;
pentru lista 1 ⇔ 2, rezultă lista 2;
pentru lista 1 ⇔ 2 ⇔ 3, rezultă lista 1 ⇔ 3;
pentru lista 1 ⇔ 2 ⇔ 3 ⇔ 4, rezultă lista 1 ⇔ 3 ⇔ 4;
pentru lista 1 ⇔ 2 ⇔ 3 ⇔ 4 ⇔ 5, rezultă lista 1 ⇔ 2 ⇔ 4 ⇔ 5.
315CAa
[2p] Implementați o funcție care primește ca parametri un pointer la începutul unei liste dublu înlănțuite și
un element și adaugă elementul în mijlocul listei. Adăugarea trebuie să se facă printr-o singură parcurgere
a listei.
Exemple (elementul adăugat este X):
pentru lista vidă, rezultă lista X;

pentru lista 1, rezultă lista X⇔ 1;
pentru lista 1 ⇔ 2, rezultă lista 1 ⇔ X ⇔ 2;
pentru lista 1 ⇔ 2 ⇔ 3, rezultă lista 1 ⇔ X ⇔ 2 ⇔ 3;
pentru lista 1 ⇔ 2 ⇔ 3 ⇔ 4, rezultă lista 1 ⇔ 2 ⇔ X ⇔ 3 ⇔ 4
pentru lista 1 ⇔ 2 ⇔ 3 ⇔ 4 ⇔ 5, rezultă lista 1 ⇔ 2 ⇔ X ⇔ 3 ⇔ 4 ⇔ 5.

315CAb
[2p] Implementați o funcție care primește ca parametru un pointer la începutul unei liste dublu înlănțuite
și întoarce o listă dublu înlănțuită obținută prin următoarea procesare a listei inițiale: între fiecare nod și
succesorul său (din lista inițială) se introduce un nou nod, având ca valoare suma valorilor celor două
noduri învecinate.
Exemplu: pentru lista 1 ⇔ 2 ⇔ 5 ⇔ 6 ⇔ 7 ⇔ 9 rezultă lista 1 ⇔ 3 ⇔ 2 ⇔ 7 ⇔ 5 ⇔ 11 ⇔ 6 ⇔ 13 ⇔ 7 ⇔ 16

⇔ 9.
Interviu
laboratorului.
1. Implementați o funcție de ștergere a duplicatelor dintr-o listă dublu înlănțuită sortată.

2. Implementați o funcție de detectare (+ înlăturare) a unui ciclu într-o listă dublu înlănțuită.
Și multe altele…
Bibliografie
1. Linked list visualization [https://visualgo.net/en/list]

2. CLRS - Introduction to Algorithms, 3rd edition, capitol 10.2 - Linked lists
sd-ca/laboratoare/lab-03.txt · Last modified: 2020/03/12 14:43 by serban_ioan.ciofu
6/11/2020 Laborator 4 - Dicţionar [CS Open CourseWare]
Laborator 4 - Dicţionar
Responsabili
Andrei Dinu [mailto:mailto:dinuaadrian@gmail.com]

Alexandru-Cosmin Mihai [mailto:mailto:alexcosmin.mihai@gmail.com]
Obiective
În urma parcurgerii acestui articol studentul va fi capabil să:
definească tipul de date dicționar

implementeze un dicționar folosind tabele de dispersie
prezinte avantaje / dezavataje ale diverselor implementări de dicționare
Ce este un dicționar?
Un dicţionar este un tip de date abstract compus dintr-o colecție de chei şi
o colecție de valori, în care fiecărei chei îi este asociată o valoare.
Operația de găsire a unei valori asociate unei chei poartă numele de

indexare, aceasta fiind și cea mai importantă operație. Din acest motiv
dicționarele se mai numesc și array-uri asociative - fac asocierea între o
cheie și o valoare.
Operația de adăugare a unei perechi (cheie-valoare) în dicționar are două

părți. Prima parte este transformarea cheii într-un index întreg, printr-o
funcție de hashing. În mod ideal, chei diferite mapează indexuri diferite în
dicționar, însa în realitate nu se întamplă acest lucru. De aceea, partea a
doua a operației de adăugare constă în procesul de rezolvare a
coliziunilor.
Operații de bază
put(key, value):
adaugă în dicționar o nouă valoare și o asociază unei anumite chei
dacă perechea există deja, valorea este înlocuită cu cea nouă
remove(key):
elimină din dicţionar cheia key (şi valoarea asociată acesteia)
get(key):
întoarce valoarea asociată cheii
dacă perechea nu există, întoarce corespunzător o eroare pentru a semnala acest lucru
has_key(key):
întoarce TRUE dacă există cheia respectivă în dicționar
întoarce FALSE dacă nu există cheia respectivă în dicționar
Implementare
O implementare frecvent întâlnită a unui dicționar este cea folosind o tabelă de dispersie - hashtable. Un
hashtable este o structură de date optimizată pentru funcția de căutare - în medie, timpul de căutare este
constant: O(1). Acest lucru se realizează transformând cheia într-un hash - un număr întreg fără semn pe
16 / 32 / 64 de biţi, etc. - folosind o funcție hash.
În cel mai defavorabil caz, timpul de căutare al unui element poate fi O(n). Totuși, tabelele de dispersie
sunt foarte utile în cazul în care se stochează cantități mari de date, a căror dimensiune (mărime a
volumului de date) poate fi anticipat.
Funcția hash trebuie aleasă astfel încât să se minimizeze numărul coliziunilor (chei diferite care produc
aceleași hash-uri). Coliziunile apar în mod inerent, deoarece lungimea hash-ului este fixă, iar obiectele de
stocare pot avea lungimi și conținut arbitrare. În cazul apariției unei coliziuni, valorile se stochează pe
aceeaşi poziție - în același bucket. În acest caz, căutarea se va reduce la compararea valorilor efective în
cadrul bucket-ului.
Exemplu de hash pentru șiruri de caractere:
hash.h
#ifndef __HASH__H__
#define __HASH__H__
// Hash function based on djb2 from Dan Bernstein

// http://www.cse.yorku.ca/~oz/hash.html
//
// @return computed hash value
unsigned int hash_fct(char *str)

{
unsigned int hash = 5381;
int c;
while ((c = *str++) != 0) {

hash = ((hash << 5) + hash) + c;
}
return hash;
}
#endif //__HASH__H__
Exemplu pentru construcția de funcții hash care minimizează numărul de coliziuni

[https://stackoverflow.com/questions/1145217/why-should-hash-functions-use-a-prime-number-modulus]
Reprezentarea internă cu liste înlănțuite

O implementare a unui hashtable care tratează coliziunile se numește înlănțuire directă - direct chaining.
Cea mai simplă formă folosește câte o listă înlănțuită pentru fiecare bucket, practic un array de liste.
Fiecare listă este asociată unui anumit hash.
inserarea în hashtable presupune găsirea indexului corect și adăugarea elementului la lista

corespunzătoare.
Hash-ul poate depăşi cu mult dimensiunea array-ului de bucket-uri, ceea ce duce la necesitatea folosirii,
cel mai frecvent, a operaţiei modulo → index = hash % HMAX, pentru a situa indexul bucket-ului în care
va fi inserat elementul în limitele necesare.
Dacă dimensiunea array-ului este exprimată în puteri ale lui 2, se mai poate folosi şi formula următoare →
index = hash & (HMAX - 1).
HMAX reprezintă dimensiunea maximă a array-ului.
ștergerea presupune căutarea și scoaterea elementului din lista corespunzătoare.

cautarea presupune determinarea index-ului prin funcția de hashing și apoi identificarea perechii
potrivite.
has_key presupune determinarea existenței unei chei în dicționar
void put(key, value, hash_table)

index <- hash(key) % DIMENSIUNE_DICTIONAR
pentru element it in bucketul hash_table[index]
// Se itereaza prin lista inlantuita de la index, pana se
// gaseste cheia dorita; daca nu este gasita, vom insera
// un entry nou in cadrul bucketului
daca it->key == key
// Daca exista key deja in bucket
// doar se updateaza valoarea
it->value <- value
return; // Cheia a fost actualizata, iesim din functie
// Daca nu a fost gasita cheia in bucket, inseram una noua

creeaza un nou element pe baza key, value
adauga elementul in hashtable
void remove(key, hash_table)

daca it->key == key
break
// it va pointa ori dupa ultimul element (hash_table.end) => nu avem ce sterge

// ori catre un element deja existent in bucket => stergem elementul it
daca it nu indica finalul listei
sterge elementul de la pozitia lui it
TypeValue get(key, hash_table)

daca it->key == key
return it->value
return null
bool has_key(key, hash_table)

daca it->key == key
return true
return false
Avantajul tabelelor de dispersie constă în faptul că operația de ștergere este simplă, iar redimensionarea
tabelei poate fi amânată mult timp, deoarece performanța este suficient de bună chiar și atunci când toate
pozițiile din hashtable sunt folosite.
Dezavantajele acestei soluții sunt cele moștenite de la listele înlănțuite: pentru stocarea unor date mici,
overhead-ul introdus poate fi semnificativ, iar parcurgerea unei liste este costisitoare.
Există și alte structuri de date cu ajutorul cărora se poate implementa un hashtable ca mai sus. Un
exemplu ar fi un arbore binar de căutare echilibrat, pentru care timpul, pe cazul cel mai defavorabil, se
poate reduce la O(log n) față de O(n). Totuși, această variantă se poate dovedi ineficientă dacă hashtable-
ul este proiectat pentru puține coliziuni.
Un alt mod de a utiliza o listă inlanțuită pentru crearea unui dicționar presupune folosirea linear probing.
Atunci când la inserarea unei perechi (cheie-valoare) în dicționar apărea o coliziune, algoritmul caută
primul “spațiu gol” și inserează acolo perechea.
Alte reprezentări interne

arbori binari de căutare echilibrați
radix-tree
prefix-tree
array-uri judy
Acestea prezintă timpi de căutare mai buni pentru cel mai defavorabil caz și folosesc eficient spațiul de
stocare în funcție de tipul de date folosit.
Schelet
schelet_laborator04_hashtable.zip
Exerciţii
poate alege cum se formează celelalte puncte ale laboratorului.
1) [3p] Implementaţi structura de date dicţionar, plecând de la pseudocodul de mai sus şi de la schelet.
[311CAb]
2) [4p] Movies
Un website are o baza de date in care retine filme si seriale. Un film este caracterizat de nume, regizor,
anul aparitiei și rating.
[1p] a. Adăugaţi cel puţin 5 filme în hashtable. Cel puţin un film trebuie să aibă un rating mai mic de 5, iar
cel puţin un film trebuie să aibă un rating mai mare de 5. Exemplu orientativ: HASH = 0: Being Human -
Bill Forsyth, 1994 | Being human - Toby Whithouse, 2008 | HASH = 1: Avatar - James Cameron, 2009 |
HASH = 2: The edge of seventeen - Kelly Fremon Craig, 2016 | HASH = 3: Twilight - Robert Benton, 1998
| Edge of Fear - Bobby Roth, 2018 | HASH = 4: Twilight - Catherine Hardwicke, 2008 | The edge of love -
John Maybury, 2008 |
[1p] b. Sa se afiseze informații despre filmul care are numele <movie_query>. Se garantează ca rezultatul
contine un singur film. Complexitatea pentru gasirea informatiilor trebuie sa fie O(1).
[1p] c. La introducerea numelui un regizor, sa se afișeze toate filmele regizate de acesta. În cazul în care
acesta nu apare deloc în baza de date, să se afișeze mesajul: “Never heard about him”. Nu parcurgeți toate
intrările din hashtable! (Hint: Este de ajuns hashtable-ul de la cerinţa b?)
[1p] d. Eliminarea filmelor cu rating mai mic de 5 stele.
[2p] (bonus). Implementați și testați redimensionarea unui hashtable: funcția resize dublează
dimensiunea structurii interne a tabelei de dispersie. Dublarea se va face în momentul în care raportul
dintre numărul de elemente introduse în hashtable şi numărul de bucket-uri HMAX este mai mare decâti o
valoare aleasă (ex: size / HMAX > 0.75).
[312CAa]
2) [4p] Bibliotecă
Cărțile dintr-o bibliotecă sunt reprezentate în sistem folosindu-se un hashtable. O carte este caracterizată
prin titlu, autor, anul în care a fost publicată și statusul (la raft sau împrumutată).
[1p] a. Adăugaţi cel puţin 5 cărţi în hashtable. Cel puţin o carte trebuie să aibă statusul de împrumutată şi
cel puţin o carte trebuie să fie disponibilă la raft. Exemplu orientativ: HASH = 0: HASH = 1: Brave New
World by Aldous Huxley | Animal Farm by George Orwell | HASH = 2: The Catcher in the Rye by J.D.
Salinger | I, Robot by Isaac Asimov | HASH = 3: HASH = 4: 1984 by George Orwell | Lord of the Flies by
William Golding |
[1p] b. Afișarea statusului unei cărți date, dacă aceasta există în hashtable. Se va afișa statusul dacă
există sau “Cartea nu a fost înregistrată”, în caz contrar.
[1p] c. Afișarea tuturor cărților scrise de autorul “famous_author” din schelet. Nu parcurgeți toate intrările
din hashtable! (HINT: Este de ajuns hashtable-ul curent?)
[1p] d. Eliminarea din hashtable a tuturor cărților împrumutate.
[312CAb]
2) [4p] Adrese
O firma de imobiliare folosește un hashtable pentru a memora imobilele pe care le administrează. Un astfel
de imobil este caracterizat de adresă, numele locatarului, anul în care a cumpărat casa, numărul de
animale de companie.
[1p] a. Adăugaţi cel puţin 5 imobile în hashtable. La cel puţin un imobil trebuie să se găsească mai mult de
5 animale de companie şi la cel puţin un imobil trebuie să se găsească mai puţin de 5 animale de
companie. Exemplu orientativ: HASH = 0: Bender Bending Rodriguez's address is Robot Arms Apts., New
York | Amy Wong's address is Wong Ranch, Western hemisphere of Mars | HASH = 1: Hubert J.
Farnsworth's address is West 57th Street, New York | Leela Turanga's address is Planet Express Starship,
New York | John A. Zoidberg's address is Decapod 10, Space | HASH = 2: HASH = 3: Kif Kroker's address
is Nimbus Starship, Space | HASH = 4: Philip J. Fry's address is Applied Cryogenics, New York |
[1p] b. Verificarea disponibilității casei de la adresa dream_house. Dacă nu locuiește nimeni la această
adresă, afișați “Omg! You can move in right now!”, altfel, afișați “Your dream house is no longer available”.
[1p] c. Căutaţi toate locuinţele din oraşul <city> şi afişaţi-le.Nu parcurgeţi toate intrările din hashtable!.
(Hint: Este de ajuns hashtable-ul curent?)
[1p] d. Eliminarea persoanelor care dețin mai mult de 5 de animale de casă.
valoare aleasă (ex: size / HMAX > 0.75). Comportamentul dorit pentru această funcţionalitate este
următorul: se redimensionează array-ul de bucket-uri, iar apoi fiecare bucket este parcus în ordine și
elementele sunt redistribuite după valoarea noului hash.
[313CAa]
2) [4p] UEFA
Site-ul UEFA se pregăteşte să publice cea mai bună echipă a tuturor timpurilor. Baza de date este ținută
sub forma unui hashtable. Un fotbalist este caracterizat prin nume, naţionalitate, poziția pe care a jucat,
cel mai important trofeu câştigat şi un rating. În cazul atacanţilor şi mijlocaşilor se contorizează numărul
de goluri marcate și assist-uri iar în cazul portarilor şi al fundașilor se contorizează numărul de meciuri fără
gol primit și tackling-uri reușite.
[1p] a. Adăugați cel puţin 5 jucători în hashtable. Cel puţin unul dintre aceştia trebuie să aibă un rating
mai mare de 200 şi cel puţin un jucător trebuie să aibă un rating mai mic de 200.
[1p] b. Afişarea informaţiilor despre un jucător
[1p] c. Eliminați din hashtable fotbaliștii cu rating mai mic de 200.
[1p] d. Afișați cei mai buni jucători din țara <country_query>. Nu parcurgeți toate intrările din hashtable!
Hint: Este de ajuns hashtable-ul curent?
[314CAb]
2) [4p] Studenţi (varianta 2)
Studenții unei universități sunt memorați într-o bază de date ce are forma unui hashtable. Fiecare student
este caracterizat prin nume, facultatea la care este înscris, anul de studiu și media obținută.
[1p] a. Adăugați cel puțin 5 studenți în hash table. Exemplu orientativ: HASH = 0: Todd Chavez | Mr.
Peanutbutter | HASH = 1: BoJack Horseman | Sarah Lynn | HASH = 2: Diane Nguyen | HASH = 3: Princess
Carolyn | HASH = 4:
[1p] b. Căutarea unui student după nume. Se va afișa “Studentul <nume_student> este înscris la
facultatea <facultate_student> și are media <nota_student>.” în cazul în care este găsit sau “Studentul
<nume_student> nu a fost găsit!”, în caz contrar.
[1p] c. Afişaţi toţi studenţii care sunt înscrişi la o anumită facultate. Nu parcurgeți toate intrările din
hashtable! (HINT: Este de ajuns hashtable-ul curent?)
[1p] d. Eliminați din hashtable toţi studenţii care au o medie mai mică decât valoarea medie a mediilor
studentilor de la facultatea lor.
[315CAa]
2) [4p] [Magazin]
Un magazin stochează date despre produsele pe care le vinde într-o bază de date implementată ca
hashtable. Fiecare produs este caracterizat prin nume, categorie, pret, număr vânzări.
[1p] a. Adăugați cel puțin 5 produse în hashtable din cel puţin două categorii diferite.
[1p] b. Căutarea unui produs după nume. Se va afișa “Produs: <nume_produs>; Categorie:
<nume_categorie>; Pret: <pret_produs>; Nr vanzari: <nr_vanzari_produs>” în cazul în care este găsit
sau “Produsul <nume_produs> nu face parte din oferta magazinului.”, în caz contrar.
[1p] c. Afişaţi toate produsele dintr-o anumită categorie. Nu parcurgeți toate intrările din hashtable!
(HINT: Este de ajuns hashtable-ul curent?)
[1p] d. Eliminați din hashtable toate produsele care au un număr de vânzări mai mic strict decât media
vânzărilor produselor din categoria lor.
[315CAb]
2) [4p] Garaj
Un service auto stochează date despre maşinile clienţilor într-o bază de date implementată ca hashtable.
Fiecare maşină este caracterizat prin număr de înmatriculare, proprietar şi status (maşina e reparată sau
aşteaptă ca un mecanic s-o verifice).
[1p] a. Adăugați cel puțin 5 maşini în hashtable. Cel puţin o maşină trebuie să aibă statusul de “reparată”
şi cel puţin una trebuie să aibă statusul de “în aşteptare”. Cel puţin 2 maşini trebuie să aibă acelaşi
proprietar.
[1p] b. Căutarea unei maşini după numărul de înmatriculare. Se va afișa “Maşina:

<numar_inmatriculare>; Proprietar: <nume_proprietar>; Status: <status_masina>” în cazul în care este
găsită sau “Masina <numar_inmatriculare> nu se afla in service.”, în caz contrar.
[1p] c. Afişaţi toate maşinile din baza de date care sunt deţinute de un acelaşi proprietar specificat. Nu
parcurgeți toate intrările din hashtable! (HINT: Este de ajuns hashtable-ul curent?)
[1p] d. Eliminați din hashtable toate maşinile care au fost deja reparate (pe baza statusului).
Interviu
laboratorului.
Pentru o colecție de date cu nume, prenume și multe alte câmpuri, cum ai defini funcția hash?
Care este complexitatea unei operatiuni de căutare într-un hashtable?
Care este diferența dintre un hashtable și un vector?
Descrie cum ai implementa DEX cu ajutorul unui hashtable.
În ce condiții căutarea într-un hashtable ar putea să nu fie constantă?
Bibliografie
1. Wikipedia: Hashtable [http://en.wikipedia.org/wiki/Hashtable]
2. Wikipedia: Hash function [http://en.wikipedia.org/wiki/Hash_function]
3. Open Hashing Visualization [http://www.cs.usfca.edu/~galles/visualization/OpenHash.html]
4. Closed Hashing Visualization [http://www.cs.usfca.edu/~galles/visualization/ClosedHash.html]

5. Closed Hashing (Buckets) Visualization
[http://www.cs.usfca.edu/~galles/visualization/ClosedHashBucket.html]
6. Collection of hash functions [http://www.cse.yorku.ca/~oz/hash.html]
sd-ca/laboratoare/lab-04.txt · Last modified: 2020/03/19 15:40 by serban_ioan.ciofu
6/11/2020 Laborator 5 - Stivă și Coadă [CS Open CourseWare]
Laborator 5 - Stivă și Coadă

Responsabili:
Rareș Cheșeli [mailto:mailto:rares96cheseli@gmail.com]

Obiective
În urma parcurgerii acestui laborator studentul va fi capabil să:
înțeleagă principiul de funcționare al structurilor de date stivă și coadă

implementeze o stivă și o coadă folosind un vector pentru stocarea elementelor
transforme o expresie din forma infixată în formă postfixată
să evalueze o expresie în formă postfixată
implementeze algoritmul de sortare Radix Sort
Stivă (Stack)
O stivă este o instanță a unui tip de date abstract ce formalizează conceptul de colecție cu acces
restricționat. Restricția respectă regula LIFO (Last In, First Out).
Accesul la elementele stivei se face doar prin vârful acesteia.
Operații:
void push(struct Stack *stack, void *new_data) – adaugă un element (entitate) în stivă. Adăugarea
se poate face doar la vârful stivei.
void* pop(struct Stack *stack) – șterge un element din stivă și îl returnează. Ștergerea se poate
face doar la vârful stivei.
void* peek(struct Stack *stack) – consultă (întoarce) elementul din vârful stivei fără a efectua nicio
modificare asupra acesteia.
int is_empty(struct Stack *stack) – întoarce 1 dacă stiva este goală; 0 dacă are cel puțin un
element
Implementare
O structură de date definește un set de operații și funcționalitatea acestora.
Implementarea efectivă a unei structuri de date poate fi realizată în diverse moduri, cât timp
funcționalitatea este păstrată.
O stivă poate fi implementată cu ajutorul unui vector sau cu liste înlănțuite.
În cadrul acestui laborator, ne vom concentra asupra implementării unei stive cu ajutorul unui vector de
stocare.
Reprezentare internă cu vector

La nivel de implementare, stiva este reprezentată printr-o structură ce folosește un vector de stocare
(stack_array) de o dimensiune maximă dată (NMAX) și un indice ce indică vârful stivei (top_level), cât și
un set de operații ce pot fi efectuate asupra stivei.
Exemplu de utilizare
Forma poloneză inversă

Forma poloneză inversă [http://en.wikipedia.org/wiki/Reverse_Polish_notation] este o notație matematică în
care fiecare operator urmează după toți operanzii săi.
Cel mai simplu exemplu de notație postfixată este cel pentru doi operanzi și un operator:
5 + 4 se scrie sub forma 5 4 +
În cazul în care există mai multe operații, operatorul apare imediat după cel de-al doilea operand:
2 + 4 - 5 se scrie sub forma 2 4 + 5 -
Avantajul major al formei poloneze inverse este faptul că elimină parantezele din cadrul expresilor:
5 + (1 + 4) se scrie sub forma 5 1 4 + +
Algoritmul de conversie a unei expresii din formă infixată în formă postfixată
1. cât timp există elemente de citit

1.1 citește un element
1.2 dacă elementul este un număr, afișare (se adaugă la forma
postfixată)
1.3 dacă elementul este o paranteză stângă, adaugă-l în stivă
1.4 dacă elementul este o paranteză dreaptă, extrage operatorii din
stivă și adaugă-i la forma postfixată până când vârful stivei
ajunge o paranteză stângă (care este extrasă, dar nu este
adăugată la forma postfixată).
!!! dacă stiva s-a golit fără să fie găsită o paranteză stângă,
înseamnă că expresia inițială avea paranteze greșite
1.5 dacă elementul este un operator (fie el O1)
1.5.1 cât timp există un alt operator în vârful stivei (fie el O2)
ȘI precedența lui O1 este MAI MICA SAU EGALA decât cea a lui O2, extrage O2
din stivă, afișare (se adaugă la forma postfixată)
1.5.2 adaugă O1 în stivă
2. când nu mai există elemente de citit, extrage toate elementele rămase
în stivă și adaugă-le la forma postfixată (elementele trebuie să fie
numai operatori; dacă este extrasă o paranteză stângă expresia inițială
avea parantezele greșite).
Exemplu
Fie expresia:
1 - 7 * 2 /(3 + 5)^2^5
Element Acțiune Forma postfixată Stiva Observaţii

1 Adaugă element la forma postfixată 1
- Pune elementul în stivă 1 -
7 Adaugă element la forma postfixată 1,7 -
*
* Pune elementul în stivă 1,7 * are precedență mai mare decât -
-
*
2 Adaugă element la forma postfixată 1,7,2
-
Extrage element din stivă - / și * au aceeași prioritate
/ 1,7,2* /
Pune elementul în stivă / are precedență mai mare decât -
-
( Pune elementul în stivă 1,7,2* (
/
-
(
3 Adaugă element la forma postfixată 1,7,2*3 /
-
+
(
+ Pune elementul în stivă 1,7,2*3
/
-
+
(
5 Adaugă element la forma postfixată 1,7,2*3,5
/
-
(
Extrage element din stivă / Se repeta până când se întâlnește (
) 1,7,2*3,5+ -
/
repetă ( a fost ignorat
-
^
^ Pune elementul în stivă 1,7,2*3,5+ / ^ are precedență mai mare decât /
-
^
2 Adaugă element la forma postfixată 1,7,2*3,5+2 /
-
^
^
^ Pune elementul în stivă 1,7,2*3,5+2 ^ este considerat asociativ-dreapta
/
-
^
^
5 Adaugă element la forma postfixată 1,7,2*3,5+2,5
/
-
Final Extrage toate elementele din stivă 1,7,2*3,5+2,5^^/-
Algoritmul de evaluare a unei expresii în formă postfixată
1. cât timp există elemente de citit

1.1 citește un element
1.2 dacă elementul este o valoare
1.2.1 pune elementul în stivă
altfel (elementul este un operator)
1.2.2 extrage 2 operanzi din stivă
1.2.3 dacă nu există 2 operanzi în stivă
EROARE: forma postfixată nu este corectă
1.2.4 evaluează rezultatul aplicării operatorului asupra celor doi
operanzi
1.2.5 pune rezultatul în stivă
2. dacă există o singură valoare în stivă
2.1 afișează valoarea ca rezultat final al evaluării expresiei
altfel
EROARE: forma postfixată nu este corectă
Coadă (Queue)
O coadă este o structură de date organizată după modelul FIFO (First In, First Out): primul element
introdus va fi primul eliminat din buffer.
Funcții generale disponibile pentru interacțiunea cu o coadă:
void enqueue(struct Queue *queue, void *new_data) – adaugă elementul la sfârșitul cozii.
Adăugarea se face doar la sfârșitul cozii.
void* dequeue(struct Queue *queue) – șterge un element din coadă și îl returnează. Ștergerea se
poate face doar la începutul cozii.
void* front(struct Queue *queue) – întoarce primul element din coada fără a-l scoate din aceasta.
int is_empty(struct Queue *queue) – întoarce 1 dacă coada este goală; 0 dacă are cel puțin un
element
O coadă se poate poate implementa folosind pe post de container lista înlănțuită, array de dimensiune
fixă, array circular.
Reprezentare internă cu listă înlănțuită
void enqueue(struct Queue *queue, void *new_data) - echivalent cu operația de add_last efectuată
pe listă. Complexitate: timp constant - O(1)
void* dequeue(struct Queue *queue) echivalent cu operația de removeFirst. Complexitate: timp
constant - O(1)
void* front(struct Queue *queue) presupune returnarea valorii stocate in `head`-ul listei.
Complexitate: timp constant - O(1)
int is_empty(struct Queue *queue) - la fel ca în cazul listei. Complexitate: timp constant - O(1)
Reprezentare internă cu vector
Vom avea doi indici (head și tail) ce vor reprezenta începutul, respectiv sfârșitul cozii în cadrul vectorului.
Apare însă următoarea problemă din punctul de vedere al spațiului neutilizat: întotdeauna spațiul de la 0 la
head-1 va fi nefolosit, iar numărul de elemente ce pot fi stocate în coadă va scădea (având inițial N
elemente ce pot fi stocate, după ce se extrage prima oară un element, mai pot fi stocate doar N-1
elemente). Vrem ca întotdeauna să putem stoca maxim N elemente.
Soluția: vector circular.
void enqueue(struct Queue *queue, void *new_data) - presupune adăugarea noului element la
sfârșitul vectorului. Se verifică în prealabil dacă dimensiunea vectorului mai permite adăugarea unui
element. Se incrementează tail. Complexitate: O(1)
void* dequeue(struct Queue *queue) - “șterge” și întoarce primul element din vector. Se
incrementează head. Complexitate: O(1)
void* front(struct Queue *queue) - întoarce primul element din vector. Complexitate: O(1)
int is_empty(struct Queue *queue) - 1 dacă vectorul nu conține niciun element, 0 în caz contrar.
Complexitate: O(1)
Reprezentare internă cu vector circular
La nivel de implementare, coada este reprezentată printr-un vector de stocare (queue_array) de o

dimensiune maximă specificată (N), doi indici ce indică începutul (head) și sfârșitul cozii (tail), cât și un set
de operații ce pot fi efectuate asupra cozii. De asemenea, se reține și dimensiunea curentă a cozii (size)
pentru a putea spune când aceasta este plină sau vidă.
void enqueue(struct Queue *queue, void *new_data) - adaugă noul element la sfârșitul vectorului.
Se incrementează modulo (dimensiune container) indicele tail. Complexitate: O(1)
void* dequeue(struct Queue *queue) - șterge și întoarce primul element din vector. Se
incrementează modulo (dimensiune container) indicele head. Complexitate: O(1)
void* front(struct Queue *queue) - întoarce primul element din vector. Complexitate: O(1)
int is_empty(struct Queue *queue) - la fel ca în celelalte cazuri. Complexitate: O(1)

int is_full(struct Queue *queue) - se verifică dacă următorul index după tail (circular) este egal cu
head. Dacă da, returnează 1, returnează 0 în caz contrar. Complexitate: O(1)
Alte tipuri de coadă
Double ended queue - Dequeue

Într-o coadă obișnuită accesul la elemente este de tip FIFO - elementele sunt introduse pe la un capăt și
scoase la celălalt capăt. În cazul unei Dequeue, se permit ambele operații, la ambele capete. Astfel, în
capătul head se pot atât introduce, cât și extrage elemente. La fel și în cazul capătului tail. Se observă că
cele două structuri prezentate în acest laborator (stiva și coada) sunt particularizări ale structurii de date
Dequeue. Dintre cele 4 operații de adaugare/ștergere puse la dispoziție de o dequeue, atât stiva cât și
coada folosesc doar 2 (push_front() și pop_front() în cazul stivei, respectiv push_back() și pop_front() în
cazul cozii). Desigur, dequeue permite vizualizarea elementelor din ambele capete ale cozii: front() și
back().
Priority Queue
Este o coadă în care un dequeue() / peek() va întoarce primul element din acea coadă în funcție de un
anumit criteriu. Exemplu: pentru o coadă cu priorități care organizează elementele în funcție de valoarea
maximă, un peek() va întoarce valoarea maximă stocată. Similar, în cazul unei cozi cu priorități de minim,
peek() va întoarce valoarea minimă stocată.
Exemple de utilizare
Radix Sort
Radix Sort este un algoritm de sortare care ține cont de cifre individuale ale elementelor sortate. Aceste
elemente pot fi nu doar numere, ci orice altceva ce se poate reprezenta prin întregi. Majoritatea
calculatoarelor digitale reprezintă datele în memorie sub formă de numere binare, astfel că procesarea
cifrelor din această reprezentare se dovedește a fi cea mai convenabilă. Există două tipuri de astfel de
sortare: LSD (least significant digit) şi MSD (most significant digit). LSD procesează reprezentările dinspre
cea mai puțin semnificativă cifră spre cea mai semnificativă, iar MSD invers.
O versiune simplă a radix sort este cea care folosește 10 cozi (câte una pentru fiecare cifră de la 0 la 9).
Aceste cozi vor reține la fiecare pas numerele care au cifra corespunzătoare rangului curent. După această
împărțire, elementele se scot din cozi în ordinea crescătoare a indicelui cozii (de la 0 la 9), și se rețin într-
un vector (care devine noua secvență de sortat). Exemplu:
Secvența inițială:
170, 45, 75, 90, 2, 24, 802, 66
Numere sunt introduse în 10 cozi (într-un vector de 10 cozi), în funcție de cifrele de la dreapta la stânga
fiecărui număr.
Cozile pentru prima iterație vor fi:
* 0: 170, 090
* 1: nimic
* 2: 002, 802
* 3: nimic
* 4: 024
* 5: 045, 075
* 6: 066
* 7 - 9: nimic
a. Se face dequeue pe toate cozile, în ordinea crescătoare a indexului cozii, și se pun numerele într-un
vector, în ordinea astfel obținută:
Noua secvență de sortat:
170, 090, 002, 802, 024, 045, 075, 066
b. A doua iterație:
Cozi:
* 0: 002, 802
* 1: nimic
* 2: 024
* 3: nimic
* 4: 045
* 5: nimic
* 6: 066
* 7: 170, 075
* 8: nimic
* 9: 090
Noua secvență:
002, 802, 024, 045, 066, 170, 075, 090
c. A treia iterație:
Cozi:
* 0: 002, 024, 045, 066, 075, 090

* 1: 170
* 2 - 7: nimic
* 8: 802
* 9: nimic
Noua secvență:
002, 024, 045, 066, 075, 090, 170, 802 (sortată)
Observam ca au fost suficiente 3 iterații, adică numărul cel mai mare de cifre dintre numerele din colecție.
În acest caz, numerele cu mai puțin de 3 cifre au fost reprezentate cu 0-uri la început pentru a fi mai ușor
de înțeles.
Schelet
schelet_laborator05_stackandqueue.zip
Exerciţii
Fiecare laborator va avea unul sau doua exerciții publice si un pool de subiecte ascunse, din care asistentul
Atenție! Pentru acest laborator asistentul poate înlocui exercițiile publice complet.
1) [3p] Implementați, plecând de la scheletul de cod, stiva.
2) [3p] Implementați, plecând de la scheletul de cod, coada.
3) [1p] Determinați dacă un șir format din caracterele (, [, {, ), ], } este corect parantezat.
4) [1p] Verificați dacă un număr este palindrom folosind un deque.
Interviu
laboratorului.
1. Implementați, folosind un singur vector, 3 stive

2. Scrieți un program cu ajutorul căruia să sortați o stivă. Nu aveți acces decât la operațiile push(),
pop(), top() și is_empty()
3. Adăugați structurii de stivă o nouă funcție numită min, funcție care returnează cel mai mic element.
Push, pop și min trebuie să aibă complexitate O(1)
4. Descrieți cum este folosită stiva sistemului în cazul transmiterii parametrilor apelului unei funcții
5. Implementați operațiile elementare ale unei stive folosind două cozi. Problema admite două
versiuni: una în care operația pop este eficientă, iar cealaltă în care operația push este eficientă.
6. Implementați operațiile elementare ale unei cozi folosind două stive.
7. Presupunând că avem o coadă ce conține un număr mare de elemente, coada neputând fi ținută în
memorie. Prezentați o modalitate de a implementa operațiile enqueue și dequeue.
8. Să se implementeze o coadă ce are și operația findmax, pe lângă operațiile enqueue și dequeue.
findmax trebuie să returneze cea mai mare valoare aflată în coadă la momentul respectiv. Oferiți o
implementare eficientă.
9. Cum s-ar implementa o stivă folosind o coadă de priorități?
10. De câte cozi este nevoie ca să se poată implementa o coadă de priorități?
Bibliografie
1. Array Stack Visualization [http://www.cs.usfca.edu/~galles/visualization/StackArray.html]

2. Linked List Stack Visualziation [http://www.cs.usfca.edu/~galles/visualization/StackLL.html]
3. Array Queue Visualization [http://www.cs.usfca.edu/~galles/visualization/QueueArray.html]
4. Linked List Queue Visualization [http://www.cs.usfca.edu/~galles/visualization/QueueLL.html]
5. CLRS - Introduction to Algorithms, 3rd edition, capitol 10.1 - Stacks and queues
sd-ca/laboratoare/lab-05.txt · Last modified: 2020/03/19 17:06 by teodor_adrian.mirea
6/11/2020 Laborator 6 - Grafuri - Basics [CS Open CourseWare]
Laborator 6 - Grafuri - Basics

Responsabili
Andrei Dinu [mailto:dinuaadrian@gmail.com]

Rareș Cheșeli [mailto:rares96cheseli@gmail.com]
Obiective
În urma parcurgerii acestui laborator, studentul va fi capabil să:
înțeleagă operațiile de parcurgere a grafurilor și diferențele dintre ele.

implementeze parcurgerile pe grafuri având la dispoziție structurile de date studiate.
evalueze complexitatea parcurgerii grafurilor.
Ce este un graf?
Un graf este o pereche de mulţimi G = (V, E). Mulțimea V conține nodurile grafului (vertices), iar
mulțimea E conține muchiile sale (edges), fiecare muchie stabilind o relație de vecinătate între două
noduri. Mulţimea E este inclusă în mulţimea VxV.
Diferenţa între graf orientat şi graf neorientat
Dacă pentru orice element al mulţimii E, e = (u, v), elementul e' = (v, u) aparţine de asemenea
mulţimii E, atunci spunem că graful este neorientat. În caz contrar, graful este orientat. În cazul grafului
orientat, muchiile se mai numesc şi arce.
Reprezentările grafurilor în memorie

În funcţie de problemă şi de tipul grafurilor, avem 2 reprezentări: liste de adiacenţă sau matrice de
adiacenţă.
Liste de adiacenţă
Reprezentarea prin liste de adiacenţă constă într-un tablou Adj cu |V| liste, una pentru fiecare vârf din V.
Pentru fiecare u din V, lista de adiacenţă Adj[u] conţine referinţe către toate vârfurile v pentru care există
muchia (u, v) în E. Cu alte cuvinte, Adj[u] este formată din totalitatea vârfurilor adiacente lui u în G.
Această reprezentare este preferată pentru grafurile rare ( |E| este mult mai mic decât |V|x|V|).
Pentru graful de mai sus, lista de adiacenţă este următoarea:
0: 1→2
1: 0→2→3→4
2: 0→1→3
3: 1→2→4
4: 1→3
Matrice de adiacenţă
Reprezentarea prin matrice de adiacenţă a unui graf constă într-o matrice A[i][j] de dimensiune
|V|x|V| astfel încât:
A[i][j] = 1, dacă muchia (i,j) aparţine lui E

A[i][j] = 0, în caz contrar.
Această reprezentare este preferată pentru grafurile dense ( |E| este aproximativ egal cu |V|x|V|).
Pentru graful de mai sus, matricea de adiacenţă este următoarea:
0 1 2 3 4
0 0 1 1 0 0
1 1 0 1 1 1
2 1 1 0 1 0
3 0 1 1 1 0
4 0 1 0 1 0
În general, preferăm reprezentarea prin liste de adiacență deoarece au o complexitate mai bună în cazul
parcurgerilor (cea mai comună operație pe grafuri). Totuși, există situații în care alegerea reprezentării prin
matrice de adiacență simplifică mult rezolvarea unei probleme. Un exemplu ar fi algoritmul Floyd-Warshall
[https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm] care se bazează pe faptul că putem obține
ușor distanța dintre două noduri pe baza matricei în care reținem, adițional, și costurile muchiilor.
Parcurgerea grafurilor
Parcurgerea în lăţime
Parcurgerea în lățime (Breadth-first Search - BFS) presupune vizitarea nodurilor în următoarea ordine:
nodul sursă (considerat a fi pe nivelul 0)

vecinii nodului sursă (aceștia constituind nivelul 1)
vecinii încă nevizitați ai nodurilor de pe nivelul 1 (aceștia constituind nivelul 2)

vecinii încă nevizitați ai nodurilor de pe nivelul 2
ş.a.m.d.
Caracteristica esențială a acestui tip de parcurgere este, deci, că se preferă explorarea în lățime, a
nodurilor de pe același nivel (aceeași depărtare față de sursă) în detrimentul celei în adâncime, a
nodurilor de pe nivelul următor.
Pași de execuție
colorarea nodurilor. Pe parcurs ce algoritmul avansează, se colorează nodurile în felul următor:

alb - nodul este nedescoperit încă
gri - nodul a fost descoperit și este în curs de procesare
negru - procesarea nodului s-a încheiat
păstrarea informațiilor despre distanța până la nodul sursă.
pentru fiecare nod în d[u] se reține distanța până la nodul sursă (poate fi util în unele
probleme)
obținerea arborelui BFS.
în urma aplicării algoritmului BFS se obține un arbore de acoperire (prin eliminarea muchiilor
pe care nu le folosim la parcurgere). Pentru a putea reconstitui acest arbore, se păstrează
pentru fiecare nod dat informația despre părintele său în p[u].
Pseudocod
Pentru implementarea BFS se utilizează o coadă (Q) în care inițial se află doar nodul sursă. Se vizitează pe
rând vecinii acestui nod şi se pun și ei în coada. În momentul în care nu mai există vecini nevizitați, nodul
sursă este scos din coadă.
// Inițializări
pentru fiecare nod u din V
{
culoare[u] = alb
d[u] = infinit
p[u] = null
}
culoare[sursa] = gri
d[sursa] = 0
enqueue(Q,sursa) // Punem nodul sursă în coada Q
// Algoritmul propriu-zis
cât timp coada Q nu este vidă
{
v = dequeue(Q) // Extragem nodul v din coadă
pentru fiecare u dintre vecinii lui v
dacă culoare[u] == alb
{
culoare[u] = gri
p[u] = v
d[u] = d[v] + 1
enqueue(Q,u) // Adăugăm nodul u în coadă
}
culoare[v] = negru // Am terminat de explorat toți vecinii lui v
}
Dacă graful are mai multe componente conexe, algoritmul, în forma dată, va parcurge doar componenta
din care face parte nodul sursă. Pe grafuri cu mai multe componente conexe se va aplica în continuare
algoritmul pentru fiecare nod rămas nevizitat și astfel se vor obține mai mulți arbori, câte unul pentru
fiecare componentă.
Exemplu
Arborele obținut în urma execuției este următorul:
Parcurgerea în adâncime
Parcurgerea în adâncime (Depth-First Search - DFS) presupune explorarea nodurilor în următoarea
ordine:
nodul sursă
primul vecin nevizitat al nodului sursă (îl vom numi V1)
primul vecin nevizitat al lui V1 (îl vom numi V2)
primul vecin nevizitat al lui V2
s.a.m.d.
în momentul în care am epuizat vecinii unui nod Vn, continuăm cu următorul vecin nevizitat al
nodului anterior, Vn-1
Așadar, spre deosebire de BFS, acest tip de parcurgere pune prioritate pe explorarea în adâncime (la
distanțe tot mai mari față de nodul sursă), în detrimentul celei în lățime (pe același nivel).
Pași de execuție
colorarea nodurilor. Pe parcurs ce algoritmul avansează, se colorează nodurile in felul următor:

alb - nodul este nedescoperit încă
gri - nodul a fost descoperit și este în curs de procesare
negru - procesarea nodului s-a încheiat
păstrarea informațiilor despre timp. Fiecare nod are două momente de timp asociate:
tDesc[u] - momentul descoperirii nodului (și a schimbării culorii din alb în gri)
tFin[u] - momentul în care procesarea nodului s-a încheiat (și culoarea acestuia s-a
schimbat din gri în negru)
obținerea arborelui DFS.
în urma aplicării algoritmului DFS asupra fiecărei componente conexe a grafului, se obține
pentru fiecare dintre acestea câte un arbore de acoperire (prin eliminarea muchiilor pe care
nu le folosim la parcurgere). Pentru a putea reconstitui acest arbore, păstram pentru fiecare
nod dat informația despre părintele său în p[u].
Pseudocod
// Inițializări
{
culoare[u] = alb
p[u] = NULL
tDesc[u] = 0
tFin[u] = 0
}
contor_timp = 0
// Funcţie de vizitare a nodului

vizitare(nod)
{
contor_timp = contor_timp + 1
tDesc[nod] = contor_timp
culoare[nod] = gri
printeaza nod;
}
// Algoritmul propriu-zis
DFS(nod)
{
stiva s;
viziteaza nod;
s.introdu(nod);
cât timp stiva s nu este goală

{
nodTop = nodul din vârful stivei
vecin = află primul vecin nevizitat al lui nodTop.

dacă vecin există
{
p[v] = nodTop
viziteaza v;
s.introdu(v);
}
altfel
{
tFin[nodTop] = contor_timp
culoare[nodTop] = negru
s.scoate(nodTop);
}
}
}
Exemplu
Nodul de pornire este I, iar pentru simplificare vecinii sunt aleși în ordine alfabetică. În stânga nodului este
notat tDesc, iar în dreapta tFin. Dacă se afișează nodurile, în urma parcurgerii se obține următorul
output: I, E, B, A, C, D, G, F, H
Arborele obținut în urma parcurgerii este următorul:
Complexitate
Pentru ambele tipuri de parcurgeri, complexitatea este O(|E|+|V|) - unde |E| este numărul de muchii,
iar |V| este numărul de noduri.
Explicație: în cazul cel mai defavorabil, vor fi explorate toate muchiile și toate nodurile (când graful este
liniarizat).
De remarcat faptul că, pentru ambele tipuri de parcurgeri, complexitatea este cea menționată
O(|E|+|V|) numai în cazul în care grafurile sunt reținute ca liste de adiacență. În acest caz, lista
corespunzătoare nodului x reține numai vecinii nodului x. În cazul matricei de adiacență, pentru a parcurge
vecinii unui nod x, trebuie să parcurgem toate nodurile. Această limitare duce la o complexitate de
O(|V|^2)
Schelet
lab06.zip
Exerciţii
Fiecare laborator va avea unul sau doua exerciții publice şi un pool de subiecte ascunse, din care asistentul
1) [2.5p] Implementați, plecând de la scheletul de cod, graful reprezentat prin maitrce de adiacență.
2) [2.5p] Implementați, plecând de la scheletul de cod, graful reprezentat prin liste de adiacență.
3) [1p] Implementați parcurgerea in adâncime (DFS) a unui graf.
4) [1p] Implementați parcurgerea in lățime (BFS) a unui graf.
5) [3p] Implementați algoritmul Floyd-Warshall pe un graf reprezentat printr-o matrice de adiacență.
Interviu
laboratorului.
Cum multe din companiile mari folosesc date stocate sub formă de grafuri (Facebook Open Graph, Google
Social Graph şi Page Rank, etc.) la angajare vor dori să vadă ca ştiţi grafuri:
cum se reprezintă grafurile

cum funcţionează şi cum se implementează parcurgerile (BFS, DFS)
Puteţi căuta mai multe întrebări pe https://leetcode.com/ [https://leetcode.com/],

http://www.careercup.com/ [http://www.careercup.com/] şi http://www.glassdoor.com/
[http://www.glassdoor.com/]
Bibliografie
1. BFS [http://en.wikipedia.org/wiki/Breadth-first_search]
2. DFS [http://en.wikipedia.org/wiki/Depth-first_search]
3. Algoritmul Floyd-Warshall [https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm]
4. Algoritmul lui Kruskal [https://ro.wikipedia.org/wiki/Algoritmul_lui_Kruskal]
6/11/2020 Laborator 7 - Grafuri - Advanced [CS Open CourseWare]
Laborator 7 - Grafuri - Advanced

Responsabili
Andrei Dinu [mailto:dinuaadrian@gmail.com]

Rareș Cheșeli [mailto:rares96cheseli@gmail.com]
Obiective
În urma parcurgerii acestui laborator, studentul va fi capabil să:
găsească soluțiile unor probleme folosind algoritmii de parcurgere

să folosească şi să adapteze algoritmii de parcurgere pentru implementarea soluţiilor găsite
Importanţă
Grafurile sunt utile pentru a modela diverse probleme şi se regăsesc implementaţi în multiple aplicaţii
practice:
reţele de calculatoare (ex: stabilirea unei topologii fără bucle)

pagini Web (ex: Google PageRank)
rețele sociale (ex: calcul centralitate)
hărţi cu drumuri (ex: drum minim)
modelare grafică (ex: prefuse, graph-cut)
Aplicaţii parcurgeri
Componente conexe
Se numeşte componentă conexă a unui graf neorientat G = (V, E) un subgraf G1 = (V1, E1) în care
pentru orice pereche de noduri (A, B) din V1 există un lanţ de la A la B, implicit şi de la B la A.
Observaţie Nu există un alt subgraf al lui G, G2 = (V2, E2) care să îndeplinească această condiţie şi
care să îl conţină pe G1. În acest caz, G2 va fi componenta conexă, iar G1 nu.
Algoritm
Atât o parcurgere BFS, cât şi una DFS, pornind dintr-un nod A, va determina componenta conexa
din care face parte A.
Pentru a determina toate componentele conexe ale unui graf G = (V, E), se vor parcurge nodurile
din V.
Din fiecare nod care nu face parte dintr-o componentă conexă găsită anterior, se va porni o
parcurgere BFS sau DFS.
Pseudocod
// Inițializări
{
stare[u] = nevizitat
}
componente_conexe = 0

vizitare(nod)
{
stare[nod] = vizitat
printeaza nod
}
// Parcurgerea în adâncime
DFS(nod)
{
stiva s
viziteaza nod
s.introdu(nod)

{

dacă vecin există
{
viziteaza v
s.introdu(v)
}
altfel
{
s.scoate(nodTop)
}
}
}
// Parcurgerea nodurilor din V

{
dacă stare[u] == nevizitat
{
componente_componente = componente_conexe + 1
DFS(u)
}
}
Exemplu
Graful din imagine are 4 componente conexe.
Aflarea distanţei minime între două noduri
Dacă toate muchiile au același cost, putem afla distanța minimă între două noduri A și B efectuând o
parcurgere BFS din nodul A și oprindu-ne atunci când nodul B a fost descoperit. Reamintindu-ne că nivelul
unui nod este analog distanței, în muchii, față de sursă, și că BFS descoperă un nod de pe nivelul N numai
după ce toate nodurile de pe nivele inferioare au fost descoperite, este ușor de văzut că nivelul nodului B în
parcurgere corespunde distanței minime între A și B.
Pentru a reține distanța și drumul exact de la A la B, se vor reține pentru fiecare nod d[x] (distanța de la
sursă la x) și p[x] (părintele lui x în drumul de la sursă spre x). În momentul descoperirii unui nod y al
cărui părinte este x, se vor face următoarele atribuiri:
d[y] = d[x] + 1
p[y] = x
sursa având d[A] = 0 și p[A] = NULL.

Observații:
dacă parcurgerea BFS se încheie fără ca nodul B să fi fost descoperit, nu există drum între A și B și
deci distanța între acestea este infinită.
Algoritmul funcționează corect numai în situații de cost uniform (toate muchiile au același cost).
Pentru grafuri cu muchii de costuri diferite, sunt necesari algoritmi mai avansați, cum ar fi: Dijkstra,
Bellman-Ford sau Floyd-Warshall.
Pseudocod
// Inițializări
{
d[u] = infinit
p[u] = null
}
// Distanța între sursă și destinație

distanța(sursă, destinație)
{
stare[sursă] = vizitat
d[sursă] = 0
enqueue(Q,sursă) // Punem nodul sursă în coada Q
// BFS
{
dacă stare[u] == nevizitat
{
stare[u] = vizitat
p[u] = v
d[u] = d[v] + 1
enqueue(Q,u) // Adăugăm nodul u în coadă
}
}
return d[destinație] // Dacă este infinit, nu există drum
}
Sortarea topologică
Se dă un graf orientat aciclic. Orientarea muchiilor corespunde unei relații de ordine de la nodul sursă către
cel destinație. O sortare topologică a unui astfel de graf este o ordonare liniară a vârfurilor sale astfel încât,
dacă (u,v) este una dintre muchiile grafului, u trebuie să apară înaintea lui v în înșiruire. Dacă graful ar fi
ciclic, nu ar putea exista o astfel de înșiruire (nu se poate stabili o ordine între nodurile care alcătuiesc un
ciclu).
Sortarea topologică poate fi văzută și ca plasarea nodurilor de-a lungul unei linii orizontale astfel încât
toate muchiile să fie direcționate de la stânga la dreapta (să nu existe nici o muchie înapoi, spre părinte).
Pseudocod
// Inițializări
{
p[u] = NULL
tDesc[u] = 0
tFin[u] = 0
}
contor_timp = 0

vizitare(nod)
{
tDesc[nod] = contor_timp
stare[nod] = vizitat
printeaza nod
}
// Parcurgere în adâncime
DFS(nod)
{
stiva s
viziteaza nod
s.introdu(nod)

{

dacă vecin există
{
p[v] = nodTop
viziteaza v
s.introdu(v)
}
altfel
{
tFin[nodTop] = contor_timp
s.scoate(nodTop)
}
}
}
// Parcurgere noduri și calculare tDesc și tFin pentru fiecare nod

{
dacă u nu a fost vizitat
{
DFS(u)
}
}
// Sortare topologica
sortează nodurile din V descrescător în funcție de tFin[nod]
Exemplu
Profesorul Bumstead își sortează topologic hainele înainte de a se îmbrăca.
fiecare muchie (u, v) înseamna că obiectul de îmbrăcăminte u trebuie îmbrăcat înaintea obiectului
de îmbrăcaminte v. Timpii de descoperire (tDesc) și de finalizare (tFin) obținuți în urma
parcurgerii DFS sunt notați lângă noduri.
același graf, sortat topologic. Nodurile lui sunt aranjate de la stânga la dreapta în ordinea
descrescătoare a tFin. Observați că toate muchiile sunt orientate de la stânga la dreapta. Acum
profesorul Bumstead se poate îmbrăca liniștit.
Așa cum se observă din imagine, sortarea topologică constă în sortarea nodurilor descrescător după timpii
de finalizare. Demonstrația acestei afirmații se face simplu, arătând că nodul care se termină mai târziu
trebuie să fie efectuat înaintea celorlalte noduri finalizate.
Graf bipartit
Se numește graf bipartit un graf G = (V, E) în care mulțimea nodurilor poate fi împărțită în două mulțimi
disjuncte A și B astfel încât V = A U B şi E este inclus în A x B (orice muchie leagă un nod din A
cu un nod din B).
Algoritm
Pentru a determina dacă un graf este bipartit sau nu, una din metode constă în efectuarea de
parcurgeriBFS și atribuirea de etichete nodurilor conform cu paritatea nivelului acestora în
parcurgere (A pentru nodurile de pe nivel par, B pentru nodurile de pe nivel impar).
Atunci când se adaugă vecinii nevizitați ai unui nod în coadă, se vor verifica de asemenea etichetele
vecinilor deja vizitați: dacă se descoperă că unul din aceștia are aceeași etichetă ca cea atribuită
nodului curent, graful are o muchie între noduri de pe același nivel și deci nu poate fi bipartit.
În caz contrar (s-a realizat parcurgerea BFS fără a apărea această situație), graful este bipartit și
nodurile sunt etichetate cu mulțimea din care fac parte.
Pseudocod
sursa = un nod ales aleator din V

nivel[sursa] = par
enqueue(Q, sursa) // Punem nodul sursă în coada Q
// BFS
{
dacă nivel[u] nedefinit
{
nivel[u] = (nivel[v] == par) ? impar : par
enqueue(Q, u) // Adăugăm nodul u în coadă
}
altfel dacă nivel[u] == nivel[v]
{
// Două noduri consecutive au acelaşi nivel
// Graful nu este bipartit
return false
}
}
// S-a terminat parcurgerea BFS fără să apară două noduri consecutive pe acelaşi nivel
// Graful este bipartit
return true
Exemplu
Ciclu hamiltonian
Un lanţ hamiltonian într-un graf orientat sau neorientat G = (V, E), este o cale ce trece prin fiecare nod
din V o singură dată. Dacă nodul de început şi cel de sfârşit coincid (este vizitat de două ori) vom spune că
lanţul formează un ciclu hamiltonian.
Un graf ce conţine un ciclu hamiltonian se numeşte graf hamiltonian.
Algoritm
În cadrul acestui laborator, vom folosi metoda backtracking pentru găsirea unui ciclu hamiltonian. Pentru
contruirea soluţiei, se menţine o listă în care sunt adăugate nodurile parcurse:
La fiecare pas, vom adăuga unul dintre nodurile care nu se află deja in listă
Se construieşte recursiv lanţul de lungime_lanţ + 1
Dacă dimensiunea listei este n (numărul de noduri din graf), se verifică dacă primul şi ultimul nod
din listă sunt adiacente. În caz contrar, s-a găsit un lanţ hamiltonian, dar nu şi un ciclu hamiltonian.
Pentru a afla toate ciclurile hamiltoniene, la revenirea cu succes din apelul recursiv nu se iese din
funcţie la găsirea primei potriviri, ci se încearcă în continuare alte posibilităţi.
Pseudocod
// Inițializări
număr_noduri = număr de noduri din V
// Verifica dacă un nod este nou în lanţ

nouÎnLanţ(nod, lanţ)
{
return !lanţ.conţine(nod)
}
// Construieste lanţul hamiltonian

construireLanţ(lanţ, lungime_lanţ)
{
dacă lungime_lanţ == număr_noduri
{
început = lanţ[0]
sfârşit = ultimul element din lanţ
// Există muchie între cele 2 noduri

dacă muchie(început, sfârşit)
{
// Lanţul este ciclu
afişează ciclul
return true
}
}
altfel
{
pentru orice nod u din V
{
sfârşit = ultimul element din lanţ
dacă muchie(u, sfârşit) şi nouÎnLanţ(u, lanţ)
{
addLast(lanţ, u) // Adaugă u la lanţ
construireLanţ(lanţ, lungime_lanţ + 1)
// Pentru afişarea unui singur ciclu hamiltonian linia anterioară este inlocuită cu:
// dacă construireLanţ(lanţ, lungime_lanţ + 1) == true
// return true
removeLast(lanţ, u) // Backtrack
}
}
}
return false
}
// Apelează construirea ciclurilor hamiltoniene

cicluriHamiltoniene
{
// Din moment ce ar trebui să formeze un ciclu, lanţul poate incepe cu orice nod
sursă = alegem un nod aleator din V
addLast(lanţ, sursă)
construireLanţ(lanţ, 1)
}
Exemplu
Schelet
lab07.zip
Exerciții
1) [3.5p]Într-o rețea de socializare pentru gameri există mai multe clanuri. Doi jucători fac parte din
același clan dacă există un drum atât de la X la Y, cât și de la Y la X. Când se creează o nouă legatură între
doi jucători, clanurile din care ei fac parte se unesc formând un singur clan.
Se dau n numărul de gameri din rețeaua de socializare si m numărul de legături ce există intre aceștia. În
continuare, sunt citite cele m legături.
Determinați numărul clanurilor existente în rețea și jucătorii care fac parte din fiecare clan, completând
metodele connected_components și dfs_connected_comps din schelet.
Exemplu
Intrare
12 10
0 1
0 2
1 2
2 3
4 5
4 6
5 6
4 7
7 8
9 10
Ieșire
4
0 1 2 3
4 5 6 7 8
9 10
11
2) [3.5p] Un curier, care se află într-un oraș A, trebuie să livreze un pachet într-un oraș B.
Pe hartă se află n orașe, conectate prin m străzi bidirecționale. Se știe faptul că fiecare dintre aceste străzi
este parcursă într-un timp constant t.
Se citesc n, m, numărul de teste, cele m străzi și un număr de perechi de orașe A și B egal cu numărul de
teste.
Determinați ruta cea mai scurtă pe care poate ajunge curierul în orașul B, în cazul în care aceasta există,
completând metoda min_path din schelet.
Exemplu
Intrare
7 10 1
0 1
0 4
1 2
1 3
1 4
2 4
3 5
3 6
4 5
4 6
0 6
Ieșire
0 4 6
3) [3.5p] În primii ani de studiu, toți studenții de la Facultatea de Automatică și Calculatoare studiază un
număr de N materii obligatorii. Dându-se un set de relații între acestea, cu semnificația că materia din
stânga trebuie studiată într-un semestru anterior (nu neapărat din același an), celei din partea dreaptă,
găsiti și implementați un algoritm care propune o ordine corectă de studiere a materiilor universitare, care
să respecte restricțiile impuse, completând metodele topo_sort și dfs_topo_sort din schelet.
Exemplu
Intrare
6 4
Programarea_Calculatoarelor Structuri_de_Date
Structuri_de_Date Programare_Orientata_pe_Obiecte
Matematica1 Fizica
Matematica2 Fizica
Ieșire
Matematica2
Matematica1
Fizica
Programarea_Calculatoarelor
Structuri_de_Date
Programare_Orientata_pe_Obiecte
4) [3.5p] Dându-se n noduri și m muchii ale unui graf neorientat, determinați dacă acest graf este bipartit
și aflați cele două mulțimi care îl formează, completând metoda check_bipartite din schelet.
Exemplu
Intrare
9 8
0 1
0 6
1 2
2 7
3 6
4 7
4 8
5 8
Ieșire
0 2 3 4 5
1 6 7 8
5) [2p] Un curier trebuie să livreze pachete în n orașe. Orașele sunt codificate prin numere de la 0 la n-1.
Se cunosc m străzi bidirecționale, legături între orașe. Se citesc numarul de teste, apoi pentru fiecare test
n, m și cele m străzi bidirecționale.
Sediul curieratului se află în orașul 0. Determinați toate rutele pe care curierul le poate urma astfel încât
acesta să efectueze toate livrările și să se întoarcă la sediu, astfel încât el va trece prin fiecare oras o
singură data.
Exemplu
Intrare
5 7
0 1
1 2
0 3
1 3
1 4
2 4
3 4
Ieșire
0 1 2 4 3 0
Bibliografie
1. Componente conexe [http://en.wikipedia.org/wiki/Connected_component_(graph_theory)]

2. Distanţa minimă [http://en.wikipedia.org/wiki/Shortest_path]
3. Sortare topologică [http://en.wikipedia.org/wiki/Topological_sorting]
4. Graf bipartit [https://en.wikipedia.org/wiki/Bipartite_graph]
5. Lanţ hamiltonian si ciclu hamiltonian [https://en.wikipedia.org/wiki/Hamiltonian_path]
6. Dijkstra [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm]
7. Bellman-Ford [http://en.wikipedia.org/wiki/Bellman-ford]
8. Floyd-Warshall [http://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm]
9. A* [http://en.wikipedia.org/wiki/A*_search_algorithm]
sd-ca/laboratoare/lab-07.txt · Last modified: 2020/04/09 11:40 by george.popescu0309
6/11/2020 Laborator 8 - Arbori și Arbori Binari [CS Open CourseWare]
Laborator 8 - Arbori și Arbori Binari

Responsabili
Alexandru-Cosmin Mihai [mailto:mailto:alexcosmin.mihai@gmail.com]

Dorin-Andrei Geman [mailto:mailto:doringeman@gmail.com]
Obiective
În urma parcurgerii articolului, studentul va fi capabil să:
înţeleagă noţiunea de arbore şi structura unui arbore binar

construiască, în limbajul C, un arbore binar
realizeze o parcurgere a structurii de date prin mai multe moduri
Noțiuni teoretice
Noțiunea de arbore. Arbori binari

Matematic, un arbore este un graf neorientat conex aciclic.
În ştiinţa calculatoarelor, termenul de arbore este folosit pentru a desemna o structură de date care
respectă definiţia de mai sus, însă are asociate un nod rădăcină şi o orientare înspre sau opusă rădăcinii.
Arborii sunt folosiţi în general pentru a modela o ierarhie de elemente.
Astfel, fiecare element (nod) poate deţine un număr de unul sau mai mulţi descendenţi, iar în acest caz
nodul este numit părinte al nodurilor descendente (copii sau fii).
Fiecare nod poate avea un singur nod părinte. Un nod fără descendenţi este un nod terminal, sau nod
frunză.
În schimb, există un singur nod fără părinte, iar acesta este întotdeauna rădăcina arborelui (root).
Un arbore binar este un caz special de arbore, în care fiecare nod poate avea maxim doi descendenţi:
nodul stâng
nodul drept.
În funcţie de elementele ce pot fi reprezentate în noduri şi de restricţiile aplicate arborelui, se pot crea
structuri de date cu proprietăţi deosebite: heap-uri, arbori AVL, arbori roşu-negru, arbori Splay şi multe
altele. O parte din aceste structuri vor fi studiate la curs şi în laboratoarele viitoare.
În acest articol ne vom concentra asupra unei utilizări comune a arborilor binari, şi anume pentru a
reprezenta şi evalua expresii logice.
Reprezentarea arborilor binari

Arborii binari pot fi reprezentați în mai multe moduri. Structura din spatele acestora poate fi un simplu
vector, alocat dinamic sau nu, sau o structură ce folosește pointeri, așa cum îi vom reprezenta în acest
articol.
binary_tree.h
typedef struct b_node_t b_node_t;

struct b_node_t {
/* left child */
b_node_t *left;
/* right child */
b_node_t *right;
/* data contained by the node */

void *data;
};
typedef struct b_tree_t b_tree_t;

struct b_tree_t {
/* root of the tree */
b_node_t *root;
};
Structura nodului de mai sus este clară: *pointer către fiul stâng *pointer către fiul drept *pointer către
date
Pentru toți membrii unui nod, trebuie să alocăm memorie dinamic, dar doar atunci când avem nevoie de
ea.
De asemenea, dealocarea memoriei se va face recursiv, dar numai atunci cand este necesar.
Pentru a ne reaminti cum alocăm memorie:
b_tree_t *binary_tree;
binary_tree = b_tree_create();
b_tree_free(binary_tree);
Parcurgerea arborilor
Se implementeaza foarte usor recursiv:
Preordine
Se parcurge rădăcina
Se parcurge subarborele stâng
Se parcurge subarborele drept
Inordine
Exemplu:
static void __b_tree_inorder(b_node_t *root)

{
if (root == NULL)
return;
__b_tree_inorder(root->left);
/* process root */
__b_tree_inorder(root->right);
}
void b_tree_inorder(b_tree_t *tree)

{
__b_tree_inorder(tree->root);
}
Postordine

Lățime
Se folosește o coadă, iar la fiecare pas se extrage din această coadă câte un nod și se adăugă înapoi în
coadă nodul stâng, respectiv drept al nodului scos. Acest algoritm continuă până când coada devine goală.
Nodurile frunză nu au descendenţi → nodul stâng şi nodul drept pointează la NULL şi nu trebuie adăugate
în coadă.
Arbori asociați expresiilor

O expresie matematică este un şir de caractere compus din:
variabile
constante
operatori
paranteze (eventual).
Fiecărei expresii i se poate asocia un arbore binar, în care:
nodurile interioare reprezintă operatorii

frunzele reprezintă constantele şi/sau variabilele.
În terminologia limbajelor formale şi a compilatoarelor, acest arbore se mai numeşte şi Abstract Syntax
Tree (AST).
Pentru expresia (a+1)*(b+10)+25/c , arborele asociat este prezentat mai jos:
Cel mai mic strămoș comun

O problemă importantă în analiza arborilor este determinarea celui mai mic strămoș comun (LCA - Lowest
Common Ancestor). LCA-ul a două noduri, u si v, este nodul cel mai depărtat de rădăcină care îi are pe u și
v ca descendenți.
Spre exemplu, cel mai mic strămoș comun al nodurilor 1 și 12 este 0, în timp ce pentru nodurile 4 și 7,
acesta este 1.
Schelet
lab08.zip
Exerciții
1) [4p] Implementați, compilați si testați funcțiile din binary_tree.c.
Inserarea se va face recursiv, pe prima poziție liberă găsită.
313CAa) [3p] Fiind dat un număr natural n, afişaţi toate nodurile de pe nivelul n din arbore.
Folosiți check.py pentru a vă testa soluțiile. Un task ce nu obține punctaj maxim NU se consideră corect!
Veți avea nevoie de Python3 pentru a rula checker-ul. Acesta este instalat by default pe versinile recente
de Ubuntu.
311CAb) [3p] Verificați dacă toate frunzele din arbore se află pe același nivel.
312CAb) [3p] Verificați dacă arborele este echilibrat.
313CAb) [3p] Se dau două noduri A şi B din acelaşi arbore. Determinaţi cel mai jos strămoş comun al
celor două noduri (LCA).
315CAa) [3p] Găsiți un subarbore cu suma nodurilor maximă.
314CAb) [3p] Un arbore binar complet este un arbore binar în care fiecare nivel, cu posibila excepţie a
ultimului nivel, este plin de noduri. Cu alte cuvinte, fiecare nivel este “umplut” de la stânga la dreapta cu
noduri, iar ultimul nivel poate să nu fie umplut până la capăt. Fiind dat un arbore binar, determinaţi dacă
acesta este complet.
315CAb) [3p] Fiind dat un arbore binar ale cărui noduri reţin valori integer, verificaţi dacă pentru fiecare
nod din arbore este adevărat faptul că valoarea sa este mai mare decât valoarea copilului stâng şi mai
mică decât valoarea copilului drept.
Interviu
laboratorului.
Ce este un arbore?
Cum poate fi reprezentat un nod dintr-un arbore binar?
Daţi exemplu de un tip (mai multe tipuri) de parcurgere al arborilor binari. Descrieţi modul de
funţionare al acestuia (acestora).
Daţi exemplu de un mod de utilizare al arborilor binari.
Ce complexitate medie / worst-case au funcţiile de inserare / ştergere / căutare pentru un arbore
binar, BST, AVL, etc. (mai multe despre complexitatea algoritmilor şi structurilor de date veţi învăţa
în anul 2: Analiza Algoritmilor şi Proiectarea Algoritmilor).
Bibliografie
1. Binary Tree [http://en.wikipedia.org/wiki/Binary_tree]

2. AVL [http://en.wikipedia.org/wiki/AVL_tree]
3. Red-Black Tree [http://en.wikipedia.org/wiki/Red%E2%80%93black_tree]
4. Arbori de Intervale [https://en.wikipedia.org/wiki/Segment_tree]
5. Arbori Indexati Binar [https://en.wikipedia.org/wiki/Fenwick_tree]
6. Splay Tree [http://en.wikipedia.org/wiki/Splay_tree]
7. AST [http://en.wikipedia.org/wiki/Abstract_syntax_tree]
8. DNF [http://en.wikipedia.org/wiki/Disjunctive_normal_form]
sd-ca/laboratoare/lab-08.txt · Last modified: 2020/04/24 13:11 by teodor_stefan.dutu
6/11/2020 Laborator 9 - ABC și Heap [CS Open CourseWare]
Laborator 9 - ABC și Heap

Responsabili

Obiective
În urma parcurgerii laboratorului, studentul va fi capabil să:
înțeleagă structura și proprietățile unui arbore binar de căutare;

construiască, în limbajul C, un arbore binar de căutare;
realizeze o parcurgere a structurii de date prin mai multe moduri;
realizeze diferite operații folosind arborii binari de căutare;
definească proprietățile structurii de heap;

implementeze operații de inserare, ștergere și căutare care să păstreze proprietatea de heap;
folosească heap-ul pentru a implementa o metodă de sortare eficientă.
Noțiuni teoretice - ABC

Un arbore binar de căutare este un arbore binar care are în plus următoarele proprietăți:
cheile stocate în noduri (informația utilă) aparțin unei mulțimi peste care există o relație de ordine
totală
cheia dintr-un nod oarecare este mai mare decât cheile tuturor nodurilor din subarborele stâng și
este mai mică decât cheile tuturor nodurilor ce compun subarborele drept
Arborii binari de căutare permit menținerea datelor în ordine și o căutare rapidă a unei chei, ceea ce îi
recomandă pentru implementarea de mulțimi și dicționare ordonate.
O importantă caracteristică a arborilor de căutare, este aceea că parcurgerea inordine produce o

secvență ordonată crescător a cheilor din nodurile arborelui.
Valoarea maximă
Valoarea maximă dintr-un arbore binar de căutare se află în nodul din extremitatea dreaptă și se
determină prin coborârea pe subarborele drept, iar valoarea minimă se află în nodul din extremitatea
stângă, determinarea fiind simetrică.
Căutarea
Căutarea unei chei într-un arbore binar de căutare este asemănătoare căutării binare: cheia căutată este
comparată cu cheia din nodul curent (inițial nodul rădăcină). În funcție de rezultatul comparației apar trei
cazuri:
acestea coincid –> elementul a fost găsit

elementul căutat este mai mic decât cheia din nodul curent –> căutarea continuă în subarborele
stâng
elementul căutat este mai mare decât cheia din nodul curent → căutarea continuă în subarborele
drept
Pseudocod:
bool căutare(nod, cheie) {

if nod == NULL
return false;
if nod.cheie == cheie
return true;
if cheie < nod.cheie

return căutare(nod.stanga, cheie);
else
return căutare(nod.dreapta, cheie);
}
Inserarea
Inserarea unui nod se face, în funcție de rezultatul comparației cheilor, în subarborele stâng sau drept.
Dacă arborele este vid, se creează un nod care devine nodul rădăcină al arborelui. În caz contrar, cheia se
inserează ca fiu stâng sau fiu drept al unui nod din arbore.
Ștergerea
Ștergerea unui nod este o operație puțin mai complicată, întrucât presupune o rearanjare a nodurilor.
Pentru eliminarea unui nod dintr-un arbore binar de căutare sunt posibile următoare cazuri:
nodul de șters nu există → operația se consideră încheiată

nodul de șters nu are succesori → este o frunză
nodul de șters are un singur succesor
nodul de șters are doi succesori
În cazul ștergerii unui nod frunză sau a unui nod având un singur succesor, legătura de la părintele nodului
de șters este înlocuită prin legătura nodului de șters la succesorul său (NULL în cazul frunzelor).
Eliminarea unui nod cu doi succesori se face prin înlocuirea sa cu nodul care are cea mai apropiată valoare
de nodul șters. Acesta poate fi din extremitatea dreaptă a subarborelui stâng (predecesorul; se caută cel
mai mare nod din acest subarbore, adică “se merge” în dreapta până se ajunge la un nod cu cel mult un
succesor, aflat evident în partea stângă, altfel am putea avansa în adâncime pe dreapta) sau nodul din
extremitatea stânga a subarborelui drept (succesorul; se caută cel mai mic nod din acest subarbore,
adică “se merge” în stânga până se ajunge la un nod cu cel mult un succesor, aflat evident în partea
dreaptă, altfel am putea avansa în adâncime pe stânga).
Complexitatea operațiilor (căutare, inserare, ștergere) într-un arbore binar de căutare este - pe cazul
mediu - O(log n).
Noțiuni teoretice - Heap

Mai sus am considerat arborii binari ca fiind o înlănțuire de structuri, legate între ele prin pointeri la
descendenții stâng, respectiv drept. Această reprezentare are avantajul flexibilității și a posibilității de a
crește sau micșora dimensiunea arborelui oricât de mult, cu un efort minim. Cu toate acestea, metoda
precedentă nu poate fi folosită atunci când este nevoie de o reprezentare compactă a arborelui în memorie
(de exemplu pentru stocarea într-un fișier), pentru că acei pointeri nu sunt valizi decât în cadrul
programului curent.
Din acest motiv, există câteva moduri de a stoca arborii într-o structura liniară de date (vectori), dintre
care:
Înlocuirea pointer-ilor din structurile asociate nodurilor cu întregi ce reprezintă indici într-un vector
de astfel de structuri. Primul element din vector va fi rădăcina arborelui, și va exista un contor
curent (la nivelul întregului vector) care indică următoarea poziție liberă. Atunci când un nod trebuie
adăugat în arbore, i se va asocia valoarea curentă a contorului, iar acesta va fi incrementat. În
nodul părinte se va reține indicele în vector al noului nod, în locul adresei lui în memorie (practic
acesta este un mic mecanism de alocare de memorie, pe care îl gestionăm noi).
Eliminarea totală a informației legate de predecesori, și folosirea unei formule de calcul a părintelui
și a descendenților unui nod pe baza indicelui acestuia în vector.
Pentru un arbore binar, cea de-a doua modalitate se implementează conform figurii de mai jos:
Se consideră că arborele este așezat în vector în ordine (începând de la 0) de la primul nivel până la
ultimul, iar nodurile fiecărui nivel se așează de la stânga la dreapta.
Reprezentarea liniara (sub formă de vector) pentru un arbore binar complet devine:
Se constată că poziția nodului rădăcină în vector este 0, iar pentru fiecare nod în parte, părintele și
descendenții se pot calcula după formulele:
Părinte(i) = (i - 1) / 2, unde i este indicele nodului curent

IndexStânga(i) = 2 * i + 1, unde i este indicele nodului curent
IndexDreapta(i) = 2 * i + 2, unde i este indicele nodului curent
Proprietăți ale structurii de heap binar. Operații elementare.

În cele ce urmează vom considera un heap ca fiind de fapt un min-heap. Noțiunile sunt perfect similare și
pentru max-heap-uri.
Un min-heap binar este un arbore binar în care fiecare nod are proprietatea că valoarea sa este mai mare
sau egală cu cea a părintelui său.
Într-o enunțare echivalentă:
Un min-heap binar este un arbore binar în care fiecare nod are proprietatea că valoarea sa este mai mică
sau egală decât cea a tuturor descendenților săi.
h[parinte(x)] <= h[x]
h[x] reprezintă valoarea nodului x, din vectorul h asociat arborelui.
În mod similar, un max-heap are semnul inegalității inversat. Astfel, putem defini și recursiv proprietatea
de heap pentru orice (sub)arbore:
nodul rădăcină trebuie să respecte proprietatea de heap (inegalitatea);

cei doi subarbori descendenți sa fie heap-uri.
Pentru a implementa operațiile de inserare, ștergere, etc. pentru un heap, vom avea nevoie mai întâi de
două operații elementare:
pushDown, care presupune că heap-ul a fost modificat într-un singur nod și noua valoare este mai
mare decât cel puțin unul dintre descendenți, și astfel ea trebuie “cernută” către nivelurile de jos,
până când heap-ul devine din nou valid.
pushUp, care presupune că valoarea modificată (sau adăugată la sfârșitul vectorului, în acest caz)
este mai mică decât părintele, și astfel se propagă acea valoare spre rădăcina arborelui, până când
heap-ul devine valid.
Operații uzuale asupra heap-ului

Având implementate cele două operații de bază, putem defini operațiile uzuale de manipulare a heap-
urilor:
Peek
Operația întoarce valoarea minimă din min-heap. Valoarea se va afla la indexul 0 al vectorului de
implementare a heap-ului.
Push (insert)
Adaugă o nouă valoare la heap, crescându-i astfel dimensiunea cu 1.
Algoritmul pentru această funcție este următorul:
1. introducem elementul de inserat pe prima poziție liberă din vectorul de implementare a heap-ului
(în principiu dimVect);
2. “împingem” elementul adăugat în vector până la poziția în care se respectă proprietatea de heap;
veți folosi funcția pushUp.
push(heap, X)
{
heap[dimVec] = X;
dimVec++;
pushUp(heap, dimVec - 1);
}
Pop (extractMin)
Funcția aceasta scoate valoarea minimă din heap (și reactualizează heap-ul). Poate întoarce valoarea
scoasă din heap.
Pentru a face operația de pop veți urma pașii:

1. elementul minim din heap (de pe prima poziție) va fi interschimbat cu elementul de pe ultima
poziție a vectorului;
2. dimensiunea vectorului va fi redusă cu 1 (pentru a ignora ultimul element, acum cel pe care doream
să-l înlăturăm)
3. vom “împinge” nodul care se afla acum în rădăcina heap-ului către poziția în care trebuie sa fie
pentru a fi respectată proprietatea de heap; acest lucru se va face cu funcția pushDown.
extractMin(heap)
{
interschimba(heap[0], heap[dimVec - 1]);
dimVect--;
pushDown(heap, 0);
}
Algoritmul Heap Sort

Întrucât operațiile de extragere a minimului și de adăugare/reconstituire sunt efectuate foarte eficient
(complexități de O(1), respectiv O(log n)), heap-ul poate fi folosit într-o multitudine de aplicații care
necesită rapiditatea unor astfel de operații. O aplicație importantă o reprezintă sortarea, care poate fi
implementată foarte eficient folosind heap-uri. Complexitatea acesteia este O(n*log n), aceeași cu cea de
la quick sort și merge sort.
Se poate implementa inserând, pe rând, în heap, toate elementele din vectorul nesortat. Apoi într-un alt șir
se extrag minimele. Noul șir va conține vechiul vector sortat.
HeapSort(heap)
{
heap = ConstruiesteMaxHeap();
for (i = dimHeap - 1; i >= 1; i--)
{
// Punem maximul la sfarsitul vectorului
interschimba(heap[0], heap[i]);
// 'Desprindem' maximul de heap (valoarea ramanand astfel in pozitia finala)
dimHeap--;
// Reconstituim heap-ul ramas
pushDown(heap, 0);
}
}
ABC vs Heap
Deși la prima vedere nu există mari diferențe între cele două structuri de date, ele sunt complet diferite. Se
poate observa că ele diferă atât la nivelul implementării (abc:pointeri către fii vs heap:vector),
cât și al complexităților operațiilor specifice. Totuși, deși ambele se pot folosi în rare cazuri pentru același
scop (fără a fi la fel de eficiente), ele au întrebuințări diferite.
ABC
Se folosește pentru a implementa arbori echilibrați, precum AVL, Red-Black.

Prezintă toate avantajele unui vector sortat, venind în plus cu inserare în timp logaritmic.
Nu este mereu echilibrat.
HEAP
Heap-ul stă la baza implementării cozii de priorități și a algoritmului heapsort.

Se poate folosi pentru găsirea eficientă a celui de-al k-lea cel mai mic/mare (minheap/maxheap)
element.
Este mereu un arbore echilibrat (complet).
Un arbore este echilibrat dacă fiecare subarbore este echilibrat și înălțimea oricăror doi subarbori diferă
cu cel mult 1. Această regulă stă la baza implementării unui arbore AVL. Arborii roșu-negru impun alte
reguli.
Schelet
lab09.zip
Exerciții
Fiecare laborator va avea unul sau două exerciții publice și un pool de subiecte ascunse, din care asistentul
1) [3.5p] ABC
Task1 va testa operațiile de insert, remove și afișarea (în ordine) a elementelor introduse în ABC.
2) [3.5p] Heap
Task2 va abstractiza următoarea problemă:
Avem un clasament în care pot fi introduse echipe - nume + scor.
Trebuie să efectuăm N operații de tipul:
1 - introducem o nouă echipă în clasament

2 - afișăm prima echipă din clasament
3 - eliminăm prima echipă din clasament
La final, vom afișa topul echipelor rămase în joc.
Bibliografie
1. Vizualizare Binary Search Tree [http://www.cs.usfca.edu/~galles/visualization/BST.html]

2. Binary Search Tree [https://en.wikipedia.org/wiki/Binary_search_tree]
3. Binary Heap [http://en.wikipedia.org/wiki/Binary_heap]
4. Heap Sort [http://en.wikipedia.org/wiki/Heap_sort]
sd-ca/laboratoare/lab-09.txt · Last modified: 2020/04/30 10:31 by teodor_adrian.mirea
6/11/2020 Laborator 10 - Treap [CS Open CourseWare]
Laborator 10 - Treap
Responsabili
Andrei Topală [mailto:mailto:topala.andrei@gmail.com]

Obiective
înțeleagă conceptul unui arbore echilibrat de căutare

exemplifice acest concept pe structura de treap
implementeze operațiile de adăugare/ștergere a unui nod și rotiri
facă operații mai complexe și parcurgeri de treapuri
Noțiuni teoretice
Necesitatea structurii de arbore binar de căutare echilibrat

O structură de date este o metodă de a reține anumite date astfel încât operațiile cu acestea (căutare, inserare,
ștergere) să fie făcute cât mai eficient și să respecte cerințele programatorului. De multe ori, o anumită structură de date
se află la baza unui algoritm sau sistem, iar o performanță bună a acesteia (complexitate spațială și temporală cât mai
mică) influențează performanța întregului sistem.
În laboratoarele precedente am observat că un arbore binar de căutare de înălțime h implementează operațiile descrise
mai sus într-o complexitate de O(h). Dacă acest arbore binar nu este capabil să gestioneze elementele ce sunt inserate
pentru a își menține o structura echilibrată atunci complexitatea pe operațiile de bază va crește.
Exemplu: Să presupunem ca avem de introdus n numere într-un arbore binar de căutare. Întâmplarea face ca numerele
să fie sortate, de unde rezultă că arborele format va avea o structură liniară → fiecare nod va avea un singur vecin
(practic, arborele se va transforma intr-o lista inlantuita). Astfel, complexitatea pe operaţiile de bază va fi O(n).
Noțiuni de bază despre treapuri

Treapurile sunt un bun exemplu de arbori de căutare echilibrați, cel mai des folosiți datorită implementării relativ ușoare
(comparativ cu alte structuri similare cum ar fi Red-Black Trees, AVL-uri sau B-Trees), dar și a modului de operare destul
de intuitiv. Fiecare nod din treap va reţine două câmpuri:
cheia - informația care se reține în arbore și pe care se fac operațiile de inserare, căutare și ștergere
prioritatea - un număr pe baza căruia se face echilibrarea arborelui
Această structură trebuie să respecte doua proprietati (sau invarianți):
Proprietatea de arbore binar de căutare → binary search tree (tr): cheia unui nod va fi mai mare sau egală decât
cheia fiului stânga, dacă există şi mai mică sau egală decât cheia fiului dreapta, dacă există. Cu alte cuvinte o
parcurgere inordine a arborelui va genera șirul sortat de chei.
Proprietatea de heap (eap): prioritatea unui nod este mai mare sau egală decât prioritățile fiilor.
Se poate observa că numele structurii de date provine din acești doi invarianți: tr-eap.
Cum se menține echilibrul structurii? De fiecare dată când un nod este inserat în arbore prioritatea lui este generată
aleator (metodă similară cu cea folosită la randomized quick sort, în care la fiecare pas pivotul este generat aleator).
Arborele va fi aranjat într-un mod aleator, bineînțeles, respectând cei doi invarianți. Cum numărul arborilor echilibrați
este mai mare decât cel al arborilor rău echilibrați, șansa este destul de mică ca prioritățile generate aleator să nu
mențină arborele echilibrat.
Demonstraţia teoretică asupra faptului că operațiile de bază au complexitatea O(logN) se poate găsi aici[0].
Structura unui nod

Mai jos avem codul pentru structura nodului unui treap; se pot observa asemănările cu structura de arbore binar și cu
cea de heap.
treap.h
typedef struct treap_node_t treap_node_t;

struct treap_node_t {
/* left child */
treap_node_t *left;
/* right child */
treap_node_t *right;
/* priority that will be randomly set at insertion */

int priority;
/* the key of the node which will also be used for sorting */
void *key;
};
typedef struct treap_t treap_t;

struct treap_t {
treap_node_t *root;
/* function used for comparing the keys */

int (*cmp)(const void *key1, const void *key2);
};
Bineînțeles, tipul de date trebuie să permită o relație de ordine totală astfel încât oricare două elemente să poată fi
comparate. Astfel, pentru fiecare Treap vom avea o funcție de comparare a cheilor care va întoarce o valoare:
0, dacă cele două chei sunt egale

< 0, dacă cheia nou introdusă este mai mică conform modalității noastre de comparare
> 0, dacă cheia nou introdusă este mai mare conform modalității noastre de comparare
Observați că Treap-ul conține un pointer la o funcție de tip int. Aceea va fi funcția folosită pentru compararea cheilor, care
vă fi oferită funcției ce creează arborele.
Operații de bază
Mai jos este descris pseudocodul pentru operațiile de bază făcute cu treapuri.
Căutarea
Deoarece treapul respecta proprietatea de arbore binar de cautare, căutarea se face exact ca la acesta. Vezi laboratorul
9.
Inserarea
Inserarea unui nod se face generând o prioritate aleatoare pentru acesta și procedând asemănător ca pentru un arbore
binar de căutare, adăugând nodul la baza arborelui printr-o procedură recursivă, pornind de la rădăcină.
Deși inserarea menține invariantul arborelui de căutare, invariantul de heap poate să nu se mai respecte. De aceea,
trebuie definite operații de rotire (stânga sau dreapta), care să fie aplicate unui nod în cazul în care prioritatea sa este
mai mare decât ce a părintelui său.
Mai jos avem pseudocodul pentru operația de inserare.
insert(nod, cheie, prioritate) {

// Daca gasim o frunza, inseram valoarea dorita la acea pozitie
if nod == NULL
nod = creeaza nou nod pe baza de cheie si prioritate
return nod

nod.stanga = insert(nod.stanga, cheie, prioritate)
// Subarborele drept nu a fost modificat, deci verificam schimbarile din stanga
// Asiguram pastrarea proprietatii de heap
if nod.stanga.prioritate > nod.prioritate
rotireDreapta(nod)
else
nod.dreapta = insert(nod.dreapta, cheie, prioritate)
// Subarborele stang nu a fost modificat, deci verificam schimbarile din dreapta
// Asiguram pastrarea proprietatii de heap
if nod.dreapta.prioritate > nod.prioritate
rotireStanga(nod)
}
Spre exemplu, dacă am dori să inserăm nodul cu cheia 9 şi prioritatea 51, pașii vor arată în felul următor:
Se observă necesitatea rotirilor pentru a aduce nodul nou inserat în vârful arborelui (are prioritatea cea mai mare).
Cele două tipuri de rotiri sunt prezentate vizual în imaginea de mai jos:
Ștergerea
Operația de ștergere este inversul operației de inserare și se aseamăna foarte mult cu ștergerea unui nod în cadrul unui
heap. Nodul pe care îl dorim a fi șters este rotit până când ajunge la baza arborelui, iar atunci este șters. Pentru a
menține invariantul de heap, vom face o rotire stânga dacă fiul drept are o prioritate mai mare decât fiul stâng și o rotire
drepta în caz contrar.
sterge(nod, cheie) {
if nod == NULL
return

sterge(nod.stanga, cheie)
else if cheie > nod.cheie

sterge(nod.dreapta, cheie)
else if nod.stanga == NULL si nod.dreapta == NULL

sterge nod
else if nod.stanga.prioritate > nod.dreapta.prioritate

rotireDreapta(nod)
sterge(nod, cheie)
else
rotireStanga(nod)
sterge(nod, cheie)
}
Schelet
Schelet
Exerciții
Fiecare laborator va avea unul sau doua exerciții publice si un pool de subiecte ascunse, din care asistentul poate alege
cum se formeaza celelalte puncte ale laboratorului.
1) [5.5p] Implementați următoarele funcții de bază pentru un treap:
Căutare
Rotiri stânga și dreapta
Inserare
2) [1.5p] Realizați o parcurgere a treap-ului astfel încât să obțineți cheile sortate crescător/descrescător.
Interviu
Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la
un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului.
1. Complexitatea pentru operațiile de bază ale Treap-urilor.

2. Implementare unei/unor funcții(rotire stânga/dreapta, inserare, ștergere).
3. Cum se menține structura de arbore echilibrat?
4. Aflarea celei mai mici/mari valori din structură.
Bibliografie
1. Fast Set Operations Using Treaps [http://www.cs.cmu.edu/afs/cs.cmu.edu/project/scandal/public/papers/treaps-
spaa98.pdf]
2. Randomized Binary Search Trees [http://compgeom.cs.uiuc.edu/~jeffe/teaching/algorithms/notes/10-treaps.pdf]
3. Balanced Search Trees [http://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15451-
s07/www/lecture_notes/lect0208.pdf]
4. Red-black Tree [http://en.wikipedia.org/wiki/Red%E2%80%93black_tree]

5. AVL Tree [http://en.wikipedia.org/wiki/AVL_tree]
6. B-Tree [http://en.wikipedia.org/wiki/B-tree]
6/11/2020 Laborator 11 - AVL & Red-Black Trees [CS Open CourseWare]
Laborator 11 - AVL & Red-Black Trees

Responsabili
Andrei Topală [mailto:mailto:topala.andrei@gmail.com]

Obiective
înțeleagă conceptul unui arbore echilibrat de căutare

exemplifice acest concept pe structurile AVL & Red-Black
își sedimenteze informațiile despre arbori echilibrați și aplicațiile acestora
Noțiuni de bază despre AVL Trees

arbore binar de căutare echilibrat după înălțime
arborele se reechilibrează(rebalancing) după fiecare inserare sau ștergere
Diferență între 2 subarbori ai oricărui nod este maxim 1. Se definește:
factor_de_balans(nod) = înălțime(subarbore_drept(nod)) - înălțime(subarbore_stang(nod))

invariant = factor_de_balans(nod) este -1, 0 sau 1
Avantajul unui AVL Tree este faptul că produce cel mai echilibrat arbore în cazul cel mai defavorabil. Fiind perfect
balansat, arborele AVL va scoate cel mai mic timp de căutare dintre toţi ceilalţi arbori. Dezavantajul său este numărul
mai mare de rotaţii pe care îl efectuează.
Înălţimea unui AVL cu n noduri în cazul cel mai defavorabil este 1.44 * log(n)
[http://lcm.csa.iisc.ernet.in/dsa/node112.html].
La inserare se adaugă nodul astfel încât să aibă proprietatea de arbore binar de căutare, iar după se verifică factorul de
balansare și se începe sau nu balansarea lui. Balansarea lui se face cu rotații duble.
Rotatie simpla L [https://en.wikipedia.org/wiki/AVL_tree#Simple_rotation]

Exemplu de rotatie RL [https://en.wikipedia.org/wiki/AVL_tree#Double_rotation]
Cele 4 tipuri de rotații (LL LR RL RR):
dacă factorul de balans este pozitiv
dacă factorul de balans al nodului stâng este pozitiv

Rotaţie LL (Left): rotire spre stânga
dacă factorul de balans al nodului stâng este negativ

Rotaţie LR (Left-Right): rotire spre stânga + rotire spre dreapta
dacă factorul de balans este negativ

dacă factorul de balans al nodului drept este pozitiv
Rotire RL (Right-Left): rotire spre dreapta + rotire spre stânga
dacă factorul de balans al nodului drept este negativ

Rotire RR (Right) : rotire spre dreapta
Puteți urmări încă un exemplu aici [https://www.gatevidyalay.com/avl-tree-avl-tree-example-avl-tree-rotation/].
Reprezentarea unui AVL

Structura de mai jos este cea folosită de noi pentru reprezentarea AVL-ului din scheletul de laborator.
avl.h
/**
* The AVL node struct definition
*/
typedef struct avl_node_t avl_node_t;
struct avl_node_t {
/* left child - smaller key */
avl_node_t *left;
/* right child - bigger key */
avl_node_t *right;
/* the key of the node which will also be used for sorting */
char *key;
/* height of the node */

int height;
};
/**
* The AVL tree struct definition
*/
typedef struct avl_tree_t avl_tree_t;
struct avl_tree_t {
avl_node_t *root;
/* function used for sorting the keys */

};
Observăm absenţa pointer-ului către nodul părinte, fapt ce ne va cere să lucrăm cu (**node) pentru a putea efectua rotaţiile corespunzător.
Inserare în AVL
Inserarea unui nod într-un AVL se realizează în 2 etape şi este asemănătoare inserării unui nod pentru un Treap:
Se adaugă nodul conform inserării într-un arbore binar de cautare: se caută poziţia de inserare pe baza
comparaţiei dintre nod şi cheia nodului stâng / drept.
Din locul unde am efectuat adăugarea până în rădăcină, se actualizează înălţimea fiecărui nod şi in cazul în care
este necesar, se aplică operaţii de rotire pentru a păstra proprietatea AVL-ului (diferenţa în modul dintre înalţimea
nodului stâng şi întălţimea nodului drept este mai mică sau egală cu 1).
Mai jos avem pseudocodul pentru operaţia de inserare:
void insert(nod, cheie) {
if (nod == NULL) {
node = create_node(cheie)
} else if (nod->cheie > cheie) {
insert(nod->left, cheie)
} else {
insert(nod->right, cheie)
}
nod->inaltime = 1 + max(intaltime(nod->left), inaltime(nod->right)

aplicare_rotiri()
}
Ștergere
Operaţia de ştergere pentru o cheie dintr-un arbore AVL se aseamănă cu ştergerea unei chei dintr-un BST. Vom elimina
nodul pe care dorim să îl ştergem în momentul în care acesta ajunge la baza arborelui. Următorul pas este să
reactualizăm înălţimile fiecărui nod şi să efectuăm rotiri atunci când este necesar. Astfel, putem rezuma stergerea unui
nod dintr-un AVL în 3 etape:
1. Căutarea cheii pe care dorim să o ştergem.
2. Ştergerea nodului cu cheia respectivă. Dacă nodul are 2 succesori, îl vom înlocui cu cel mai mare nod din subarborele
stâng (sau cel mai mic nod din subarborele drept). Altfel, nodul va fi înlocuit cu unul dintre succesorii săi nenuli (sau
NULL, în cazul în care nodul este frunză).
3. Reactualizarea înălţimilor şi realizarea rotaţiilor necesare.
Mai jos avem pseudocodul pentru operaţia de ştergere:
void avl_delete(nod, cheie) {

if (nod == NULL) {
return
}
if (nod->cheie > cheie) {
avl_delete(node->left, cheie)
} else if (nod->cheie < cheie) {
avl_delete(node->right, cheie)
} else {
if (node are 0 succesori) {
stergere(node)
return;
} else if (node are 1 succesor) {
node = succesor(node)
} else {
max_node = max_element(node->left);
copy(node, max_node)
avl_delete(node->left, max_node->cheie)
}
}
nod->inaltime = 1 + max(intaltime(nod->left), inaltime(nod->right))

aplicare_rotiri()
}
Noțiuni de bază despre Red-Black Trees

Un arbore roșu-negru este un arbore binar de căutare care are un bit suplimentar pentru memorarea fiecărui nod:
culoarea acestuia, care poate fi roșu sau negru. Prin restrângerea modului în care se colorează nodurile pe orice drum
de la rădăcină la o frunză, arborii roșu-negru garantează că nici un astfel de drum nu este mai lung decât dublul lungimii
oricărui alt drum, deci că arborele este aproximativ echilibrat.
Un arbore binar de căutare este arbore roșu-negru dacă el îndeplineste următoarele proprietăți:
Fiecare nod este fie roșu, fie negru.

Fiecare frunză (nil) este neagră.
Dacă un nod este roșu, atunci ambii fii ai săi sunt negri.
Fiecare drum simplu de la un nod la un descendent care este frunza conține același număr de noduri negre.
Mai multe detalii, aici:
Colour it please as Red-Black Trees [https://medium.com/@aleksandrasays/colour-it-please-as-red-black-trees-

a74af93b8561]
Cormen, p269 [https://www.cs.auckland.ac.nz/software/AlgAnim/red_black_op.html]
AVL vs Red-Black
AVL permite căutări mai rapide - sunt echilibrați mai “strict”
Red-Black este mai potrivit pentru multe inserări și ștergeri - mai puține rotiri necesare
Cu toate acestea, ambele tipuri de arbori discutate in acest articol sunt foarte populare si folosite.
Arborii Red-Black sunt foarte folosiți în cazuri generale, unde se descurcă binișor la toate capitolele, în timp ce arborii
AVL sunt folosiți în domeniul bazelor de date, unde timpul pentru o căutare reprezintă un factor foarte important.
Cazuri concrete unde este utilizat Red-Black Tree:
Java: TreeMap, TreeSet

C++ STL: map, multimap, multiset
Linux Kernel: Completely Fair Scheduler [https://en.wikipedia.org/wiki/Completely_Fair_Scheduler]
AVL Trees vs. Red-Black Trees [https://discuss.fogcreek.com/joelonsoftware/default.asp?cmd=show&ixPost=22948]
Reprezentarea unui Red-Black

rb_tree.h
enum COLOR {
RED,
BLACK
};
/**
* The Red-Black node struct definition
*/
typedef struct rb_node_t rb_node_t;
struct rb_node_t {
/* parent - RB_NODE_NULL for root */
rb_node_t *parent;
/* left child - smaller key */
rb_node_t *left;
/* right child - bigger key */
rb_node_t *right;
/* the sorting is based on key */

void *key;
/* data contained by the node */
void *data;
/* color of the node */

enum COLOR color;
};
/**
* The Red-Black tree struct definition
*/
typedef struct rb_tree_t rb_tree_t;
struct rb_tree_t {
rb_node_t *root;
/* key size */
size_t key_size;
/* data size */
size_t data_size;
/* function used for sorting the keys */

};
Schelet
Schelet
Exerciții
1) [45p] Completați funcția de reechilibrare și implementați funcțiile de inserare, căutare și ștergere pentru AVL.
2) [45p] Completați părțile de cod care lipsesc din funcțiile din rb_tree.c.
6/11/2020 Quiz Lab2 - Liste înlănțuite: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 24 February - 1 March / Quiz Lab2 - Liste înlănțuite
Started on Tuesday, 3 March 2020, 2:27 PM

State Finished
Completed on Tuesday, 3 March 2020, 2:31 PM
Time taken 4 mins 29 secs
Grade 4 out of 5 (80%)
Question 1 De ce tip pot fi elementele unei liste?

Correct
Mark 1 out of 1 Select one:

a. cel mult 4 tipuri diferite
b. orice tip definit de programator care conține în interiorul său un tip de bază
c. tipuri de bază cum ar fi int, float, char, etc.
d. orice tip, dar să fie toate de același tip 
Răspunsul dumneavoastră este corect.

The correct answer is: orice tip, dar să fie toate de același tip
Question 2 Care va fi conținutul listei înlănțuite l după efectuarea următoarelor operații (metoda add_first(l, x) adaugă
Correct elementul x la începutul listei, iar add_last(l, x) adaugă elementul x la sfârșitul listei)?
Mark 1 out of 1
LinkedList* l = (LinkedList*) calloc(1, sizeof(LinkedList));
for (int i = 0; i < 3; i++)

add_last(l, i);
add_first(l, 3);
add_first(l, 1);
Select one:
a. 3 1 0 1 2
b. 1 3 0 1 2 
c. 0 1 2 4 3
d. 0 1 2 3 4

The correct answer is: 1 3 0 1 2
Question 3 Care structură de date este mai eficientă din punctul de vedere al utilizării memoriei (ocupă mai puțină memorie)?
Incorrect

a. LinkedList 
b. Un array din C
Răspunsul dumneavoastră este incorect.

The correct answer is: Un array din C
https://acs.curs.pub.ro/2019/mod/quiz/review.php?attempt=9061&cmid=11005 1/2
Question 4 Accesul la al i-lea element din structură se face cu o complexitate mai mică în cazul listelor înlănţuite faţă de
Correct array-uri. Operaţia de eliminare a unui element (la care avem deja acces) are o complexitate mai mică în cazul
Mark 1 out of 1 array-urilor faţă de liste.
Select one:
a. Adevărat, Adevărat
b. Fals, Fals 
c. Fals, Adevărat
d. Adevărat, Fals

The correct answer is: Fals, Fals
Question 5 Care dintre următoarele operații se realizează mult mai rapid cu elementele unei liste (la care avem acces la
Correct pointerii head și tail) decât cu elementele unui vector?
Mark 1 out of 1 1. modificarea primului element
2. adăugarea unui element la început sau la sfârșit
3. găsirea unui element, considerând că atât în listă, cât și în vector, elementele sunt sortate
Select one:
a. 2 
b. 1 și 2
c. 1, 2 și 3
d. 1 și 3

The correct answer is: 2
◄ lab02 - Liste înlănțuite Jump to... curs03 - LinkedList part2 ►
6/11/2020 Quiz Lab3 - Liste înlănțuite (continuare): Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 2 March - 8 March / Quiz Lab3 - Liste înlănțuite (continuare)

State Finished
Question 1 O listă dublu-înlănţuită foloseşte pentru stocare mai puţină memorie decât o listă dublu-înlănţuită circulară. În
Incorrect general, adăugarea unui nou element pe a doua poziţie se face mai rapid într-o listă dublu-înlănţuită faţă de un
Mark 0 out of 1 array simplu.
Select one:
a. Adevărat. Fals 
b. Fals. Adevărat
c. Adevărat. Adevărat
d. Fals. Fals

The correct answer is: Fals. Adevărat
Question 2 Considerând că într-o listă înlănțuită bine formată head reprezintă pointer la primul element al listei, iar tail
Correct reprezintă pointer la ultimul element al listei, ce se poate spune despre listă dacă head -> next == head este true,
Mark 1 out of 1 iar tail -> next == tail este true?
Select one:
a. Lista are un singur element
b. tail -> next == head este true
c. Lista este o listă circulară
d. Toate variantele sunt adevărate 

The correct answer is: Toate variantele sunt adevărate
Question 3 Dezavantajul listelor dublu înlănțuite față de cele simplu înlănțuite este:
Correct

a. au nevoie obligatoriu de pointer la ultimul element
b. accesul la un element aleator este mai încet
c. necesită o zonă contiguă de memorie
d. ocupă mai multă memorie 

The correct answer is: ocupă mai multă memorie
Question 4
În cazul cărei structuri de date ștergerea primului element este mult mai costisitoare din punct de vedere al
Incorrect
timpului de execuție?
Mark 0 out of 1
Select one:
a. Lista dublu înlănțuită
b. Un array simplu din C
c. Lista înlănțuită circulară 
d. Lista simplu înlănțuită

The correct answer is: Un array simplu din C
Question 5 Care dintre următoarele afirmaţii este adevărată ?

Correct

a. Într-o listă liniară dublu înlănţuită ultimul nod are un pointer next care indică spre nodul head.
b. Cunoscând dinainte numărul maxim N de elemente stocate, o listă dublu înlănţuită foloseşte mai puţină memorie
pentru a stoca cele N elemente în comparaţie cu un array.
c. Cunoscând dimensiunea listei, accesul la un element oarecare (al i-lea element) într-o listă dublu înlănţuită circulară
este, în medie, mai rapid decât în cazul listelor liniare dublu înlănţuite. 
d. Într-o listă liniară dublu înlănţuită se poate ajunge de la nodul head la ultimul nod din listă printr-un singur pas,
fără a parcurge întreaga listă.

The correct answer is: Cunoscând dimensiunea listei, accesul la un element oarecare (al i-lea element) într-o listă dublu
înlănţuită circulară este, în medie, mai rapid decât în cazul listelor liniare dublu înlănţuite.
◄ lab03 - Liste înlănțuite (continuare) Jump to... curspr02 ►
6/11/2020 Quiz Lab5 - Stivă și Coadă: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 16 March - 22 March / Quiz Lab5 - Stivă și Coadă

State Finished
Question 1 Ce element poate fi accesat intr-o stiva in O(1) (adica timp constant, aproape instantaneu)?
Correct

a. ultimul element adaugat in stiva 
b. primul element adaugat in stiva
c. nici un element
d. orice element

The correct answer is: ultimul element adaugat in stiva
Question 2 Metoda enqueue a unei cozi:

Correct

a. extrage un element de la inceput
b. extrage un element de la sfarsit
c. adauga un element la inceput
d. adauga un element la sfarsit 

The correct answer is: adauga un element la sfarsit
Question 3 Metoda pop a unei stive:

Correct

a. adauga un element in varful stivei
b. sterge elementul din varful stivei si il intoarce ca rezultat 
c. verifica daca stiva este goala
d. intoarce elementul din varful stivei (fara a-l sterge din stiva)

The correct answer is: sterge elementul din varful stivei si il intoarce ca rezultat
Question 4 Initial avem dequeue cu elementele (in aceasta ordine, de la head la tail): 1 2 3 4
Correct
Presupunem ca efectuam urmatoarele operatii:
Mark 1 out of 1
push_front(dequeue, 3);
pop_back(dequeue);
front(dequeue);
push_back(dequeue, 5);
pop_front(dequeue);
pop_front(dequeue);
Ce elemente are dequeue dupa executarea operatiilor?
Select one:
a. 5 2 3
b. 2 3 5 
c. 1 2 3
d. 2 3 4

The correct answer is: 2 3 5
Question 5 Initial avem o coada cu elementele (in aceasta ordine, de la head la tail): 1 2 3 4 5.
Correct
Mark 1 out of 1
dequeue(queue);
dequeue(queue);
dequeue(queue);
enqueue(queue, 6);
dequeue(queue);
enqueue(queue, 7);
Ce elemente are coada dupa executia operatiilor?
Select one:
a. 5 6 7 
b. 7 6 1
c. 7 4 5
d. 4 5 6 7

◄ lab05 - stiva si coada Jump to... Upload Lab5 - Stiva si Coada ►
6/11/2020 Quiz Lab9 - ABC și Heap: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 20 April - 26 April / Quiz Lab9 - ABC și Heap
Started on Tuesday, 28 April 2020, 2:12 PM

State Finished
Completed on Tuesday, 28 April 2020, 2:17 PM
Time taken 5 mins
Question 1 Se dă vectorul asociat unui max-heap binar:

Incorrect
22, 11, 13, 10, 7, 5, 9
Mark 0 out of 1
Cum va arăta vectorul dupa 2 operații de pop?
Select one:
a. 11, 10, 9, 7, 5 
b. 11, 9, 10, 5, 7
c. 11, 10, 9, 5, 7
d. 11, 10, 5, 9, 7
Your answer is incorrect.

The correct answer is: 11, 10, 9, 5, 7
Question 2 Următoarea parcurgere va rezulta în afișarea elementelor unui arbore binar de căutare în ordine crescătoare:
Correct

a. parcurgere în adâncime
b. preordine
c. parcurgere în lățime
d. postordine
e. inordine 

The correct answer is: inordine
Question 3 Elementul maxim dintr-un arbore binar de căutare se află în:

Correct

a. Cea mai din stânga frunză
b. Cea mai din dreapta frunză aparținând ultimului nivel
c. Cea mai din stânga frunză aparținând ultimului nivel
d. Cea mai din dreapta frunză 

The correct answer is: Cea mai din dreapta frunză
Question 4
Care din următoarele proprietăți este adevărată pentru un min-heap?
Correct

a. H[Parinte(x)] >= H[x]
b. H[Parinte(x)] = H[x]
c. Nu exista relație de ordine între părinte și nod
d. H[Parinte(x)] <= H[x] 
Your answer is correct.

The correct answer is: H[Parinte(x)] <= H[x]
Question 5 Se dă următorul cod:

Correct
int count = 0;
Mark 1 out of 1
void printeaza(BSTNode *root, int k)

{
if (root != NULL && count <= k) {
printeaza(root->right_son, k);
++count;
if (count == k)
cout << root->info;
printeaza(root->left_son, k);
}
}
Ce output va genera printeaza(root, 3) dacă root este rădăcina următorului arbore binar de căutare:
Select one:
a. 16 
b. 15
c. 10
d. 20

◄ Lab09 - ABC și Heap Jump to... Upload Laborator 9 - ABC si Heap ►
6/11/2020 Quiz Lab10 - Treap: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 27 April - 3 May / Quiz Lab10 - Treap
Started on Tuesday, 5 May 2020, 2:12 PM

State Finished
Completed on Tuesday, 5 May 2020, 2:17 PM
Time taken 5 mins
Grade 3.00 out of 5.00 (60%)
Question 1 Două rotații stânga ale unui nod al treap-ului sunt echivalente cu o rotație dreapta
Correct a aceluiași nod:
Mark 1.00 out of
1.00 Select one:
True
False 
The correct answer is 'False'.
Question 2 Fie următorul treap (nodurile sunt de forma (cheie, prioritate)):

Incorrect
Mark 0.00 out of (5, 10)

1.00 / \
(3, 7) (7, 8)
\
(11, 5)
Daca inserăm un nod cu cheia 6, care este cea mai mare prioritate pe care ar putea să
o aibă pentru ca inserarea să se facă fără nicio rotire.
Answer: 6 
Question 3 De ce trebuie ca un treap (cu N noduri) să respecte invariantul arborilor de căutare?

Incorrect
Mark 0.00 out of Select one:

1.00
a. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(înălțime treap)
b. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(logN) 
c. pentru a putea parcurge treap-ul pe nivele și a obține cheile sortate crescător
d. pentru a fi echilibrat

The correct answer is: pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(înălțime treap)
Question 4 Fie următorul treap:

Correct
Mark 1.00 out of A

1.00 / \
B C
/ \
D E
Dacă facem o rotație stânga din nodul A, care vor fi fiii acestuia dupa rotație?
Select one:
a. D și E
b. B și C
c. B și D 
d. C și E

The correct answer is: B și D

Correct
Mark 1.00 out of (5, 10)

1.00 / \
(3, 7) (7, 8)
\
(11, 5)
Daca inserăm nodurile (4, 3), respectiv (12, 9), care vor fi fiii rădăcinei?
Select one:
a. (3, 7) și (12, 9) 
b. (4, 3) și (12, 9)
c. (3, 7) și (7, 8)
d. (3, 7) și (4, 3)

The correct answer is: (3, 7) și (12, 9)
◄ Upload Laborator 10 - Treap Jump to... curs11 - Arbori Echilibrati ►
6/11/2020 Quiz Laborator 4 - Dictionar: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 9 March - 15 March / Quiz Laborator 4 - Dictionar

State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Când are loc o coliziune într-o tabelă de dispersie?

Correct

1.00
a. când funcția de hash returnează același număr pentru două chei diferite 
b.
când două chei sunt identice
c. când două valori din perechi de tip cheie-valoare coincid
d.
când se accesează o adresă de memorie nevalida

The correct answer is: când funcția de hash returnează același număr pentru două chei diferite
Question 2
Când o funcție de hash este considerată bună?
Correct
Mark 1.00 out of

1.00
Select one:
a.
când returnează cât mai multe numere care coincid
b. atunci când pentru un număr mic de date de intrare sunt multe coliziuni
c.
când aplică doar operația modulo asupra cheii
d.
atunci când pentru un număr mare de date de intrare sunt puține coliziuni 

The correct answer is:
atunci când pentru un număr mare de date de intrare sunt puține coliziuni
Question 3
Se introduc următorele elemente:
Correct
1 2 3 4 5 6 7 8 9 10
Mark 1.00 out of
1.00
folosind funcția de hash
unsigned int hash(int x) {
return (x + 1) % 4;
}
Ce elemente sunt in bucket-ul cu index-ul 3?
Select one:
a. 2, 6, 10 
b. 2, 5, 8
c. 1, 5, 9
d. 1, 4, 8

The correct answer is: 2, 6, 10
Question 4
Funcția de hash returnează numere întregi. Numărul de bucket-uri dintr-un hashtable trebuie să fie prim.
Incorrect
Mark 0.00 out of

1.00
Select one:
a. adevarat, adevarat
b.
fals, fals
c. adevarat, fals 
d. fals, adevarat

fals, fals
Question 5
De ce se efectuează operația modulo pe numărul întors de funcția de hash?
Correct
Mark 1.00 out of

1.00
Select one:
a. pentru a îmbunătăți performanța hashtable-ului
b.
pentru a nu obține un număr mai mare decât numărul de bucket-uri 
c.
pentru a minimiza numărul de coliziuni

pentru a nu obține un număr mai mare decât numărul de bucket-uri
◄ lab04 - Dictionar Jump to... Laborator 313CAb 10-12 ►
6/11/2020 Quiz Laborator 6 - Grafuri Basics: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 23 March - 29 March / Quiz Laborator 6 - Grafuri Basics

State Finished
Grade 5.00 out of 5.00 (100%)
Question 1
Care este corespondenta corecta intre tipul de parcurgere si structura de date utilizata:
Correct
Mark 1.00 out of

1.00
Select one:
a. DFS - coada / BFS - lista inlantuita circulara
b. DFS - stiva / BFS - coada 
c. DFS - coada / BFS - stiva
d. BFS - lista dublu inlantuita / DFS - ArrayList
The correct answer is: DFS - stiva / BFS - coada
Question 2
Ce se poate spune despre un graf in care in urma unei parcurgeri DFS se observa ca unul dintre vecinii nodului
Correct
curent a fost deja vizitiat?
Mark 1.00 out of
1.00
Select one:
a. Graful are doar 2 noduri
b. Graful contine un ciclu 
c. Graful are o structura liniara

The correct answer is: Graful contine un ciclu
Question 3
In grafurile orientate conteaza sensul muchiilor. Reprezentarea prin matrice de adiacenta este potrivita pentru grafuri rare.
Correct
Mark 1.00 out of

Select one:
1.00
a. Adevarat, Adevarat
b. Adevarat, Fals 
c. Fals, Adevarat
d. Fals, Fals

The correct answer is: Adevarat, Fals
Question 4
Pentru a realiza o parcurgere BFS a unui graf, nodurile care urmează sa fie explorate sunt reținute în:
Correct

1.00
a. Stivă
b. Listă
c. Coadă 

Pentru implementarea BFS se utilizează o coadă (Q) în care inițial se află doar nodul sursă. Se vizitează pe rând vecinii
acestui nod şi se pun și ei în coada. În momentul în care nu mai există vecini nevizitați, nodul sursă este scos din coadă.
The correct answer is: Coadă
Question 5
Prin intermediul carei parcurgeri se poate determina eficient drumul minim intre doua noduri in graf?
Correct

1.00
a. DFS
b. BFS 
c. Ambele
d. Niciuna

The correct answer is: BFS
◄ lab 6 - Grafuri - reprezentare si Upload lab 6 - Grafuri - reprezentare si

Jump to...
parcurgeri parcurgeri ►
6/11/2020 Quiz Laborator 7 - Grafuri Advanced: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 30 March - 5 April / Quiz Laborator 7 - Grafuri Advanced

State Finished
Time taken 5 mins 1 sec
Grade 5.00 out of 5.00 (100%)
Question 1 Care din următoarele afirmații sunt adevărate despre parcurgerea BFS a unui graf cu muchii egale:
Correct
1. Determină lungimea minimă a drumului dintre două noduri conectate.
Mark 1.00 out of 2. Diferența distanțelor nodurilor aflate în coadă în algoritm poate fi oricât de mare.
1.00
3. Determină componentele conexe ale grafului.
4. Nu determină ce noduri pot fi atinse plecând dintr-un anumit nod.
Select one:
a. 1, 2 și 3
b. Toate
c. 1 și 2
d. 1 și 3 

The correct answer is: 1 și 3
Question 2 Determinarea componentelor conexe ale unui graf se poate efectua folosind parcurgerea:
Correct

1.00
a. BFS sau DFS 
b. BFS
c. Nici o parcurgere nu determină componentele conexe ale unui graf
d. DFS

The correct answer is: BFS sau DFS
Question 3 Make este un utilitar care folosește fișiere makefile în care se specifică cum se obține fiecare target în funcție de
Correct dependențe pentru a crea executabile și biblioteci. Make construiește un graf în care targeturile și dependențele sunt
Mark 1.00 out of noduri și există muchii orientate de la dependențe la targeturi.
1.00
Care din următorii algoritmi este folosit de către Make?
Select one:
a. Niciunul de mai sus
b. Parcurgere în lățime
c. Sortare topologică 

Sortarea topologică este folosită în cadrul utilitarului Make pentru a rezolva mai întâi dependențele necesare unui target.
The correct answer is: Sortare topologică
Question 4 Un graf este bipartit daca oricare doua noduri consecutive se afla pe acelasi nivel (au aceeasi culoare).
Correct

1.00
True
False 
Question 5 Care din următoarele afirmații sunt adevărate despre parcurgerea DFS a unui graf cu muchii egale:
Correct
Mark 1.00 out of 1. Determină lungimea minimă a drumului dintre două noduri conectate.
1.00 2. Poate ordona nodurile astfel încât să respecte relația de ordine a muchiilor.
Select one:
a. Toate
b. 1 si 2
c. 2 si 3 
d. 1, 2 si 3

The correct answer is: 2 si 3
◄ Lab07 - Grafuri Advanced Jump to... Upload Lab7 - Grafuri advanced ►
6/11/2020 Quiz Laborator 08 - Arbori si arbori binari: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 6 April - 12 April / Quiz Laborator 08 - Arbori si arbori binari
Started on Wednesday, 15 April 2020, 6:15 PM

State Finished
Completed on Wednesday, 15 April 2020, 6:19 PM
Marks 5.00/5.00
Grade 10.00 out of 10.00 (100%)
Question 1 Care este cel mai mic strămoș comun al nodurilor 4 și 8 al arborelui următor?
Correct
Mark 1.00 out of

1.00
Select one:
a. 8
b. 3
c. 10
d. 7 

Question 2 Se dă un arbore binar în care nodul X dispune de 2 subarbori. Ținând cont că nodul Y este succesorul nodului X într-o
Correct traversare în inordine care dintre următoarele afirmații este adevărată:
Mark 1.00 out of
1.00 Select one:
a. Y nu are subarbore stâng 
b. Y nu are subarbore drept
c. Y are 2 subarbori

În cadrul parcurgerii în inordine, se repetă recursiv următorul algoritm pornind din nodul rădăcină:
Pentru ca Y să fie succesorul nodului X într-o parcurgere în inordine, este imperativ ca nodul Y sa nu aibă subarbore
stâng. Dacă nodul Y ar dispune de un subarbore stâng, atunci în cadrul traversării, acel subarbore stâng ar fi succesorul
nodului X.
The correct answer is: Y nu are subarbore stâng
Question 3 Se dă următorul arbore binar:

Correct
Mark 1.00 out of

1.00
Parcurgerea în preordine a arborelui din figură este:
Select one:
a. D B G E H I F C A
b. A B C D E F G H I
c. A B D C E G F H I 
d. B D A G E C H F I

În cadrul parcurgerii în preordine, se repetă recursiv următorul algoritm pornind din nodul rădăcină:
The correct answer is: A B D C E G F H I
Question 4 Parcurgerea inordine pe un arbore binar, începând din nodul de pe nivelul 2 (nivelul 1 este rădăcina), respectiv
Correct subarborele drept are că efect:
Mark 1.00 out of
1.00 Select one:
a. afișarea tuturor elementelor
b. afișarea tuturor elementelor, mai puțin rădăcina și subarborele stâng 
c. afișarea elementelor din subarborele stâng
d. afișarea rădăcinii și a elementelor din subarborele drept

The correct answer is: afișarea tuturor elementelor, mai puțin rădăcina și subarborele stâng
Question 5 Parcurgerea preordine pe următorul arbore este:

Correct
Mark 1.00 out of

1.00
Select one:
a. 10 7 11 3 8 13 4 8 12 17
b. 10 7 3 4 8 8 11 13 12 17 
c. 3 4 7 8 8 10 11 12 13 17
d. 4 3 8 8 7 12 17 13 11 10

The correct answer is: 10 7 3 4 8 8 11 13 12 17
Upload Laborator 8 - Arbori și Arbori

◄ Lab08 - Arbori si Arbori Binari Jump to...
Binari ►
6/11/2020 Quiz Laborator 11 - AVL & Red-Black Trees: Attempt review
Dashboard / My courses / L-A1-S2-SD-CA / 4 May - 10 May / Quiz Laborator 11 - AVL & Red-Black Trees

State Finished
Grade 5.00 out of 5.00 (100%)
Question 1 Un AVL este:

Correct
Mark 1.00 out of Select one or more:

1.00
a. Un arbore binar de cautare echilibrat dupa numere de prioritate
b. Un arbore binar de cautare complet
c. Un arbore binar de cautare echilibrat dupa inaltime 
d. Un arbore binar de cautare aproape complet

The correct answer is: Un arbore binar de cautare echilibrat dupa inaltime
Question 2 Unui nod dintr-un arbore Red-Black nu i se va schimba niciodata culoarea primita la inserare.
Correct

1.00
a. Fals 
b. Adevarat

The correct answer is: Fals
Question 3 Daca un nod este rosu, ce culoare trebuia sa aiba fiii sai?
Correct

1.00
a. Rosie
b. Un fiu rosu, altul negru
c. Neagra 
d. Un nod rosu trebuie sa fie frunza
The correct answer is: Neagra
Question 4 Fie un AVL cu N noduri. Care este inaltimea maxima a acestuia, in cazul cel mai defavorabil?
Correct

1.00
a. n
b. sqrt(n)
c. log(n)
d. 1.44 * log(n) 

The correct answer is: 1.44 * log(n)
Question 5 De ce am folosi un arbore Red-Black in locul unui Hashmap, avand in vedere ca Hashmap-ul are timp constant pentru
Correct majoritatea operatiilor?
Mark 1.00 out of
1.00 Select one or more:
a. pentru ca arborele nu are nevoie de o zona continua de memorie
b. nu am folosi niciodata un Red-Black Tree in locul unui Hashmap
c. pentru ca sa implementezi arbori este mai placut
d. pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem avantajul ordinii in Red-
Black Tree 

The correct answer is: pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem avantajul
ordinii in Red-Black Tree
Upload Laborator 11 - AVL & Red-Black

◄ Laborator 11 - AVL & Red-Black Trees Jump to...
Trees ►
Quiz Lab2 - Liste înlănțuite: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Time taken 5 mins
Question 1 Cum sunt stocate în memorie elementele unei liste înlănțuite?

Correct

a. Într-o zonă contiguă de memorie
b. Arbitrar 

The correct answer is: Arbitrar
Question 2 Din punct de vedere al memoriei utilizate pentru memorarea unui singur element, ce se poate spune
Incorrect despre array-urile din C și LinkedList?
Mark 0 out of 1
Select one:
a. Ambele utilizează aceeași cantitate de memorie 
b. LinkedList utilizează mai puțină memorie decât un array
c. Array-urile utilizează mai multă memorie decât LinkedList
d. LinkedList utilizează mai multă memorie decât un array
The correct answer is: LinkedList utilizează mai multă memorie decât un array
1 of 3 6/11/20, 10:44 PM
Question 3
Care va fi conținutul listei l după efectuarea următoarelor operații (metoda add_first(l, x) adaugă elementul
Correct
x la începutul listei, iar add_last(l, x) adaugă elementul x la sfârșitul listei)?
Mark 1 out of 1
add_last(l, 1);
add_first(l, 2);
add_last(l, 3);
add_first(l, 0);
Select one:
a. 2 0 1 3
b. 0 1 2 3
c. 0 2 1 3 
d. 2 1 0 3

The correct answer is: 0 2 1 3
Question 4
Care va fi conținutul listei simplu înlănțuite l, care iniţial este vidă, după efectuarea următoarelor operații
Correct
(metoda add_first(l, x) adaugă elementul x la începutul listei, iar add_last(l, x) adaugă elementul x la
Mark 1 out of 1 sfârșitul listei)?
for (int i = 0; i < 4; i++)
if (i % 2)
add_last(l, i);
else
add_first(l, i);
add_last(l, 4);
add_first(l, 5);
Select one:
a. 4 2 0 1 3 5
b. 5 1 3 0 2 4
c. 5 1 0 3 2 4
d. 5 2 0 1 3 4 

The correct answer is: 5 2 0 1 3 4
2 of 3 6/11/20, 10:44 PM
Question 5 Dacă într-o listă simplu înlănțuită se identifică un element X pentru care pointerul său next duce la un
Correct element anterior Y diferit de X, atunci:
Mark 1 out of 1
Select one:
a. există un ciclu în listă 
b. X și Y sunt la aceeași adresă de memorie
c. lista are exact 2 elemente
d. lista are un singur element

The correct answer is: există un ciclu în listă
3 of 3 6/11/20, 10:44 PM
Quiz Lab3 - Liste înlănțuite (continuare): Attemp... https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Question 1 O listă dublu-înlănţuită foloseşte pentru stocare mai puţină memorie decât o listă dublu-înlănţuită
Correct circulară. În general, adăugarea unui nou element pe a doua poziţie se face mai rapid într-o listă dublu-
Mark 1 out of 1 înlănţuită faţă de un array simplu.
Select one:
a. Fals. Adevărat 
b. Adevărat. Adevărat
c. Fals. Fals
d. Adevărat. Fals

Question 2 Ştiind că atât pentru o listă dublu-înlănţuită, cât şi pentru una dublu-înlănţuită circulară nu reţinem un
Correct pointer tail la ultimul element din listă, ci doar un pointer head la primul element din listă, atunci care
Mark 1 out of 1 dintre cele două tipuri de liste (şi de ce) permite adăugarea mai rapidă a unui nou element la finalul listei
într-un caz general când deja sunt mai multe noduri?
Select one:
a. Lista dublu-înlănţuită deoarece nu mai trebuie actualizaţi şi pointerul prev al primului nod şi pointerul next
al ultimului nod ca în cazul listelor circulare.
b. Lista dublu-înlănţuită circulară deoarece nu trebuie să parcurgem toate nodurile din listă pentru a ajunge la
ultimul. 
c. Ambele liste sunt la fel de rapide.
d. Lista dublu-înlănţuită deoarece foloseşte mai puţină memorie şi astfel apelul de alocare a memoriei se
întoarce mai repede.

The correct answer is: Lista dublu-înlănţuită circulară deoarece nu trebuie să parcurgem toate nodurile din listă
pentru a ajunge la ultimul.
1 of 2 6/11/20, 10:45 PM
Quiz Lab3 - Liste înlănțuite (continuare): Attemp... https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 3 Un avantaj al listelor dublu înlănţuite faţă de listele simplu înlănţuite este:
Correct

a. Listele dublu înlănţuite folosesc mai puţină memorie deoarece adresele la care pointează pointerii din
noduri se repetă.
b. Adăugarea unui nod pe prima poziţie într-o listă dublu înlănţuită este strict mai rapid decât în cazul listelor
simplu înlănţuite.
c. Accesarea elementelor vecine unui nod se face mult mai rapid. 
d. Listele dublu înlănţuite permit parcurgerea tuturor nodurilor mai rapidă, de la head la finalul listei.

The correct answer is: Accesarea elementelor vecine unui nod se face mult mai rapid.
Question 4 Care dintre următoarele afirmaţii este adevărată ?

Correct

a. Într-o listă liniară dublu înlănţuită se poate ajunge de la nodul head la ultimul nod din listă printr-un singur
pas, fără a parcurge întreaga listă.
b. Cunoscând dimensiunea listei, accesul la un element oarecare (al i-lea element) într-o listă dublu înlănţuită
circulară este, în medie, mai rapid decât în cazul listelor liniare dublu înlănţuite. 
c. Într-o listă liniară dublu înlănţuită ultimul nod are un pointer next care indică spre nodul head.
d. Cunoscând dinainte numărul maxim N de elemente stocate, o listă dublu înlănţuită foloseşte mai puţină
memorie pentru a stoca cele N elemente în comparaţie cu un array.
The correct answer is: Cunoscând dimensiunea listei, accesul la un element oarecare (al i-lea element) într-o listă
dublu înlănţuită circulară este, în medie, mai rapid decât în cazul listelor liniare dublu înlănţuite.
Question 5 Având o listă circulară simplu înlănțuită cu mai mult de 3 noduri, al câtelea nod este aferent instrucțiunii: tail ->
Correct next -> next -> next (primul nod are asociat indexul 0)?
Mark 1 out of 1
Select one:
a. Niciun nod, se ajunge la NULL.
b. Nodului cu index 2. 
c. head -> next
d. Tot tail.

The correct answer is: Nodului cu index 2.
2 of 2 6/11/20, 10:45 PM
Quiz Laborator 4 - Dictionar: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Grade 2.00 out of 5.00 (40%)
Question 1 Care din următoarele operații nu sunt suportate de un dicționar:

Incorrect

1.00
a. put(key)
b. get(key) 
c. has_key(key)
d. remove(key)

Operația de put folosește o pereche de (cheie, valoare). Nu există operația de put(key).
The correct answer is: put(key)
Question 2 Care este timpul mediu de regăsire a unei perechi cheie-valoare dintr-un dicționar?
Incorrect

1.00
a.
timp constant (O(1))
b.
timp pătratic (O(n*n))
c.
timp liniar (O(n))
d.
timp logaritmic (O(log n)) 

1 of 3 6/11/20, 10:45 PM
Question 3
Se introduc următorele elemente:
Correct
1 2 3 4 5 6 7 8 9 10
Mark 1.00 out of
1.00
folosind funcția de hash
unsigned int hash(int x) {
return (x + 1) % 4;
}
Ce elemente sunt in bucket-ul cu index-ul 3?
Select one:
a. 1, 5, 9
b. 2, 6, 10 
c. 1, 4, 8
d. 2, 5, 8

The correct answer is: 2, 6, 10
Question 4
Considerând următoarele elemente:
Correct
23456, 34561, 78534, 45623, 12343, 89761
Mark 1.00 out of
1.00
și funcția de hash
x % 3
care dintre următoarele afimații sunt valide?
i) 23456 și 45623 produc același hash
ii) 34561, 12343 și 89761 produc același hash
iii) toate valorile produc același hash
Select one:
a. i) si ii) 
b. i)
c. ii)
d. iii)

The correct answer is: i) si ii)
2 of 3 6/11/20, 10:45 PM
Question 5
Ce bucket va returna următoarea funcție de hash pentru cheia "abcd" (fară ghilimele):
Incorrect
int hash(char* key) {
Mark 0.00 out of
1.00 int index = 0;
for (int i = 0; i < 3; ++i) {
index += key[i] - 'a';
}
return index % 5;
}
Select one:
a. 4
b. 3
c. 1 
d. 2

3 of 3 6/11/20, 10:45 PM
Quiz Lab5 - Stivă și Coadă: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Time taken 5 mins
Question 1 Ce operatii sunt suportate de o coada cu doua capete (dequeue - double ended queue)?
Partially correct
Mark 1 out of 1 Select one or more:

a. Inlocuirea unui element din coada
b. Returnarea celui mai vechi element din coada 
c. Stergerea celui mai recent element din coada 
d. Adaugarea unui element in coada
e. Stergerea celui mai vechi element din coada 
Răspunsul dumneavoastră este parțial corect.

You have correctly selected 3.
The correct answers are: Adaugarea unui element in coada, Stergerea celui mai recent element din coada,
Stergerea celui mai vechi element din coada, Returnarea celui mai vechi element din coada
Question 2 Initial avem o coada goala. Presupunem ca efectuam urmatoarele operatii:

Incorrect
enqueue(queue, 'a');
Mark 0 out of 1 enqueue(queue, 'b');
dequeue(queue);
enqueue(queue, 'c');
enqueue(queue, 'd');
dequeue(queue);
front(queue);
enqueue(queue, 'x');
Ce elemente raman in coada dupa executia operatiilor?
Select one:
a. d x 
b. a c x
c. b d x
d. c d x

The correct answer is: c d x
1 of 2 6/11/20, 10:46 PM
Quiz Lab5 - Stivă și Coadă: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 3 Coada se poate implementa folosind pe post de container un hashmap (dictionar). Stiva se poate implementa
Correct folosind pe post de container un array sau liste inlantuite.
Mark 1 out of 1
Select one:
a. Fals, Fals
b. Adevarat, Fals
c. Fals, Adevarat 
d. Adevarat, Adevarat

The correct answer is: Fals, Adevarat

Correct

b. intoarce elementul din varful stivei (fara a-l sterge din stiva)
d. sterge elementul din varful stivei si il intoarce ca rezultat 
Question 5 Dequeue (double-ended queue) este o coada care suporta:

Correct

a. doar introducerea elementelor pe la un capat si extragerea pe la celalalt capat
b. doar introducerea elementelor prin ambele capete
c. doar extragerea elementelor din ambele capete
d. introducerea si extragerea elementelor din ambele capete 

The correct answer is: introducerea si extragerea elementelor din ambele capete
2 of 2 6/11/20, 10:46 PM
Quiz Laborator 6 - Grafuri Basics: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Grade 5.00 out of 5.00 (100%)
Question 1
Care dintre urmatoarele parcurgeri poate fi folosita pentru a determina numarul de componente conexe ale unui
Correct
graf?
Mark 1.00 out of
1.00
Select one:
a. Niciuna
b. Ambele 
c. DFS
d. BFS

The correct answer is: Ambele
Question 2 În cazul grafurilor dense (|E| este aproximativ egal cu |V| x |V|) se preferă reprezentarea grafurilor prin:
Correct

1.00
a. Matrice de adiacență 
b. Stivă de adiacență
c. Liste de adiacență
The correct answer is: Matrice de adiacență
1 of 2 6/11/20, 10:46 PM
Quiz Laborator 6 - Grafuri Basics: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 3 O posibilă vizitare prin BFS a nodurilor din graful de mai jos este:
Correct
R-----M-----N
Mark 1.00 out of | |
1.00
Q-----O-----P
Select one:
a. O N M R Q P
b. Q O N M P R
c. R M N Q O P 
The correct answer is: R M N Q O P
Question 4 În cazul grafurilor rare (|E| este foarte mic in comparatie cu |V| x |V|) se preferă reprezentarea grafurilor prin:
Correct

1.00
a. Liste de adiacență 
b. Matrice de adiacență
c. Stivă de adiacență

The correct answer is: Liste de adiacență
Question 5
Ce se poate spune despre un graf cu n noduri daca matricea sa de adiacenta este simetrica fata de diagonala
Correct
principala?
Mark 1.00 out of
1.00
Select one:
a. Graful este neorientat 
b. Graful este orientat
c. Graful este complet
d. Graful contine un ciclu de lungime n

The correct answer is: Graful este neorientat

Jump to...
2 of 2 6/11/20, 10:46 PM
Quiz Laborator 7 - Grafuri Advanced: Attempt r... https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Grade 3.00 out of 5.00 (60%)
Question 1 Pe un graf orientat aciclic cu mai multe componente conexe în care ordinea nodurilor nu contează, se pot realiza
Correct sortări topologice cu rezultate diferite.
Mark 1.00 out of
1.00 Select one:
a. Adevărat 
b. Nu se poate realiza o sortare topologică pe un graf orientat aciclic
c. Fals

Se pot obține rezultate diferite în funcție de nodurile de pe care se începe sortarea. Sortarea poate începe de pe
orice nod care nu depinde de alte noduri.
The correct answer is: Adevărat
Question 2
Incorrect
Mark 0.00 out of

1.00
Pentru graful din imagine, se pot afirma urmatoarele:
Select one or more:

a. Graful este bipartit.
b. Drumul minim de la nodul A la nodul I trece prin nodul B.
c. Graful contine doua componente conexe. 
d. Drumul minim de la nodul A la nodul I trece prin nodul C. 

The correct answers are: Graful contine doua componente conexe., Graful este bipartit., Drumul minim de la nodul
A la nodul I trece prin nodul C.
1 of 2 6/11/20, 10:47 PM
Quiz Laborator 7 - Grafuri Advanced: Attempt r... https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 3 Un ciclu hamiltonian este definit astfel:

Correct

1.00
a. O componenta conexa.
b. Un drum care trece prin toate nodurile grafului si ajunge inapoi la sursa. 
c. Un ciclu in graf.
d. Un drum care trece prin toate nodurile grafului, fara a mai ajunge inapoi la sursa.
The correct answer is: Un drum care trece prin toate nodurile grafului si ajunge inapoi la sursa.
Question 4 Make este un utilitar care folosește fișiere makefile în care se specifică cum se obține fiecare target în funcție de
Incorrect dependențe pentru a crea executabile și biblioteci. Make construiește un graf în care targeturile și dependențele
Mark 0.00 out of sunt noduri și există muchii orientate de la dependențe la targeturi.
1.00
Care din următorii algoritmi este folosit de către Make?
Select one:
a. Sortare topologică
b. Parcurgere în lățime 
c. Niciunul de mai sus

Sortarea topologică este folosită în cadrul utilitarului Make pentru a rezolva mai întâi dependențele necesare unui
target.
The correct answer is: Sortare topologică
Question 5 Care din următoarele afirmații sunt adevărate despre parcurgerea DFS a unui graf cu muchii egale:
Correct
Mark 1.00 out of 1. Determină lungimea minimă a drumului dintre două noduri conectate.
1.00 2. Poate ordona nodurile astfel încât să respecte relația de ordine a muchiilor.
Select one:
a. 2 si 3 
b. Toate
c. 1 si 2
d. 1, 2 si 3

The correct answer is: 2 si 3
2 of 2 6/11/20, 10:47 PM
Quiz Laborator 08 - Arbori si arbori binari: Atte... https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Started on Wednesday, 15 April 2020, 6:14 PM

State Finished
Completed on Wednesday, 15 April 2020, 6:19 PM
Marks 4.00/5.00
Grade 8.00 out of 10.00 (80%)

Correct
Mark 1.00 out of

1.00
Select one:
a. A B D C E G F H I 
b. B D A G E C H F I
c. D B G E H I F C A
d. A B C D E F G H I

The correct answer is: A B D C E G F H I
Question 2 Parcurgerile preordine, inordine și postordine se pot numi și:

Correct

1.00
a. BFS
b. DFS 

The correct answer is: DFS
1 of 2 6/11/20, 10:47 PM
Quiz Laborator 08 - Arbori si arbori binari: Atte... https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 3 Nivelul unui nod într-un arbore este distanța de la rădăcină până la acel nod. De exemplu, nodul rădăcină se află
Correct pe nivelul 1 iar nodurile imediat descendente pe nivelul 2.
Mark 1.00 out of Numărul maxim de noduri pe nivelul i al unui arbore binar este:
1.00
Select one:
a. 2i + 1
b. 2i-1 
c. 2i

The correct answer is: 2i-1
Question 4 Parcurgerea inordine pe un arbore binar, începând din nodul de pe nivelul 2 (nivelul 1 este rădăcina),
Incorrect respectiv subarborele drept are că efect:
Mark 0.00 out of
1.00 Select one:
a. afișarea rădăcinii și a elementelor din subarborele drept 
b. afișarea tuturor elementelor, mai puțin rădăcina și subarborele stâng
d. afișarea tuturor elementelor

Question 5 Parcurgerea postordine pe următorul arbore este:

Correct
Mark 1.00 out of

1.00
Select one:
a. 10 7 11 3 8 13 4 8 12 17
b. 10 7 3 4 8 8 11 13 12 17
c. 4 3 8 8 7 12 17 13 11 10 
d. 3 4 7 8 8 10 11 12 13 17


Binari ►
2 of 2 6/11/20, 10:47 PM
Quiz Lab9 - ABC și Heap: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Question 1 Pentru a obține secvența ordonată crescător a cheilor din nodurile arborelui binar de căutare se realizează o
Correct traversare în:
Mark 1 out of 1
Select one:
a. lățime
b. postordine
c. preordine
d. inordine 

The correct answers are: inordine, lățime
Question 2 Care proprietate a unui arbore binar de căutare este adevărată:

Correct

a. Subarborele stâng al unui nod are toate elementele mai mici decât nodul respectiv 
b. Este un arbore echilibrat
c. Se poate reprezenta mai eficient sub formă de vector
The correct answer is: Subarborele stâng al unui nod are toate elementele mai mici decât nodul respectiv
Question 3 Care dintre următorii vectori poate ﬁ folosit pentru a reprezenta un min-heap binar?
Correct

a. 5, 22, 25, 14, 17, 40, 36
b. 5, 14, 17, 25, 22, 40, 36 
c. 5, 22, 14, 17, 25, 40, 36
d. 40, 36, 25, 14, 22, 17, 5

The correct answer is: 5, 14, 17, 25, 22, 40, 36
1 of 2 6/11/20, 10:48 PM
Quiz Lab9 - ABC și Heap: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 4 Următoarea parcurgere va rezulta în afișarea elementelor unui arbore binar de căutare în ordine
Correct crescătoare:
Mark 1 out of 1
Select one:
a. preordine
b. parcurgere în adâncime
c. parcurgere în lățime
d. inordine 
e. postordine

The correct answer is: inordine
Question 5 Se dă următorul arbore binar de căutare:

Correct
Mark 1 out of 1
Parcurgerea sa postordine este:
Select one:
a. 6, 9, 7, 5, 12, 16, 24, 27, 20, 11 
b. 11, 5, 7, 6, 9, 20, 16, 12, 27, 24
c. 5, 6, 7, 9, 11, 12, 16, 20, 24, 27

The correct answer is: 6, 9, 7, 5, 12, 16, 24, 27, 20, 11
2 of 2 6/11/20, 10:48 PM
Quiz Lab10 - Treap: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Structura echilibrată a unui treap este dată de:

Correct

1.00
a. invariantul de heap și invariantul de arbore de căutare
b. invariantul de heap 
c. invariantul de arbore de căutare
d. treap-ul nu are o structură echilibrată

The correct answer is: invariantul de heap
Question 2 Pentru a asigura echilibrarea treap-ului, prioritățile trebuie să fie:

Correct

1.00
a. generate random 
b. prioritatea nu asigură echilibrarea treap-ului
c. identice cu cheile nodurilor
d. generate crescător

The correct answer is: generate random
Question 3 Într-un treap, prioritatea unui nod este mai mare ca prioritatea fiului său stâng (dacă există) și mai mică ca
Correct prioritatea fiului drept (dacă există)
Mark 1.00 out of
1.00 Select one:
True
False 
1 of 2 6/11/20, 10:48 PM
Quiz Lab10 - Treap: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Question 4 Atunci când inserăm într-un treap nevid un nod cu o prioritate mai mare decât toate prioritățile din treap nu va
Incorrect avea loc nicio rotație.
Mark 0.00 out of
1.00 Select one:
True 
False
Question 5 Într-un treap, elementul cu cheia minimă se va afla:

Correct

1.00
a. în rădăcina treap-ului
b. cea mai din stânga frunză 
c. cea mai din dreapta frunză
d. se poate afla oriunde în treap

The correct answer is: cea mai din stânga frunză
2 of 2 6/11/20, 10:48 PM
Quiz Laborator 11 - AVL & Red-Black Trees: At... https://acs.curs.pub.ro/2019/mod/quiz/review.p...

State Finished
Grade 5.00 out of 5.00 (100%)
Question 1 De ce impunem restrictiile cunoscute pentru un arbore Red-Black?

Correct

1.00
a. pentru a obtine timp liniar
b. pentru a patenta o noua structura de date pe baza de arbori
c. pentru a obtine timp exponential
d. pentru a obtine timp logaritmic 

The correct answer is: pentru a obtine timp logaritmic
Question 2 De ce am folosi un arbore Red-Black in locul unui Hashmap, avand in vedere ca Hashmap-ul are timp constant
Correct pentru majoritatea operatiilor?
Mark 1.00 out of
a. nu am folosi niciodata un Red-Black Tree in locul unui Hashmap
b. pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem avantajul ordinii in
Red-Black Tree 
d. pentru ca arborele nu are nevoie de o zona continua de memorie

The correct answer is: pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem
avantajul ordinii in Red-Black Tree
Correct

1.00
a. Fals 
b. Adevarat

1 of 2 6/11/20, 10:49 PM
Quiz Laborator 11 - AVL & Red-Black Trees: At... https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Correct

1.00
a. Rosie
b. Un nod rosu trebuie sa fie frunza
c. Neagra 
d. Un fiu rosu, altul negru
Question 5 Cate tipuri de rotatii se folosesc pentru a balansa un AVL?

Correct

1.00
a. 5
b. 2
c. 3
d. 4 

◄ Laborator 11 - AVL & Red-Black Upload Laborator 11 - AVL & Red-

Jump to...
Trees Black Trees ►
2 of 2 6/11/20, 10:49 PM
Simulare examen - grila: Attempt review https://acs.curs.pub.ro/2019/mod/quiz/review.p...
Dashboard / My courses / L-A1-S2-SD-CA / General / Simulare examen - grila
Started on Sunday, 7 June 2020, 12:32 AM

State Finished
Completed on Sunday, 7 June 2020, 12:45 AM
Marks 22.00/35.00
Grade 20.74 out of 33.00 (63%)
Question 1 Intr-o lista simplu inlantuita, pentru a determina care este elementul maxim:
Correct

3.00
a. Poate fi necesar sa parcurgem intreaga lista 
b. Este suficient sa luam elementul din mijlocul listei
c. Trebuie sa o transformam in lista dublu inlantuita pentru a determina maximul
d. Trebuie sa parcurgem lista de la sfarsit la inceput

The correct answer is: Poate fi necesar sa parcurgem intreaga lista
Question 2 Pentru arborele din figura, succesorul nodului 20 in parcurgerea in inordine este:
Incorrect
Mark 0.00 out of

3.00
Select one:
a. 50
b. 55
c. 10
d. 15 

1 of 6 6/11/20, 10:43 PM
Question 3 Pentru a rezolva subiectele de la acest examen e ok sa apelez la orice materiale (carti, curs, lab, pagini de pe
Correct internet etc.), dar nu si la colegi. Voi incerca sa rezolv singur(a) subiectele pentru ca (hint: trebuie bifate toate
Mark 3.00 out of raspunsurile pentru a primi acest punct):
3.00
Select one or more:

a. subiectele sunt personalizate pentru fiecare student, daca apelez la un coleg sa imi rezolve subiectele ii
iau din timpul sau de examen 
b. peste cinci ani o sa conteze ce aptitudini si competente mi-am format si nu ce nota am avut la SD sau cat
de bine stiu sa dau search intr-un doc cu raspunsurile colegilor 
c. prin semnarea contractului de studii am aderat la un cod de conduita academica prin care ma oblig sa nu
fraudez 
d. in activitatea mea profesionala, colegii nu vor putea sa imi rezolve mie toate problemele, trebuie sa imi
aduc si eu contributia cu ceva ca sa imi merit locul intr-o echipa 

The correct answers are: peste cinci ani o sa conteze ce aptitudini si competente mi-am format si nu ce nota am
avut la SD sau cat de bine stiu sa dau search intr-un doc cu raspunsurile colegilor, prin semnarea contractului de
studii am aderat la un cod de conduita academica prin care ma oblig sa nu fraudez, in activitatea mea
profesionala, colegii nu vor putea sa imi rezolve mie toate problemele, trebuie sa imi aduc si eu contributia cu
ceva ca sa imi merit locul intr-o echipa, subiectele sunt personalizate pentru fiecare student, daca apelez la un
coleg sa imi rezolve subiectele ii iau din timpul sau de examen
Question 4 Care afirmatii sunt adevarate pt o functie de hash:

Correct

3.00
a. O functie de hash nu poate intoarce acelasi cod pentru doua mesaje diferite
b. O functie de hash poate intoarce acelasi cod pentru doua inputuri diferite 
c. O functie de hash primeste un mesaj de dimensiune arbitrara si genereaza un cod de lungime fixa 
d. O functie de hash primeste un mesaj de dimensiune fixa si genereaza un cod de lungime variabila
The correct answers are: O functie de hash poate intoarce acelasi cod pentru doua inputuri diferite, O functie de
hash primeste un mesaj de dimensiune arbitrara si genereaza un cod de lungime fixa
2 of 6 6/11/20, 10:43 PM
Question 5 Cate componente tare-conexe sunt in graful din figura?

Correct
Mark 3.00 out of

3.00
Select one:
a. 4
b. 1
c. 2
d. 3 

Question 6 Fie o matrice declarata astfel:

Incorrect
Mark 0.00 out of int **array2 = malloc(nrows * sizeof(int *));

3.00 array2[0] = malloc(nrows * ncolumns * sizeof(int));
Se stie ca nrows = 20, ncolumns = 10, sizeof(int) = 4 si sizeof(int*)=4.

Daca adresa primului element array2[0][0] este 100, atunci adresa lui array2[11][5] este:
Answer: 1105 
3 of 6 6/11/20, 10:43 PM
Question 7 Printre aplicatiile stivei se numara:

Correct

3.00
a. Verificarea expresiilor pentru corectitudinea inchiderii parantezelor 
b. Parcuregerea DFS 
c. Parcurgerea BFS
d. Radix Sort
The correct answers are: Parcuregerea DFS, Verificarea expresiilor pentru corectitudinea inchiderii parantezelor
Question 8 In cazul cel mai defavorabil, numarul de comparatii necesar pentru a cauta un element intr-un arbore binar cu n
Incorrect elemente este:
Mark 0.00 out of
3.00 Select one:
a. log n 
b. log n – 1
c. n
d. n/2
The correct answer is: n
Question 9 Fie arborele AVL din figura. Se doreste inserarea nodului 9. Cine va fi parintele sau dupa inserare?
Incorrect
Mark 0.00 out of

3.00
Select one:
a. 20
b. 10
c. 8 
d. Nimeni, 9 devine radacina
4 of 6 6/11/20, 10:43 PM
Question 10 Cat fac 2 + 3

Correct
Mark 2.00 out of

2.00
Answer: 5 
The correct answer is: 5.0
Question 11 Care dintre urmatoarele sunt parcurgeri DFS valide pentru graful din figura
Partially correct
Mark 2.00 out of

3.00
Select one or more:

a. 1 0 2 3 5 6 4 7
b. 0 4 7 5 1 3 2 6 
c. 0 4 7 5 1 6 2 3
d. 3 1 2 0 4 7 5 6 

You have correctly selected 2.
The correct answers are: 0 4 7 5 1 3 2 6, 0 4 7 5 1 6 2 3, 3 1 2 0 4 7 5 6
Question 12 Which of the following is true about Red Black Trees?

Correct

3.00
a. A leaf node may be red
b. At least one children of every black node is red
c. The path from the root to the furthest leaf is no more than twice as long as the path from the root to the
nearest leaf 
d. Root may be red

The correct answer is: The path from the root to the furthest leaf is no more than twice as long as the path from
the root to the nearest leaf
5 of 6 6/11/20, 10:43 PM
◄ subiecte examen 2019 Jump to... Simulare examen - raspuns liber ►
6 of 6 6/11/20, 10:43 PM
11.06.2020 Quiz Lab2 - Liste înlănțuite: Attempt review
Started on Thursday, 5 March 2020, 12:33 PM

State Finished
Completed on Thursday, 5 March 2020, 12:38 PM
Question 1 Care va fi conținutul listei înlănțuite l după efectuarea următoarelor operații (metoda add_first(l, x) adaugă
Correct elementul x la începutul listei, add_last(l, x) adaugă elementul x la finalul listei, iar remove_first(l) elimină primul
Mark 1 out of 1 element din listă)?
for (int i = 0; i < 3; i++)

add_first(l, 3 - i);
add_last(l, 5);
remove_first(l);
Select one:
a. 1 2 3
b. 0 2 3
c. 1 2 5
d. 2 3 5 

Question 2 Dacă într-o listă simplu înlănțuită se identifică un element X pentru care pointerul său next duce la un element
Not answered anterior Y diferit de X, atunci:
Marked out of 1
Select one:
a. lista are un singur element
b. lista are exact 2 elemente
c. există un ciclu în listă
d. X și Y sunt la aceeași adresă de memorie

Question 3 Care dintre următoarele operații se realizează mult mai rapid cu elementele unei liste (la care avem acces la
Not answered pointerii head și tail) decât cu elementele unui vector?
Marked out of 1
1. modificarea primului element
2. adăugarea unui element la început sau la sfârșit
3. găsirea unui element, considerând că atât în listă, cât și în vector, elementele sunt sortate
Select one:
a. 1 și 3
b. 2
c. 1, 2 și 3
d. 1 și 2

Question 4 De ce tip pot fi elementele unei liste?

Correct

a. orice tip definit de programator care conține în interiorul său un tip de bază
b. cel mult 4 tipuri diferite
c. orice tip, dar să fie toate de același tip 
d. tipuri de bază cum ar fi int, float, char, etc.

The correct answer is: orice tip, dar să fie toate de același tip
Question 5 Cum sunt stocate în memorie elementele unei liste înlănțuite?

Correct

a. Într-o zonă contiguă de memorie
b. Arbitrar 

The correct answer is: Arbitrar
11.06.2020 Quiz Lab3 - Liste înlănțuite (continuare): Attempt review

State Finished
Correct general, adăugarea unui nou element pe a doua poziţie se face mai rapid într-o listă dublu-înlănţuită faţă de un
Select one:
a. Adevărat. Adevărat
b. Adevărat. Fals
c. Fals. Adevărat 
d. Fals. Fals
Question 2
Pentru a transforma o listă dublu-înlănţuită oarecare într-o listă dublu-înlănţuită circulară (head este un pointer
Correct
la primul nod din listă, iar tail este un pointer la ultimul nod din listă):
Mark 1 out of 1
Select one:
a. Trebuie să parcurgem întreaga listă şi să actualizăm legăturile dintre toate nodurile.
b. Nu se poate transforma lista, trebuie neapărat să construim o nouă listă care să fie circulară de la început.
c. Actualizăm head->prev să pointeze la tail şi tail->next să pointeze la head. 
d. Actualizăm head->next să pointeze la tail şi tail->prev să pointeze la head.
The correct answer is: Actualizăm head->prev să pointeze la tail şi tail->next să pointeze la head.
Question 3
Având două liste, una liniară dublu înlănțuită și alta circulară dublu înlănțuită, cu aceleași proprietăți (ambele au
Correct
sau nu au pointer tail, ambele au aceleași tipuri de elemente stocate și același număr de elemente, etc.), atunci:
Mark 1 out of 1
Select one:
a. Cantitățile de memorie ale celor două liste nu se pot compara.
b. Ele ocupă aceeași cantitate de memorie. 
c. Lista liniară ocupă mai multă memorie decât cea circulară.
d. Lista liniară ocupă mai puțină memorie decât cea circulară.

The correct answer is: Ele ocupă aceeași cantitate de memorie.
Question 4 Considerând că un pointer are dimensiunea de 4 octeți, iar informația stocată într-un nod ocupă 8 octeți, atunci o
Incorrect listă simplu înlănțuită cu 3 elemente ocupă ___________ o listă dublu înlănțuită cu 2 elemente, unde prima listă are
Mark 0 out of 1 doar pointer head, iar a doua are head și tail.
Select one:
a. aceeași memorie ca
b. mai puțină memorie decât
c. o memorie ce nu poate fi comparată cu memoria ocupată de
d. mai multă memorie decât 
The correct answer is: aceeași memorie ca
Question 5 Având o listă circulară simplu înlănțuită cu mai mult de 3 noduri, al câtelea nod este aferent instrucțiunii: tail -> next ->
Correct next -> next (primul nod are asociat indexul 0)?
Mark 1 out of 1
Select one:
a. Nodului cu index 2. 
b. Tot tail.
c. head -> next
d. Niciun nod, se ajunge la NULL.
The correct answer is: Nodului cu index 2.
11.06.2020 Quiz Lab5 - Stivă și Coadă: Attempt review

State Finished
Time taken 5 mins
Question 1 Ce operatii sunt suportate de o coada normala?

Correct

a. Returnarea celui mai vechi element din coada 
b. Stergerea celui mai recent element din coada
c. Stergerea celui mai vechi element din coada 
d. Inlocuirea unui element din coada
e. Adaugarea unui element in coada 
The correct answers are: Adaugarea unui element in coada, Stergerea celui mai vechi element din coada, Returnarea celui
mai vechi element din coada
Question 2 Ce element poate fi accesat intr-o stiva in O(1) (adica timp constant, aproape instantaneu)?
Correct

a. ultimul element adaugat in stiva 
b. primul element adaugat in stiva
c. nici un element
d. orice element
The correct answer is: ultimul element adaugat in stiva
Question 3 Presupunem ca avem o stiva goala. Efectuam urmatoarele operatii:

Correct
push(stack, 1);
Mark 1 out of 1
push(stack, 2);
pop(stack);
peek(stack);
push(stack, 3);
push(stack, 2);
Care este continutul stivei (primul element este varful stivei)?
Select one:
a. 2 3 2
b. 1 3 2
c. 2 3 1 
d. 1 2
Question 4 Initial avem o coada goala. Presupunem ca efectuam urmatoarele operatii:

Correct
enqueue(queue, 'a');
Mark 1 out of 1
enqueue(queue, 'b');
dequeue(queue);
enqueue(queue, 'c');
enqueue(queue, 'd');
dequeue(queue);
front(queue);
enqueue(queue, 'x');
Ce elemente raman in coada dupa executia operatiilor?
Select one:
a. d x
b. b d x
c. c d x 
d. a c x
The correct answer is: c d x
Question 5 Ce operatii sunt suportate de o coada cu doua capete (dequeue - double ended queue)?
Correct

a. Adaugarea unui element in coada 
b. Stergerea celui mai vechi element din coada 
c. Returnarea celui mai vechi element din coada 
d. Stergerea celui mai recent element din coada 
e. Inlocuirea unui element din coada
The correct answers are: Adaugarea unui element in coada, Stergerea celui mai recent element din coada, Stergerea celui
mai vechi element din coada, Returnarea celui mai vechi element din coada
Jump to...
◄ lab05 - stiva si coada Upload Lab5 - Stiva si Coada ►
11.06.2020 Quiz Lab9 - ABC și Heap: Attempt review
Started on Thursday, 30 April 2020, 12:46 PM

State Finished
Completed on Thursday, 30 April 2020, 12:51 PM
Question 1 În urma traversării unui arbore binar de căutare T în postordine se obține următoarea secvență de chei:
Correct
8, 7, 21, 20, 25, 23, 13, 48, 93, 58, 38, 27
Mark 1 out of 1
Care din următoarele secvențe de chei va rezulta în urma unei traversări în inordine a arborelui T?
Select one:
a. 7, 8, 13, 20, 38, 48, 58, 93, 21, 23, 25, 27
b. 93, 48, 58, 38, 25, 21, 20, 23, 8, 7, 13, 27
c. 7, 8, 13, 20, 21, 23, 25, 27, 38, 48, 58, 93 
d. 27, 13, 7, 8, 23, 20, 21, 25, 38, 58, 48, 93
Nu este necesar să reconstruiți structura arborelui în funcție de secvența obținută după parcurgerea în postordine. Trebuie
să știți că prin traversarea în inordine se obține secvența crescătoare de chei a arborelui binar de căutare.
The correct answer is: 7, 8, 13, 20, 21, 23, 25, 27, 38, 48, 58, 93
Question 2 Care este complexitatea medie a operațiilor de căutare, inserare și ștergere într-un arbore binar de căutare?
Correct

a. O(log n) pentru toate operațiile 
b. O(log n) pentru căutare și inserare, O(n) pentru ștergere
c. O(n) pentru toate operațiile
d. O(log n) pentru căutare, O(n) pentru inserare și ștergere

The correct answer is: O(log n) pentru toate operațiile
Question 3 O aplicație a unui heap este:

Correct

a. Coada de priorități 
b.
Implementarea unui deque
c. Implementarea BFS
The correct answer is: Coada de priorități

Correct

a. Este un arbore echilibrat
b. Se poate reprezenta mai eficient sub formă de vector
c. Subarborele stâng al unui nod are toate elementele mai mici decât nodul respectiv 
Question 5 Operațiile pe un arbore binar de căutare se fac, în medie, în:

Correct

a. Toate în O(log n) 
b. Căutare - O(n), inserare și stergere - O(log n)
c. Toate în O(n)
d. Căutare și inserare - O(log n), ștergere - O(n)
The correct answer is: Toate în O(log n)
11.06.2020 Quiz Lab10 - Treap: Attempt review
Started on Thursday, 7 May 2020, 12:51 PM

State Finished
Completed on Thursday, 7 May 2020, 12:54 PM
Grade 4.00 out of 5.00 (80%)
Question 1 Structura echilibrată a unui treap este dată de:

Correct

1.00
a. invariantul de arbore de căutare
b. invariantul de heap și invariantul de arbore de căutare
c. treap-ul nu are o structură echilibrată
d. invariantul de heap 
The correct answer is: invariantul de heap
Question 2 Două rotații stânga ale unui nod al treap-ului sunt echivalente cu o rotație dreapta
Correct a aceluiași nod:
Mark 1.00 out of
1.00 Select one:
True
False 
Question 3 Atunci când dorim să ștergem un nod dintr-un treap, trebuie să:
Correct

1.00
a. îl aducem în rădăcina treap-ului
b. îl aducem la baza treap-ului (ca frunză) 
c. nu trebuie mutat - fiii nodului șters se leagă la părintele acestuia
d. un nod nu se poate șterge întotdeauna dintr-un treap

The correct answer is: îl aducem la baza treap-ului (ca frunză)
Question 4 Atunci când inserăm un nod într-un treap, nu ne folosim de prioritatea acestuia (aceasta este folosită doar la ștergere):
Correct

1.00
True
False 

Incorrect

1.00
a. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(logN)
b. pentru a putea parcurge treap-ul pe nivele și a obține cheile sortate crescător
c. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(înălțime treap)
d. pentru a fi echilibrat 

11.06.2020 Quiz Laborator 4 - Dictionar: Attempt review

State Finished
Time taken 5 mins
Grade 4.00 out of 5.00 (80%)
Question 1
Care este diferența între linear probing și direct chaining?
Correct
Mark 1.00 out of

1.00
Select one:
a.
dicționarele care folosesc linear probing au un număr mai mare de bucket-uri
b.
la direct chaining se caută primul loc liber din dicționar
c.
la linear probing se caută primul loc liber din dicționar

d.
implementarea prin libear probing se face folosind liste înlănțuite

Question 2
Considerând următoarele elemente:
Correct
23456, 34561, 78534, 45623, 12343, 89761
Mark 1.00 out of
1.00
și funcția de hash
x % 3
care dintre următoarele afimații sunt valide?
i) 23456 și 45623 produc același hash
ii) 34561, 12343 și 89761 produc același hash
iii) toate valorile produc același hash
Select one:
a. i)
b. i) si ii) 
c. iii)
d. ii)

The correct answer is: i) si ii)
Question 3
Correct
Mark 1.00 out of

1.00
Select one:
a. pentru a îmbunătăți performanța hashtable-ului
b.
c.

Question 4 Care este timpul mediu de regăsire a unei perechi cheie-valoare dintr-un dicționar?
Correct

1.00
a.
timp logaritmic (O(log n))
b.
timp pătratic (O(n*n))
c.
timp constant (O(1)) 
d.
timp liniar (O(n))

Question 5
Ce bucket va returna următoarea funcție de hash pentru cheia "abcd" (fară ghilimele):
Incorrect
int hash(char* key) {
Mark 0.00 out of
1.00 int index = 0;
for (int i = 0; i < 3; ++i) {
index += key[i] - 'a';

}
return index % 5;
}
Select one:
a. 3
b. 4 
c. 1
d. 2

11.06.2020 Quiz Laborator 6 - Grafuri Basics: Attempt review

State Finished
Grade 3.00 out of 5.00 (60%)
Question 1
Gradul intern al unui nod i intr-un graf orientat reprezinta numarul de noduri catre care nodul i are muchie directa.
Incorrect
Complexitatile parcurgerilor BFS si DFS sunt egale.
Mark 0.00 out of
1.00
Select one:
a. Adevarat, Adevarat 
b. Fals, Adevarat
c. Fals, Fals
d. Adevarat, Fals

The correct answer is: Fals, Adevarat
Question 2
Care dintre urmatoarele afirmatii este adevarata?
Correct
Mark 1.00 out of

Select one:
1.00
a. Daca in cadrul parcurgerii DFS a unui graf neorientat conex cu n noduri se intalneste un nod care a mai fost vizitat
in aceeasi parcurgere, graful are n - 1 muchii
b. Structura de date folosita pentru parcurgerea BFS este stiva, iar pentru DFS este coada
c. Suma gradelor interne ale tuturor nodurilor este egala cu suma gradelor externe ale tuturor nodurilor, intr-un graf
orientat 
d. Parcurgerea DFS a unui graf este mai rapida decat parcurgerea BFS a aceluiasi graf, pornind din acelasi nod

The correct answer is: Suma gradelor interne ale tuturor nodurilor este egala cu suma gradelor externe ale tuturor
nodurilor, intr-un graf orientat
Question 3
In grafurile orientate conteaza sensul muchiilor. Reprezentarea prin matrice de adiacenta este potrivita pentru grafuri rare.
Correct
Mark 1.00 out of

Select one:
1.00
a. Adevarat, Adevarat
b. Adevarat, Fals 
c. Fals, Fals
d. Fals, Adevarat

The correct answer is: Adevarat, Fals
Question 4 Complexitatea parcurgerii prin BFS este:

Correct

1.00
a. identică cu cea în cazul DFS 
b. mai mare ca în cazul DFS
c. mai mică ca în cazul DFS
Ambele parcurgeri au complexitatea O(|E|+|V|), unde |E| este numărul de muchii, iar |V| este numărul de noduri.
The correct answer is: identică cu cea în cazul DFS
Question 5
Care dintre urmatoarele parcurgeri poate fi folosita pentru a determina numarul de componente conexe ale unui graf?
Incorrect
Mark 0.00 out of

1.00
Select one:
a. Niciuna
b. BFS 
c. Ambele
d. DFS

The correct answer is: Ambele

Jump to...
11.06.2020 Quiz Laborator 7 - Grafuri Advanced: Attempt review

State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Un graf este bipartit daca oricare doua noduri consecutive se afla pe acelasi nivel (au aceeasi culoare).
Correct

1.00
True
False 
Correct

1.00
a. Nici o parcurgere nu determină componentele conexe ale unui graf
b. BFS sau DFS 
c. DFS
d. BFS

Question 3
Incorrect
Mark 0.00 out of

1.00
Select one or more:

a. Drumul minim de la nodul A la nodul I trece prin nodul B.
b. Graful este bipartit.
c. Drumul minim de la nodul A la nodul I trece prin nodul C. 
d. Graful contine doua componente conexe. 
The correct answers are: Graful contine doua componente conexe., Graful este bipartit., Drumul minim de la nodul A la
nodul I trece prin nodul C.
Question 4 Pe un graf orientat aciclic cu mai multe componente conexe în care ordinea nodurilor nu contează, se pot realiza sortări
Correct topologice cu rezultate diferite.
Mark 1.00 out of
1.00 Select one:
a. Adevărat 
b. Fals
c. Nu se poate realiza o sortare topologică pe un graf orientat aciclic
Se pot obține rezultate diferite în funcție de nodurile de pe care se începe sortarea. Sortarea poate începe de pe orice
nod care nu depinde de alte noduri.
Correct
1.00 3. Determină componentele conexe ale grafului.
Select one:
a. 1 și 2
b. 1 și 3 
c. Toate
d. 1, 2 și 3
11.06.2020 Quiz Laborator 08 - Arbori si arbori binari: Attempt review

State Finished
Time taken 5 mins
Marks 3.00/5.00
Grade 6.00 out of 10.00 (60%)

Incorrect
Mark 0.00 out of

1.00
Ce fel de parcurgere este cea în care au rezultat nodurile A B C D E F G H I:
Select one:
a. inordine
b. nu există o astfel de parcurgere
c. lățime
d. postordine
e. preordine 
În cadrul parcurgerii în lățime se folosește o coadă în care se află inițial doar nodul rădăcină, iar la fiecare pas se
extrage din această coadă câte un nod și se adăugă înapoi în coadă nodul stâng, respectiv drept al nodului scos. Acest
algoritm continuă până când coada devine goală.
The correct answer is: lățime
Question 2 Definim înălțimea unui arbore binar că fiind lungimea maximă a unui drum de la rădăcină spre oricare frunza, la
Incorrect care se adaugă 1. Numărul maxim de noduri într-un arbore binar cu înălțimea h este:
Mark 0.00 out of
1.00 Select one:
a. 2^(2^h)
b. 2^h
c. 2^h - 1
d. 2^h + 1 

The correct answer is: 2^h - 1

Correct
Mark 1.00 out of

1.00
Parcurgerea în inordine a arborelui din figură este:
Select one:
a. A B D C E G F H I
b. B D A G E C H F I 
c. D B G E H I F C A
d. A B C D E F G H I
The correct answer is: B D A G E C H F I
Question 4 Parcurgerea preordine pe următorul arbore este:

Correct
Mark 1.00 out of

1.00
Select one:
a. 4 3 8 8 7 12 17 13 11 10
b. 3 4 7 8 8 10 11 12 13 17
c. 10 7 11 3 8 13 4 8 12 17
d. 10 7 3 4 8 8 11 13 12 17 
Question 5 Care este cel mai mic strămoș comun al nodurilor 4 și 8 al arborelui următor?
Correct
Mark 1.00 out of

1.00
Select one:
a. 7 
b. 3
c. 8
d. 10


Binari ►
11.06.2020 Quiz Laborator 11 - AVL & Red-Black Trees: Attempt review

State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Care este diferenta maxima (in modul) a inaltimilor dintre subarborele stang si subarborele drept al unui nod dintr-un
Incorrect AVL?
Mark 0.00 out of
a. 2
b. 0
c. 1
d. log(n) 
Correct

1.00
a. Fals 
b. Adevarat
Question 3 In ce situatie preferam un arbore Red-Black in locul unui AVL?

Correct

1.00
a. cand avem nevoie de mai multe cautari
b. cand avem un monitor ce ne permite sa vedem culorile nodurilor din arborele Red-Black
c. cand avem nevoie de mai multe inserari/stergeri 
d. cand arborele trebuie sa fie echilibrat

The correct answer is: cand avem nevoie de mai multe inserari/stergeri
Mark 1.00 out of
a. pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem avantajul ordinii in Red-
Black Tree 
b. pentru ca sa implementezi arbori este mai placut
c. pentru ca arborele nu are nevoie de o zona continua de memorie
d. nu am folosi niciodata un Red-Black Tree in locul unui Hashmap

Correct

1.00
a. 3
b. 5
c. 2
d. 4 

Trees ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 24 februarie - 1 martie / Quiz Lab2 - Liste înlănțuite
Început la marţi, 3 martie 2020, 14:27

State Terminat
Completat la marţi, 3 martie 2020, 14:32
Timp luat 4 min 58 secs
Notează 2 din maxim 5 (40%) posibil
1 întrebare
Fiind dată o listă simplu înlănţuită oarecare şi un pointer targetNode spre un nod din această listă, pentru a obţine
Corect
un pointer previousNode care pointează la nodul anterior celui la care pointează targetNode:
Marcat 1 din 1
Alegeți o opțiune:
a. previousNode = targetNode - 1.
b. Parcurgem lista de la head până la targetNode reţinând mereu şi nodul vizitat înaintea nodului curent în
parcurgere. 
c. previousNode = targetNode - sizeof(Node).
d. Este imposibil şi reprezintă un dezavantaj al listelor simplu înlănţuite.
Răspunsul corect este: Parcurgem lista de la head până la targetNode reţinând mereu şi nodul vizitat înaintea nodului
curent în parcurgere.
2 întrebare
Care va fi conținutul listei simplu înlănțuite l, care iniţial este vidă, după efectuarea următoarelor operații (metoda
Incorect
add_first(l, x) adaugă elementul x la începutul listei, iar add_last(l, x) adaugă elementul x la sfârșitul listei)?
Marcat 0 din 1
for (int i = 0; i < 4; i++)
if (i % 2)
add_last(l, i);
else
add_first(l, i);
add_last(l, 4);
add_first(l, 5);
a. 5 2 0 1 3 4
b. 4 2 0 1 3 5
c. 5 1 0 3 2 4
d. 5 1 3 0 2 4 
Răspunsul corect este: 5 2 0 1 3 4
3 întrebare Care va fi conținutul listei înlănțuite l după efectuarea următoarelor operații (metoda add_first(l, x) adaugă
Incorect elementul x la începutul listei, add_last(l, x) adaugă elementul x la finalul listei, iar remove_first(l) elimină primul
Marcat 0 din 1 element din listă)?
for (int i = 0; i < 3; i++)

add_first(l, 3 - i);
add_last(l, 5);
remove_first(l);
a. 1 2 3
b. 2 3 5
c. 1 2 5 
d. 0 2 3

Răspunsul corect este: 2 3 5
4 întrebare Care structură de date este mai eficientă din punctul de vedere al utilizării memoriei (ocupă mai puțină memorie)?
Incorect
Marcat 0 din 1 Alegeți o opțiune:

a. LinkedList 
b. Un array din C

Răspunsul corect este: Un array din C
5 întrebare Cum sunt stocate în memorie elementele unei liste înlănțuite?

Corect

a. Arbitrar 
b. Într-o zonă contiguă de memorie

Răspunsul corect este: Arbitrar
◄ lab02 - Liste înlănțuite Salt la... curs03 - LinkedList part2 ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 2 martie - 8 martie / Quiz Lab3 - Liste înlănțuite (continuare)

State Terminat
1 întrebare Ştiind că atât pentru o listă dublu-înlănţuită, cât şi pentru una dublu-înlănţuită circulară nu reţinem un pointer tail
Corect la ultimul element din listă, ci doar un pointer head la primul element din listă, atunci care dintre cele două tipuri
Marcat 1 din 1 de liste (şi de ce) permite adăugarea mai rapidă a unui nou element la finalul listei într-un caz general când deja
sunt mai multe noduri?
a. Lista dublu-înlănţuită deoarece foloseşte mai puţină memorie şi astfel apelul de alocare a memoriei se întoarce mai
repede.
b. Ambele liste sunt la fel de rapide.
c. Lista dublu-înlănţuită deoarece nu mai trebuie actualizaţi şi pointerul prev al primului nod şi pointerul next al
ultimului nod ca în cazul listelor circulare.
d. Lista dublu-înlănţuită circulară deoarece nu trebuie să parcurgem toate nodurile din listă pentru a ajunge la ultimul.

Răspunsul corect este: Lista dublu-înlănţuită circulară deoarece nu trebuie să parcurgem toate nodurile din listă pentru a
ajunge la ultimul.
2 întrebare Având o listă circulară simplu înlănțuită cu mai mult de 3 noduri, al câtelea nod este aferent instrucțiunii: tail -> next ->
Incorect next -> next (primul nod are asociat indexul 0)?
Marcat 0 din 1
a. Niciun nod, se ajunge la NULL. 
b. head -> next
c. Nodului cu index 2.
d. Tot tail.

Răspunsul corect este: Nodului cu index 2.
3 întrebare Dezavantajul listelor dublu înlănțuite față de cele simplu înlănțuite este:
Corect

a. necesită o zonă contiguă de memorie
b. au nevoie obligatoriu de pointer la ultimul element
c. ocupă mai multă memorie 
d. accesul la un element aleator este mai încet
Răspunsul corect este: ocupă mai multă memorie
4 întrebare
Dacă pentru o listă dublu înlănțuită head -> next == head este true, ce puteți spune despre această listă (head
Corect
este pointer la primul element al listei, tail este pointer la ultimul element al listei, iar next este pointer către
Marcat 1 din 1
succesorul elementului curent în listă)?
a. head -> next este diferit de tail
b. lista este goală
c. cel de-al doilea element al listei este head -> next -> next
d. lista este una circulară 

Răspunsul corect este: lista este una circulară
5 întrebare
Se dă următoarea funcţie de mai jos care primeşte la intrare o listă circulară. Care este valoarea întoarsă de această
Corect
funcţie pentru lista circulară ce conţine valorile 1 7 2 10 în această ordine?
Marcat 1 din 1
int computeList(CircularDoublyLinkedList *l) {
Node *now;
int nodes_num = 0, nodes_sum = 0;
if (l == NULL || l->head == NULL)

return 0;
now = l->head;
while (now != NULL) {
nodes_sum += *((int *)now->data);
nodes_num++;
now = now->next;
}
return nodes_sum / nodes_num;

}
a. 5
b. 4
c. 10
d. Funcţia ciclează la infinit 

Răspunsul corect este: Funcţia ciclează la infinit
◄ lab03 - Liste înlănțuite (continuare) Salt la... curspr02 ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 9 martie - 15 martie / Quiz Laborator 4 - Dictionar

State Terminat
Timp luat 5 min
Notează 5,00 din maxim 5,00 (100%) posibil
1 întrebare
Corect
Marcat 1,00 din

1,00
a.
b.
c. pentru a îmbunătăți performanța hashtable-ului
Răspunsul corect este:

2 întrebare
Considerând următoarele elemente inserate într-un hashtable cu dimensiunea 10:
Corect
23456, 12345, 66784, 234214, 9875, 23451, 23454
Marcat 1,00 din
1,00
și folosind funcția de hash
x % 10
care este numărul maxim de elemente ce se află în același bucket?
a. 3 
b. 2
c. 4
66784, 234214 și 23454 vor fi plasate în același bucket.

Răspunsul corect este: 3
3 întrebare Care din următoarele operații nu sunt suportate de un dicționar:

Corect
Marcat 1,00 din Alegeți o opțiune:

1,00
a. put(key) 
b. remove(key)
c. has_key(key)
d. get(key)

Răspunsul corect este: put(key)
4 întrebare Când facem put(cheie, valoare) într-un hashtable:

Corect

1,00
a. putem să adăugam direct noul element, pentru că trebuie stocate toate combinațiile de (cheie,valoare)
b. verificăm întâi dacă există un element cu aceeași cheie, pentru că în acest caz trebuie să îi inlocuim valoarea 
c. verificăm întâi dacă există un element cu aceeași cheie, pentru că noul element trebuie adăugat în același bucket

Răspunsul corect este: verificăm întâi dacă există un element cu aceeași cheie, pentru că în acest caz trebuie să îi inlocuim
valoarea
5 întrebare
Care dintre următoarele NU reprezintă o modalitate de gestiune a coliziunilor:
Corect
Marcat 1,00 din

1,00
a.
înlănțuire directă
b. adresare indexată și bazată 
c.
linear probing
d. direct chaining

Răspunsul corect este: adresare indexată și bazată
◄ lab04 - Dictionar Salt la... Laborator 313CAb 10-12 ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 16 martie - 22 martie / Quiz Lab5 - Stivă și Coadă

State Terminat
Timp luat 5 min 1 sec
1 întrebare Coada se poate implementa folosind pe post de container un hashmap (dictionar). Stiva se poate implementa folosind pe
Corect post de container un array sau liste inlantuite.
Marcat 1 din 1
a. Adevarat, Fals
b. Adevarat, Adevarat
c. Fals, Fals
d. Fals, Adevarat 
Răspunsul corect este: Fals, Adevarat
2 întrebare Presupunem ca avem o stiva goala. Efectuam urmatoarele operatii:

Corect
push(stack, 1);
Marcat 1 din 1
push(stack, 2);
pop(stack);
peek(stack);
push(stack, 3);
push(stack, 2);
a. 1 2
b. 1 3 2
c. 2 3 1 
d. 2 3 2
3 întrebare Initial avem dequeue cu elementele (in aceasta ordine, de la head la tail): 1 2 3 4
Corect
Marcat 1 din 1
pop_back(dequeue);
front(dequeue);
pop_front(dequeue);
pop_front(dequeue);
a. 2 3 4
b. 5 2 3
c. 2 3 5 
d. 1 2 3

4 întrebare Metoda pop a unei stive:

Corect

d. sterge elementul din varful stivei si il intoarce ca rezultat 

Răspunsul corect este: sterge elementul din varful stivei si il intoarce ca rezultat
5 întrebare Ce operatii sunt suportate de o coada normala?

Parțial corect
Marcat 0 din 1 Alegeți una sau mai multe opțiuni:

a. Adaugarea unui element in coada 
b. Returnarea celui mai vechi element din coada
c. Stergerea celui mai recent element din coada 
d. Stergerea celui mai vechi element din coada
e. Inlocuirea unui element din coada

Ați selectat în mod corect 1.
◄ lab05 - stiva si coada Salt la... Upload Lab5 - Stiva si Coada ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 23 martie - 29 martie / Quiz Laborator 6 - Grafuri Basics

State Terminat
1 întrebare Complexitatea parcurgerii prin BFS este:

Corect

1,00
a. mai mare ca în cazul DFS
b. identică cu cea în cazul DFS 
c. mai mică ca în cazul DFS
Răspunsul corect este: identică cu cea în cazul DFS
2 întrebare
Ce reprezinta gradul unui nod intr-un graf neorientat?
Corect
Marcat 1,00 din

1,00
a. Numarul de vecini ai nodului considerat 
b. Jumatatea numarului de vecini ai nodului considerat
c. Suma gradelor tuturor vecinilor nodului considerat
Răspunsul corect este: Numarul de vecini ai nodului considerat
3 întrebare
Diametrul unui graf reprezinta maximul distantelor minime dintre oricare doua noduri din acel graf. Ce se poate spune
Incorect
despre un graf cu n noduri, al carui diametru este egal cu n - 1?
Marcat 0,00 din
1,00
a. Graful are o structura liniara
b. Parcurgerea BFS a grafului, va fi identica cu parcurgerea DFS a grafului, pornind din orice nod al grafului 
c. Graful contine un ciclu de lungime n - 1
d. Graful este complet

Răspunsul corect este: Graful are o structura liniara
4 întrebare
Diferenta dintre un graf orientat si un graf neorientat cu acelasi numar de noduri si acelasi numar de muchii este ca:
Corect
Marcat 1,00 din

1,00
a. Parcurgerea BFS a grafului neorientat este realizata mai rapid decat parcurgerea BFS a grafului orientat
b. Reprezentarea cu liste de adiacenta a grafului orientat necesita o cantitate mai mica de memorie decat
reprezentarea cu liste de adiacenta a grafului orientat
c. Sensul muchiilor nu este precizat in graful neorientat 
d. Niciun raspuns nu este corect

Răspunsul corect este: Sensul muchiilor nu este precizat in graful neorientat
5 întrebare
Corect
Marcat 1,00 din

1,00
Graful din imagine se parcurge in latime, pornind din nodul A. Nodul G va avea nivelul N in cadrul parcurgerii. (Se
considera ca nodul sursa este pe nivelul 0)
a. N = 2 
b. N = 4
c. N = 3
d. N = 5

Răspunsul corect este: N = 2

Salt la...
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 30 martie - 5 aprilie / Quiz Laborator 7 - Grafuri Advanced
Început la marţi, 7 aprilie 2020, 14:21

State Terminat
Completat la marţi, 7 aprilie 2020, 14:26
Timp luat 5 min
1 întrebare Pe un graf orientat aciclic cu mai multe componente conexe în care ordinea nodurilor nu contează, se pot realiza sortări
Incorect topologice cu rezultate diferite.
Marcat 0,00 din
1,00 Alegeți o opțiune:
a. Adevărat
b. Fals 
c. Nu se poate realiza o sortare topologică pe un graf orientat aciclic
Răspunsul corect este: Adevărat
2 întrebare Un graf este bipartit daca oricare doua noduri consecutive se afla pe acelasi nivel (au aceeasi culoare).
Corect
Marcat 1,00 din Selectați o opțiune:

1,00
Adevărat
Fals 
Răspunsul corect este "Fals".
3 întrebare Care din următoarele afirmații sunt adevărate despre parcurgerea DFS a unui graf cu muchii egale:
Incorect
Marcat 0,00 din 1. Determină lungimea minimă a drumului dintre două noduri conectate.
1,00 2. Poate ordona nodurile astfel încât să respecte relația de ordine a muchiilor.
a. 1, 2 si 3
b. 1 si 2
c. Toate 
d. 2 si 3
Răspunsul corect este: 2 si 3
4 întrebare
Nu a primit
răspuns
Marcat din 1,00
Alegeți una sau mai multe opțiuni:

a. Graful este bipartit.
b. Graful contine doua componente conexe.
c. Drumul minim de la nodul A la nodul I trece prin nodul C.
d. Drumul minim de la nodul A la nodul I trece prin nodul B.
The correct answers are: Graful contine doua componente conexe., Graful este bipartit., Drumul minim de la nodul A la
nodul I trece prin nodul C.
5 întrebare Determinarea componentelor conexe ale unui graf se poate efectua folosind parcurgerea:
Corect

1,00
a. DFS
b. BFS
c. Nici o parcurgere nu determină componentele conexe ale unui graf
d. BFS sau DFS 
Răspunsul corect este: BFS sau DFS
◄ Lab07 - Grafuri Advanced Salt la... Upload Lab7 - Grafuri advanced ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 6 aprilie - 12 aprilie / Quiz Laborator 08 - Arbori si arbori binari
Început la miercuri, 15 aprilie 2020, 18:14

State Terminat
Completat la miercuri, 15 aprilie 2020, 18:19
Timp luat 5 min
Puncte 3,00/5,00
1 întrebare Se dă următorul arbore binar:

Corect
Marcat 1,00 din

1,00
a. A B D C E G F H I 
b. B D A G E C H F I
c. A B C D E F G H I
d. D B G E H I F C A

Răspunsul corect este: A B D C E G F H I
2 întrebare Parcurgerea inordine pe următorul arbore este:

Corect
Marcat 1,00 din

1,00
a. 10 7 11 3 8 13 4 8 12 17
b. 10 7 3 4 8 8 11 13 12 17
c. 4 3 8 8 7 12 17 13 11 10
d. 3 4 7 8 8 10 11 12 13 17 

Răspunsul corect este: 3 4 7 8 8 10 11 12 13 17
3 întrebare Se dă următorul arbore binar:

Corect
Marcat 1,00 din

1,00
Ce fel de parcurgere este cea în care au rezultat nodurile A B C D E F G H I:
a. inordine
b. nu există o astfel de parcurgere
c. preordine
d. lățime 
e. postordine

În cadrul parcurgerii în lățime se folosește o coadă în care se află inițial doar nodul rădăcină, iar la fiecare pas se
extrage din această coadă câte un nod și se adăugă înapoi în coadă nodul stâng, respectiv drept al nodului scos. Acest
algoritm continuă până când coada devine goală.
Răspunsul corect este: lățime
4 întrebare Parcurgerea postordine pe următorul arbore este:

Incorect
Marcat 0,00 din

1,00
a. 4 3 8 8 7 12 17 13 11 10
b. 10 7 11 3 8 13 4 8 12 17
c. 3 4 7 8 8 10 11 12 13 17 
d. 10 7 3 4 8 8 11 13 12 17

Răspunsul corect este: 4 3 8 8 7 12 17 13 11 10
5 întrebare Pentru evaluarea expresiilor reprezentate sub formă de arbori binari, se poate folosi o parcurgere:
Incorect

1,00
a. preordine sau postordine
b. postordine
c. inordine, preordine sau postordine 
d. preordine

Răspunsul corect este: postordine

◄ Lab08 - Arbori si Arbori Binari Salt la...
Binari ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 20 aprilie - 26 aprilie / Quiz Lab9 - ABC și Heap
Început la marţi, 28 aprilie 2020, 14:11

State Terminat
Completat la marţi, 28 aprilie 2020, 14:16
1 întrebare Se dă următorul arbore binar de căutare:

Corect
Marcat 1 din 1
Parcurgerea sa preordine este:
a. 8, 2, 3, 4, 26, 21, 9, 30, 28, 27 
b. 2, 3, 4, 8, 9, 21, 26, 27, 28, 30
c. 4, 3, 2, 9, 21, 27, 28, 30, 26, 8
Răspunsul corect este: 8, 2, 3, 4, 26, 21, 9, 30, 28, 27
2 întrebare Care dintre următoarele structuri este un max-heap?

Corect
Marcat 1 din 1
a.
b. 
c.
d.

Răspunsul corect este:
3 întrebare Care din cele două implementări ale unui heap este mai eficient din punct de vedere al memoriei?
Corect

a.
struct node {
int value;
struct* node;
struct* node;
b. vector<int> v(10) 
Răspunsul corect este: vector<int> v(10)

Corect
Marcat 1 din 1
Parcurgerea sa preordine este:
a.
6, 9, 7, 5, 12, 16, 24, 27, 20, 11
b. 11, 5, 7, 6, 9, 20, 16, 12, 27, 24 
c. 5, 6, 7, 9, 11, 12, 16, 20, 24, 27


Corect
Marcat 1 din 1
Parcurgerea sa inordine este:
a. 8, 2, 3, 4, 26, 21, 9, 30, 28, 27
b.
4, 3, 2, 9, 21, 27, 28, 30, 26, 8
c. 2, 3, 4, 8, 9, 21, 26, 27, 28, 30 
◄ Lab09 - ABC și Heap Salt la... Upload Laborator 9 - ABC si Heap ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 27 aprilie - 3 mai / Quiz Lab10 - Treap
Început la marţi, 5 mai 2020, 14:11

State Terminat
Completat la marţi, 5 mai 2020, 14:16
1 întrebare Atunci când inserăm un nod într-un treap, nu ne folosim de prioritatea acestuia (aceasta este folosită doar la ștergere):
Corect
Marcat 1,00 din Selectați o opțiune:

1,00 Adevărat
Fals 
2 întrebare Atunci când dorim să ștergem un nod dintr-un treap, trebuie să:
Corect

1,00
a. îl aducem în rădăcina treap-ului
b. îl aducem la baza treap-ului (ca frunză) 
c. nu trebuie mutat - fiii nodului șters se leagă la părintele acestuia
d. un nod nu se poate șterge întotdeauna dintr-un treap

Răspunsul corect este: îl aducem la baza treap-ului (ca frunză)
3 întrebare Într-un treap, prioritatea unui nod este mai mare ca prioritatea fiului său stâng (dacă există) și mai mică ca prioritatea
Corect fiului drept (dacă există)
Marcat 1,00 din
1,00 Selectați o opțiune:
Adevărat
Fals 
4 întrebare Presupunând că avem o structură de treap cu N noduri, în ce complexitate se pot afișa elementele în ordine crescătoare?
Incorect

1,00
a. O(1)
b. O(logN) 
c. O(N)
d. O(log^2N)
Răspunsul corect este: O(N)
5 întrebare Parcurgerea în inordine a unui treap obține:

Corect

1,00
a. cheile nodurilor sortate descrescător
b. cheile nodurilor sortate crescător 
c. prioritățile sortate descrescător
d. prioritățile nodurilor sortate crescător
Răspunsul corect este: cheile nodurilor sortate crescător
◄ Upload Laborator 10 - Treap Salt la... curs11 - Arbori Echilibrati ►
Dashboard / Cursurile mele / L-A1-S2-SD-CA / 4 mai - 10 mai / Quiz Laborator 11 - AVL & Red-Black Trees
Început la marţi, 12 mai 2020, 14:10

State Terminat
Completat la marţi, 12 mai 2020, 14:14
1 întrebare Care dintre urmatoarele structuri produce cel mai echilibrat arbore?
Corect
Marcat 1,00 din Alegeți una sau mai multe opțiuni:

1,00
a. BST
b. Red-Black Tree
c. AVL 
d. Treap
Răspunsul corect este: AVL
2 întrebare Care este diferenta maxima (in modul) a inaltimilor dintre subarborele stang si subarborele drept al unui nod dintr-un
Corect AVL?
Marcat 1,00 din
1,00 Alegeți una sau mai multe opțiuni:
a. 2
b. 0
c. log(n)
d. 1 
Răspunsul corect este: 1
3 întrebare Un AVL este:

Corect

1,00
a. Un arbore binar de cautare echilibrat dupa inaltime 
b. Un arbore binar de cautare echilibrat dupa numere de prioritate
c. Un arbore binar de cautare complet
d. Un arbore binar de cautare aproape complet
Răspunsul corect este: Un arbore binar de cautare echilibrat dupa inaltime
4 întrebare Fie un AVL cu N noduri. Care este inaltimea maxima a acestuia, in cazul cel mai defavorabil?
Corect

1,00
a. n
b. sqrt(n)
c. 1.44 * log(n) 
d. log(n)
Răspunsul corect este: 1.44 * log(n)
5 întrebare In ce situatie preferam un arbore Red-Black in locul unui AVL?

Corect

1,00
a. cand arborele trebuie sa fie echilibrat
b. cand avem nevoie de mai multe inserari/stergeri 
c. cand avem nevoie de mai multe cautari
d. cand avem un monitor ce ne permite sa vedem culorile nodurilor din arborele Red-Black
Răspunsul corect este: cand avem nevoie de mai multe inserari/stergeri

◄ Laborator 11 - AVL & Red-Black Trees Salt la...
Trees ►

State Finished
Question 1
Concatenarea listei simplu înlănțuite L2 la sfârșitul listei simplu înlănțuite L1 se poate face cel mai eficient astfel:
Correct

a.
se setează L1 -> tail -> next = L2 -> head

b.
se copiază elementele lui L1 într-un vector auxiliar, apoi și cele ale lui L2, urmând ca din vector sa se suprascrie lista L1
c.
se setează L1 -> head - > next = L2 -> tail
d.
se parcurg elementele lui L2 și se adaugă pe rând la sfârșitul listei L1

se setează L1 -> tail -> next = L2 -> head
Question 2 Care structură de date este mai eficientă din punctul de vedere al utilizării memoriei (ocupă mai puțină memorie)?
Incorrect

a. Un array din C
b. LinkedList 

The correct answer is: Un array din C
Question 3 Dacă într-o listă simplu înlănțuită se identifică un element X pentru care pointerul său next duce la un element
Correct anterior Y diferit de X, atunci:
Mark 1 out of 1
Select one:
a. X și Y sunt la aceeași adresă de memorie
b. lista are un singur element
c. lista are exact 2 elemente
d. există un ciclu în listă 
Question 4 Considerând că un pointer are dimensiunea de 4 octeți, iar informația stocată într-un nod ocupă 8 octeți, atunci o
Not answered listă simplu înlănțuită cu 3 elemente ocupă ___________ o listă simplu înlănțuită cu 2 elemente, unde prima listă are
Marked out of 1 doar pointer head, iar a doua are head și tail.
Select one:
a. mai puțină memorie decât
b. o memorie ce nu poate fi comparată cu memoria ocupată de
c. aceeași memorie ca
d. mai multă memorie decât

The correct answer is: mai multă memorie decât
Question 5
O listă simplu înlănțuită l nu conține inițial nicio valoare şi va fi folosită pentru a reţine valori numere întregi. Care
Not answered
va fi conținutul listei după efectuarea următoarelor operații (metoda remove_last(l) elimină ultimul nod din listă şi
Marked out of 1 întoarce valoarea întreagă reţinută de acesta, iar add_first(l, x) adaugă un nou nod cu valoarea x la începutul
listei)?
add_first(l, 3);
add_first(l, 4);
add_first(l, 0);
remove_last(l);
add_first(l, 2);
add_first(l, remove_last(l));
Select one:
a. 3 0 2
b. 4 2 0
c. 4 0 2 3
d. 4 0

State Finished
Incorrect general, adăugarea unui nou element pe a doua poziţie se face mai rapid într-o listă dublu-înlănţuită faţă de un
Select one:
a. Fals. Fals
b. Fals. Adevărat
c. Adevărat. Adevărat
d. Adevărat. Fals 

Question 2
Pentru a transforma o listă dublu-înlănţuită oarecare într-o listă dublu-înlănţuită circulară (head este un pointer
Correct
la primul nod din listă, iar tail este un pointer la ultimul nod din listă):
Mark 1 out of 1
Select one:
a. Trebuie să parcurgem întreaga listă şi să actualizăm legăturile dintre toate nodurile.
b. Actualizăm head->next să pointeze la tail şi tail->prev să pointeze la head.
c. Nu se poate transforma lista, trebuie neapărat să construim o nouă listă care să fie circulară de la început.
d. Actualizăm head->prev să pointeze la tail şi tail->next să pointeze la head. 

The correct answer is: Actualizăm head->prev să pointeze la tail şi tail->next să pointeze la head.
Question 3
O listă înlănțuită circulară l conține inițial elementele 4, 8, 2, 10 (în această ordine, evident). Care va fi conținutul
Correct
listei după efectuarea următoarelor operații (metoda remove_last(l) elimină ultimul element al listei, iar
Mark 1 out of 1 add_first(l, x) adaugă elementul x la începutul listei)?
remove_last(l);
add_first(l, 10);
remove_last(l);
add_first(l, 2);
remove_last(l);
add_first(l, 8);
remove_last(l);
add_first(l, 4);
Select one:
a. 4 8 2 10 
b. 4 2 8 10
c. 8 2 4 10
d. 10 4 8 2

The correct answer is: 4 8 2 10
Question 4 Se poate efectua ștergerea ultimului nod în timp constant într-o listă dublu înlănțuită?
Correct

a. Da, prin parcurgerea element cu element a listei
b. Da, prin inversarea listei, eliminarea primului element și inversarea listei rezultate
c. Nu
d. Da, dacă se menține un pointer la ultimul nod al listei 

The correct answer is: Da, dacă se menține un pointer la ultimul nod al listei
Question 5 Ștergerea ultimului nod a unei liste circulare dublu înlănțuite se face în mod optim:
Correct

a. în timp invers proporțional cu numărul de elemente.
b. (aproape) instantaneu doar dacă există pointer tail pentru listă
c. (aproape) instantaneu. 
d. în timp proporțional cu numărul de elemente.

The correct answer is: (aproape) instantaneu.

State Finished
Grade 2.00 out of 5.00 (40%)
Question 1 Când are loc o coliziune într-o tabelă de dispersie?

Correct

1.00
a. când funcția de hash returnează același număr pentru două chei diferite 
b.
când se accesează o adresă de memorie nevalida
c. când două valori din perechi de tip cheie-valoare coincid
d.
când două chei sunt identice

The correct answer is: când funcția de hash returnează același număr pentru două chei diferite
Question 2
Funcția de hash returnează numere întregi. Numărul de bucket-uri dintr-un hashtable trebuie să fie prim.
Incorrect
Mark 0.00 out of

1.00
Select one:
a. adevarat, adevarat 
b. adevarat, fals
c. fals, adevarat
d.
fals, fals

fals, fals
Question 3
Care este diferența între linear probing și direct chaining?
Correct
Mark 1.00 out of

1.00
Select one:
a.

b.
la direct chaining se caută primul loc liber din dicționar
c.
dicționarele care folosesc linear probing au un număr mai mare de bucket-uri
d.
implementarea prin libear probing se face folosind liste înlănțuite

Question 4
Care dintre următoarele NU reprezintă o modalitate de gestiune a coliziunilor:
Incorrect
Mark 0.00 out of

1.00
Select one:
a.
înlănțuire directă 
b.
linear probing
c. direct chaining
d. adresare indexată și bazată

The correct answer is: adresare indexată și bazată
Question 5 Care din următoarele operații nu sunt suportate de un dicționar:

Incorrect

1.00
a. put(key)
b. remove(key)
c. get(key)
d. has_key(key) 

The correct answer is: put(key)

State Finished
Question 1 Presupunem ca avem o stiva goala. Efectuam urmatoarele operatii:

Correct
push(stack, 1);
Mark 1 out of 1 push(stack, 2);
pop(stack);
peek(stack);
push(stack, 3);
push(stack, 2);
Select one:
a. 2 3 2
b. 1 3 2
c. 2 3 1 
d. 1 2
Question 2 Ce operatii sunt suportate de o coada normala?

Correct

a. Stergerea celui mai recent element din coada
b. Inlocuirea unui element din coada
c. Adaugarea unui element in coada 
d. Returnarea celui mai vechi element din coada 
e. Stergerea celui mai vechi element din coada 


Correct

a. verifica daca stiva este goala
c. sterge elementul din varful stivei si il intoarce ca rezultat 
d. adauga un element in varful stivei

Question 4 Accesul in coada prezinta o restrictie de tipul:

Correct

a. FIFO (First In, First Out) 
b. LIFO (Last In, First Out)
c. LIBO (Last In, Best Out)
d. FIBO (First In, Best Out)

The correct answer is: FIFO (First In, First Out)
Question 5 Initial avem dequeue cu elementele (in aceasta ordine, de la head la tail): 1 2 3 4
Correct
Mark 1 out of 1
pop_back(dequeue);
front(dequeue);
pop_front(dequeue);
pop_front(dequeue);
Select one:
a. 2 3 4
b. 2 3 5 
c. 5 2 3
d. 1 2 3


State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Complexitatea parcurgerii prin BFS este:

Correct

1.00
a. mai mică ca în cazul DFS
b. mai mare ca în cazul DFS
c. identică cu cea în cazul DFS 

The correct answer is: identică cu cea în cazul DFS
Question 2 Care dintre urmatoarele parcurgeri poate fi folosita pentru a determina eficient daca exista un ciclu intr-un graf?
Correct

1.00
a. DFS 
b. Algoritmul lui Kruskal
c. BFS
d. Parcurgere pe nivel

Question 3 O posibilă vizitare prin BFS a nodurilor din graful de mai jos este:
Correct
R-----M-----N
Mark 1.00 out of | |
1.00 Q-----O-----P
Select one:
a. O N M R Q P
b. Q O N M P R
c. R M N Q O P 
The correct answer is: R M N Q O P
Question 4
Prin intermediul carei parcurgeri se poate determina eficient drumul minim intre doua noduri in graf?
Incorrect

1.00
a. DFS 
b. BFS
c. Ambele
d. Niciuna

The correct answer is: BFS
Question 5
Care este numarul minim de noduri pe care il poate avea un graf neorientat cu 3 muchii? Nu se permit muchii de la un
Correct
nod la el insusi, nu se permite existenta a doua muchii intre aceleasi doua noduri.
Mark 1.00 out of
1.00
Select one:
a. 2
b. 3 
c. 5
d. 4


Jump to...

State Finished
Grade 4.00 out of 5.00 (80%)
Question 1 Pe un graf orientat aciclic cu mai multe componente conexe în care ordinea nodurilor nu contează, se pot realiza sortări
Correct topologice cu rezultate diferite.
Mark 1.00 out of
1.00 Select one:
a. Fals
b. Nu se poate realiza o sortare topologică pe un graf orientat aciclic
c. Adevărat 

Question 2 Cum se poate determina prezența unui ciclu într-un graf?

Correct
Mark 1.00 out of

1.00 Select one:
a. Nu se poate determina prezența unui ciclu
b. Doar cu o parcurgere BFS
c. Doar cu o parcurgere DFS
d. Parcurgere a grafului (DF/BF) 

Se poate determina cu ușurință prezența unui ciclu într-un graf, atât prin intermediul parcurgerii în lățime cât și prin
adâncime, dacă în cadrul procesării unui nod se observă că există un nod vecin marcat ca în curs de procesare sau ca
procesat și care nu îi este părinte direct în cadrul parcurgerii.
The correct answer is: Parcurgere a grafului (DF/BF)
Incorrect

1.00
a. BFS sau DFS
b. Nici o parcurgere nu determină componentele conexe ale unui graf
c. DFS 
d. BFS

Question 4 Algoritmul de aflare al distantei minime, pentru un graf cu muchii de cost 1, foloseste:
Correct

1.00
a. O coada si un vector de distante 
b. O stiva si un vector de distante
c. O stiva si o coada
d. O coada si un hashtable

The correct answer is: O coada si un vector de distante
Correct
1.00
Select one:
a. Toate
b. 1, 2 și 3
c. 1 și 2
d. 1 și 3 


State Finished
Marks 2.00/5.00
Grade 4.00 out of 10.00 (40%)
Question 1 Se dă un arbore binar în care nodul X dispune de 2 subarbori. Ținând cont că nodul Y este succesorul nodului X într-o
Incorrect traversare în inordine care dintre următoarele afirmații este adevărată:
Mark 0.00 out of
1.00 Select one:
a. Y nu are subarbore drept
b. Y nu are subarbore stâng
c. Y are 2 subarbori 
Pentru ca Y să fie succesorul nodului X într-o parcurgere în inordine, este imperativ ca nodul Y sa nu aibă subarbore
stâng. Dacă nodul Y ar dispune de un subarbore stâng, atunci în cadrul traversării, acel subarbore stâng ar fi succesorul
nodului X.
The correct answer is: Y nu are subarbore stâng
Question 2 Parcurgerea inordine pe următorul arbore este:

Correct
Mark 1.00 out of

1.00
Select one:
a. 3 4 7 8 8 10 11 12 13 17 
b. 10 7 11 3 8 13 4 8 12 17
c. 10 7 3 4 8 8 11 13 12 17
d. 4 3 8 8 7 12 17 13 11 10
Question 3 Pentru evaluarea expresiilor reprezentate sub formă de arbori binari, se poate folosi o parcurgere:
Incorrect

1.00
a. preordine sau postordine
b. inordine, preordine sau postordine 
c. preordine
d. postordine
The correct answer is: postordine
Question 4 Parcurgerile preordine, inordine și postordine se pot numi și:

Incorrect

1.00
a. BFS 
b. DFS

Question 5 Parcurgerea inordine pe un arbore binar, începând din nodul de pe nivelul 2 (nivelul 1 este rădăcina), respectiv
Correct subarborele drept are că efect:
Mark 1.00 out of
1.00 Select one:
a. afișarea tuturor elementelor
b. afișarea tuturor elementelor, mai puțin rădăcina și subarborele stâng 
d. afișarea rădăcinii și a elementelor din subarborele drept

Binari ►

State Finished
Time taken 5 mins
Question 1 Se dă următorul arbore binar de căutare:

Correct
Mark 1 out of 1
Parcurgerea sa postordine este:
Select one:
a. 4, 1, 5, 16, 15, 10, 21, 23, 24, 22 
b. 22, 21, 10, 5, 1, 4, 15, 16, 24, 23
c. 1, 4, 5, 10, 15, 16, 21, 22, 23, 24

The correct answer is: 4, 1, 5, 16, 15, 10, 21, 23, 24, 22
Question 2 Elementul minim dintr-un arbore binar de căutare se află în:

Correct

a. Cea mai din dreapta frunză
b. Cea mai din stânga frunză aparținând ultimului nivel
c. Cea mai din dreapta frunză aparținând ultimului nivel
d. Cea mai din stânga frunză 

The correct answer is: Cea mai din stânga frunză
Question 3 Avem un min-heap. Care dintre următoarele afirmații este adevărată?

Correct

a. Nodul rădăcină va avea valoarea cea mai mică 
b. Nodul rădăcină va avea valoarea cea mai mare
c. Copilul drept al unui nod va fi întotdeaua mai mare decât copilul stâng al aceluiași nod
d.
Copilul stâng al unui nod va fi întotdeaua mai mare decât copilul drept al aceluiași nod

The correct answer is: Nodul rădăcină va avea valoarea cea mai mică
Question 4 Care din cele două implementări ale unui heap este mai eficient din punct de vedere al memoriei?
Correct

a.
struct node {
int value;
struct* node;
struct* node;
b. vector<int> v(10) 

The correct answer is: vector<int> v(10)

Correct

a. Se poate reprezenta mai eficient sub formă de vector
b. Este un arbore echilibrat
c. Subarborele stâng al unui nod are toate elementele mai mici decât nodul respectiv 


State Finished
Grade 3.00 out of 5.00 (60%)
Question 1 Fie următorul treap:

Correct
Mark 1.00 out of A

1.00 / \
B C
/ \
D E
Dacă facem o rotație stânga din nodul A, care vor fi fiii acestuia dupa rotație?
Select one:
a. D și E
b. B și D 
c. C și E
d. B și C

The correct answer is: B și D

Incorrect

1.00
a. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(înălțime treap)
b. pentru ca un element cu o anumită cheie să poată fi inserat/șters în O(logN)
c. pentru a fi echilibrat
d. pentru a putea parcurge treap-ul pe nivele și a obține cheile sortate crescător 


Incorrect
Mark 0.00 out of (5, 10)

1.00 / \
(3, 7) (7, 8)
\
(11, 5)
Daca inserăm nodurile (4, 3), respectiv (12, 9), care vor fi fiii rădăcinei?
Select one:
a. (3, 7) și (4, 3)
b. (3, 7) și (12, 9)
c. (4, 3) și (12, 9) 
d. (3, 7) și (7, 8)

The correct answer is: (3, 7) și (12, 9)

Correct
Mark 1.00 out of (5, 10)

1.00 / \
(3, 7) (7, 8)
\
(11, 5)
Daca inserăm un nod cu cheia 6, care este cea mai mare prioritate pe care ar putea să
o aibă pentru ca inserarea să se facă fără nicio rotire.
Answer: 8 
Question 5 Presupunând că avem o structură de treap cu N noduri, în ce complexitate se poate afla elementul cu cheia minimă din
Correct el?
Mark 1.00 out of
1.00 Select one:
a. O(1)
b. O(log^2N)
c. O(logN) 
d. O(N)

The correct answer is: O(logN)

State Finished
Time taken 5 mins
Grade 5.00 out of 5.00 (100%)
Correct

1.00
a. Un nod rosu trebuie sa fie frunza
b. Rosie
c. Un fiu rosu, altul negru
d. Neagra 


Correct

1.00
a. 4 
b. 5
c. 3
d. 2

Question 3 De ce impunem restrictiile cunoscute pentru un arbore Red-Black?

Correct

1.00
a. pentru a obtine timp exponential
b. pentru a obtine timp liniar
c. pentru a obtine timp logaritmic 
d. pentru a patenta o noua structura de date pe baza de arbori

The correct answer is: pentru a obtine timp logaritmic
Question 4 Care este diferenta maxima (in modul) a inaltimilor dintre subarborele stang si subarborele drept al unui nod dintr-un
Correct AVL?
Mark 1.00 out of
a. 1 
b. 0
c. log(n)
d. 2
Mark 1.00 out of
a. pentru ca arborele nu are nevoie de o zona continua de memorie
b. pentru ca este foarte costisitoare operatia de redimensionare a unui Hashmap si avem avantajul ordinii in Red-
Black Tree 
d. nu am folosi niciodata un Red-Black Tree in locul unui Hashmap


Trees ►

Curs, Lab, Quiz - SD 2020

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs, Lab, Quiz - SD 2020

Încărcat de

Drepturi de autor:

Formate disponibile

Universitatea

"States of Matter", by D.L. Goodstein

Ce face aceasta facultate? Ce NU face aceasta facultate?

Gasiti cat mai multe modalitati Ce urmeaza in urmatoarea secventa?

Sistemele de calcul au nevoie de structură

Cum obținem aceste competente?

Lessons Learned - Team Work

Lessons Learned – Work Ethics

Lessons Learned – Teorie vs Cod

void sayHello(char* name) {

Global variables should be avoided when unnecessary

Alocare statica si dinamica

Alocare statica Alocare dinamica

Tipuri de baza – alocare statica

Alocare statica Alocare dinamica

Tipuri de baza – alocare dinamica

Alocare statica Alocare dinamica

int *ptr = malloc(sizeof (int));

memory leaks; no garbage collector

Struct – alocare statica

Alocare statica Alocare dinamica

struct Masina o_masina;

Struct – alocare dinamica

Alocare statica Alocare dinamica

struct Masina* o_masina = malloc(sizeof(struct Masina));

Array – alocare statica

Alocare statica Alocare dinamica

char name[10] = “Mike";

Array – alocare dinamica

Alocare statica Alocare dinamica

int *ptr = malloc(10 * sizeof (int));

Metode de alocare dinamica

Alocarea dinamica a matricelor

int **array1 = malloc(nrows * sizeof(int *));

int **array2 = malloc(nrows * sizeof(int *));

Alocarea dinamica a matricelor

int **array1 = malloc(nrows * sizeof(int *));

int **array2 = malloc(nrows * sizeof(int *));

Dar ce parere aveti de array3 si array4? 

int *array3 = malloc(nrows * ncolumns * sizeof(int));

int (*array4)[NCOLUMNS] = malloc(nrows * sizeof(*array4));

• Cap 3 din Cormen, Thomas H. Introduction to algorithms.

Start with the Why

Simon Sinek, “Start with the Why” TED Talk

Red Team – student vs professional

Michael Seibel on advice and bias

The pressure on college students

Sir Ken Robinson, “Bring on the learning revolution” TED Talk

Abstract Data Types

Abstract Data Type

Abstract Data Type A set of data values and associated

Ce operatii ati vrea sa faceti cu liste?

• adaugare element la sfarsit

Operatiile unei liste

Operatiile unei liste

Operatiile unei liste

Extragere din L la inceput la sfarsit pozitie arbitrara

Pozitie element prima aparitie ultima aparitie

Operatiile unei liste

Modificare in L la inceput la sfarsit pozitie arbitrara

Operatiile unei liste

• Shuffle, rotate, compare, count de elemente, umplere (random, paddin

Alte structuri de date se bazeaza pe liste

Comparatie ArrayList vs LinkedList

int ptr = malloc(10 sizeof (int));

int array3 = malloc(nrows ncolumns * sizeof(int));

int (array4)[NCOLUMNS] = malloc(nrows sizeof(*array4));