[zz]编程之美-重建二叉树扩展问题1 2

zz http://blog.csdn.net/vividonly/article/details/6688327

编程之美3.9：重建二叉树

扩展问题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;
}