C++ 将非完整二进制搜索树转换为完整二进制搜索树

我在完整的二进制搜索树中遇到了问题 如何将非完整二进制搜索树转换为完整二进制搜索树，如以下示例：
我在树中有一个节点结构：

结构节点 {
int键；
节点*左，*右；
})

我有一棵二叉树
--------十八
------/----\
-----16-19
-----/-\----\
----8-17-20
---/-----------
--七,------------
它不是一个完整的二叉搜索树，它只是一个二叉树。 我想将此树转换为完整的二叉搜索树，如：
---------十七,
-------/-----\
------8---19
-----/-\-----/---\
----7-16--18--20

---

请帮我解决这个问题，非常感谢

如果二叉树中的节点数足以构建完整树，即节点数等于1或3或7或15或。。。2^n-1是一个正整数n，它将树读入一个向量并对其排序。然后，可以将排序后的向量传递给所述的众所周知的算法。其思想是BST的根位于向量的中间，而左节点子根的根节点的左子将位于排序向量的左半部分中（同样适用于右节点和向量的右半部分）。 请注意：如果二叉树（您的输入）中的节点数不等于2^n-1，则无法构建完整的二叉树（搜索），因为您没有正确的可用节点数。但是，如果允许添加额外的节点，即不在二叉树中的节点（您在问题中没有提到这一点），下面的代码也可以工作，但您需要向排序向量添加额外的节点（例如，在末尾递增的数）

#包括
#包括
#包括
使用名称空间std；
结构节点{
int键；
节点*左，*右；
};
/*
*像这样构造一个树并返回一个指针
*到根节点
*/
//--------18
//------/----\
//-----16---19
//-----/-\----\
//----8--17--20
//---/-----------
//--7------------
节点*constructExampleTree（）；
/*
*放置属于树的所有节点
*在“节点”（包括“节点”）下装入“vec”。
*/
void placeIntoVector（vector&vec，节点*节点）；
/*
*按顺序打印“节点”下的根目录树
*/
void printInOder（节点*节点）；
/*
*按post顺序删除“节点”下的所有根节点
*/
void deleteInPostOrder（节点*节点）；
/*使用
给定数据和空的左指针和右指针*/
节点*newNode（int数据）；
/*从排序数组构造平衡二进制搜索树的函数
*
*算法取自：http://www.geeksforgeeks.org/sorted-array-to-balanced-bst/
* */
节点*SorterDarrayToBST（矢量和arr、整数开始、整数结束）
{
/*基本情况*/
如果（开始>结束）
返回NULL；
/*获取中间元素并使其成为根元素*/
int mid=（开始+结束）/2；
Node*root=newNode（arr[mid]）；
/*递归地构造左子树并使其
根的左子代*/
root->left=分拣机阵列TOBST（arr、start、mid-1）；
/*递归地构造正确的子树并使其
根的右子代*/
root->right=分拣机DarrayTobst（arr，mid+1，end）；
返回根；
}
int main（）{
Node*root=constructExampleTree（）；
向量向量机；
placeIntoVector（向量，根）；
排序（vec.begin（），vec.end（））；
int计数器=静态_转换（向量大小（））；
节点*bstRoot=SORTEDARYTOBST（vec，0，计数器-1）；
//按顺序打印BST将为我们提供排序输出
printInOder（bstRoot）；
deleteInPostOrder（根）；
deleteInPostOrder（bstRoot）；
返回0；
}
节点*constructExampleTree（）{
/*
*一级和二级
*/
节点*18=新节点（）；
十八->键=18；
十八->左=空；
十八->右=空；
Node*十六=新节点（）；
十六->键=16；
十六->左=空；
十六->右=空；
节点*19=新节点（）；
十九->键=19；
十九->左=空；
十九->右=空；
十八->左=十六；
十八->右=十九；
/*
*三级
*/
节点*8=新节点（）；
八->键=8；
八->左=空；
八->右=空；
节点*17=新节点（）；
十七->键=17；
十七->左=空；
十七->右=空；
节点*二十=新节点（）；
二十->键=20；
二十->左=空；
二十->右=空；
十六->左=八；
十六->右=十七；
十九->右=二十；
/*
*四级
*/
Node*seven=新节点（）；
七->键=7；
七->左=空；
七->右=空；
八->左=七；
返回十八；
}
void placeIntoVector（向量和向量，节点*节点）{
if（node==NULL）
返回；
placeIntoVector（向量，节点->左）；
向量推回（节点->键）；
placeIntoVector（向量，节点->右侧）；
}
void printInOder（节点*节点）{
if（node==NULL）
返回；
打印顺序（节点->左侧）；
cout键（右键）；
}
void deleteInPostOrder（节点*节点）{
if（node==NULL）
返回；
deleteInPostOrder（节点->左侧）；
deleteInPostOrder（节点->右侧）；
删除节点；
}
/*使用
给定数据和空的左指针和右指针*/
Node*newNode（int数据）
{
Node*Node=新节点（）；
节点->键=数据；
节点->左=空；
节点->右=空；
返回节点；
}

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

