重建二叉树

浙大重建二叉树题 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1944

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _DEBUG 0
#define MAX_C 26
typedef struct Node{
	struct Node* pLeft;
	struct Node* pRight;
	char chValue;
}Node;

void Rebuild(char *pPreOrder,char *pInOrder,int nTreeLen,Node **pRoot){

	if(nTreeLen <= 0){
		pRoot = NULL;
		return;
	}
	Node *pTemp = new Node();
	char c=*pPreOrder;
	pTemp->chValue = c;

	if(*pRoot == NULL){
		*pRoot = pTemp;
	}

	int i;
	for(i=0;pInOrder[i] && pInOrder[i] != c;++i);//寻找c
	if(pInOrder[i] != c){//错误
		//throw new RuntimeError();
	}
	if(i>0)
		Rebuild(pPreOrder+1,pInOrder,i,&((*pRoot)->pLeft));//建立左子树
	else
		(*pRoot)->pLeft = NULL;

	if(nTreeLen-i-1>0)
		Rebuild(pPreOrder+i+1,pInOrder+i+1,nTreeLen-i-1,&((*pRoot)->pRight));//建立右子树
	else
		(*pRoot)->pRight = NULL;
}

void travse_post(Node *root){
	if(root == NULL)
		return;
	if(root->pLeft)
		travse_post(root->pLeft);
	if(root->pRight){
		travse_post(root->pRight);
	}
	printf("%c",root->chValue);
}
int main(){
#if _DEBUG==1
	freopen("Rebuild.in","r",stdin);
#endif
	char pPreOrder[MAX_C+1];
	char pInOrder[MAX_C+1];
	while(scanf("%s",pPreOrder)>0){
		scanf("%s\n",pInOrder);
		int len=strlen(pPreOrder);
		Node *root=NULL;
	    Rebuild(pPreOrder,pInOrder,len,&root);
		travse_post(root);
		printf("\n");
	}
	return 0;
}

以下转自 http://blog.youkuaiyun.com/vividonly/article/details/6688327

扩展问题1：

如果前序和中序遍历的字母有重复的，那么怎么构造所有可能的解呢？

扩展问题2：

如何判断给定的前序遍历和中序遍历的结果是合理的？

思路：

问题1：搜索所有可能的情况，并调用扩展问题2的解决方案，判断此情况是否合理（剪枝操作），如果合法，则构造解

问题2：递归判断左右子树是否合理，递归的返回条件是到达叶子节点。

/*
 * 编程之美重建二叉树，扩展问题1，2
 * 扩展问题1：如果前序和中序的字母可能是相同的，怎么重构出所有可能的解？
 * 扩展问题2：如何判断给定的前序和中序遍历的结果是合理的？
 *
 * */

#include <iostream>
#include <string>
using namespace std;

struct Node
{
        Node *left;
        Node *right;
        char value;
};

void pre_travel(Node *p)
{
        if(p == NULL)
                return;
        cout << p->value << endl;
        pre_travel(p->left);
        pre_travel(p->right);
}


//枚举所有的情况，递归判断是否合法，如果递归到只剩一个叶子节点
//则肯定是合法的
bool isvalid(const char *preorder, const char *inorder, int len)
{
        const char *leftend = inorder;

        if(len == 1)
                return true;

        for(int i=0; i<len; i++, leftend++){
                if(*leftend == *preorder){
                        int leftlen = leftend - inorder;
                        int rightlen = len - leftlen - 1;               

                        bool lres = false, rres = false;
                        if(leftlen > 0){
                                lres = isvalid(preorder+1, inorder, leftlen);
                        }               
                        if(rightlen > 0){
                                rres = isvalid(preorder+leftlen+1, inorder+leftlen+1, rightlen);
                        }
        
                        //如果leftlen和rightlen都大于零，则lres和rres必须都为true，此分割方法才算合法           
                        if((leftlen > 0 && rightlen >0 && lres && rres) || 
                        (leftlen > 0 && rightlen <=0 && lres) || (left <=0 && rightlen > 0 && rres)){
                                return true;    
                        }
                }
        }

        return false;   
}


//枚举法，在枚举的同时使用isvalid函数，排除非法情况
void rebuild(const char *preorder, const char *inorder, int len, Node **root)
{
        if(preorder == NULL || inorder == NULL)
                return;

        if(*root == NULL){
                Node *temp = new Node;
                temp->left = NULL;
                temp->right = NULL;
                temp->value = *preorder;
                *root = temp;
        }

        if(len == 1)
                return;

        const char *leftend = inorder;

        for(int i=0; i<len; i++, leftend++){
                if(*leftend == *preorder){
                        int leftlen = leftend - inorder;
                        int rightlen = len - leftlen - 1;

                        if(leftlen > 0  && rightlen >0){
                                if(isvalid(preorder+1, inorder, leftlen) && isvalid(preorder+leftlen+1, inorder+leftlen+1, rightlen)){
                                        rebuild(preorder+1, inorder, leftlen, &((*root)->left));
                                        rebuild(preorder+leftlen+1, inorder+leftlen+1, rightlen, &((*root)->right));
                                }
                        }else if(leftlen > 0 && rightlen <= 0){
                                if(isvalid(preorder+1, inorder, leftlen))
                                        rebuild(preorder+1, inorder, leftlen, &((*root)->left));
                        }else if(leftlen <=0 && rightlen >0){
                                if(isvalid(preorder+leftlen+1, inorder+leftlen+1, rightlen))
                                        rebuild(preorder+leftlen+1, inorder+leftlen+1, rightlen, &((*root)->right));
                        }
                        
                }
        }
}

int main()
{
        string pre1 = "abdefc";
        string mid1 = "dbfeac";

        string pre2 = "abdefc";
        string mid2 = "dcfeab";

        //有重复的字母
        string pre3 = "aadcef";
        string mid3 = "daaecf";

        bool valid = isvalid(pre1.c_str(), mid1.c_str(), pre1.length());
        cout << valid << endl;

        valid = isvalid(pre2.c_str(), mid2.c_str(), pre2.length());
        cout << valid << endl;
        
        valid = isvalid(pre3.c_str(), mid3.c_str(), pre3.length());
        cout << valid << endl;
       
        Node *root = NULL;
        rebuild(pre3.c_str(), mid3.c_str(), 6, &root);
        pre_travel(root);
 
        return 0;
}