园龄：1年4个月粉丝：2 关注：0

我在代码随想录|写代码Day19之二叉树-106.从中序与后序遍历序列构造二叉树,654.最大二叉树,617.合并二叉树

学习目标：

博主介绍: 27dCnc
专题 : 数据结构帮助小白快速入门
👍👍👍👍👍👍👍👍👍👍👍👍
☆*: .｡. o(≧▽≦)o .｡.:*☆

主题: 二叉树

今日份打卡
在这里插入图片描述

代码随想录-二叉树

文章目录

学习目标：
主题: 二叉树
学习内容：
106.从中序与后序遍历序列构造二叉树
654.最大二叉树
617.合并二叉树
学习时间：
学习产出：

学习内容：

从中序与后序遍历序列构造二叉树
最大二叉树
合并二叉树

106.从中序与后序遍历序列构造二叉树

题目 vector 二叉树
从中序与后序遍历序列构造二叉树

思路
1.先在后序中确定根结点
2. 中序中确定区间
3. 根据区间去划分二叉树

图解
在这里插入图片描述
操作步骤

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间

代码

class Solution {
public:
    TreeNode*traversal (vector<int>& inorder,vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;
        int rootValue = postorder[postorder.size()-1];
        TreeNode* root =  new TreeNode(rootValue);//找到中间节点
        //叶子节点
        if(postorder.size() == 1) return root;
        //找到中序遍历的切割点
        int delimiterIndex;
       for ( delimiterIndex = 0;delimiterIndex < inorder.size();delimiterIndex++) {
           if (inorder[delimiterIndex] == rootValue) break;
       }
       vector<int> leftnorder(inorder.begin(),inorder.begin()+delimiterIndex);
       vector<int> rightInorder(inorder.begin()+delimiterIndex+1,inorder.end());
       //postorder 舍弃末尾元素
       postorder.resize(postorder.size()-1);
       vector<int> leftPostorder(postorder.begin(),postorder.begin()+leftnorder.size());
       vector<int> rightPostorder(postorder.begin() + leftnorder.size(),postorder.end());

       root->left = traversal(leftnorder,leftPostorder);
       root ->right = traversal(rightInorder,rightPostorder);

       return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder,postorder);
    }
};

654.最大二叉树

题目考点: 二叉树 贪心

图解

通过图像可以知道最大二叉树应该是每次在取根结点时都选取区间内最大的结点

代码

class Solution {
public:
//思路:->这么样构造最大树->每次去找最大值左树然后先上层后下层
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        if(nums.size() == 1) {
            node -> val = nums[0];//退出条件
            return node;
        }
        //找到数组中最大值对应的下标
        int maxValue = 0;
        int maxValueIndex = 0;
        for (int i = 0; i < nums.size();i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        node -> val = maxValue;
        //最大值所在的下标左区间,构造左子树
        if (maxValueIndex > 0) {
            vector<int> newVec(nums.begin(),maxValueIndex + nums.begin());
            node -> left = constructMaximumBinaryTree(newVec);
        }
        //最大值所在下标右区间,构造右子树
        if (maxValueIndex < (nums.size()-1)) {
            vector<int> newVec(nums.begin() + maxValueIndex + 1,nums.end());
            node ->right = constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

617.合并二叉树

题目考点: 二叉树 对双树的操作

合并二叉树

图解

前序代码

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->val += t2->val;                             // 中
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

中序

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->val += t2->val;                             // 中
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

后序

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        t1->val += t2->val;                             // 中
        return t1;
    }
};

迭代法

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        queue<TreeNode*> que;
        que.push(t1);
        que.push(t2);
        while(!que.empty()) {
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();
            // 此时两个节点一定不为空，val相加
            node1->val += node2->val;

            // 如果两棵树左节点都不为空，加入队列
            if (node1->left != NULL && node2->left != NULL) {
                que.push(node1->left);
                que.push(node2->left);
            }
            // 如果两棵树右节点都不为空，加入队列
            if (node1->right != NULL && node2->right != NULL) {
                que.push(node1->right);
                que.push(node2->right);
            }

            // 当t1的左节点 为空 t2左节点不为空，就赋值过去
            if (node1->left == NULL && node2->left != NULL) {
                node1->left = node2->left;
            }
            // 当t1的右节点 为空 t2右节点不为空，就赋值过去
            if (node1->right == NULL && node2->right != NULL) {
                node1->right = node2->right;
            }
        }
        return t1;
    }
};

扩展 双指针

class Solution {
public:
    void process(TreeNode** t1, TreeNode** t2) {
        if ((*t1) == NULL && (*t2) == NULL) return;
        if ((*t1) != NULL && (*t2) != NULL) {
            (*t1)->val += (*t2)->val;
        }
        if ((*t1) == NULL && (*t2) != NULL) {
            *t1 = *t2;
            return;
        }
        if ((*t1) != NULL && (*t2) == NULL) {
            return;
        }
        process(&((*t1)->left), &((*t2)->left));
        process(&((*t1)->right), &((*t2)->right));
    }
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        process(&t1, &t2);
        return t1;
    }
};