[算法系列之三]二叉树中序前序序列(或后序)求解树

【思路】

这种题一般有二种形式，共同点是都已知中序序列。如果没有中序序列，是无法唯一确定一棵树的。

<1>已知二叉树的前序序列和中序序列，求解树。

1、确定树的根节点。树根是当前树中所有元素在前序遍历中最先出现的元素。

2、求解树的子树。找出根节点在中序遍历中的位置，根左边的所有元素就是左子树，根右边的所有元素就是右子树。若根节点左边或右边为空，则该方向子树为空；若根节点

边和右边都为空，则根节点已经为叶子节点。

3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。

<2>、已知二叉树的后序序列和中序序列，求解树。

1、确定树的根。树根是当前树中所有元素在后序遍历中最后出现的元素。

2、求解树的子树。找出根节点在中序遍历中的位置，根左边的所有元素就是左子树，根右边的所有元素就是右子树。若根节点左边或右边为空，则该方向子树为空；若根节点

边和右边都为空，则根节点已经为叶子节点。

3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。

测试用例：

【先序 中序 求 后序】

输入：

先序序列：ABCDEGF

中序序列：CBEGDFA

输出后序：CGEFDBA

代码：

 /*
     PreIndex: 前序序列字符串中子树的第一个节点在PreArray[]中的下标
     InIndex:  中序序列字符串中子树的第一个节点在InArray[]中的下标
     subTreeLen: 子树的字符串序列的长度
     PreArray： 先序序列数组
     InArray：中序序列数组
 */
 void PreInCreateTree(BiTree &T,int PreIndex,int InIndex,int subTreeLen){
     //subTreeLen < 0 子树为空
     if(subTreeLen <= 0){
         T = NULL;
         return;
     }
     else{
         T = (BiTree)malloc(sizeof(BiTNode));
         //创建根节点
         T->data = PreArray[PreIndex];
         //找到该节点在中序序列中的位置
         int index = strchr(InArray,PreArray[PreIndex]) - InArray;
         //左子树结点个数
         int LenF = index - InIndex;
         //创建左子树
         PreInCreateTree(T->lchild,PreIndex + 1,InIndex,LenF);
         //右子树结点个数(总结点 - 根节点 - 左子树结点)
         int LenR = subTreeLen - 1 - LenF;
         //创建右子树
         PreInCreateTree(T->rchild,PreIndex + LenF + 1,index + 1,LenR);
     }
 }

主函数调用：

 BiTree T;
     PreInCreateTree(T,0,0,strlen(InArray));
     PostOrder(T);

另一种算法：

 /*
     PreS       先序序列的第一个元素下标
     PreE       先序序列的最后一个元素下标
     InS        中序序列的第一个元素下标
     InE        先序序列的最后一个元素下标
     PreArray   先序序列数组
     InArray    中序序列数组
 */
 void PreInCreateTree(BiTree &T,int PreS ,int PreE ,int InS ,int InE){
     int RootIndex;
     //先序第一个字符
     T = (BiTree)malloc(sizeof(BiTNode));
     T->data = PreArray[PreS];
     //寻找该结点在中序序列中的位置
     for(int i = InS;i <= InE;i++){
         if(T->data == InArray[i]){
             RootIndex = i;
             break;
         }
     }
     //根结点的左子树不为空
     if(RootIndex != InS){
         //以根节点的左结点为根建树
         PreInCreateTree(T->lchild,PreS+1,(RootIndex-InS)+PreS,InS,RootIndex-1);
     }
     else{
         T->lchild = NULL;
     }
     //根结点的右子树不为空
     if(RootIndex != InE){
         //以根节点的右结点为根建树
         PreInCreateTree(T->rchild,PreS+1+(RootIndex-InS),PreE,RootIndex+1,InE);
     }
     else{
         T->rchild = NULL;
     }
 }

主函数调用：

 PreInCreateTree(T,0,strlen(PreArray)-1,0,strlen(InArray)-1);

/*---------------------------------------
*   日期：2015-04-28
*   作者：SJF0115
*   题目: 105.Construct Binary Tree from Preorder and Inorder Traversal
*   网址：https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
*   结果：AC
*   来源：LeetCode
*   博客：
-----------------------------------------*/
#include 
#include 
#include 
using namespace std;

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

