代码随想录算法训练营day 17第六章二叉树part04

最新推荐文章于 2024-07-19 19:11:19 发布

.wsy.

最新推荐文章于 2024-07-19 19:11:19 发布

阅读量334

点赞数 9

分类专栏：代码随想录训练营文章标签：算法数据结构

本文链接：https://blog.csdn.net/mrmobi/article/details/135893953

版权

代码随想录训练营专栏收录该内容

49 篇文章 1 订阅

订阅专栏

110.平衡二叉树（优先掌握递归）

再一次涉及到，什么是高度，什么是深度，可以巩固一下。

题目链接/文章讲解/视频讲解：代码随想录

递归法。其实就是在求最大深度（最大深度才能代表这个节点的高度）的函数的基础上修改的，如果左右节点的高度差的绝对值不超过1，才会返回该节点的高度，便于求该节点的祖先节点们是否满足这个关系，而且不需要完全遍历，只要判断出来一次递归的结果是-1，就能直接返回所有之前调用的递归函数。最后用根节点的结果是否为-1，来判断是否平衡——

class Solution {
public:
    int getheight(TreeNode* node){
        if (node==NULL) return 0;
        int leftnode=getheight(node->left);
        if(leftnode==-1) return -1;
        int rightnode=getheight(node->right);
        if(rightnode==-1) return -1;
        if(abs(leftnode-rightnode)>1) return -1;
        else return max(leftnode,rightnode)+1;
    }
    bool isBalanced(TreeNode* root) {
        
        return getheight(root)==-1?false:true;
    }
};

迭代法。对于求深度的函数：首先是使用栈来储存节点的，这是因为栈先进后出的特点契合于高度的求法，高度就是从底往上求的，是后序遍历；在使用后序遍历的基础上，加入对深度的求解，每遍历一个节点，就试图更新最大深度。对于主要函数：使用前序遍历，是因为不需要遍历全部节点，反而要尽少的便利次数来迅速判定不平衡——

class Solution {
private:
    int getDepth(TreeNode* cur) {
        stack<TreeNode*> st;
        if (cur != NULL) st.push(cur);
        int depth = 0; // 记录深度
        int result = 0;
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);
                depth++;
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                depth--;
            }
            result = result > depth ? result : depth;
        }
        return result;
    }

public:
    bool isBalanced(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL) return true;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                       // 中
            st.pop();
            if (abs(getDepth(node->left) - getDepth(node->right)) > 1) {
                return false;
            }
            if (node->right) st.push(node->right);           // 右（空节点不入栈）
            if (node->left) st.push(node->left);             // 左（空节点不入栈）
        }
        return true;
    }
};

257. 二叉树的所有路径（优先掌握递归）

这是大家第一次接触到回溯的过程，我在视频里重点讲解了本题为什么要有回溯，已经回溯的过程。如果对回溯似懂非懂，没关系，可以先有个印象。

题目链接/文章讲解/视频讲解：代码随想录

这是在训练营接触到的第一道使用回溯法解决的问题，当然，说是回溯，实际上并不存在选择哪个节点最终到不了叶子节点的情况。

第一种递归方式，也是我选择的递归方式，就是将潜在的一条解决方案的路径按照vector<int>的方式存储（使用栈或者队列都并不方便，因为存入最后的结果数组的时候并不能将之前存入的数值pop掉，否则就会无法实现正确回溯），注意，数组传入的方式必须是传入地址，如果是复制的话，下层的递归改变的数组的值不会影响上层递归，导致回溯不成功——

// 版本一
class Solution {
private:

    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
        path.push_back(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中 
        // 这才到了叶子节点
        if (cur->left == NULL && cur->right == NULL) {
            string sPath;
            for (int i = 0; i < path.size() - 1; i++) {
                sPath += to_string(path[i]);
                sPath += "->";
            }
            sPath += to_string(path[path.size() - 1]);
            result.push_back(sPath);
            return;
        }
        if (cur->left) { // 左 
            traversal(cur->left, path, result);
            path.pop_back(); // 回溯
        }
        if (cur->right) { // 右
            traversal(cur->right, path, result);
            path.pop_back(); // 回溯
        }
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        vector<int> path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;
    }
};

第二种递归方式。直接将panth存储为string，这时候参数string就不是引用传递了，因为回溯pop掉的并不是子节点的值而只是“->”，利用这一特点可以不必pop掉难搞的数字，上一个递归方式也可以通过值传递来免去写pop回溯——

