5. leetcode(二叉树)

最新推荐文章于 2024-10-27 05:38:01 发布
最新推荐文章于 2024-10-27 05:38:01 发布
阅读量771 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44847326/article/details/123558105
版权

二叉树

//前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if (root == NULL) {
            return res;
        }

        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node->val);

            if (node->right) {
                st.push(node->right)
            }
            if (node->left) {
                st.push(node->left);
            }
        }
        return res;
    }    
};

//中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != nullptr || !st.empty()) 
        {
            if (cur != nullptr) {  // 指针访问节点，访问到最底层
                st.push(cur);      // 将访问的节点放入栈
                cur = cur->left;   // 左
            } else {               // 左空
                cur = st.top();    // 从栈里弹出数据
                st.pop();
                res.push_back(cur->val); //中
                cur = cur->right;  //右
            }
        }
        return res;
        
    }
};

二叉树的层序遍历

//层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;

        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i  = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);

                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

1. leetcode 107 二叉树的层序遍历 II

/**
 * 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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);

                if (node->left) {
                    que.push(node->left); 
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            res.push_back(vec);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

2. leetcode 199 二叉树的右视图

/**
 * 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:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;

        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();

                if (i == size - 1) {   //将每一层的最后元素放入result数组中
                    res.push_back(node->val);
                }
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return res;
    }
};

3. leetcode 637 二叉树的层平均值


/**
 * 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:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        queue<TreeNode*> que;

        if (root != nullptr) {
            que.push(root); 
        }

        while (!que.empty()) {
            double sum = 0;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();

                sum += node->val;

                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            res.push_back(sum / size);  //将每一层的均指放入结果集
        }
        return res;
    }
};

4. leetcode 429. N 叉树的层序遍历

//4. leetcode 429. N 叉树的层序遍历
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        queue<Node*> que;

        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                //将孩子节点加入队列
                for (int i = 0; i < node->children.size(); i++) {  
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

5. leetcode 515 在每个树行中找最大值

//5. leetcode 515 在每个树行中找最大值
/**
 * 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:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN;

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;

                if (node->left) {
                    que.push(node->left); 
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            res.push_back(maxValue);
        }
        return res;
    }
};

6. leetcode 116 填充每个节点的下一个右侧节点指针

//6.leetcode 116 填充每个节点的下一个右侧节点指针

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;

        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            Node* nodepre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodepre = que.front();  // 取出每层的头节点
                    que.pop();
                    node = nodepre;
                } else {
                    node = que.front();
                    que.pop();
                    nodepre->next = node;  //本层的前个节点的next值向本节点
                    nodepre = nodepre->next;
                }

                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            nodepre->next = nullptr;   //本层的尾节点指向nullptr
        } 
        return root;
    }
};

7. leetcode 117 填充每个节点的下一个右侧节点指针 II

//7.leetcode 117 填充每个节点的下一个右侧节点指针 II

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;

        if (root != nullptr) {
            que.push(root);
        }

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;

            Node* nodepre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodepre = que.front();  // 取出每层的头节点
                    que.pop();
                    node = nodepre;
                } else {
                    node = que.front();
                    que.pop();
                    nodepre->next = node;  //本层的前个节点的next值向本节点
                    nodepre = nodepre->next;
                }

                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
            nodepre->next = nullptr;   //本层的尾节点指向nullptr
        } 
        return root;
    }
};

二叉树的属性

8. leetcode 226 翻转二叉树

//8.leetcode 226 翻转二叉树

/**
 * 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* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return root;
        }

        std::swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;

    }
};


//迭代 深度优先遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return root;
        }
        stack<TreeNode*> st;
        st.push(root);

        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if (node->left) {
                st.push(node->left);
            }
            if (node->right) {
                st.push(node->right);
            }
        }
        return root;
    }
};
//迭代 广度优先遍历
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }
        while(!que.empty()) {
            int size = que.size();

            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

9. leetcode 101 对称二叉树

//9.leetcode 101 对称二叉树 

//递归
/**
 * 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 compare(TreeNode* left, TreeNode* right) {
        //先排除空节点
        if (left == nullptr && right == nullptr) {
            return true;
        } else if (left != nullptr && right == nullptr) {
            return false;
        } else if (left == nullptr && right != nullptr) {
            return false;
        //排除数值不同的情况
        } else if (left->val != right->val){
            return false;
        }
        
        //左右不空且数值相同，做递归
        bool outside = compare(left->left, right->right);  //外
        bool inside = compare(left->right, right->left);   //内
        bool isSame = outside && inside;
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }
        return compare(root->left, root->right);
    }
};
//迭代
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }
        queue<TreeNode*> que;
        que.push(root->left);  //左子树头节点加入队列
        que.push(root->right); //右子树头节点加入队列
        while (!que.empty()) {
            TreeNode* leftNode = que.front();
            que.pop();
            TreeNode* rightNode = que.front();
            que.pop();

            if (!leftNode && !rightNode) {  //左右节点都为空，则对称
                continue;
            }

            //左右节点有且仅有一个为空，或都不空但是数值不同，则false
            if (!leftNode || !rightNode || (leftNode->val != rightNode->val)) {
                return false;
            }

            que.push(leftNode->left);   // 加入左子树左孩子
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);

        }
        return true;
    }
};

10. leetcode 104 二叉树的最大深度

//10.leetcode 104 二叉树的最大深度

//递归
/**
 * 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 getDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int leftDepth = getDepth(root->left);
        int rightDepth = getDepth(root->right);
        int depth = 1 + max(leftDepth, rightDepth);
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

//迭代  层序遍历
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return depth;
    }
};

11. leetcode 559 N 叉树的最大深度

//11.leetcode 559 N 叉树的最大深度

//递归
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == nullptr) {
            return 0;
        }
        int depth = 0;

        for (int i = 0; i < root->children.size(); i++) {
            depth = max(depth, maxDepth(root->children[i]));
        }
        return depth + 1;
    }
};

//迭代

class Solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> que;
        if (root != nullptr) {
            que.push(root);
        }

        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for (int j = 0; j < node->children.size(); j++) {
                    if (node->children[j]) {
                        que.push(node->children[j]);
                    }
                }
            }
        }
        return depth;
    }
};

12. leetcode 111 二叉树的最小深度

//12.leetcode 111 二叉树的最小深度

//递归
/**
 * 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 getDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }

        int leftDepth = getDepth(root->left);
        int rightDepth = getDepth(root->right);

        //当一个左子树为空，右不为空，这是并不是最低点
        if (root->left == nullptr && root->right != nullptr) {
            return 1 + rightDepth;
        }
        if (root->left != nullptr && root->right == nullptr) {
            return 1 + leftDepth;
        }
        int res = 1 + min(leftDepth, rightDepth);
        return res;
    }
    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

//迭代
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();

                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
                if (!node->left && !node->right) {
                    return depth;
                }
            }
        }
        return depth;
    }
};

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        if (root->left == nullptr && root->right == nullptr) {
            return 1;
        }

        int min_depth = INT_MAX;
        if (root->left != nullptr) {
            min_depth = min(minDepth(root->left), min_depth);
        }
        if (root->right != nullptr) {
            min_depth = min(minDepth(root->right), min_depth);
        }

        return min_depth + 1;
    }
};

13. leetcode 222 完全二叉树的节点个数

//13.leetcode 222 完全二叉树的节点个数

// 按普通二叉树来解
//递归
/**
 * 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 getNodeNum(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int leftNum = getNodeNum(root->left);
        int rightNum = getNodeNum(root->right);
        int nodenum = 1 + leftNum + rightNum;
        return nodenum;
    }
    int countNodes(TreeNode* root) {
        return getNodeNum(root);
    }
};

//迭代
class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }
        int res = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                res++;
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return res;
    }
};

//利用完全二叉树性质

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        TreeNode* leftnode = root->left;
        TreeNode* rightnode = root->right;
        int leftheight = 0, rightheight = 0;
        //求左子树深度
        while (leftnode) {   
            leftnode = leftnode->left;
            leftheight++;
        }
        //求右子树深度
        while(rightnode) {
            rightnode = rightnode->right;
            rightheight++;
        }
        if (leftheight == rightheight) {
            return (2 << leftheight) - 1;  //(2 << 1) 相当于 2^2 所以leftheight初始为0
        }
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

14. leetcode 110 平衡二叉树

//14.leetcode 110 平衡二叉树

//递归
/**
 * 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 getDepth(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int leftDepth = getDepth(root->left);
        if (leftDepth == -1) {  //说明左子树已经不是二叉平衡树
            return -1;
        }
        int rightDepth = getDepth(root->right);
        if (rightDepth == -1) {  // 说明右子树已经不是二叉平衡树
            return -1;
        }
        return abs(leftDepth - rightDepth) > 1 ? -1 :1 + max(leftDepth, rightDepth);
    }
    bool isBalanced(TreeNode* root) {
        return getDepth(root) == -1 ? false : true;
    }
};

15. leetcode 257 二叉树的所有路径

//15.leetcode 257 二叉树的所有路径

//深度优先搜索
/**
 * 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 construct_paths(TreeNode* root, string path, vector<string>& paths) {
        if (root != nullptr) {
            path += to_string(root->val);
            //当前节点是叶子节点 把路径加入到答案中
            if (root->left == nullptr && root->right == nullptr) {
                paths.push_back(path);
            }  else {
                path += "->";   //当前节点不是叶子节点，继续递归遍历
                construct_paths(root->left, path, paths);
                construct_paths(root->right, path, paths);
            }
        }
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> paths;
        construct_paths(root, "", paths);
        return paths;
    }
};

16. leetcode 100 相同的树

//16.leetcode 100 相同的树

//递归  深度优先搜索
/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if (p == nullptr && q == nullptr) {
            return true;
        } else if (p == nullptr || q == nullptr) {
            return false;
        } else if (p->val != q->val) {
            return false;
        } else {
            return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
        }
    }
};

17. leetcode 572 另一棵树的子树

//17.leetcode 572 另一棵树的子树
class Solution {
public:
    bool isSame(TreeNode* root, TreeNode* subRoot) {
        if (!root && !subRoot) {
            return true;
        }
        if (root->val != subRoot->val) {
            return false;
        }
        return isSame(root->left, subRoot->left) && isSame(root->right, subRoot->right);
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if (!root) {
            return false;
        }
        if (isSame(root, subRoot)) {
            return true;
        }
        return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
    }
    
};

18. leetcode 404 左叶子之和

//18.leetcode 404 左叶子之和

/**
 * 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 sumOfLeftLeaves(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }

        int leftValue = sumOfLeftLeaves(root->left);
        int rightValue = sumOfLeftLeaves(root->right);
        int midValue = 0;
        if (root->left && !root->left->left && !root->left->right) {
            midValue = root->left->val;
        }
        int sum = midValue + leftValue + rightValue;
        return sum;
    }
};

19. leetcode 513 找树左下角的值

//19.leetcode 513 找树左下角的值

/**
 * 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*> que;
        if (root != nullptr) {
            que.push(root);
        }
        int res = 0;
        while(!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == 0) {
                    res = node->val;  //每行的首元素
                }
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return res;
    }
};

20. leetcode 112 路径总和

//20.leetcode 112 路径总和
class solution {
private:
    bool traversal(treenode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回

        if (cur->left) { // 左
            count -= cur->left->val; // 递归，处理节点;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; // 回溯，撤销处理结果
        }
        if (cur->right) { // 右
            count -= cur->right->val; // 递归，处理节点;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val; // 回溯，撤销处理结果
        }
        return false;
    }

public:
    bool haspathsum(treenode* root, int sum) {
        if (root == null) return false;
        return traversal(root, sum - root->val);
    }
};
EurekaZzz
关注
专栏目录
12-5 LeetCode：101. 对称二叉树.mp4
05-30
12-5 LeetCode：101. 对称二叉树.mp4
leetcode100-LiuBoss.LeetCode:LeetCodeby刘老板
06-30
5. 项目结构：可能按照LeetCode的分类（如数组、链表、二叉树等）组织，便于学习和查阅。 总的来说，"LeetCode100-LiuBoss.LeetCode"项目是一个专注于LeetCode热门100题目的学习资源，涵盖了数组、链表和二叉树等...
LeetCode二叉树系列——101.对称二叉树
w20001118的博客
07-31 1079
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。intval;};大家会发现二叉树的定义和链表是差不多的，相对于链表，二叉树的节点里多了一个指针，有两个指针，指向左右孩子。这里要提醒大家要注意二叉树节点定义的书写方式。在现场面试的时候面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。...
leetcode——二叉树问题汇总
Michael_Jay的博客
03-12 1166
本章汇总了二叉树相关题目
【宽搜】5.leetcode 199 二叉树的右视图
gaogo
10-09 437
用宽度优先遍历的方式讲解leetcode 199 二叉树的右视图
leetcode 617. 合并二叉树 python
ganggang的博客
10-09 289
题目描述： 题解： 1.如果当前位置两个二叉树的节点都非空，则将root1.val更新为root1.val和root2.val之和。 2.如果当前位置只存在root1或root2，则直接返回即可。 3.然后在对左右子树递归调用。 class Solution(object): def connect(self, root): if root is None or root.left is None: return None r.
LeetCode-110. 平衡二叉树(java)
**My Coding Family**
03-24 1264
金三银四，又到了刷题月。有时间的话，希望大家还是尽量刷起来咯。帮助往往不是直接体现出来的，但会让你对很多东西的底层实现了解的更深刻。
leetcode 110. 平衡二叉树
行走巨人国
05-21 700
题目描述： 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树[3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回true。示例 2: 给定二叉树[1,2,2,3,3...
leetcode110. 平衡二叉树，详细步骤附代码
qq_51350957的博客
07-28 382
leetcode110. 平衡二叉树，详细步骤附代码
代码随想录算法训练营第14天 |LeetCode226.翻转二叉树 LeetCode101. 对称二叉树 LeetCode104.二叉树的最大深度 LeetCode111.二叉树的最小深度
2301_79647020的博客
07-16 1066
今天的内容应用了好多二叉树遍历的做法，个人对递归更熟悉，主要用递归实现，其实栈和层序遍历也可实现。
leetcode二叉树的层序遍历
weixin_45237107的博客
09-01 287
给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其自底向上的层序遍历为： [ [15,7], [9,20], [3] ] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii /* // Definiti
LeetCode二叉树系列——144.二叉树的前序遍历
w20001118的博客
07-29 669
关于二叉树的遍历方式，要知道二叉树遍历的基本方式都有哪些。 一些同学用做了很多二叉树的题目了，可能知道前中后序遍历，可能知道层序遍历，但是却没有框架。 我这里把二叉树的几种遍历方式列出来，大家就可以一一串起来了。 二叉树主要有两种遍历方式： 深度优先遍历：先往深走，遇到叶子节点再往回走。 广度优先遍历：一层一层的去遍历。 这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候 还会介绍到。 那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式： 深度优先遍历 前序遍历（递归法，迭代.
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
LeetCode 331. 验证二叉树的前序序列化
12-21
对于题目“LeetCode 331. 验证二叉树的前序序列化”，主要涉及以下几点： 1. **前序遍历序列化**： - 前序遍历序列化过程通常会将每个节点的值（通常是整数）以及空节点（用符号如 '#' 表示）依次记录下来。 - ...
leetcode:oj.leetcode 的代码
07-04
5. **效率优化**：LeetCode的问题往往有时间复杂度和空间复杂度的要求，因此在编写Java代码时，要注重算法效率。通过减少不必要的计算、使用更优的数据结构或算法，以及避免冗余操作，可以提高代码运行速度和内存...
二叉树习题其六【力扣】【算法学习day.13】
2301_79232523的博客
10-25 589
书接上篇文章二叉树习题其四，这篇文章我们将基础拓展###我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
C++ | Leetcode C++题解之第514题自由之路
最新发布
Ddddddd_158的博客
10-27 372
C++ | Leetcode C++题解之第514题自由之路
力扣 中等 198.打家劫舍
qq_51352130的博客
10-25 456
法一：动态规划 和716最少花费爬楼梯思路一样链接确定dp数组（dp table）以及下标的含义：dp[i]的定义为到第i号房屋能偷窃到的最高金额为dp[i]确定递推公式：可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。所以 dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1])dp数组如何初始化：dp[0] = nums[0];确定遍历顺序举例推导dp数组// nums.length是大于等于1的。
Java | Leetcode Java题解之第514题自由之路
m0_57195758的博客
10-27 289
Java | Leetcode Java题解之第514题自由之路
PHP解决LeetCode二叉树深度问题
资源摘要信息:"php-leetcode题解之二叉树的最大深度.zip" 知识点概述： 1. 二叉树的数据结构 2. 二叉树的最大深度问题 3. PHP编程语言 4. LeetCode在线编程平台 5. 算法问题解决方法 1. 二叉树的数据结构： 二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值