class Solution {
public:
    TreeNode *buildTree(vector &preorder, vector &inorder) {
        int size = preorder.size();
        if(size <= 0){
            return nullptr;
        }//if
        return PreInBuildTree(preorder,inorder,0,0,size);
    }
private:
    TreeNode* PreInBuildTree(vector &preorder,vector &inorder,int preIndex,int inIndex,int size){
        if(size <= 0){
            return nullptr;
        }//if
        // 根节点
        TreeNode* root = new TreeNode(preorder[preIndex]);
        // 寻找根节点在中序遍历数组的下标
        int index = 0;
        for(int i = 0;i < size;++i){
            if(preorder[preIndex] == inorder[inIndex+i]){
                index = inIndex+i;
                break;
            }//if
        }//for
        // 左子树个数
        int leftSize = index - inIndex;
        // 右子树个数
        int rightSize = size - leftSize - 1;
        // 左子树
        root->left = PreInBuildTree(preorder,inorder,preIndex+1,inIndex,leftSize);
        // 右子树
        root->right = PreInBuildTree(preorder,inorder,preIndex+1+leftSize,index+1,rightSize);
        return root;
    }
};

void PostOrder(TreeNode* root){
    if(root){
        PostOrder(root->left);
        PostOrder(root->right);
        cout<val< preorder = {1,2,4,8,5,3,6,7};
    vector inorder = {8,4,2,5,1,6,3,7};
    TreeNode* root = solution.buildTree(preorder,inorder);
    // 输出
    PostOrder(root);
    return 0;
}

具体讲解请看：点击打开链接

【中序 后序 求先序】

输入：

中序序列：CBEGDFA

后序序列：CGEFDBA

输出先序：ABCDEGF

代码：

 /*
     PostIndex: 后序序列字符串中子树的最后一个节点在PreArray[]中的下标
     InIndex:  中序序列字符串中子树的第一个节点在InArray[]中的下标
     subTreeLen: 子树的字符串序列的长度
     PostArray： 后序序列数组
     InArray：中序序列数组
 */
 void PostInCreateTree(BiTree &T,int PostIndex,int InIndex,int subTreeLen){
     //subTreeLen < 0 子树为空
     if(subTreeLen <= 0){
         T = NULL;
         return;
     }
     else{
         T = (BiTree)malloc(sizeof(BiTNode));
         //创建根节点
         T->data = PostArray[PostIndex];
         //找到该节点在中序序列中的位置
         int index = strchr(InArray,PostArray[PostIndex]) - InArray;
         //左子树结点个数
         int LenF = index - InIndex;
         //创建左子树
         PostInCreateTree(T->lchild,PostIndex - (subTreeLen - 1 - LenF) - 1,InIndex,LenF);
         //右子树结点个数(总结点 - 根节点 - 左子树结点)
         int LenR = subTreeLen - 1 - LenF;
         //创建右子树
         PostInCreateTree(T->rchild,PostIndex-1,index + 1,LenR);
     }
 }

主函数调用：

 BiTree T2;
     PostInCreateTree(T2,strlen(PostArray) - 1,0,strlen(InArray));
     PreOrder(T2);

/*---------------------------------------
*   日期：2015-05-01
*   作者：SJF0115
*   题目: 106.Construct Binary Tree from Inorder and Postorder Traversal
*   网址：https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
*   结果：AC
*   来源：LeetCode
*   博客：
-----------------------------------------*/
#include 
#include 
using namespace std;

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

class Solution {
public:
    TreeNode *buildTree(vector &inorder, vector &postorder) {
        int size = inorder.size();
        if(size <= 0){
            return nullptr;
        }//if
        return InPostBuildTree(inorder,postorder,0,size-1,size);
    }
private:
    TreeNode* InPostBuildTree(vector &inorder,vector &postorder,int inIndex,int postIndex,int size){
        if(size <= 0){
            return nullptr;
        }//if
        // 根节点
        TreeNode* root = new TreeNode(postorder[postIndex]);
        // 寻找postorder[postIndex]在中序序列中的下标
        int index = 0;
        for(int i = 0;i < size;++i){
            if(postorder[postIndex] == inorder[inIndex+i]){
                index = inIndex+i;
                break;
            }//if
        }//for
        int leftSize = index - inIndex;
        int rightSize = size - leftSize - 1;
        root->left = InPostBuildTree(inorder,postorder,inIndex,postIndex-1-rightSize,leftSize);
        root->right = InPostBuildTree(inorder,postorder,index+1,postIndex-1,rightSize);
        return root;
    }
};

void PreOrder(TreeNode* root){
    if(root){
        cout<val<left);
        PreOrder(root->right);
    }//if
}

