重建二叉树

struct TreeNode 
{
	int val;
	TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

以数组形式

前序和中序

TreeNode *pre_in_construct(vector<int> pre,int preleft,int preright,vector<int> vin,int vinleft,int vinright)
{
   int val=pre[preleft];
    TreeNode *root=new TreeNode(val);
    root->left=root->right=NULL;
    
    int pos;
    for(int i=vinleft;i<=vinright;i++)
    {
        if(vin[i]==val)
        {
            pos=i;
            break;
        }
    }
    
    int leftlength=pos-vinleft;
    if(leftlength>0)
    {
        root->left=pre_in_construct(pre,preleft+1,preleft+leftlength,vin,vinleft,pos-1);
    }
    
    if(leftlength<preright-preleft)
    {
        root->right=pre_in_construct(pre,preleft+leftlength+1,preright,vin,pos+1,vinright);
    }
    
    return root;
}
TreeNode* pre_in_ConstructBinaryTree(vector<int> pre,vector<int> vin) 
{

    if(pre.empty() || vin.empty())
    {
        return NULL;
    }
    return pre_in_construct(pre,0,pre.size()-1,vin,0,vin.size()-1);
}

后序和中序

TreeNode *in_ps_construct(vector<int> ps,int psleft,int psright,vector<int> vin,int vinleft,int vinright)
{
	int val=ps[psright];
	TreeNode *root=new TreeNode(val);
	root->left=root->right=NULL;

	int pos;
	for(int i=vinleft;i<=vinright;i++)
	{
		if(vin[i]==val)
		{
			pos=i;
			break;
		}
	}

	int leftlength=pos-vinleft;
	if(leftlength>0)
	{
		root->left=in_ps_construct(ps,psleft,psleft+leftlength-1,vin,vinleft,pos-1);
	}

	if(leftlength<psright-psleft)
	{
		root->right=in_ps_construct(ps,psleft+leftlength,psright-1,vin,pos+1,vinright);
	}

	return root;
}

TreeNode *in_ps_ConstructBinaryTree(vector<int> vin,vector<int> ps)
{
	if(vin.empty() || ps.empty())
	{
		return NULL;
	}

	return in_ps_construct(ps,0,ps.size()-1,vin,0,vin.size()-1);
}

主函数测试

int main() 
{
//前序
	int ar[]={1,2,4,7,3,5,6,8};
	int len1=sizeof(ar)/sizeof(ar[0]);
	
//中序
	int br[]={4,7,2,1,5,3,8,6};
	int len2=sizeof(br)/sizeof(br[0]);
	
//后序
	int cr[]={7,4,2,5,8,6,3,1};
	int len3=sizeof(cr)/sizeof(cr[0]);

	vector<int> pre(ar,ar+len1);
	vector<int> in(br,br+len2);
	vector<int> ps(cr,cr+len3);
	
	TreeNode* root1=pre_in_ConstructBinaryTree(pre,in);
	TreeNode *root2=in_ps_ConstructBinaryTree(in,ps);
	
    return 0;
}

以字符串形式

struct TreeNode 
{
	char val;
	TreeNode *left;
    TreeNode *right;
    TreeNode(char x) : val(x), left(NULL), right(NULL) {}
};

前序和中序

TreeNode *pre_in_construct(char *pre,char *vin,int n)
{
    
    TreeNode *root=NULL;
	if(n>0)
	{
		char val=*pre;
		root=new TreeNode(val);
        
		int pos=-1;
		for(int i=0;i<n;i++)
		{
			if(vin[i]==val)
			{
				pos=i;
				break;
			}
		}
		
		root->left=pre_in_construct(pre+1,vin,pos);
		
		root->right=pre_in_construct(pre+pos+1,vin+pos+1,n-pos-1);
	}  
	
    return root;
}
TreeNode* pre_in_ConstructBinaryTree(char* pre,char* vin) {

    if(pre==NULL || vin==NULL)
    {
        return NULL;
    }
    int n=strlen(vin);
    return pre_in_construct(pre,vin,n);
}

后序和中序

TreeNode *in_ps_construct(char* ps,char* vin,int n)
{

	TreeNode *root=NULL;
	if(n>0)
	{
		char val=ps[n-1];
		root=new TreeNode(val);

		int pos=-1;
		for(int i=0;i<n;i++)
		{
			if(vin[i]==val)
			{
				pos=i;
				break;
			}
		}

		root->left=in_ps_construct(ps,vin,pos);

		root->right=in_ps_construct(ps+pos,vin+pos+1,n-pos-1);
		
	}
	return root;
}

TreeNode *in_ps_ConstructBinaryTree(char *ps,char *vin)
{
	if(vin==NULL || ps==NULL)
	{
		return NULL;
	}
	int n=strlen(vin);
	return in_ps_construct(ps,vin,n);
}

主函数测试

int main() 
{
 //前序
	char ar[]="ABDGCEFH";
	
 //中序
	char br[]="DGBAECHF";
	
 //后序
	char cr[]="GDBEHFCA";


	TreeNode* root1=pre_in_ConstructBinaryTree(ar,br);

	TreeNode *root2=in_ps_ConstructBinaryTree(cr,br);

    return 0;
}