我想将左平衡二叉树的数组表示形式从按顺序转换为级别顺序表示形式：

Question

As shown in the following fig, I have a program which stores data of a tree in in-order manner.

for example: A[7]={0,1,2,3,4,5,6};

I want that to convert in level-order manner: Such that the first node is root, and left children can be found at 2i+1 the location, right child can be found at 2i+2 th location, and parent of any node can be found at i/2th location.

Namely:

B[0]=A[3]
B[1]=A[1]
B[2]=A[5]
B[3]=A[0]
B[4]=A[2]
B[5]=A[4] and
B[6]=A[6]

I am stuck and unable to find any strategy.

I need to perform this operation to make a compatible tree structure for an algorithm I've written earlier.

The data set contains thousand of nodes and it's impossible to do it manually. Kindly suggest a iterative or recursive algorithm for that.

Thanks.

Answer 1

Though not much confidence...

#include <stdio.h>

void toOrder(int a[], int b[], size_t index, size_t size, size_t a_size){
    int i;

    if(index >= a_size) return;
    if(size == 1){
        b[index] = a[0];
        return;
    }
    size /=2;
    b[index]=a[size];
    toOrder(&a[0]     , b, index * 2 + 1, size, a_size);
    toOrder(&a[size+1], b, index * 2 + 2, size, a_size);
}


#define SIZE 7

int main(void){
    int a[SIZE] = {0,1,2,3,4,5,6};
    int b[SIZE];
    int i;

    toOrder(a, b, 0, SIZE, SIZE);
    for(i=0;i<SIZE;++i)
        printf("b[%d]=%d\n", i, b[i]);
    printf("\n");

    return 0;
}

Answer 2

Here's an algorithm that takes one record-keeping sweep and then one output.

Take an array of the size of the tree, n.

Create a record-keeping array depths of size depth, initialized to 0. Each entry is how many nodes are at depth i.

Walk the tree, noting each node's depth. At each node:

depths[d] += 1

This'll leave you with a list of how many nodes are at each depth.

Make a new array, depth-offset . Where depth-offset[i] = depth-offset[i-1] + depths[i-1] and depth-offset[0] = 0. This shows you where a node of a given depth starts in the output array. Now it's just a matter of walking and placing, while incrementing the position of the next node at that level.

Walk the tree in-order, noting the depth again.

offset = depth-offset[d]
output[offset] = value-at-node
depth-offset[d] = depth-offset[d]+1

output should be your list.