ikili arama ağacına bir ikili ağaç nasıl dönüştürülür yerinde, yani, herhangi bir ekstra alan kullanamazsınız

Bir ikili ağaç genellikle olduğu hiçbir dönüşüm gereklidir, bu durumda bir ikili arama ağacı,.

Belki sen dönüştürme şeyin yapısını açıklamak gerekir. Kaynak ağacı dengesiz mi? Eğer üzerinde aramak istediğiniz anahtarı tarafından sipariş değil mi? Nasıl kaynak ağacının ulaştılar?

ve tekrar eden tüm ikili yineleme ve küçük elemanı bulmak: Bu bir görüşme soru buysa, ilk şey şudur (sıfır fiili düşünceyle) yumurtlamak ederim. İkili ağaçtan götürün. Şimdi, tüm ağacı yineleme ve en küçük elemanı bulmak işlemi tekrarlayın ve (yeni düğümün sol çocuğu olma önceki eleman ile) bulunan son elemanın bir ebeveyn olarak ekleyin. Orijinal ağaç boşalana kadar gerektiği kadar kez tekrarlayın. Bağlantılı bir listede - sonunda, olası en kötü sıralı ikili ağacın kalır. İşaretçiniz büyük unsurdur kök düğümü, işaret ediyor.

Bu korkunç bir algoritma çepeçevre - O (n ^ 2) olası en kötü ikili ağaç çıkışı ile çalışma süresi, ama daha iyi bir şeyle gelmeden önce iyi bir başlangıç ​​noktası olduğunu ve sizin için kod yazmak mümkün olma avantajına sahiptir bir beyaz tahta yaklaşık 20 hatlarında bu.

İkili ağacın kastetmek inorder yapın ve sonucu saklayın. emir root olarak sıralı listenin orta eleman alarak ikili arama ağacı oluşturmak acending sonucu (bu ikili arama kullanılarak yapılabilir edebilirsiniz) sıralamak. bu yüzden dengeli ikili arama ağacı olsun.

algoritması aşağıdaki çözüme ulaşmak için vermeyin.

1) Herhangi bir boşluk kullanmadan sipariş halefi bulmak.

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) boşluk kullanmadan sipariş kastetmek yapın.

a) inorder kastetmek ilk düğümü bulun. O varsa ağacın en çocuğa sola veya ilk sağa çocuğun sol o varsa, ya da sağ çocuk kendisi olmalıdır. b) birinci düğümün halefi inoder bulma algoritması üzerinde kullanın. Tüm iade halefi c) 2. adımı tekrarlayın.

2 algoritma üzerinde kullanın ve ekstra alan kullanmadan ikili ağaç üzerinde sipariş kastetmek yapmak. Geçişi yaparken ikili arama ağacı oluşturun. Ama karmaşıklığı olduğunu O(N2)kötü durum.

sıralama ağaç .. nlogn karmaşıklığını yağdırmak ..

Postorder Traversal'i yapın ve bundan bir ikili arama ağacı oluşturun.

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

O (n) 'de INPLACE yapılabilir bir iki kat bağlantılı listesi-İkiliden Ağacı dönüştürme
Sonraki sıralama bu tür birleştirme nlogn kullanılarak
O (n) - Bir ağaca geri listeyi dönüştürme

Basit nlogn çözüm.

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