Build binary tree from level order & inorder tree traversal - binary-tree

Question

I have been preparing for an interview and came across this question:
Q. Build a binary tree from level order & inorder tree traversal.
Can someone guide me in this regard. I have been struggling with formulating the algorithm for long time now.
Here is the code I wrote:
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
Thanks a ton!

Answer 1

Finally, I could debug my code and work it out to function correctly. Next approach will be to optimise this algorithm. Suggestions to optimise this code (space wise) are welcomed.
/*
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;
}