Как преобразовать двоичное дерево бинарного дерева поиска на месте, то есть, мы не можем использовать любое дополнительное пространство

Двоичное дерево обычно это бинарное дерево, в этом случае не требуется никакого преобразования.

Возможно, вам необходимо выяснить структуру того, что вы хотите конвертировать. Ваш источник дерево несбалансированным? Разве это не заказывали ключ вы хотите искать дальше? Как вы пришли на дерево исходных кодов?

Ну, если это интервью вопрос, то первое, что я бы ляпнуть (с нулевой фактической мысли) заключается в следующем: перебирать весь двоичный файл рекурсивно и найти наименьший элемент. Возьмите его из бинарного дерева. Теперь, повторите процесс, в котором вы перебирать все дерево и найти наименьший элемент, и добавить его в качестве родителя последнего найденного элемента (с предыдущим элементом становится левым потомком нового узла). Повторите столько раз, сколько необходимо, пока оригинальное дерево не пусто. В конце концов, вы остались с неподходящим отсортированным бинарным деревом - связанный списком. Ваш указатель указывает на корневой узел, который является самым большим элементом.

Это ужасный алгоритм многоборье - O (N ^ 2) время работы с неподходящим выходом бинарного дерева, но это достойная отправной точкой, прежде чем придумать что-то лучше и имеет то преимущество, что вы можете быть в состоянии написать код это примерно 20 линий на доске.

У симметричного обхода бинарного дерева и сохранить результат. сортировать результат в acending порядка формирования двоичного дерева поиска, принимая средний элемент из отсортированного списка, как корень (это может сделать, используя бинарный поиск). таким образом мы получаем сбалансированное бинарное дерево поиска.

Есть следующий алгоритм, чтобы достичь решения.

1) найти в порядке правопреемника без использования пространства.

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) Есть ли в порядке обхода без использования пространства.

а) Найдите первый узел заказовМои обхода. Он должен оставил большинство ребенка дерева, если он имеет, или слева от первого правого ребенка, если у него есть, или право ребенок сам. б) Использование выше алгоритма для выяснения inoder преемника первого узла. с) Повторите шаг 2 для всех возвращенной преемники.

Использование выше 2 алгоритма и сделать в порядке обхода на бинарном дереве без использования дополнительного пространства. Сформировать дерево двоичного поиска при выполнении обхода. Но сложность в O(N2)худшем случае.

куча сортировать дерево .. NlogN сложности ..

Сделайте PostOrder Traversal и от создания двоичного дерева поиска.

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

Преобразование двоичного дерева в двусвязном list- можно сделать Inplace в O (N)
Тогда разбирайтесь с помощью сортировки слияния, NlogN
Преобразовать список обратно в дерево - O (п)

Простой NlogN решение.

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