使用C将数组转换为二叉树？

Question

我正在尝试使用 C 将整数数组转换为二叉树。

例如对于数组a[10]={5,2,1,6,7,3,4}，二叉树应该是这样的

    5    
   / \  
  2   1    
 /\   /\  
6  7  3  4    

我尝试使用以下代码进行转换

typedef struct btree    
{        
    int value;    
    struct btree *left;    
    struct btree *right;    
}Btree;    
void insert(Btree *t,int *a,int index,int n)    
{    
    t=(Btree *)malloc(sizeof(Btree));    
    if(index<n)    
    {    
        t->value=a[index];    
        insert(t->left,a,2*index,n);    
        insert(t->right,a,2*index+1,n);    
    }    
}    
int main(void) {    
    int a[100],i;    
    Btree *t;    
    for(i=0;i<10;i++)    
        scanf("%d",&a[i]);    
    insert(t,a,0,i+1);    
    return 0;    
}  

有人可以帮我解决这个问题吗？

Answer 1

这里有几个问题：

• 您的节点分配应该放在insert 的条件块内，否则您会为空节点分配内存。
• 您应该将left 和right 指针初始化为NULL，以防节点是叶节点并且没有子节点。
• 最重要的。您对树所做的更改将丢失。指针变量对于insert（递归调用）的当前实例是本地的，不会转移到更早的实例或main。传递一个指向节点指针的指针。
• 考虑始终使用零基索引；它们在 C 中是标准的。

所以，它应该是这样工作的：

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

typedef struct btree {
    int value;
    struct btree *left;
    struct btree *right;
} Btree;

void insert(Btree **t, int *a, int index, int n)
{
    if (index < n) {
        *t = malloc(sizeof(**t));
        
        (*t)->value = a[index];
        (*t)->left = NULL;
        (*t)->right = NULL;
        
        insert(&(*t)->left, a, 2 * index + 1, n);
        insert(&(*t)->right, a, 2 * index + 2, n);
    }
}

void print(Btree *t, int level)
{
    if (t) {
        print(t->left, level + 1);
        printf("%*s->%d\n", 4*level, "", t->value);
        print(t->right, level + 1);
    }
}

int main(void)
{
    int a[] = {5, 2, 1, 6, 7, 3, 4};
    Btree *t;

    insert(&t, a, 0, 7);
    print(t, 0);

    // TODO: Clean up memory used by nodes

    return 0;
}

（我已经用硬编码数组替换了scanf 的东西。代码不会清理分配的内存，它确实应该这样做。）

Answer 2

您可能只需要输出数组以匹配树状视图。在这种情况下，您不需要制作带有节点的二叉树，只需使用具有适当索引的数组即可。

如果您当前的索引是 X，则子级变为 2X+1 和 2X+2 。可能这就是你真正想要的。

看例子：

#include <stdio.h>

int main()
{

    int a[7]={5,2,1,6,7,3,4}; // <= A hard coded array

    int n=0;

    // Getting the unsorted Tree output. 
    //  sizeof(a)/sizeof(int) - used to get the array length

    while(n < (sizeof(a)/sizeof(int))/2){
        printf("Parent: %d\n",a[n]);  // <= parent node
        printf("Left Child: %d\n",a[2*n +1]); // <= left Child
        printf("Right Child: %d\n",a[2*n +2]); // <= right Child

        printf("\n");
        n++;
    }

    return 0;
}

输出：

Parent: 5                                                                                                                                                            
Left Child: 2                                                                                                                                                        
Right Child: 1                                                                                                                                                       

Parent: 2                                                                                                                                                            
Left Child: 6                                                                                                                                                        
Right Child: 7                                                                                                                                                       

Parent: 1                                                                                                                                                            
Left Child: 3                                                                                                                                                        
Right Child: 4