Come convertire un albero binario di albero binario di ricerca sul posto, vale a dire, non possiamo usare qualsiasi spazio extra

Un albero binario di solito è un albero binario di ricerca, nel qual caso non è necessaria alcuna conversione.

Forse avete bisogno di chiarire la struttura di quello che si esegue la conversione. È il vostro albero dei sorgenti non bilanciata? Non è forse ordinato dal tasto che si desidera cercare? Come sei arrivato a l'albero dei sorgenti?

Beh, se questo è un questione intervista, la prima cosa che vorrei spifferare (da zero pensiero reale) è questo: iterare l'intero binario in modo ricorsivo e e trovare l'elemento più piccolo. Tirarla fuori della albero binario. Ora, ripetere il processo in cui si itera l'intero albero e trovare il più piccolo elemento e aggiungerlo come un genitore dell'ultimo elemento trovato (con l'elemento precedente diventare figlio sinistro del nuovo nodo). Ripetere tante volte quanto necessario fino a quando l'albero originale è vuota. Alla fine, si sono lasciati con la peggiore possibile albero binario ordinata - una lista collegata. Il puntatore punta al nodo radice, che è l'elemento più grande.

Si tratta di un orribile algoritmo di all-around - O (n ^ 2) tempo di esecuzione con la peggiore possibile uscita albero binario, ma è un punto di partenza decente prima di venire con qualcosa di meglio e ha il vantaggio di voi di essere in grado di scrivere il codice per in circa 20 linee su una lavagna.

Fare ordine simmetrico dell'albero binario e memorizzare il risultato. ordinare il risultato per formare l'albero binario di ricerca prendendo elemento centrale della lista ordinata come root acending (questo può fare usando la ricerca binaria). in modo da ottenere equilibrato albero binario di ricerca.

Non seguente algoritmo per raggiungere la soluzione.

1) trovare il successore al fine senza l'utilizzo di qualsiasi spazio.

Node InOrderSuccessor(Node node)
{ 
    if (node.right() != null) 
    { 
        node = node.right() 
        while (node.left() != null)  
            node = node.left() 
        return node 
    }
    else
    { 
        parent = node.getParent(); 
        while (parent != null && parent.right() == node)
       { 
            node = parent 
            parent = node.getParent() 
        } 
        return parent 
    } 
} 

2) fare ordine di attraversamento senza utilizzare spazio.

a) Trovare il primo nodo di ordine simmetrico. Dovrebbe lasciato la maggior parte del bambino dell'albero se ha, o di sinistra del primo figlio a destra se ha, o se stesso figlio destro. b) Utilizzare algoritmo di cui sopra per scoprire inoder successore del primo nodo. c) Ripetere il passaggio 2 per tutti il ​​successore restituito.

Utilizzare sopra 2 algoritmo e fare l'in ordine di attraversamento su albero binario senza l'utilizzo di spazio in più. Formare l'albero binario di ricerca quando si fa l'attraversamento. Ma la complessità è O(N2)peggiore dei casi.

mucchio sorta l'albero .. complessità nlogn ..

Fare la postorder Traversal e da quella di creare un albero binario di ricerca.

struct Node * newroot = '\0';

struct Node* PostOrder(Struct Node* root)
{
      if(root != '\0')
      {
          PostOrder(root->left);
          PostOrder(root->right);
          insertBST(root, &newroot);
      }
}

insertBST(struct Node* node, struct Node** root)
{
   struct Node * temp, *temp1;
   if( root == '\0')
   {
      *root == node;
       node->left ==  '\0';
       node->right == '\0';
   }
   else
   {
       temp = *root;
       while( temp != '\0')
       {
           temp1= temp;
           if( temp->data > node->data)
               temp = temp->left;
           else
               temp = temp->right;
       }
       if(temp1->data > node->data)
       {
           temp1->left = node;
       }
       else
       {
           temp1->right = node;
       }
       node->left = node->right = '\0';
    }
}

Convertire albero binario a una lista- doppiamente legato può essere fatto inplace in O (n)
quindi ordinare utilizzando merge sort, nlogn
convertire l'elenco di nuovo ad un albero - O (n)

soluzione nlogn semplice.

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

typedef int data_t;

struct tree_node {
    struct tree_node * left;
    struct tree_node * right;
    data_t data;
};

        /* a bonsai-tree for testing */
struct tree_node nodes[10] =
{{ nodes+1, nodes+2, 1}
,{ nodes+3, nodes+4, 2}
,{ nodes+5, nodes+6, 3}
,{ nodes+7, nodes+8, 4}
,{ nodes+9, NULL, 5}
,{ NULL, NULL, 6}
,{ NULL, NULL, 7}
,{ NULL, NULL, 8}
,{ NULL, NULL, 9}
        };

struct tree_node * harvest(struct tree_node **hnd)
{
struct tree_node *ret;

while (ret = *hnd) {
        if (!ret->left && !ret->right) {
                *hnd = NULL;
                return ret;
                }
        if (!ret->left ) {
                *hnd = ret->right;
                ret->right = NULL;;
                return ret;
                }
        if (!ret->right) {
                *hnd = ret->left;
                ret->left = NULL;;
                return ret;
                }
        hnd = (rand() &1) ? &ret->left : &ret->right;
        }

return NULL;
}

void insert(struct tree_node **hnd, struct tree_node *this)
{
struct tree_node *ret;

while ((ret= *hnd)) {
        hnd = (this->data  < ret->data ) ? &ret->left : &ret->right;
        }
*hnd = this;
}

void show(struct tree_node *ptr, int indent)
{
if (!ptr) { printf("Null\n"); return; }

printf("Node(%d):\n", ptr->data);
printf("%*c=", indent, 'L');  show (ptr->left, indent+2);
printf("%*c=", indent, 'R');  show (ptr->right, indent+2);
}

int main(void)
{
struct tree_node *root, *this, *new=NULL;

for (root = &nodes[0]; this = harvest (&root);  ) {
        insert (&new, this);
        }

show (new, 0);
return 0;
}

struct Node
{
    int value;
    Node* left;
    Node* right;
};

void swap(int& l, int& r)
{
    int t = l;
    l = r;
    r = t;
}

void ConvertToBST(Node* n, Node** max)
{
    if (!n) return;

    // leaf node
    if (!n->left && !n->right)
    {
        *max = n;
        return;
    }

    Node *lmax = NULL, *rmax = NULL;
    ConvertToBST(n->left, &lmax);
    ConvertToBST(n->right, &rmax);

    bool swapped = false;
    if (lmax && n->value < lmax->value)
    {
        swap(n->value, lmax->value);
        swapped = true;
    }

    if (rmax && n->value > rmax->value)
    {
        swap(n->value, n->right->value);
        swapped = true;
    }

    *max = n;
    if (rmax && rmax->value > n->value) *max = rmax;

    // If either the left subtree or the right subtree has changed, convert the tree to BST again
    if (swapped) ConvertToBST(n, max);
}