/* PEMET ( TREE ) */

/* IMPLEMENTIMI I PEMES */
// Femijet e pemes
typedef struct tree_node *tree_ptr;
struct tree_node
{
element_type element;
tree_ptr first_femije;
tree_ptr next_vella;
};
// Implementimi i pemes binare
typedef struct tree_node *tree_ptr;
struct tree_node
{
element_type element;
tree_ptr left;
tree_ptr right;
};
typedef tree_ptr TREE;
// Deklarimi i nje peme binare kerkimi
typedef struct tree_node *tree_ptr;
struct tree_node
{
element_type element;
tree_ptr left;
tree_ptr right;
};
typedef tree_ptr SEARCH_TREE;
/* Operatoret per PBK */
// Operatori inicializo PBK
SEARCH_TREE make_null ( void )
{
return NULL;
}
/* Operatori gjej , Kthen nje pointer ne nyjen e pemes e cila ka vleren e celesit
X, ose
NULL nqs nuk ka nje nyje te tille ne peme. Struktura e pemes e ben
kete veprim te thjeshte. */
tree_ptr gjej( element_type x, SEARCH_TREE T )
{
if( T == NULL )
return NULL;
if( x < T->element )
return( gjej( x, T->left ) );
else
if( x > T->element )
return( gjej( x, T->right ) );
else
return T;
}

/* Operatori MIN MAX, Kthen nje pointer ne elementin me te madh ose me te vogel
ne peme.
Per operatorin gjejMin fillohet kontrolli ne rrenjen e pemes dhe shkohet
gjithmone majtas per aq kohe sa ekziston nje femije i majte. Pozicioni ku
ndalohet eshte pozicioni i elementit me celes me te vogel ne pemen
binare te kerkimit.
Operatori gjejMax implementohet ne menyre te ngjashme me gjejMin
vetem se kerkimi behet gjithmone ne drejtim te femijes se djathte.
Do ti implementojme keto operatore ne dy menyre: Me ane te
perdorimit te logjikes se kursive dhe asaj iterative. */
// Operatori i gjetjes se vleres minimum ne PBK (Implementimi rekursiv)
tree_ptr gjejMin( SEARCH_TREE T )
{
if( T == NULL )
return NULL;
else
if( T->left == NULL )
return( T );
else
return(gjejMin( T->left ) );
}
// Operatori i gjetjes se vleres maximum ne PBK ( Implementimi iterativ)
tree_ptr gjejMax( SEARCH_TREE T )
{
if( T != NULL )
while( T->right != NULL )
T = T->right;
return T;
}

/* Operatori i shtimit, Per te shtuar X ne nje pemeT, levizim ne peme njelloj sikur
jemi duke
kerkuar nje vlere X ne peme. Nqs X gjendet nuk bejme asgje.
Perndryshe, shtohet X ne pozicionin e fundit te vizituar.
Per te shtuar vleren 5, vizitojme elementet e pemes si ne rastin e
operatorit gjej. Kur arrijme ne nyjen me celes 4, na duhet te shkojme
ne te djathte, por nuk ka nenpeme te djathte. Rrjedhimisht 5 nuk
ndodhet ne peme dhe pozicioni ku jemi eshte vendi i duhur per te
vendosur elementin e ri. */
// Operatori i shtimit ne PBK
tree_ptr insert( element_type x, SEARCH_TREE T )
{
if( T == NULL )
{ /*Krijon dhe kthen nje peme me nje nyje */
T = (SEARCH_TREE) malloc ( sizeof (struct tree_node) );
if( T == NULL )
fatal_error("mungese kujtese!!!");
else
{
T->element = x;
T->left = T->right = NULL;
}
}
else
if( x < T->element )
T->left = insert( x, T->left );
else
if( x > T->element )
T->right = insert( x, T->right );
/* perndryshe x ndodhet aktualisht ne
peme. Nuk do te bejme asgje. */
return T; /* Mos harroni kete rresht!! */
}