//版本二
class Solution {
private:
    void traversal(TreeNode* cur, string path, vector<string>& result) {
        path += to_string(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中
        if (cur->left == NULL && cur->right == NULL) {
            result.push_back(path);
            return;
        }
        if (cur->left) {
            path += "->";
            traversal(cur->left, path, result); // 左
            path.pop_back(); // 回溯 '>'
            path.pop_back(); // 回溯 '-'
        }
        if (cur->right) {
            path += "->";
            traversal(cur->right, path, result); // 右
            path.pop_back(); // 回溯'>'
            path.pop_back(); // 回溯 '-'
        }
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        string path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;

    }
};

迭代法。需要将根节点到每一个节点的路径都存储起来，然后试图更新这个路径（也就是增加路径的长度，到达它的子节点们），只有当该节点是叶子节点的时候才会真正存入结果数组中——

vector<string> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> treeSt;// 保存树的遍历节点
        stack<string> pathSt;   // 保存遍历路径的节点
        vector<string> result;  // 保存最终路径集合
        if (root == NULL) return result;
        treeSt.push(root);
        pathSt.push(to_string(root->val));
        while (!treeSt.empty()) {
            TreeNode* node = treeSt.top(); treeSt.pop(); // 取出节点 中
            string path = pathSt.top();pathSt.pop();    // 取出该节点对应的路径
            if (node->left == NULL && node->right == NULL) { // 遇到叶子节点
                result.push_back(path);
            }
            if (node->right) { // 右
                treeSt.push(node->right);
                pathSt.push(path + "->" + to_string(node->right->val));
            }
            if (node->left) { // 左
                treeSt.push(node->left);
                pathSt.push(path + "->" + to_string(node->left->val));
            }
        }
        return result;
    }

404.左叶子之和（优先掌握递归）

其实本题有点文字游戏，搞清楚什么是左叶子，剩下的就是二叉树的基本操作。

题目链接/文章讲解/视频讲解：代码随想录

其实就是判断这个叶子节点必须是它的父母节点的左子树，也就是判断每一个节点它的左子节点是否是叶子节点。要注意的一点是左叶子不仅可能会出现在左子树上，还可能出现在右子树上，这是因为判定是否左叶子只和父母节点有关，和祖先节点没有关系。

我感觉文章里面的解法并不如我自己的解法更加简单易懂些。但是本质上都是一个意思。

文章解法（递归）。注意不能只写第二句提前返回，但是只写第一句提前返回是对的，只不过多执行几次函数罢了；对leftValue的重新赋值必须放在它的递归调用初始化的后面，否则执行了if语句之后，再递归调用函数leftValue的值又改为0了——

int sumOfLeftLeaves(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right== NULL) return 0;

        int leftValue = sumOfLeftLeaves(root->left);    // 左
        if (root->left && !root->left->left && !root->left->right) { // 左子树就是一个左叶子的情况
            leftValue = root->left->val;
        }
        int rightValue = sumOfLeftLeaves(root->right);  // 右

        int sum = leftValue + rightValue;               // 中
        return sum;
    }

我的解法（递归）——

class Solution {
public:
    int sum=0;
    void getsum(TreeNode* node){
        if(node->left&&node->left->left==NULL&&node->left->right==NULL){
            sum+=node->left->val;
        }else if(node->left) getsum(node->left);
        if(node->right) getsum(node->right);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        getsum(root);
        return sum;
    }
};

迭代法。主要就是对每个节点进行一下判断就可以了——

int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL) return 0;
        st.push(root);
        int result = 0;
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                result += node->left->val;
            }
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }

.wsy.

关注

9
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营day 17第六章二叉树part04

第一种递归方式，也是我选择的递归方式，就是将潜在的一条解决方案的路径按照vector<int>的方式存储（使用栈或者队列都并不方便，因为存入最后的结果数组的时候并不能将之前存入的数值pop掉，否则就会无法实现正确回溯），注意，数组传入的方式必须是传入地址，如果是复制的话，下层的递归改变的数组的值不会影响上层递归，导致回溯不成功——需要将根节点到每一个节点的路径都存储起来，然后试图更新这个路径（也就是增加路径的长度，到达它的子节点们），只有当该节点是叶子节点的时候才会真正存入结果数组中——
复制链接

扫一扫