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

古城微笑少年丶 2023-06-08 03:29 5阅读 0赞

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

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

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

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

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

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

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

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

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

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

测试用例：  
![format_png][]

【先序 中序 求 后序】

输入：

先序序列：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 <iostream>
    #include <vector>
    #include <algorithm>
    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<int> &preorder, vector<int> &inorder) {
            int size = preorder.size();
            if(size <= 0){
                return nullptr;
            }//if
            return PreInBuildTree(preorder,inorder,0,0,size);
        }
    private:
        TreeNode* PreInBuildTree(vector<int> &preorder,vector<int> &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<<root->val<<endl;
        }//if
    }
     
    int main(){
        Solution solution;
        vector<int> preorder = {1,2,4,8,5,3,6,7};
        vector<int> inorder = {8,4,2,5,1,6,3,7};
        TreeNode* root = solution.buildTree(preorder,inorder);
        // 输出
        PostOrder(root);
        return 0;
    }

具体讲解请看：[点击打开链接][Link 1]

【中序 后序 求先序】

输入：

中序序列：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 <iostream>
    #include <vector>
    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<int> &inorder, vector<int> &postorder) {
            int size = inorder.size();
            if(size <= 0){
                return nullptr;
            }//if
            return InPostBuildTree(inorder,postorder,0,size-1,size);
        }
    private:
        TreeNode* InPostBuildTree(vector<int> &inorder,vector<int> &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<<root->val<<endl;
            PreOrder(root->left);
            PreOrder(root->right);
        }//if
    }
     
    int main() {
        Solution solution;
        vector<int> inorder = {8,4,2,5,1,6,3,7};
        vector<int> postorder = {8,4,5,2,6,7,3,1};
        TreeNode* root = solution.buildTree(inorder,postorder);
        PreOrder(root);
    }

完整代码：

#include<iostream>  
    #include<string>  
    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;  
    }

本文原文地址：[https://blog.csdn.net/SunnyYoona/article/details/24903815][https_blog.csdn.net_SunnyYoona_article_details_24903815]

[format_png]: /images/20230531/04a8e4abbe3d47959340b05bf681a0be.png
[Link 1]: http://blog.csdn.net/sjf0115/article/details/8682529
[https_blog.csdn.net_SunnyYoona_article_details_24903815]: https://blog.csdn.net/SunnyYoona/article/details/24903815