Hoe maak je een binaire boom te zetten in binaire zoekboom in-place, dat wil zeggen, we kunnen geen gebruik maken van extra ruimte

Een binaire boom meestal is een binaire zoekboom, in welk geval geen conversie nodig is.

Misschien moet je de structuur van wat je converteren van verduidelijken. Is uw source tree onevenwichtig? Is het niet in opdracht van de toets die u wilt zoeken aan de hand? Hoe kwam u bij de bron boom?

Nou, als dit is een interview vraag, het eerste wat ik zou flappen uit (met nul werkelijke denken) is dit: herhaal het gehele binaire recursief en en vind de kleinste element. Neem het uit van de binaire boom. Nu, herhaal het proces waar u de gehele structuur niet herhalen en vind de kleinste element en voeg het als een ouder van de laatste gevonden (met de vorige element steeds linker kind van de nieuwe node) element. Herhaal dit zo vaak als nodig totdat de oorspronkelijke boom is leeg. Op het einde, heeft u nog met het slechtst mogelijke gesorteerde binaire boom - een gekoppelde lijst. Aanwijzer wijst naar het hoofdknooppunt, die het grootste element.

Dit is een verschrikkelijke algoritme all-around - O (n ^ 2) looptijd met het slechtst mogelijke binaire boom-uitgang, maar het is een fatsoenlijke uitgangspunt voor de proppen komen met iets beter en heeft het voordeel dat u de mogelijkheid om de code te schrijven voor het in ongeveer 20 lijnen op een bord.

Doe inorder traversal van de binaire boom en het resultaat. sorteren het resultaat in acending bestelformulier de binaire zoekboom door het nemen van midden element van de gesorteerde lijst als root (dit kan gedaan met behulp van binary search). zodat we evenwichtige binaire zoekboom.

Heeft volgende algoritme om de oplossing te komen.

1) vindt de in orde opvolger zonder het gebruik van de ruimte.

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) doen om traversal zonder het gebruik van de ruimte.

a) Bepaal het eerste knooppunt van inorder traversal. Het moet de meeste kind van de boom links zo ja, of links van de eerste rechts kind zo ja, of naar rechts kind zelf. b) Gebruik bovenstaand algoritme voor het vinden van inoder opvolger eerste knooppunt. c) Herhaal stap 2 voor alle de geretourneerde opvolger.

Gebruik boven de 2-algoritme en doe het in orde traversal op binaire boom zonder het gebruik van extra ruimte. Vorm de binaire zoekboom bij het doen van traversal. Maar de complexiteit is O(N2)het slechtste geval.

heap soort de boom .. nlogn complexiteit ..

Doe de postorder Traversal en vanaf dat het creëren van een binaire zoekboom.

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

Zet Binary Tree aan een dubbel verbonden lijst-kan inplace worden gedaan in O (n)
Dan soort gebruik samenvoegen soort, nlogn
terug te zetten in de lijst om een boom - O (n)

Simple nlogn oplossing.

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