Znajdź największe poddrzewo bez duplikatów w danym BST

Question

Nowe wierzchołki wkładam do drzewa następująco: lewy < korzeń <= prawy. Przez ,,największe poddrzewo" rozumiem takie o największej wysokości.

Mój program działa następująco:

1. Zacznij od odwiedzenia korzenia

2. Zbadaj poddrzewo w każdym odwiedzonym wierzchołku, aby zobaczyc czy zawiera duplikaty, w     nastepujący sposob:

a) sprawdz czy prawy syn nie jest taki sam jak ojciec

b) jesli nie, to sprawdzaj kolejnych lewych synow

3. Jesli zawiera, zakolejkuj synow do kolejnego przejscia

4. Jesli nie, zbadaj wysokosc poddrzewa i wprowadz nowy element do listy

5. Znajdz element listy o największej wysokości.

Funckja sprawdzająca czy dane drzewo ma duplikaty działa poprawnie. Mam jednak problem z operacjami na liście, której elementami są wskazniki do korzeni poddrzew bez duplikatów.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>
#define MAX_Q_SIZE 500 

typedef struct vertex {
    int klucz;
    struct vertex *lewy;
    struct vertex *prawy;
} vertex, *pvertex;

typedef struct NondupeSubtree { //elementy kolejki priorytetowej
    struct vertex *root;
    //int height; // im wieksza, tym wiekszy priorytet
    struct NondupeSubtree *next;
} NondupeSubtree, *pNondupeSubtree; 

//.................................................................

int CzyMaDuplikaty_temp(pvertex v,int k);

int CzyMaDuplikaty(pvertex t){

    if(t==NULL)
        return 0;
    int k = t->klucz; 
    pvertex v = t->prawy;

    if(CzyMaDuplikaty_temp(v,k))
        return 1;
    // CzyWlasciwePoddrzewo_temp(t->prawy);
}

int CzyMaDuplikaty_temp(pvertex v,int k){
    //gdzie "v" to wskaznik korzenia prawego syna t
    //a "k" to t->klucz

    // puste poddrzewo jest ok 
    if (v==NULL)  
        return 0; 
    if (v->klucz == k) 
    // bo w programie wrzucam wartosci rowne korzeniowi do prawego poddrzewa
    // jesli dziecko jest rowne ojcowi, to mamy duplikat 
        return 1;
    //teraz w prawym poddrzewie sprawadzam czy nie ma po lewej stronie szukanego k
    if(v->klucz > k)
        return CzyMaDuplikaty_temp(v->lewy,k);  
}

int CzyMaDuplikaty_total(pvertex root) 
{ 
    int rear, front; 
    pvertex *queue = createQueue(&front, &rear); 
    pvertex temp_vertex = root; 


    while (temp_vertex) 
    { 
        if(CzyMaDuplikaty(temp_vertex))
            return 1;
        // Enqueue lewy child 
        if (temp_vertex->lewy) 
            enQueue(queue, &rear, temp_vertex->lewy); 

        // Enqueue prawy child 
        if (temp_vertex->prawy) 
            enQueue(queue, &rear, temp_vertex->prawy); 

        // Dequeue wierzcholek i robie z niego temp_vertex
        temp_vertex = deQueue(queue, &front); 
    } 
} 

pvertex MaxHeightTree(pNondupeSubtree head)
{
  pNondupeSubtree p, pmax;
  pmax = head;
  if(head)
    for(p = head->next; p; p = p->next)
      if(Height(p->root) > Height(pmax->root)) 
        pmax = p;
  return pmax->root;
} 

// /* Print all the elements in the linked list */
// void print(pNondupeSubtree head) {
//   pNondupeSubtree current_node = head;
//   while ( current_node != NULL) {
//     printf("%d ", current_node->data);
//     current_node = current_node->next;
//   }
// }
pvertex Funkcja(pvertex t, pNondupeSubtree pq) 
{ 
    int rear, front; 
    pvertex *queue = createQueue(&front, &rear); 
    pvertex temp_vertex = t; 


    while (temp_vertex){ 
        if(!CzyMaDuplikaty(temp_vertex)){
          printf("aaaaa");
            // if(isEmpty(&pq)){

            //     pq->next = newNode(temp_vertex);
            //     pq=pq->next;
            //     printf("aaa\n");
            // }
            pq->next = insert_top(temp_vertex, pq);
            pq=pq->next;
            MaxHeightTree(pq);
            temp_vertex = deQueue(queue, &front); 
        }


        else{

            //Kolejkuje lewe dziecko
            if (temp_vertex->lewy) 
                enQueue(queue, &rear, temp_vertex->lewy); 

            //Kolejkuje prawy dziecko 
            if (temp_vertex->prawy) 
                enQueue(queue, &rear, temp_vertex->prawy); 

            /*Dequeue vertex and make it temp_vertex*/
            temp_vertex = deQueue(queue, &front); 
        }
    }
     
}
int main()
{
  int input; 
  pNondupeSubtree head;
  head = (pNondupeSubtree)malloc(sizeof(NondupeSubtree)); 
  pvertex t, prev_t, next_t;
  t = (pvertex)malloc(sizeof(vertex));;

  /* Display Menu */
   
   printf("Dostepne komendy:\n");
    
        printf("1 <Stworz losowe drzewo BST.>\n");
        printf("2 <Wstaw wierchołek o danym kluczu.>\n");
        printf("3 <Czy drzewo ma duplikaty?>\n");
        printf("4 <Najwieksze drzewo bez duplikatow.>\n");
        printf("5 <Koniec.>\n");
        printf(".............................................\n");
    do{ 
        scanf("%d", &input);
     
        if (input == 1){
            int i;
            srand (time(NULL));


            printf("Wprowadz liczbę wierzchołków\n");
            int n;
            scanf("%d",&n);

            for (i = 0; i < n; i++)
                t = InsertBST(t, rand() % 1000);
            DisplayTree(t);
            continue;
        }         
        else if (input == 2){
            printf("Wprowadz klucz\n");
            int k;
            scanf("%d", &k);
                
            InsertBST(t, k);
            DisplayTree(t);
            continue;
        }

        else if (input == 3){
        
            if(CzyMaDuplikaty_total(t))
                printf("Drzewo ma duplikaty.\n");
            else
                printf("Drzewo nie ma duplikatow.\n");
            continue;
        }       

        else if (input ==4){
            printf("Najwieksze drzewo bez duplikatow to: \n");   
            DisplayTree(Funkcja(t, head));
            continue;

        }  
        else if (input == 5)
            break;
        else{
            printf("Prosze wprowadzic prawidlowe polecenie.\n"); 
            continue; 
        }    
    }while(input!= 5);

    return 0;
}