Question

我一直在准备接受采访并遇到了这个问题：问：从级别顺序构建二叉树＆amp; inorder树遍历。

有人可以在这方面指导我。我一直在努力制定这个算法很久了。

这是我写的代码：

struct node * buildLevelInTree(int * in, int * Level, int inStart, int inEnd, int level){

static int levelIndex=0;

struct node * root=newNode(Level[levelIndex++]);

//node has no child
if(inStart==inEnd)
        return root;

int inIndex=searchIndex(in,inStart,inEnd,root->data);//search index of root in inorder traversal

//Note the use of level to take the next root from level order traversal
root->left=buildLevelInTree(in,Level,inStart,inIndex-1,2*level+1);
if(root->left!=NULL)
root->right=buildLevelInTree(in,Level,inIndex+1,inEnd,2*level+2);
else
root->right=buildLevelInTree(in,Level,inIndex+1,inEnd,2*level+1);
return root;

}//end of buildLevelInTree

非常感谢！

Answer 1

最后，我可以调试我的代码并将其解决以便正常运行。接下来的方法是优化该算法。建议优化此代码（空间方面）。

/*

Algorithm Hint:
         A
     /        \
    B          C
   / \        / \
  D   E       F  G
inorder order will be DBEAFCG 
and leve order will be ABCDEFG 
From the level order, we know that A is the root, then check inorder, we further know DBE is left subtree and FCG is right subtree. to construct left subtree, from level order, we know left subtree's level order is BDE(find DBE's order in level order after A), we call the method to construct left subtree with inorder DBE and level order BDE.


*/

struct node * buildLevelInTree(int * in, int in_size, int *level, int l_size){

if(in_size==0 || l_size==0)
    return NULL;
int in_index,l_count,r_count;
in_index=searchIndex(in,0,in_size,level[0]);
l_count=in_index;r_count=in_size-in_index-1;

struct node* root=newNode(level[0]);
int *in_left=makeInorder_left(in,in_size,in_index);
int *in_right=makeInorder_right(in,in_size,in_index);
int *level_left=makeLevel_left(level,l_size,in_left,l_count);
int *level_right=makeLevel_right(level,l_size,in_right,r_count);

root->left=buildLevelInTree(in_left,l_count,level_left,l_count);
root->right=buildLevelInTree(in_right,r_count,level_right,r_count);

return root;

}//end of buildLevelInTree


//Helping function for buildLevelInTree
int * makeInorder_right(int *in, int in_size, int pivot){
if(in==NULL)
    return NULL;
int *in_right;
in_right=(int *)malloc(sizeof(int)*(in_size-pivot-1));
int i=pivot+1;
for(;i<in_size;i++)
in_right[i-pivot-1]=in[i];

return in_right;
}


//Helping function for buildLevelInTree
int *makeLevel_left(int *level, int lv_size, int * in_left, int inleft_size){
if(in_left == NULL || level == NULL)
    return NULL;
int *level_left;
level_left=(int *)malloc(sizeof(int)*inleft_size);

int i=0;
int temp;
for(i=0;i<inleft_size;i++){
    temp=searchLevel(level,lv_size,in_left[i]);
    level_left[i]=temp;//searchLevel(level, lv_size, in_left[i]);
}

level_left=sort(level_left,inleft_size);

for(i=0;i<inleft_size;i++){
    temp=level[level_left[i]];
    level_left[i]=temp;//level[level_left[i]];
}

return level_left;
}

//Helping function for buildLevelInTree
int *makeLevel_right(int *level, int lv_size, int * in_right, int inright_size){
if(in_right == NULL || level == NULL)
    return NULL;
int *level_right;
level_right=(int *)malloc(sizeof(int)*inright_size);

int i=0;
for(i=0;i<inright_size;i++)
    level_right[i]=searchLevel(level, lv_size, in_right[i]);

level_right=sort(level_right,inright_size);
for(i=0;i<inright_size;i++)
    level_right[i]=level[level_right[i]];

return level_right;
}

//Helping function for buildLevelInTree
int * sort(int *a,int n)
{
int i,j,k,temp;

    for(i=1;i< n;i++)
    {
         for(j=0;j< n-1;j++)
         if(a[j]>a[j+1])
               {
               temp=a[j];
               a[j]=a[j+1];
               a[j+1]=temp;
               }
    }
return a;
}

//Helping function for buildLevelInTree
int searchLevel(int *level, int lv_size, int value){

int i=0;
for(i=0;i<lv_size;i++){
if(level[i]==value)
    return i;

}

return -1;
}

从级别顺序构建二叉树＆amp; inorder树遍历

1 个答案: