C++ 二进制搜索树数组实现C++；

我正在实现一个二进制搜索树，该树使用数组实现来表示。这是我到目前为止的代码：请注意，我已经完成了树的结构，并将其保存为链表。我想将此链表转换为数组

我的想法如下。生成一个返回数组函数。将数组的大小设置为最大节点数（2^（n-1）+1），然后遍历链接列表。根节点将位于数组上的@position 0，然后他的L-child=（2*[index\u of_parent]+1）和R-child=（2*[index\u of_parent]+2）。我环顾四周，寻找一些东西，让我了解如何跟踪每个节点，以及如何通过每个节点

我是不是想得太多了？ 会有递归吗

此外，我正在考虑创建一个可视树而不是数组，但不知道如何正确地将其隔开。如果有人对如何做到这一点有想法，那么更好地理解这一点就太棒了

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>

using namespace std;

struct node { 
    int data; 
    struct node* left; 
    struct node* right; 
};

void inorder(struct node* node){
    if(node){
        inorder(node->left);
        cout << node->data << " ";
        inorder(node->right);
    }
}

void insert(struct node** node, int key){

    if(*node == NULL){
        (*node) = (struct node*)malloc(sizeof(struct node));
        (*node)->data = key;
        (*node)->left = NULL;
        (*node)->right = NULL;
        printf("inserted node with data %d\n", (*node)->data);
    }
    else if ((*node)->data > key){
        insert((&(*node)->left),key);

    }
    else
        insert((&(*node)->right),key);
}

int max_tree(struct node* node){
    int left,right;
    if(node == NULL)
       return 0;
    else
    {
      left=max_tree(node->left);
      right=max_tree(node->right);
      if(left>right)
         return left+1;
      else
         return right+1;
}
}

//This is where i dont know how to keep the parent/children the array.
void return_array(struct node* node, int height){
    int max;
    height = height - 1;
    max = pow(2, height) - 1;
    int arr [height];








}

int main(){
    int h;
    struct node* root = NULL;

    insert(&root, 10);
    insert(&root, 20);
    insert(&root, 5);
    insert(&root, 2);


   inorder(root);
   cout << endl;
   cout << "Height is: ";
   cout << max_tree(root);
   h = max_tree(root)
   return_array(root, h)
}

#包括
#包括
#包括
#包括
使用名称空间std；
结构节点{
int数据；
结构节点*左；
结构节点*右；
};
无效索引顺序（结构节点*节点）{
如果（节点）{
顺序（节点->左）；
cout（数据权）；
}
}
无效插入（结构节点**节点，int键）{
如果（*节点==NULL）{
（*node）=（结构节点*）malloc（sizeof（结构节点））；
（*节点）->数据=键；
（*节点）->left=NULL；
（*节点）->right=NULL；
printf（“插入了数据为%d\n的节点，（*节点）->数据）；
}
else if（（*节点）->数据>键）{
插入（&（*节点）->左键）；
}
其他的
插入（&（*节点）->右键）；
}
int max_树（结构节点*节点）{
int左，右；
if（node==NULL）
返回0；
其他的
{
左=最大树（节点->左）；
右=最大树（节点->右）；
如果（左>右）
返回左+1；
其他的
返回权+1；
}
}
//这就是我不知道如何保持父/子数组的地方。
void return_数组（结构节点*节点，整数高度）{
int max；
高度=高度-1；
最大值=功率（2，高度）-1；
内方位[高度]；
}
int main（）{
int-h；
结构节点*root=NULL；
插入（&根，10）；
插入（&root，20）；
插入（&根，5）；
插入（&根，2）；
顺序（根）；
cout如果要将树节点存储在数组中，最好从数组的1个位置开始！因此父节点与其子节点之间的关系应该很简单：

parent = n;
left = 2n;
right = 2n + 1;

您应该对树进行BFS，并将节点存储在数组中（如果节点为null，则还应该使用标志ex0将其存储在数组中），应该得到树的数组！
如果要将树节点存储在数组中，最好从数组的1个位置开始！因此父节点与其子节点之间的关系应该很简单：

parent = n;
left = 2n;
right = 2n + 1;

您应该创建树的BFS，并将节点存储在数组中（如果节点为null，您还应该使用标志ex0将其存储在数组中），您应该获取树的数组！
要执行此操作，您必须遵循以下步骤

创建一个空队列
将列表的第一个节点设为根节点，并将其排入队列
在列表结束之前，请执行以下操作

a、 从队列中退出一个节点。这是当前父节点

b、 遍历列表中的两个节点，将它们添加为当前父节点的子节点

c、 将两个节点加入队列

时间复杂度：上述解决方案的时间复杂度为O（n），其中n是节点数。
要做到这一点，您必须遵循以下步骤

创建一个空队列
将列表的第一个节点设为根节点，并将其排入队列
在列表结束之前，请执行以下操作

a、 从队列中退出一个节点。这是当前父节点

b、 遍历列表中的两个节点，将它们添加为当前父节点的子节点

c、 将两个节点加入队列

时间复杂度：上述解决方案的时间复杂度为O（n），其中n是节点数。
考虑到您希望高效地存储二叉搜索树，请使用

l = 2i + 1
r = 2i + 2

每棵树遇到树末端不出现的叶子节点（宽度优先），就会浪费空间。考虑下面的简单例子：

  2
 / \
1   4
   / \
  3   5

这（将宽度优先转换为数组时）会导致

[ 2, 1, 4, -, -, 3, 5 ]

并浪费阵列中的两个插槽

现在，如果要在阵列中存储同一棵树而不浪费空间，只需先将其转换为阵列深度：

要从此恢复原始树，请对每个节点执行以下步骤：

选择第一个节点作为根节点
对于每个节点（包括根节点），选择

a） 左子项作为数组中当前键之后的下一个较小键

b） 右子项作为数组中下一个较大的键，不大于上次向左分支时遇到的最小父项，并且小于当前位于其左分支中的直接父项的键

显然，找到正确的b）稍微复杂一点，但不太复杂。请参考我的代码示例

如果我没有弄错的话，在这两种情况下，数组之间的转换都需要O（n），因为没有空间被浪费，所以空间复杂度也是O（n）

这是因为二叉搜索树比普通二叉树具有更多的结构；在这里，我只使用了左子节点较小的二叉搜索树属性，右子节点大于当前节点的键

编辑：

在对这个主题做了进一步的研究之后，我发现按前序遍历顺序重建树要简单得多。分别实现了递归函数和

它基本上包括以下步骤：


只要