----------------------------LAB

2-----------------------------------------------------
#include <stdio.h>
#include <stdlib.h>

typedef struct nodetype

{
int key;
struct nodetype *next;
} NodeT;

NodeT *search(NodeT *first, int givenKey)

{
NodeT *p=first;
while(p!=NULL)
{
if(p->key==givenKey) // functia cauta cheia givenKey
return p;
p=p->next;
}
return NULL;
}

void insert_first(NodeT **first, NodeT **last, int givenKey)

{
NodeT *p=(NodeT*)malloc(sizeof(NodeT));
p->key=givenKey;
p->next=*first;

if(*first==NULL) // daca lista e goala

*last=p;

*first=p;
}

void insert_last(NodeT **first, NodeT **last, int givenKey)

{
NodeT *p=(NodeT*)malloc(sizeof(NodeT));
p->next=NULL;
p->key=givenKey;

if(*last==NULL) // daca lista e goala

*first=*last=p;
else
{
(*last)->next = p;
*last=p;
}
}

void insert_after_key(NodeT **first, NodeT **last, int afterKey, int givenKey)

{
NodeT *p=(NodeT*)malloc(sizeof(NodeT));
p->key=givenKey;

NodeT *q; // prin q o sa cautam nod-ul cu cheia afterKey

q=*first;
while(q!=NULL)
{
 if(q->key==afterKey)
break;
q=q->next;
}

p->next=q->next;
q->next=p;

if(q==*last)
{
p->next=NULL;
*last=p;
}

void afisare(NodeT *first)

{
NodeT *p=first;
while(p!=NULL)
{
printf("%d ",p->key);
p=p->next;
}
printf("\n");
}

void delete_first(NodeT **first, NodeT **last)

{
NodeT *p;

if(*first!=NULL)
{
p=*first;
*first=(*first)->next;
free(p);

if(*first==NULL) // daca acum lista este goala

*last=NULL;
}
}

void delete_last(NodeT **first, NodeT **last)

{
NodeT *q1;
NodeT *q;
q1=NULL;
q=*first;
if(q!=NULL)
{
while(q!=*last)
{
q1=q;
q=q->next;
}

if(q==*first) // daca avem un singur element

*first=*last=NULL;
else
 {
q1->next=NULL;
*last=q1;
}
free(q);
}

void delete_key(NodeT **first, NodeT **last, int givenKey)

{
NodeT *q;
NodeT *q1;
q1=NULL;
q=*first;

while(q!=NULL)
{
if(q->key==givenKey) break;
q1=q;
q=q->next;
}

if(q!=NULL) // daca nu am ajuns la final si am gasit nodul

{
if(q==*first)
{
*first=(*first)->next;
free(q);
if(*first==NULL) // daca dupa stergere, lista e goala
*last=NULL;
}
else
{
q1->next=q->next;
if(q==*last) // daca nodul ce trebuie sters e ultimul
*last=q1;
free(q);
}

}
}
~~~~~~~~~~~~~~~~~~~~~~~~~`vector~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
int search_vector(int *arr, int size, int key)
{
for(int i=0; i<size; i++)
if(arr[i]==key)
{
return i;
}
}

void insert_first_vector(int *arr, int *size,int *capacity, int key)

{
if(*size==*capacity)
arr=(int*)realloc(arr,2*(*capacity)*sizeof(int));
 (*size)++;
for(int i=*size; i>0; i--)
arr[i]=arr[i-1];

arr[0]=key;

void insert_last_vector(int *arr,int *size,int *capacity,int key)

{
if(*size==*capacity)
arr=(int*)realloc(arr,2*(*capacity)*sizeof(int));

(*size)++;
arr[*size-1]=key;
}

void delete_first_vector(int *arr, int *size)

{
for(int i=0; i<*size-1; i++)
arr[i]=arr[i+1];
(*size)--;
}

void delete_last_vector(int *arr, int *size)

{
(*size)--;
}

void delete_key_vector(int *arr, int *size, int key)

{
int poz;
for(int i=0; i<*size; i++)
if(arr[i]==key)
poz=i;
for(int i=poz; i<*size; i++)
arr[i]=arr[i+1];
(*size)--;
}

void afisare_vector(int *arr,int size)

{
for(int i=0; i<size; i++)
printf("%d ",arr[i]);
printf("\n");
}

int main()
{
NodeT *first;
NodeT *last;
first=NULL;
last=NULL;

insert_first(&first,&last,4);
insert_first(&first,&last,1);
 insert_last(&first,&last,3);
insert_after_key(&first,&last,4,22);
insert_after_key(&first,&last,3,25);

// afisarea listei
afisare(first);

NodeT *test_false=search(first,2);
printf("%d\n",test_false);
NodeT *test_true=search(first,3);
printf("%d\n",test_true);

delete_first(&first,&last);
delete_last(&first,&last);
delete_key(&first,&last,22);
delete_key(&first,&last,8);
afisare(first);

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

int *v=(int*)calloc(10,sizeof(int));
int size=0;
/*for(int i=0;i<size;i++)
{printf("v[%d]=",i);
scanf("%d",&v[i]);
printf("\n");}*/

int capacity=10;
insert_first_vector(v,&size,&capacity,5);
insert_first_vector(v,&size,&capacity,2);
insert_first_vector(v,&size,&capacity,7);
insert_last_vector(v,&size,&capacity,12);
insert_last_vector(v,&size,&capacity,13);
afisare_vector(v,size);
printf("%d este indexul cheii 2\n",search_vector(v,size,2));
printf("%d este indexul cheii 20\n",search_vector(v,size,20));
delete_first_vector(v,&size);
delete_key_vector(v,&size,12);
afisare_vector(v,size);

}
--------------------------------Lab 3 --------------------------------------
~~~~~~~~~~~~~~~~~stiva~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <stdio.h>
#include <stdlib.h>

typedef struct node_type

{
int key;
struct node_type *next;
} NodeT;

NodeT *init(int givenKey)

{
NodeT *p=(NodeT*)malloc(sizeof(NodeT));
p->key=givenKey;
 p->next=NULL;

return p;
}

void push(NodeT **stack, int givenKey)

{
NodeT *p=(NodeT*)malloc(sizeof(NodeT));
p->key=givenKey;
p->next=NULL;

if(*stack==NULL)
*stack=p;
else
{
p->next=*stack;
*stack=p;
}
}

NodeT *pop(NodeT **stack)

{
NodeT *p=*stack;

if((*stack)->next==NULL)
*stack=NULL;
else
*stack=(*stack)->next;
return p;

void afisare(NodeT *stack)

{
NodeT *p;
p=stack;

while(p!=NULL)
{
printf("%d ",p->key);
p=p->next;
}
printf("\n");
}

int main()
{
NodeT *stack;

stack=init(1);
push(&stack,5);
push(&stack,6);
push(&stack,7);
afisare(stack);

NodeT *nod_sters=pop(&stack);
 printf("Nodul sters este %d\n",nod_sters->key);
push(&stack,100);
afisare(stack);
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~`lista ddublu inlantuita
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <stdio.h>
#include <stdlib.h>

typedef struct node_type

{
int key;
struct node_type *next;
struct node_type *prev;
} NodeDL;

struct list_header
{
NodeDL *first;
NodeDL *last;
};

void insert_first(struct list_header *L, int givenKey)

{
NodeDL *p=(NodeDL*)malloc(sizeof(NodeDL));
p->key=givenKey;
p->next=NULL;
p->prev=NULL;

if(L->first==NULL)
L->first=L->last=p;
else
{
p->next=L->first;
L->first->prev=p;
L->first=p;
}
}

void insert_last(struct list_header *L, int givenKey)

{
NodeDL *p=(NodeDL*)malloc(sizeof(NodeDL));
p->key=givenKey;
p->prev=NULL;
p->next=NULL;

if(L->last==NULL)
L->first=L->last=p;
else
{
p->prev=L->last;
L->last->next=p;
L->last=p;
}
}

void insert_after_key(struct list_header *L, int afterKey, int givenKey)

{
NodeDL *q;
 q=L->first;
while(q->key!=afterKey)
q=q->next;

if(q->key==afterKey)
{
NodeDL *p=(NodeDL*)malloc(sizeof(NodeDL));
p->key=givenKey;
p->next=NULL;
p->prev=NULL;

if(q->next==NULL)
{
p->prev=q;
p->next=NULL;
q->next=p;
L->last=p;
}
else
{
p->prev=q;
p->next=q->next;
(q->next)->prev=p;
q->next=p;
}
}
}

void delete_first(struct list_header *L)

{
NodeDL *q;
q=L->first;

if(L->first!=NULL)
{
if(L->first->next!=NULL)
{
(L->first)->next->prev=NULL;
L->first=L->first->next;
//free(q);
}
else
L->first=L->first->next=NULL;
free(q); // am adus free(q) de sus, aici :)) mergea si inainte
//if(L->first==NULL)
//L->last=NULL;
}
else
{
printf("Lista este deja goala !\n");
}
}

void delete_last(struct list_header *L)

{
NodeDL *p=L->last;
if(L->last!=NULL)
{
if(L->last->prev!=NULL)
 {
((L->last)->prev)->next=NULL; // daca nu avem un singur nod
L->last=L->last->prev;
}
else
{
L->first=L->last=NULL;
}
free(p);
}
else
printf("Lista este deja goala!\n");
}

void delete_key(struct list_header *L, int givenKey)

{
NodeDL *q;
q=L->first;

while(q!=NULL)
{
if(q->key == givenKey)
break;
q=q->next;
}

if(L->first!=NULL)
if(q->next==NULL && q->prev==NULL)
{
L->first=L->last=NULL;
free(q);
}
else
{
if(q->next==NULL)
{
(q->prev)->next=NULL;
L->last=L->last->prev;
free(q);
}
else
{
(q->prev)->next=q->next;
(q->next)->prev=q->prev;
free(q);
}
}
else
printf("Lista este deja goala!\n");
}

void print_forward(struct list_header L)

{
if(L.first!=NULL && L.last!=NULL)
{
NodeDL *q;
for(q=L.first; q!=NULL; q=q->next)
printf("%d ",q->key);
printf("\n");
 }
else
printf("Lista este goala !\n");
}

void print_backward(struct list_header L)

{
if(L.first!=NULL && L.last!=NULL)
{
NodeDL *q;
for(q=L.last; q!=NULL; q=q->prev)
printf("%d ",q->key);
printf("\n");
}
else
printf("Lista este goala !\n");
}

int main()
{
struct list_header L= {NULL,NULL};
//NodeDL *test_false=search(L,10);
//NodeDL *test_true=search(L,4);

//insert_first(&L,4);
//insert_first(&L,3);
//print_forward(L);
//insert_first(&L,2);
//insert_first(&L,1);
//insert_last(&L,10);
//print_backward(L);
/*insert_after_key(&L,4,100);
insert_last(&L,10);
insert_last(&L,20);
insert_first(&L,3);
insert_after_key(&L,3,500);
insert_after_key(&L,20,1000);
insert_last(&L,15);
delete_first(&L);
delete_first(&L);
insert_first(&L,99);
insert_after_key(&L,99,40);
delete_last(&L);
delete_first(&L);
insert_first(&L,99);
insert_after_key(&L,99,40);
delete_first(&L);
delete_last(&L);
insert_last(&L,9999);
print_forward(L);
print_backward(L);
delete_key(&L,100);
print_forward(L);
print_backward(L);
delete_key(&L,9999);
print_forward(L);
print_backward(L);
 insert_last(&L,9999);
insert_last(&L,99999);
delete_key(&L,4);
insert_first(&L,99);
insert_after_key(&L,99,40);*/
delete_key(&L,4);
print_forward(L);
print_backward(L);
}
~~~~~~~~~~~~~~~~~~~~`coada cu vector ~~~~~~~~~~~~~~~~~~~~~~~~~~~~``
#include <stdio.h>
#include <stdlib.h>

struct queue
{
int *v;
int head,tail;
int capacity;
};

void init(struct queue *my_queue,int cap)

{
//struct queue *my_queue=(struct queue*)malloc(sizeof(struct queue));
my_queue->capacity=cap;
my_queue->v=(int*)malloc((my_queue->capacity)*sizeof(int));
my_queue->head=0;
my_queue->tail=0;

void enqueue(struct queue *my_queue, int givenKey)

{
if(my_queue->tail==my_queue->head-1 || (my_queue->head==0 && my_queue-
>tail==my_queue->capacity-1))
printf("Coada este plina, nu am putut introduce elementul %d\n", givenKey);
//my_queue->capacity=my_queue->capacity*2;
//my_queue->v=realloc(my_queue->v, my_queue->capacity);
else
{
my_queue->v[my_queue->tail]=givenKey;

if(my_queue->tail==my_queue->capacity-1)
my_queue->tail=0;
else
my_queue->tail++;
}

int dequeue(struct queue *my_queue)

{
if(my_queue->tail==my_queue->head)
{
printf("Sorry lista este goala deja !\n");
return 0;
}
else
{
int elem_sters=my_queue->v[my_queue->head];
 /*for(int i=my_queue->head; i<my_queue->tail-1; i++)
my_queue->v[i]=my_queue->v[i+1];*/ // am facut o prostie, dupa ce
stergem un element, head avanseaza spre dreapta, nu mutam elementele :))) tampitule
my_queue->v[my_queue->head]=0;
my_queue->head++;
//if(my_queue->head==my_queue->capacity)
//my_queue->head=0;
if(my_queue->head==my_queue->capacity)
my_queue->head=0;
return elem_sters;
}
}

void afisare(struct queue *my_queue)

{
if(my_queue->tail==my_queue->head)
printf("Acum, lista este goala, nu mai incercati sa stergeti
nimic !!!!\n");
else
{
if(my_queue->tail<my_queue->head)
{
for(int i=my_queue->head; i<(my_queue->capacity); i++)
printf("%d ",my_queue->v[i]);
for(int j=0; j<my_queue->tail; j++)
printf("%d ",my_queue->v[j]);
printf("\n");
}
else
{
for(int k=my_queue->head; k<(my_queue->tail); k++)
printf("%d ",my_queue->v[k]);
printf("\n");
}
}
}

int main()
{
struct queue my_queue;
int capacity=8;
init(&my_queue,capacity);

enqueue(&my_queue,1);
afisare(&my_queue);
enqueue(&my_queue,2);
afisare(&my_queue);
enqueue(&my_queue,3);
afisare(&my_queue);
enqueue(&my_queue,4);
afisare(&my_queue);
enqueue(&my_queue,5);
afisare(&my_queue);
enqueue(&my_queue,6);
afisare(&my_queue);
enqueue(&my_queue,7);
afisare(&my_queue);
enqueue(&my_queue,8);
 int a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);

afisare(&my_queue);
/*enqueue(&my_queue,1);
afisare(&my_queue);
int a=dequeue(&my_queue);
enqueue(&my_queue,2);
afisare(&my_queue);
enqueue(&my_queue,3);
afisare(&my_queue);
enqueue(&my_queue,4);
afisare(&my_queue);
enqueue(&my_queue,5);
afisare(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
enqueue(&my_queue,6);
afisare(&my_queue);
enqueue(&my_queue,7);
afisare(&my_queue);
enqueue(&my_queue,8);
afisare(&my_queue);
enqueue(&my_queue,9);
afisare(&my_queue);
enqueue(&my_queue,10);
afisare(&my_queue);
enqueue(&my_queue,11);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
a=dequeue(&my_queue);
//a=dequeue(&my_queue);
afisare(&my_queue);
// dupa aceasta operatie, coada mea este goala deja, si daca mai incerc sa
sterg un element, ar trebui sa apara UN MESAJ DE EROARE !!!
a=dequeue(&my_queue);
afisare(&my_queue);*/

//afisare(&my_queue);

}
---------------------------lab4----------------------------------arbore binar
----------------1 7 2 0 5 0 0 0 9 3 0 0 4 0 6 0 0

#include <stdio.h>
#include <stdlib.h>
typedef struct binary_tree
{
int key;
struct binary_tree *left;
struct binary_tree *right;
} NodeT;

NodeT *CreateBinTreeFromFile(FILE *f)

{
NodeT *p;
int val;

fscanf(f,"%d",&val);
if(val==0)
{
return NULL; // daca prima valoare din fisierul text e 0 => radacina
e 0 => nu avem arbore/subarbore (folosim recursivity)
}
else
{
p=(NodeT*)malloc(sizeof(NodeT));
p->key=val;
p->left=CreateBinTreeFromFile(f);
p->right=CreateBinTreeFromFile(f);
//return p; putem pune linistit si aici returnp, e totuna :))
}
return p;
}

void preorder(NodeT *p)

{
if(p!=NULL)
{
printf("%d ",p->key);
preorder(p->left);
preorder(p->right);
}
}

void postorder(NodeT *p)

{
if(p!=NULL)
{
postorder(p->left);
postorder(p->right);
printf("%d ",p->key);
}
}

void inorder(NodeT *p)

{
if(p!=NULL)
{
inorder(p->left);
printf("%d ",p->key);
inorder(p->right);
}
}
int nr_frunze(NodeT *p)
{
if(p==NULL)
return 0;
else if(p->left == NULL && p->right == NULL)
return 1; // puteam ca in acelasi moment in care am gasit o frunza,
sa o si afisam pentru ca tot recursiv se rezolva problema :))
else
return nr_frunze(p->left) + nr_frunze(p->right);
}

void afis_frunze(NodeT *p)

{
if(p!=NULL)
{
if(p->left == NULL && p->right == NULL)
printf("%d ",p->key);
afis_frunze(p->left);
afis_frunze(p->right);
}
}

int nr_noduri_interne(NodeT *p)

{
if(p==NULL)
return 0;
else if(p->left==NULL && p->right==NULL)
return 0;
else
return 1+nr_noduri_interne(p->left)+nr_noduri_interne(p->right);

void afis_noduri_interne(NodeT *p)

{
if(p!=NULL)
{
if(p->left!=NULL || p->right!=NULL)
printf("%d ",p->key);
afis_noduri_interne(p->left);
afis_noduri_interne(p->right);
}
}

int max(int a, int b)

{
if(a<=b)
return b;
else
return a;
}

int inaltime_arbore(NodeT *p) // la recursivitate, trebuie sa gandim fff

simplu, fara sa intram in detalii
{
if(p==NULL)
return -1;
else
return(1+max(inaltime_arbore(p->left),inaltime_arbore(p->right)));
}

NodeT* Compare(NodeT* p, NodeT* q)

{
if(p==NULL)
return q;
else
return p;
}

NodeT *finderleft(NodeT *p, int givenKey)

{
if(p==NULL)
return 0;
else if(p->key==givenKey)
return p;
else
return(Compare(finderleft(p->left,givenKey),finderleft(p-
>right,givenKey)));
}

NodeT *finderright(NodeT *p, int givenKey)

{
if(p==NULL)
return 0;
else if(p->key==givenKey)
return p;
else
return(Compare(finderright(p->left,givenKey),finderright(p-
>right,givenKey)));
}

NodeT *search(NodeT *p, int givenKey)

{
NodeT *aux;
aux=p->left; // Am facut ca daca
gaseste nodul in subarborele stang
NodeT *finder_left; // sa nu mai caute si
in subarborele drept => MAI EFICIENT
finder_left=finderleft(aux,givenKey);

if(finder_left->key==givenKey)
return finder_left;
else
{
NodeT *aux_2;
aux_2=p->right;
NodeT *finder_right;
finder_right=finderright(aux_2,givenKey);
return finder_right;
}

/*if(p==NULL)
return 0;
else if(p->key==givenKey) //
recursivitate, m-o ajutat marcusucu tucu-i capu lui
return p;
else
return(Compare(search(p->left,givenKey),search(p->right,givenKey)));*/
}

NodeT *search_eficient(NodeT *p, int givenKey)

{
NodeT *aux;
if(p!=NULL)
{
if(p->key==givenKey)
return p;
else
{
aux=search_eficient(p->left,givenKey); // if(search_eficient(p-
>left,givenKey)!=NULL return AUX, else return search_eficient(p->right,givenKey);
if(aux!=NULL)
return aux;
else
return search_eficient(p->right,givenKey);
}
}
return NULL;
}
int diametrul(NodeT *p) //nu e ok diametrul asa pentru ca NU E NEAPARAT CA ACEA
CALE SA TREACA PRIN RADACINA
{
if(p == NULL)
return 0;
NodeT *st=(NodeT*)malloc(sizeof(NodeT));
st=p->left;
int h_st=inaltime_arbore(st);

NodeT *dr=(NodeT*)malloc(sizeof(NodeT));
dr=p->right;
int h_dr=inaltime_arbore(dr);

int diametru_1=h_st+h_dr+2;

int diametru_2 = diametrul(p->left);

int diametru_3 = diametrul(p->right);
return max(diametru_1, max(diametru_2,diametru_3));

void interschimbare_st_cu_dr(NodeT *p)

{
NodeT *aux=(NodeT*)malloc(sizeof(NodeT));
aux=p->left;
p->left=p->right;
p->right=aux;
}

int main()
{
FILE *f=fopen("ArboreBinar.txt","r");
if(feof(f))
{
printf("Can't open the file");
return -1;
}
NodeT *root;
 root=CreateBinTreeFromFile(f); // creez
arborele folosind datele din fisierul text

printf("Parcurgerea arborelui in preordine: ");

preorder(root); // afisez
nodurile in preordine
printf("\n");

printf("Parcurgerea arborelui in inordine: ");

inorder(root);
printf("\n");

printf("Parcurgerea arborelui in postordine: ");

postorder(root);
printf("\n");

printf("%d este numarul de frunze al arborelui\n",nr_frunze(root));

// numarul de frunze al arborelui

printf("Frunzele din arbore sunt: ");

afis_frunze(root);
printf("\n");
// frunzele arborelui

printf("%d este numarul de noduri interne al

arborelui\n",nr_noduri_interne(root));
// numarul de noduri interne (non-terminale) al arborelui

printf("Nodurile interne ale arborelui sunt: ");

afis_noduri_interne(root);
printf("\n");
// nodurile interne ale arborelui

printf("Inaltimea arborelui este: %d\n",inaltime_arbore(root));

// inaltimea arborelui

NodeT *nod_cautat=search_eficient(root,1);
printf("Inaltimea nodului cautat este %d\n",inaltime_arbore(nod_cautat));
nod_cautat=search_eficient(root,12);
printf("Inaltimea nodului cautat este %d\n",inaltime_arbore(nod_cautat));
nod_cautat=search_eficient(root,4);
printf("Inaltimea nodului cautat este %d\n",inaltime_arbore(nod_cautat));
NodeT *test=search_eficient(root,4);
printf("Inaltimea nodului cautat este %d\n",test->key);

printf("Diametrul arborelui este %d\n",diametrul(root));

//interschimbarea subarborelui stang cu cel drept

//interschimbare_st_cu_dr(root);
//preorder(root);
return 0;
}

----------------------lab 5
-----------------------------------------------------------arbore binar de cautare
--------------

#include <stdio.h>
#include <stdlib.h>

typedef struct node_type

{
int key;
struct node_type *left;
struct node_type *right;
} NodeT;

NodeT *newNode(int givenKey)

{
NodeT *p=(NodeT *)malloc(sizeof(NodeT));
p->key=givenKey;
p->left=NULL;
p->right=NULL;

return p;
}

NodeT *insertNode(NodeT *root,int givenKey)

{
if(root==NULL)
return newNode(givenKey);

if(givenKey<root->key)
root->left=insertNode(root->left,givenKey);
else if(givenKey>root->key)
root->right=insertNode(root->right,givenKey);

return root; // totdeauna returnam radacina ... nu uita boss

}

NodeT *insert_nerecursiv(NodeT *root, int givenKey)

{
if(root==NULL)
return newNode(givenKey);
else
{
NodeT *p=root;
while(p->key!=givenKey)
{
while(givenKey<p->key)
if(p->left==NULL)
p->left=newNode(givenKey);
else
p=p->left;
while(givenKey>p->key)
if(p->right==NULL)
p->right=newNode(givenKey);
else
p=p->right;
}
}
return root;
}

NodeT *search(NodeT *root, int givenKey)

{
if(root==NULL || root->key==givenKey)
 return root;

if(givenKey<root->key)
return search(root->left,givenKey);

return search(root->right,givenKey);
}

NodeT *search_nerecursiv(NodeT *root, int givenKey)

{

void preorder(NodeT *p, int level)

{
if(p!=NULL)
{
for(int i=0; i<level; i++)
printf(" ");
printf("%d \n",p->key);
level++;
preorder(p->left,level);
preorder(p->right,level);
}
}

void inorder(NodeT *p, int level)

{
if(p!=NULL)
{
inorder(p->left,++level);
for(int i=0; i<level; i++)
printf(" ");
printf("%d \n",p->key);
inorder(p->right,++level);
}
}

void postorder(NodeT *p, int level)

{
if(p!=NULL)
{
postorder(p->left,++level);
postorder(p->right,level);
for(int i=0; i<level; i++)
printf(" ");
printf("%d \n",p->key);
}
}

NodeT *findMin(NodeT *node)

{
NodeT *current;
current=node;

while(current->left!=NULL)
current=current->left;
return current;
}
NodeT *findMax(NodeT *node)
{
NodeT *current;
current=node;

while(current->right!=NULL)
current=current->right;
return current;
}

NodeT *find_succesor(NodeT *root, NodeT *p)

{
if(p->right!=NULL)
return findMin(p->right);

NodeT *succesor=(NodeT*)malloc(sizeof(NodeT));
succesor=NULL;

while(root!=NULL)
{
if(root->key>p->key)
{
succesor=root;
root=root->left;
}
else
root=root->right;
}
return succesor;

NodeT* find_predecesor(NodeT *root,NodeT *p)

{
if(p->left!=NULL)
return findMax(p->left);
else
{
NodeT *predec=(NodeT*)malloc(sizeof(NodeT));
predec=NULL;
while(root!=NULL)
{
if(root->key<p->key)
{
predec=root;
root=root->right;
}
else
root=root->left;
}
return predec;
}
}

NodeT *delNode(NodeT *root, int givenKey)

{
if(root==NULL)
 return root;

if(givenKey<root->key)
root->left=delNode(root->left,givenKey);
else if(givenKey>root->key)
root->right=delNode(root->right,givenKey);
else
{
NodeT *p;

if(root->left==NULL && root->right!=NULL)

{
p=root->right;
free(root);
return p;
}
else if(root->left!=NULL && root->right==NULL)
{
p=root->left;
free(root);
return p;
}
else if(root->left==NULL && root->right==NULL)
{
free(root);
return NULL;
}
else
{
p=findMin(root->right); // gasim succesorul
root->key=p->key; // inlocuim cheia radacinii cu cheia succesorului
root->right=delNode(root->right,p->key); // stergem succesorul, care
se afla in dreapta radacinii , eazy think eazy
}

}
return root;
}

int main()
{
//ex1
int level=0;
NodeT *root;
root=NULL;
root=insert_nerecursiv(root,15);
insert_nerecursiv(root,6);
insert_nerecursiv(root,18);
insert_nerecursiv(root,20);
insert_nerecursiv(root,17);
insert_nerecursiv(root,7);
insert_nerecursiv(root,13);
insert_nerecursiv(root,3);
insert_nerecursiv(root,2);
insert_nerecursiv(root,4);
insert_nerecursiv(root,9);
printf("Parcurgerea in preordine: \n");
preorder(root,level);
printf("\n");
 printf("Parcurgerea in inordine: \n");
inorder(root,level);
printf("\n");
printf("Parcurgerea in postordine: \n");
postorder(root,level);
printf("\n");

NodeT *p=search(root,15);
printf("%d este cheia nodului care a fost cautat !\n",p->key);

NodeT *min=findMin(p);
printf("%d este nodul cu valoarea minima pentru subarborele cu radacina
%d !\n",min->key,p->key);

NodeT *max=findMax(p);
printf("%d este nodul cu valoarea maxima pentru subarborele cu radacina
%d !\n",max->key,p->key);

NodeT *node=p;
NodeT *succesor = find_succesor(root,node);
printf("%d este succesorul nodului %d !\n",succesor->key,node->key);

NodeT *predecessor = find_predecesor(root,node);

printf("%d este predecesorul nodului %d !\n",predecessor->key,node->key);

NodeT *nod_sters=delNode(root,4);
printf("Nodul care a fost sters este: %d\n",nod_sters->key);
preorder(root,level);
return 0;
}
------------------------lab 6
-------------------------------------------------------------
~~~~~~~~~~~~~chaining~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
#include <stdio.h>
#include <stdlib.h>
#define M 7 //dimensiunea tabelei de dispersie

typedef struct cell //// e exact ca la o lista structura

{
int val; // asta ar fi key
struct cell *next, *prev;
} NodeT;

int hFunction(int key)

{
return key%M; //// functia returneaza acea functie de dispersie,
CHEIA % nr_elem
}

NodeT* search(NodeT* hTable[M], int key)

{
int i=hFunction(key);
NodeT *p;
p=hTable[i];
 while(p!=NULL && p->val!=key)
{
p=p->next;
}

if(p==NULL)
return 0;
else
return p;
}

void insert(NodeT* hTable[M], int key)

{
int i=hFunction(key);
NodeT* p=(NodeT*)malloc(sizeof(NodeT));
p->val=key;
p->prev=NULL;
p->next=NULL;

if(hTable[i]==NULL)
{
hTable[i]=p;
}
else
{
NodeT *q=hTable[i];
/*while(q->next!=NULL)
q=q->next;

q->next=p;
p->prev=q; */

p->next=q;
q->prev=p;
hTable[i]=p; //// acasa am inserat la final ca un tampit ...
}
}

void deleteKey(NodeT* hTable[M], int key)

{
int i=hFunction(key);
NodeT *p=search(hTable,key);
if(p!=NULL)
{
if(hTable[i]==p && p->next==NULL) //// daca avem un singur element la
pozitia respectiva
hTable[i]=NULL;
else if(hTable[i]==p && p->next!=NULL) //// daca e primul element, dar mai
avem elemente dupa
{
p->next->prev=NULL;
hTable[i]=p->next;
}
else if(p->prev!=NULL && p->next==NULL) //// daca e ultimul element din
lista de la pozitia respectiva
{
p->prev->next=NULL;
}
 else //// daca elementul se afla intre
alte doua elemente din lista
{
p->prev->next=p->next;
p->next->prev=p->prev;
}
}

//afisarea tuturor elmentelor din tebela de dispersie

void showAll(NodeT* hTable[M])
{
int i;
for(i = 0; i < M; i++)
{
printf(" %d :",i);
//verificam daca la slotul i am adaugat ceva
if(hTable[i] != NULL)
{

NodeT *p;
p = hTable[i];
while (p != NULL)
{
printf(" %d ",p->val);
p = p->next;
}
}
printf("\n");
}
printf("\n");
}

int main()
{

// tabela de dispersie
NodeT* hTable[M]; //// toata diferenta e ca, in loc de o singura lista,
avem UN VECTOR DE LISTE(7 LISTE)
int i,n,x;
//initializam tabelul nostru de dispersie
for(i = 0; i < M; i++)
{
hTable[i] = NULL; //// hTable ar fi ca un fel de first, deci il punem
NULL la fiecare lista pt inceput
}

//inseram un nou element in tabel

insert(hTable, 36); //// rest 1
insert(hTable, 18); //// rest 4
insert(hTable, 6); //// rest 6
insert(hTable, 43); //// rest 1
insert(hTable, 72); //// rest 2

insert(hTable, 10); //// rest 3

insert(hTable, 5); //// rest 5
insert(hTable, 15); //// rest 1
 //// verific functia de cautare
NodeT *cautare=NULL;
cautare=search(hTable, 15);
if(cautare==0)
printf("NULL FRATICA\n");
else
printf("%d \n",cautare->val);

//afisam toate elementele

showAll(hTable);
//stergere
deleteKey(hTable, 10);
deleteKey(hTable, 36);

printf("Dupa stergeri, tabela de dispersie arata asa: \n");

//afisam toate elementele din tabel din nou
showAll(hTable);

return 0;
}

~~~~~~~~~~~~~~~~adresare deschisa, linear quadratic, double

hashing~~~~~~~~~~~~~~~~~~~
#include <stdio.h>
#include <stdlib.h>

typedef struct cell

{
int val;
int status;
} Cell;

enum { FREE, OCCUPIED };

void afisare(Cell *T, int m)

{
int i;
printf("\n\nTabela de dispersie este \n");
for (i = 0; i < m; i++)
{
if(T[i].status == OCCUPIED)
printf("T[%d]=%d\n",i,T[i]);
else
printf("T[%d]= --\n",i);

}
}

//verificam daca toata tabela e ocupata

int hash_table_occupied(Cell *T, int m)
{
int i;
for (i = 0; i < m; i++)
{
if (T[i].status == FREE) return 0;
}
 return 1;
}

int h_prime(int k, int m)

{
return k % m;
}

//returneaza pozitia la care se va verifica tabela de dispersie folosind

verificarea liniara
int linear_probing(int k, int m, int i)
{
//h(k, i) = (h’(k)+i) mod m
int val = (h_prime(k,m) + i ) % m;
return val;
}

void insert_linear_probing(int k, Cell *T, int m)

{

if (hash_table_occupied(T, m))
{
printf("Nu se mai poate insera cheia %d, tabela este plina \n", k);
return;
}
int i = 0;
int collision = 1;
int h = 0;
do
{
h = linear_probing(k, m, i);
if (T[h].status == FREE)
collision = 0;
else i++;
}
while (collision);
T[h].status = OCCUPIED;
T[h].val = k;
}

int quadratic_probing(int k, int m, int i)

{
int val = ((h_prime(k,m)+i+(i*i))%m);
return val;
}

void insert_quadratic_probing(int k, Cell *T, int m)

{
int i=0;
int poz;
int colision = 1;

if (hash_table_occupied(T, m))
{
printf("Nu se mai poate insera cheia %d, tabela este plina \n", k);
return;
}
 do
{
poz = quadratic_probing(k,m,i);
i++;
if(T[poz].status==FREE)
colision = 0;
}
while(colision);

T[poz].val=k;
T[poz].status=OCCUPIED;
}

int double_hashing(int k, int m, int i)

{
int val=((h_prime(k,m) + (i * ( 5- (h_prime(k,5))))) % m );
return val;
}

void insert_double_hashing(int k, Cell *T, int m)

{
int i=0;
int colision=1;
int poz;

if(hash_table_occupied(T,m)==1)
{
printf("Tabelul este plin! \n");
return;
}

do
{
poz = double_hashing(k,m,i);
i++;
if(T[poz].status==FREE)
colision=0;
}
while(colision);

T[poz].val=k;
T[poz].status=OCCUPIED;
}

void set_table_free(Cell *T, int m)

{
//initializam tabela
int i;
for (i = 0; i<m; i++)
{
T[i].status = FREE;
}

int main()
{
int m = 7;
Cell *T = (Cell*) malloc(m*sizeof(Cell)); //tabela de dispersie - se aloca

set_table_free(T, m);
afisare(T, m);
insert_linear_probing(19, T, m);
insert_linear_probing(36, T, m);
insert_linear_probing(5, T, m);
insert_linear_probing(21, T, m);
insert_linear_probing(4, T, m);
insert_linear_probing(26, T, m);
insert_linear_probing(14, T, m);
insert_linear_probing(17, T, m);
afisare(T, m);

//resetam tabela
set_table_free(T, m);
afisare(T, m);
insert_quadratic_probing(19, T, m);
insert_quadratic_probing(36, T, m);
insert_quadratic_probing(5, T, m);
insert_quadratic_probing(21, T, m);
insert_quadratic_probing(4, T, m);
insert_quadratic_probing(26, T, m);
insert_quadratic_probing(14, T, m);
insert_quadratic_probing(17, T, m);
afisare(T, m);

//resetam tabela
set_table_free(T, m);
afisare(T, m);
insert_double_hashing(19, T, m);
insert_double_hashing(36, T, m);
insert_double_hashing(5, T, m);
insert_double_hashing(21, T, m);
insert_double_hashing(4, T, m);
insert_double_hashing(26, T, m);
insert_double_hashing(14, T, m);
insert_double_hashing(17, T, m);
afisare(T, m);

free(T);
return 0;
}