编程之美 3.9 重建二叉树 扩展问题

扩展问题1

如果前序和中序遍历的字母有重复的，那么怎么构造所有可能的解呢？
搜索所有可能的情况，并调用扩展问题2的解决方案，判断此情况是否合理（剪枝操作），
如果合法，则构造解.

扩展问题2

如何判断给定的前序遍历和中序遍历的结果是合理的？
递归算法实现，分别遍历左右子树，递归中迭代查找左右子树的长度，类似于书中的方法。
代码，可判断给定前序遍历和中序遍历是否合理?

#include <iostream>
#include <string>

using namespace std;

bool valid = true;

//判断前序中的根节点能否在中序中找到
inline int find(char needle, const char* haystack, int start, int end )
{
    const char* p = haystack + start;
    int i = 0;
    int offset = end - start ;

    while ( p && i < offset )
    {
        if ( *p == needle )
        {
            if ( start != 0 )
                return i + start;
            else
                return i;
        }
        p++, i++;
    }
    return -1;
}

void isValid( const char* preOrder, const char* inOrder, int start, int end )
{
    if ( !valid )
        return ;

    int position = find( *preOrder, inOrder, start,end );
    if ( position == -1 )
    {
        valid = false;
        return ;
    }

    if ( start < position )
    {
        isValid( preOrder + 1, inOrder,start,position ); //在左子树中遍历
    }

    if ( position + 1 < end )
    {
        isValid( preOrder + position + 1, inOrder, position + 1, end ); //在右子树中遍历
    }
}

// Two Simple Test Cases
int main()
{
    string pre1 = "abdefc";
    string mid1 = "dbfeac";

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

    isValid(pre1.c_str(),mid1.c_str(),0,mid1.length());
    cout << valid << endl;    // 输出 true

    valid = true;
    isValid(pre2.c_str(),mid2.c_str(),0,mid2.length());
    cout << valid << endl;   //输出false
    return 0;
}

扩展问题3：

如果知道前序和后序的结果，能重构二叉树吗？
前序+后序，这个组合是无法重建确定的二叉树的。
对于满二叉树，利用子树节点的排列顺序能区分开左右子树节点集合，构建是没有问题的。但一旦有单个叶子的节点存在，则无法确定叶子是左儿子还是右儿子。因为无论是前序还是后序序列，都无法体现单个儿子情况下，儿子的位置。前序会将左右子树的点置于节点之后，后序则是将左右子树的点置于节点之前。

举个简单的反例：
给出如下的前序序列和后序序列： preorder: A, B; postorder: B, A能构建的二叉树有两种可能，1.A 是根节点，B 是 A 左儿子； 2.A 是根节点， B 是 A 的右儿子。无法得到一个唯一的结果。

总结

中序遍历配合另外任何一个遍历，能重建二叉树。其他的任意两个序列的组合都不能唯一的确定重建的二叉树。

已知后序和中序重构二叉树：

void ReBuild_AftIn(char *pAftOrder, char *pInOrder, int nTreeLen, NODE **pRoot)
{
	int nTempLen = 0;
    if (pAftOrder == NULL || pInOrder == NULL)
    {
        return;
    }
    
    NODE *pTemp = new NODE;
    pTemp->chValue = *pAftOrder;
    pTemp->pLeft   = NULL;
    pTemp->pRight  = NULL;
    
    if (*pRoot == NULL)
    {
        *pRoot = pTemp;
    }
    
    if (nTreeLen == 1)
    {
        return;
    }
    
    char* pLeftEnd=pInorder;
char* pOrgInOrder = pInorder; 
char* pAftTempNode = *pAftOrder;
//找到左子树的结尾
while((pAftTempNode+1)!=NULL){
    pAftTempNode++;
}

while(*pAftTempNode!=*pLeftEnd){
    if(pAftTempNode==NULL||pLeftEnd==NULL){
        return;
    }

    nTempLen++;
    //记录临时长度，以免溢出
    if(nTempLen > nTreeLen){
        break;
    }

    pLeftEnd++;
}

int nLeftLen = 0;
nLeftLen = (int)(pLeftEnd - pOrgInOrder);

    assert(nLeftLen != -1);
    int nRightLen = nTreeLen - nLeftLen -1;
    
    if (nLeftLen > 0)
    {
        ReBuild_AftIn(pAftOrder + nRightLen + 1, pInOrder, nLeftLen, &((*pRoot)->pLeft));
    }
    
    if (nRightLen > 0)
    {
        ReBuild_AftIn(pAftOrder + 1, pInOrder + nLeftLen + 1,
            nRightLen, &((*pRoot)->pRight));
    }
}