Hvordan konvertere et binært tre til binært søketre på stedet, dvs. vi kan ikke bruke noen ekstra plass

En binærtreet vanligvis er et binært søketre, i så fall ingen konvertering er nødvendig.

Kanskje du trenger å avklare strukturen av hva du konverterer fra. Er din kilde treet ubalansert? Er det ikke bestilt av nøkkelen du vil søke på? Hvordan fikk du kommer til kilden treet?

Vel, hvis dette er et intervju spørsmålet, det første jeg ville blurt ut (med null selve tanken) er dette: gjenta hele binære rekursivt og og finne det minste elementet. Ta den ut av binære treet. Nå gjenta prosessen der du gjenta hele treet og finne det minste elementet, og legge den som en forelder av den siste element som finnes (med foregående element bli den nye nodens venstre barn). Gjenta så mange ganger som nødvendig inntil den opprinnelige treet er tom. På slutten, er du igjen med den verst tenke sorterte binærtreet - en lenket liste. Pekeren peker til rotnoden, som er den største element.

Dette er en fryktelig algoritme all-around - O (n ^ 2) gangtid med den verst tenkebinærtreet utgang, men det er en anstendig utgangspunkt før du kommer opp med noe bedre, og har fordelen av at du er i stand til å skrive koden for den i ca 20 linjer på en tavle.

Gjør inorder traversering av det binære treet og lagre resultatet. sortere resultatet i acending orden danne binært søketre ved å ta midt element av den sorterte listen som root (dette kan gjøres ved hjelp av binære søk). så vi får balansert binært søketre.

Har følgende algoritme for å nå løsningen.

1) finne den for etterfølgeren uten å bruke noe plass.

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) Gjør for traversering uten å bruke plass.

a) Finn den første noden inorder traversering. Det bør forlot de fleste barn av treet hvis den har, eller venstre side av første til høyre barn hvis den har, eller høyre barnet selv. b) Bruk ovenfor algoritme for å finne ut inoder etterfølger av første noden. c) Gjenta trinn 2 for alle de returnerte etterfølger.

Bruk over to algoritme og gjøre for overgang på binærtreet uten å bruke ekstra plass. Danner det binære søketre når du gjør traversering. Men kompleksiteten er O(N2)worst case.

heap slags treet .. nlogn kompleksitet ..

Gjør Postorder overgang og fra det skape et binært søketre.

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

Konvertere Binary Tre til en dobbeltlenket liste-kan gjøres inplace i O (n)
Deretter sortere det ved hjelp av flettesortering, nlogn
konvertere listen tilbake til et tre - O (n)

Enkelt nlogn løsning.

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