struct Node {
    int key;
    Node* left,*right;
};


/*
 * Construct a tree like this and return a pointer
 * to the root node
 */
//--------18
//------/----\
//-----16---19
//-----/-\----\
//----8--17--20
//---/-----------
//--7------------
Node* constructExampleTree();

/*
 * Place all nodes which are part of the tree
 * mounted under 'node' (including 'node') into 'vec'.
 */
void placeIntoVector(vector<int>& vec, Node* node);

/*
 * Print the tree rooted under 'node' in order
 */
void printInOder(Node* node);

/*
 * Delete all nodes rooted under 'node' in post order
 */
void deleteInPostOrder(Node* node);

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
Node* newNode(int data);

/* A function that constructs Balanced Binary Search Tree from a sorted array
 *
 * Algorithm taken from: http://www.geeksforgeeks.org/sorted-array-to-balanced-bst/
 * */
Node* sortedArrayToBST(vector<int>& arr, int start, int end)
{
    /* Base Case */
    if (start > end)
      return NULL;

    /* Get the middle element and make it root */
    int mid = (start + end)/2;
    Node *root = newNode(arr[mid]);

    /* Recursively construct the left subtree and make it
       left child of root */
    root->left =  sortedArrayToBST(arr, start, mid-1);

    /* Recursively construct the right subtree and make it
       right child of root */
    root->right = sortedArrayToBST(arr, mid+1, end);

    return root;
}

int main (){

    Node* root = constructExampleTree();

    vector<int> vec;
    placeIntoVector(vec, root);

    sort(vec.begin(),vec.end());

    int counter = static_cast<int>( vec.size());
    Node *bstRoot = sortedArrayToBST(vec, 0, counter -1);

    // Printing a BST in order will give us a sorted output
    printInOder(bstRoot);

    deleteInPostOrder(root);
    deleteInPostOrder(bstRoot);

    return 0;
}

Node* constructExampleTree() {

    /*
     * Level 1 and 2
     */
    Node* eighteen = new Node();
    eighteen->key = 18;
    eighteen->left = NULL;
    eighteen->right= NULL;

    Node* sixteen = new Node();
    sixteen->key = 16;
    sixteen->left = NULL;
    sixteen->right= NULL;

    Node* nineteen = new Node();
    nineteen->key = 19;
    nineteen->left = NULL;
    nineteen->right= NULL;

    eighteen->left = sixteen;
    eighteen->right = nineteen;

    /*
     * Level 3
     */
    Node* eight = new Node();
    eight->key = 8;
    eight->left = NULL;
    eight->right= NULL;

    Node* seventeen = new Node();
    seventeen->key = 17;
    seventeen->left = NULL;
    seventeen->right= NULL;

    Node* twenty = new Node();
    twenty->key = 20;
    twenty->left = NULL;
    twenty->right= NULL;

    sixteen->left = eight;
    sixteen->right = seventeen;

    nineteen->right = twenty;

    /*
     * Level 4
     */
    Node* seven = new Node();
    seven->key = 7;
    seven->left = NULL;
    seven->right= NULL;

    eight->left = seven;

    return eighteen;
}

void placeIntoVector(vector<int>& vec, Node* node){
    if (node == NULL)
        return;

    placeIntoVector(vec, node->left);
    vec.push_back(node->key);
    placeIntoVector(vec, node->right);
}

void printInOder(Node* node){
    if (node == NULL)
        return;

    printInOder(node->left);
    cout << node->key << " ";
    printInOder(node->right);
}

void deleteInPostOrder(Node* node){
    if (node == NULL)
        return;

    deleteInPostOrder(node->left);
    deleteInPostOrder(node->right);
    delete node;
}


/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
Node* newNode(int data)
{
    Node* node = new Node();
    node->key = data;
    node->left = NULL;
    node->right = NULL;

    return node;
}