int main() {
    Solution solution;
    vector inorder = {8,4,2,5,1,6,3,7};
    vector postorder = {8,4,5,2,6,7,3,1};
    TreeNode* root = solution.buildTree(inorder,postorder);
    PreOrder(root);
}

完整代码：

 #include
 #include
 using namespace std;

 //二叉树结点
 typedef struct BiTNode{
     //数据
     char data;
     //左右孩子指针
     struct BiTNode *lchild,*rchild;
 }BiTNode,*BiTree;

 //先序序列
 char PreArray[101] = "ABCDEGF";
 //中序序列
 char InArray[101] = "CBEGDFA";
 //后序序列
 char PostArray[101] = "CGEFDBA";
 /*
     PreIndex: 前序序列字符串中子树的第一个节点在PreArray[]中的下标
     InIndex:  中序序列字符串中子树的第一个节点在InArray[]中的下标
     subTreeLen: 子树的字符串序列的长度
     PreArray： 先序序列数组
     InArray：中序序列数组
 */
 void PreInCreateTree(BiTree &T,int PreIndex,int InIndex,int subTreeLen){
     //subTreeLen < 0 子树为空
     if(subTreeLen <= 0){
         T = NULL;
         return;
     }
     else{
         T = (BiTree)malloc(sizeof(BiTNode));
         //创建根节点
         T->data = PreArray[PreIndex];
         //找到该节点在中序序列中的位置
         int index = strchr(InArray,PreArray[PreIndex]) - InArray;
         //左子树结点个数
         int LenF = index - InIndex;
         //创建左子树
         PreInCreateTree(T->lchild,PreIndex + 1,InIndex,LenF);
         //右子树结点个数(总结点 - 根节点 - 左子树结点)
         int LenR = subTreeLen - 1 - LenF;
         //创建右子树
         PreInCreateTree(T->rchild,PreIndex + LenF + 1,index + 1,LenR);
     }
 }
 /*
     PostIndex: 后序序列字符串中子树的最后一个节点在PreArray[]中的下标
     InIndex:  中序序列字符串中子树的第一个节点在InArray[]中的下标
     subTreeLen: 子树的字符串序列的长度
     PostArray： 后序序列数组
     InArray：中序序列数组
 */
 void PostInCreateTree(BiTree &T,int PostIndex,int InIndex,int subTreeLen){
     //subTreeLen < 0 子树为空
     if(subTreeLen <= 0){
         T = NULL;
         return;
     }
     else{
         T = (BiTree)malloc(sizeof(BiTNode));
         //创建根节点
         T->data = PostArray[PostIndex];
         //找到该节点在中序序列中的位置
         int index = strchr(InArray,PostArray[PostIndex]) - InArray;
         //左子树结点个数
         int LenF = index - InIndex;
         //创建左子树
         PostInCreateTree(T->lchild,PostIndex - (subTreeLen - 1 - LenF) - 1,InIndex,LenF);
         //右子树结点个数(总结点 - 根节点 - 左子树结点)
         int LenR = subTreeLen - 1 - LenF;
         //创建右子树
         PostInCreateTree(T->rchild,PostIndex-1,index + 1,LenR);
     }
 }
 //先序遍历
 void PreOrder(BiTree T){
     if(T != NULL){
         //访问根节点
         printf("%c ",T->data);
         //访问左子结点
         PreOrder(T->lchild);
         //访问右子结点
         PreOrder(T->rchild);
     }
 }
 //后序遍历
 void PostOrder(BiTree T){
     if(T != NULL){
         //访问左子结点
         PostOrder(T->lchild);
         //访问右子结点
         PostOrder(T->rchild);
         //访问根节点
         printf("%c ",T->data);
     }
 }
 int main()
 {
     BiTree T;
     PreInCreateTree(T,0,0,strlen(InArray));
     PostOrder(T);
     printf("\n");
     BiTree T2;
     PostInCreateTree(T2,strlen(PostArray) - 1,0,strlen(InArray));
     PreOrder(T2);
     return 0;
 }