Cum de a converti un arbore binar pentru arbore binar de căutare în loc, adică, nu putem folosi nici un spațiu suplimentar

Un arbore binar , de obicei , este un arbore binar de căutare, în cazul în care este necesară nici o conversie.

Poate că aveți nevoie pentru a clarifica structura a ceea ce sunt de conversie de la. Este arborele sursă dezechilibrată? Nu este comandat de tasta pe care doriți să căutați pe? Cum ai ajuns la arborele sursă?

Ei bine, în cazul în care acest lucru este o întrebare de interviu, primul lucru pe care l-aș izbucnesc (cu gândul la zero reală) este aceasta: itera întregul binar recursiv și și pentru a găsi cel mai mic element. Ia-l din copac binar. Acum, repetați procesul în care itera întregul copac și pentru a găsi cel mai mic element, și adăugați-l ca părinte al ultimului element găsit (cu elementul anterior devenind copil stâng nou nodului). Se repetă de câte ori este necesar, până când arborele original este gol. La final, au rămas cu cel mai rău posibil arbore binar sortat - o listă legată. indicatorul este îndreptat spre nodul rădăcină, care este cel mai mare element.

Acesta este un algoritm oribil all-in jurul - O (n ^ 2) timpul de funcționare cu cel mai rău posibil ieșire arbore binar, dar este un punct de plecare decent înainte de a veni cu ceva mai bun și are avantajul de a vă fi capabil să scrie codul ea în aproximativ 20 de linii pe o tablă albă.

Do inordine Traversarea arborelui binar și stoca rezultatul. sortați rezultatul pentru a forma arborele binar de căutare luând elementul de mijloc al listei sortată ca root acending (acest lucru se poate face cu ajutorul binar de căutare). așa că vom obține arbore echilibrat binar de căutare.

Nu următorul algoritm pentru a ajunge la soluția.

1) găsi o în ordine succesoare fără a utiliza orice spațiu.

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) Do pentru parcurgeri fără a utiliza spațiu.

a) Găsiți primul nod al traversal inordine. Ar trebui lăsat cea mai mare copil al copacului dacă are, sau la stânga primului copil drept în cazul în care are, sau în sine a copilului drept. b) utilizarea de mai sus algoritm pentru a afla inoder succesor al primului nod. c) Repetați pasul 2 pentru toți succesorul returnat.

Utilizați 2 de mai sus algoritm și de a face în ordine pe Traversarea arborelui binar fără a utiliza spațiu suplimentar. Forma arborele binar de căutare atunci când faci traversal. Dar complexitatea este O(N2)cel mai rău caz.

morman sortare copac .. complexitatea nlogn ..

Face postordine traversal și de la care a crea un arbore binar de căutare.

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';
    }
}

Conversia binar la un copac legat de două ori lista- se poate face INPLACE în O (n)
Apoi , ordonați - l folosind îmbinare de sortare, nlogn
Conversia lista înapoi la un copac - O (n)

Soluție nlogn simplă.

#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);
}