/* Operatori i fshirjes, Pasi kemi gjetur nyjen qe do fshijme, duhet te konsiderojme

disa
raste:
1) Nqs nyja eshte gjethe ajo mund te fshihet menjehere.
2) Nqs nyja ka nje femije, nyja mund te fshihet pasi prindi i tij te
kete modifikuar pointerin e tij per te kapercyer kete nyje. Pas
kesaj nyjes qe duhet te fshihet nuk referohet asnje pointer i
PBK.
3) Rasti me i nderlikuar lidhet me situaten kur nyja qe duhet te
fshihet ka dy femije. Ne pergjithesi mund te zevendesohet celesi i
kesaj nyje me celesin me te vogel te nenpemes se djathte (qe gjehet
lehtesisht) dhe ne menyre rekursive fshihet ajo nyje. Mqs nyja me e
vogel ne nenpemen e djathte nuk mund te kete femije te majte,
fshirja e dyte eshte rast i thjeshte. */
// Operatori i fshirjes
tree_ptr delete(element_type x, SEARCH_TREE T)
{
tree_ptr tmp_cell, child;
if( T == NULL )
error(Elementi nuk u gjend");
else
if( x < T->element ) /* kalo majtas*/
T->left = delete( x, T->left );
else
if( x > T->element ) /* Kalo djathtas*/
T->right = delete( x, T->right );
else /* U gjet elementi qe do fshihet */
if( T->left && T->right ) /* dy femije*/
{ /* Zevendeso me me te voglin ne nenpemen e djathte */
tmp_cell = find_min( T->right );
T->element = tmp_cell->element;
T->right = delete( T->element, T->right );
}
else /* nje femije*/
{
tmp_cell = T;
if( T->left == NULL ) /* vetem nje femije i djathte*/
child = T->right;
if( T->right == NULL ) /* vetem nje femije i majte*/
child = T->left;
free( tmp_cell );
return child;
}
return T;
}

/* BREDHJET NE PEME */
/* Perkufizim: te bredhesh ne nje peme do te thote te trajtosh
cdo kulm te saj nje dhe vetem nje here sipas nje renditjeje. */
// Funksioni rekursiv per bredhjen nder-rendore
void nderrendore(struct node *p)
{
if(p!=NULL)
{
nderrendore(p->left);
printf(Vlera :%d\n",p->element);
nderrendore(p->right);
}
else
return;
}
// Funksioni rekursiv per bredhjen pararendore
void pararendore(struct node *p)
{
if(p!=NULL)
{
printf(Vlera :%d\n",p->element);
pararendore(p->left);
pararendore(p->right);
}
else
return;
}
// Funksioni rekursiv per bredhjen pasrendore
void pasrendore(struct node *p)
{
if(p!=NULL)
{
pasrendore(p->left);
pasrendore(p->right);
printf(Vlera :%d\n",p>element);
}
else
return;
}

// Funksion iterativ pararendore

void iterativePararendore(nodePema *root)
{
nodePema *save[100];
int top = 0;
if (root == NULL)
{
return;
} save[top++] =
root;
while (top != 0)
{
root = save[--top];
printf("[%d] ", root->value);
if (root->right != NULL)
save[top++] = root->right;
if (root->left != NULL)
save[top++] = root->left;
}
}
// Funksioni iterativ pasrendore
void iterativPasrendore(nodePema *root)
{s
truct
{
nodePema *node;
int vleft ; // Eshte vizituar majtas?
int vright; // Eshte vizituar djathtas?
}save[100];
int top = 0;
save[top++].node = root;
save[top].vleft = 0;
while ( top != 0 )
{/
* Kalo ne nenpemen e majte nqs ekziston dhe nuk eshte
vizituar*/
if(root->left != NULL && !save[top].vleft)
{
save[top].vleft = 1;
save[top++].node = root;
root = root->left;
continue;
}
/* Kalo ne nenpemen e djathte nqs ekziston dhe
nuk eshte vizituar */
if(root->right != NULL && !save[top].vright )
{
save[top].vright = 1;
save[top++].node = root;
root = root->right;
continue;
}
printf("[%d] ", root->value);
/* pastrohet stiva*/
save[top].vleft = 0;
save[top].vright = 0;

/* ecen nje hap*/

root = save[--top].node;
}
}

// Funksioni iterativ nder-rendore

void iterativNderrendore (nodePema *root)
{
nodePema *save[100];
int top = 0;
while(root != NULL)
{
while (root != NULL)
{
if (root->right != NULL)
{
save[top++] = root->right;
}s
ave[top++] = root;
root = root->left;
}r
oot = save[--top];
while(top != 0 && root->right == NULL)
{
printf("[%d] ", root->value);
root = save[--top];
}p
rintf("[%d] ", root->value);
root = (top != 0) ? save[--top] : (nodePema *) NULL;
}
}

/* Bredhja ne gjeresi */
/* Struktura per implementimin e bredhjes ne gjeresi */
typedef struct node
{
int vlera;
struct node *right;
struct node *left;
}nodePema;
nodePema *root;

// Funksioni bredhje ne gjeresi

void bredhjeGjeresi(nodePema *root)
{
nodePema *queue[100] = {(nodePema *)0};
int size = 0;
int queue_pointer = 0;
while(root)
{
printf("[%d] ", root->vlera);
if(root->left)
{
queue[size++] = root->left;
}
if(root->right)
{
queue[size++] = root->right;
}
root = queue[queue_pointer++];
}
}
// Funksioni per gjetjen e thellesises se pemes
int thellesia( TREE T )
{
if( T == NULL )
return -1;
else
return ( max(thellesia(T->left),
thellesia(T->right) ) + 1 );
}