算法学习记录四（C++）--->通过前序和中序序列重建二叉树

描述

• 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路

• 前序 DLR —> 根左右 第一个元素就是当前根节点
• 中序 LDR —> 左根右 根元素分割了左子树和右子树
  
  
  1.我们首先从前序中找到第一个元素创建，就是根节点，然后拿这个根节点去中序序列中遍历，找到后左侧就是左子树，右侧就是右子树
  2.然后分别通过数量，找到前序中的左右子树，然后再进行前中左子树和前中右子树进行递归，直到叶节点不在有子树
  3.先看下第一个例子，每次递归都创建出前序左右子树vector和中序左右子树vectot

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int inLenth = vin.size();
        // 递归结束的时候 vector为空
        if(inLenth == 0)
            return NULL;

        // 每次递归都创建新的向量 存储DLR和LDR的L和R
        vector<int> left_pre,right_pre,left_in,right_in;
        //创建根节点，根节点肯定是前序遍历的第一个数
        TreeNode* head=new TreeNode(pre[0]);
        //对于中序遍历，根节点左边的节点位于二叉树的左边，根节点右边的节点位于二叉树的右边
        // 通过DLR的第一个数字，锁定LDR中左右子树的分割线
        int gen = 0;
        for(int i = 0;i<inLenth;i++){
            if(vin[i] == pre[0]){
                gen = i;
                break;
            }
        }
        // 获取中前序中的左子树
        for(int i = 0;i<gen;i++){
            left_pre.push_back(pre[i+1]);
            left_in.push_back(vin[i]);
        }
        // 这里一定要从gen+1开始遍历，避免出现数组越界
        // 获取中前序中的右子树
        for(int i = gen+1;i<inLenth;i++){
            right_pre.push_back(pre[i]);
            right_in.push_back(vin[i]);
        }
        // 递归，每次把对应深度的跟节点返回，进行逆向回归
        //和shell排序的思想类似，取出前序和中序遍历根节点左边和右边的子树
        //递归，再对其进行上述所有步骤，即再区分子树的左、右子子数，直到叶节点
        head->left = reConstructBinaryTree(left_pre,left_in);
        head->right = reConstructBinaryTree(right_pre,right_in);
        return head;

    }
};

更加精简

• 通过初始出来的前序序列和中序序列，只是改变其子树的起始和终点进行递归遍历

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return Find(pre, 0, pre.size() - 1, vin, 0, vin.size() - 1);
    }
private:
    TreeNode* Find(const vector<int> &pre,int p_begin,int p_end,const vector<int> &vin,int v_begin,int v_end){
        // 递归结束 当开始的下标大于结束的下标，表示已经没有子树了
        if(p_begin > p_end || v_begin > v_end){
            return NULL;
        }

        // 前序 DLR-> 第一个数就是根节点
        TreeNode *root = new TreeNode(pre[p_begin]);

        // 遍历 中序 LDR 分割出左子树和右子树
        int i = v_begin;
        for(;i<=v_end;i++){
            if(vin[i] == pre[p_begin]){
                break;
            }
        }
        // 获取左子树的数量和右子树的数量
        int left_num = i-v_begin;
        int right_num = v_end - i;

        // 左右子树分别进行递归
        root->left = left_num == 0 ? NULL : Find(pre,p_begin+1,p_begin+left_num,vin,v_begin,i);
        root->right = right_num == 0 ? NULL : Find(pre,p_begin+left_num+1,p_end,vin,i+1,v_end);
        return root;
    }

};