代码随想录打卡—day18—【二叉树】— 8.8+8.19

Vaidurya_99

已于 2023-08-19 21:35:46 修改

阅读量75

点赞数

分类专栏： SXL 文章标签：数据结构算法

于 2023-08-08 17:54:15 首次发布

本文链接：https://blog.csdn.net/weixin_60899084/article/details/132168072

版权

SXL 专栏收录该内容

42 篇文章 1 订阅

订阅专栏

1 513. 找树左下角的值

513. 找树左下角的值

一眼层序遍历，AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) 
    {
        // 层序遍历
        queue<TreeNode*> q;
        q.push(root);
        vector<TreeNode*> now;
        while(!q.empty())
        {
            int size = q.size();   // 新的一层
            now.clear();
            for(int i = 0; i < size;i++)
            {
                TreeNode* tmp = q.front();
                q.pop();
                now.push_back(tmp);
                if(tmp->left)q.push(tmp->left);
                if(tmp->right)q.push(tmp->right);
            }
        }
        return now[0]->val;
    }
};

2 112. 路径总和 & 113. 路径总和 II

112. 路径总和

直接做，普通的深搜（无所谓什么序）AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    bool pathsum(TreeNode* root,int tmpsum, int targetSum)
    {
        if(root == nullptr)  //考虑空树的情况！！！！
        {
            return 0;
        }

        if(!root->left && !root->right)  //叶子节点
        {
            if(tmpsum + root->val == targetSum)return 1;
            else return 0;
        }
        bool ans1 = 0;
        bool ans2 = 0;
        // 左儿子
        if(root->left)ans1 = pathsum(root->left,tmpsum + root->val,targetSum);
        // 右儿子
        if(root->right)ans2 = pathsum(root->right,tmpsum + root->val,targetSum);

        if((ans1 || ans2) == true)return 1;
        else return 0;
    }


    bool hasPathSum(TreeNode* root, int targetSum) {
        // 写一个深搜
        return pathsum(root,0,targetSum);
    }
};

113. 路径总和 II

和前一题差不多，就是多加了存储路径的工作，一次AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void pathsearch(vector<vector<int>>& ans,TreeNode* root, int targetSum,int tmpsum,vector<int> tmproot)
    {
        if(root == nullptr)return;
        if(!root->left && !root->right)  //叶子节点
        {
            if(tmpsum + root->val == targetSum)
            {
                tmproot.push_back(root->val);
                ans.push_back(tmproot);
            }
            return;
        }
        tmproot.push_back(root->val);
        if(root->left)pathsearch(ans,root->left,targetSum,tmpsum + root->val,tmproot);
        tmproot.pop_back();

        tmproot.push_back(root->val);
        if(root->right)pathsearch(ans,root->right,targetSum,tmpsum + root->val,tmproot);
        tmproot.pop_back();

    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) 
    {
        vector<vector<int>> ans;
        vector<int> tmproot;
        pathsearch(ans,root,targetSum,0,tmproot);
        return ans;
    }
};

3 106. 从中序与后序遍历序列构造二叉树 & 105. 从前序与中序遍历序列构造二叉树

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

根据Carl的思路来写的，

六个步骤：

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

AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* search(vector<int>& inorder, vector<int>& postorder) 
    {
        // 第一步：如果数组大小为零的话，说明是空节点了。
        if(postorder.size() == 0 || inorder.size() == 0)return nullptr;
        

        // 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
        int tmp = postorder[postorder.size() - 1];
        TreeNode* node = new TreeNode(tmp);  // 一个新的节点
        if(postorder.size() == 1)return node;

        // 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
        auto tmpitr = find(inorder.begin(),inorder.end(),tmp);

        // 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
        vector<int> inorderleft(inorder.begin(),tmpitr);  // 根据切割点分割
        vector<int> inorderright(tmpitr + 1,inorder.end());

        // 第五步：切割后序数组，切成后序左数组和后序右数组
        vector<int> postorderleft(postorder.begin() , postorder.begin() + inorderleft.size());  // 根据已知的切割后的中序数组的大小来切分
        vector<int> postorderright(postorder.begin() + inorderleft.size(), postorder.end() - 1);

        // 第六步：递归处理左区间和右区间
        node->left = search(inorderleft , postorderleft);
        node->right = search(inorderright , postorderright);
        return node;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) 
    {
        return search(inorder, postorder);
    }
};

105. 从前序与中序遍历序列构造二叉树

和前一题差不多。

重新写一遍，AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* search(vector<int>& preorder, vector<int>& inorder) 
    {
        if(preorder.size() == 0 || inorder.size() == 0)return nullptr;

        int tmp = preorder[0];
        TreeNode* node = new TreeNode(tmp);
        if(inorder.size() == 1)return node;

        auto tmpite = find(inorder.begin(),inorder.end(),tmp);
        vector<int> inleft(inorder.begin(),tmpite);  // 先切分 中序
        vector<int> inright(tmpite + 1,inorder.end());

        vector<int> preleft(preorder.begin() + 1,preorder.begin() + inleft.size() + 1);
        vector<int> preright(preorder.begin() + inleft.size() + 1,preorder.end());  

        node->left = search(preleft,inleft);
        node->right = search(preright,inright); 

        return node;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) 
    {
        return search(preorder, inorder);
    }
};