1--递归遍历

1-1--前序遍历

前序遍历：根→左→右；

#include <iostream>
#include <vector>

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:
    std::vector<int> preorderTraversal(TreeNode* root) {
        std::vector<int> res;
        dfs(root, res);
        return res;
    }

    void dfs(TreeNode* root, std::vector<int>& res){
        if(root == nullptr) return;
        res.push_back(root->val);
        dfs(root->left, res);
        dfs(root->right, res);
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.preorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

1-2--中序遍历

中序遍历：左→根→右；

#include <iostream>
#include <vector>

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:
    std::vector<int> inorderTraversal(TreeNode* root) {
        std::vector<int> res;
        dfs(root, res);
        return res;
    }

    void dfs(TreeNode* root, std::vector<int>& res){
        if(root == nullptr) return;
        dfs(root->left, res);
        res.push_back(root->val);
        dfs(root->right, res);
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.inorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

1-3--后序遍历

后序遍历：左→右→根；

#include <iostream>
#include <vector>

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:
    std::vector<int> postorderTraversal(TreeNode* root) {
        std::vector<int> res;
        dfs(root, res);
        return res;
    }

    void dfs(TreeNode* root, std::vector<int>& res){
        if(root == nullptr) return;
        dfs(root->left, res);
        dfs(root->right, res);
        res.push_back(root->val);
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.postorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

2--迭代遍历

2-1--前序遍历

        基于栈结构，先将根节点入栈，再将节点从栈中弹出，如果节点的右孩子不为空，则右孩子入栈；如果节点的左孩子不为空，则左孩子入栈；

        循环出栈处理节点，并将右孩子和左孩子存在栈中（右孩子先进栈，左孩子再进栈，因为栈先进后出，这样可以确保左孩子先出栈，符合根→左→右的顺序）；

#include <iostream>
#include <vector>
#include <stack>

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:
    std::vector<int> preorderTraversal(TreeNode* root) {
        std::vector<int> res;
        if(root == nullptr) return res;
        std::stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode *tmp = stk.top();
            stk.pop();
            res.push_back(tmp->val);
            if(tmp->right != nullptr) stk.push(tmp->right); // 右
            if(tmp->left != nullptr) stk.push(tmp->left); // 左
        }
        return res;
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.preorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

2-2--后序遍历

        可以使用两个栈来实现，一个是遍历栈，一个是收集栈，参考之前的笔记：后序遍历的迭代实现        

        也可以类似于前序遍历，基于一个栈实现，只不过需要改变入栈顺序：每出栈处理一个节点，其左孩子入栈，再右孩子入栈；此时处理顺序为：根->右->左，最后将结果 reverse 即可；

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>

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:
    std::vector<int> postorderTraversal(TreeNode* root) {
        std::vector<int> res;
        if(root == nullptr) return res;
        std::stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* tmp = stk.top();
            stk.pop();
            if(tmp->left != nullptr) stk.push(tmp->left);
            if(tmp->right != nullptr) stk.push(tmp->right);
            res.push_back(tmp->val);
        }
        // 反转
        std::reverse(res.begin(), res.end());
        return res;
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.postorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

2-3--中序遍历

基于栈结构，初始化一个栈，根节点入栈；

        ①：左子结点全部入栈；

        ②：结点出栈，处理结点；

        ③：对出栈结点的右子树重复执行第 ① 步操作；

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>

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:
    std::vector<int> inorderTraversal(TreeNode* root) {
        std::vector<int> res;
        if(root == nullptr) return res;
        std::stack<TreeNode*> stk;
        while(!stk.empty() || root != nullptr){
            if(root != nullptr){ // 左子结点全部入栈
                stk.push(root);
                root = root->left;
            }
            else{
                TreeNode *tmp = stk.top();
                stk.pop();
                res.push_back(tmp->val);
                // 出栈节点的右孩子执行相同操作
                root = tmp->right;
            }    
        }
        return res;
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    Node1->right = Node2;
    Node2->left = Node3;

    Solution S1;
    std::vector<int> res = S1.inorderTraversal(Node1);
    for(auto item : res) std::cout << item << " ";
    std::cout << std::endl;
    return 0;
}

3--二叉树的层序遍历

主要思路：

        经典广度优先搜索，基于队列；

        对于本题需要将同一层的节点放在一个数组中，因此遍历的时候需要用一个变量 nums 来记录当前层的节点数，即 nums 等于队列元素的数目；

#include <iostream>
#include <vector>
#include <queue>

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:
    std::vector<std::vector<int>> levelOrder(TreeNode* root) {
        std::vector<std::vector<int>> res;
        if(root == nullptr) return res;
        std::queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int nums = q.size(); // 当前层的节点数
            std::vector<int> tmp;
            while(nums > 0){ // 遍历处理同一层
                TreeNode *cur = q.front();
                q.pop();
                tmp.push_back(cur->val);

                if(cur->left != nullptr) q.push(cur->left);
                if(cur->right != nullptr) q.push(cur->right);
                
                nums--;
            }
            res.push_back(tmp); // 记录当前层的元素
        }
        return res;
    }
};

int main(int argc, char* argv[]){
    // root = [1, null, 2, 3]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);
    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;

    Solution S1;
    std::vector<std::vector<int>> res = S1.levelOrder(Node1);
    for(auto item : res) {
        for (int v : item) std::cout << v << " ";
        std::cout << std::endl;
    }
    return 0;
}

4--翻转二叉树

主要思路：

        递归交换左右子树；

#include <iostream>
#include <vector>
#include <queue>

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) {
        reverse(root);
        return root;
    }
    void reverse(TreeNode *root){
        if(root == nullptr) return;
        reverse(root->left);
        reverse(root->right);
        TreeNode *tmp = root->left;
        root->left = root->right;
        root->right = tmp;
    }
};

// 层次遍历打印
void PrintTree(TreeNode *root){
    std::queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()) {
        TreeNode *tmp = q.front();
        q.pop();
        std::cout << tmp->val << " ";
        if(tmp->left != nullptr) q.push(tmp->left);
        if(tmp->right != nullptr) q.push(tmp->right);
    }
}

int main(int argc, char* argv[]){
    // root = [4,2,7,1,3,6,9]
    TreeNode *Node1 = new TreeNode(4);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(7);
    TreeNode *Node4 = new TreeNode(1);
    TreeNode *Node5 = new TreeNode(3);
    TreeNode *Node6 = new TreeNode(6);
    TreeNode *Node7 = new TreeNode(9);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    TreeNode *res = S1.invertTree(Node1);
    PrintTree(res);
}

5--对称二叉树

主要思路：

        递归判断左树的左子树是否与右数的右子树相等，左树的右子树是否与右树的左子树相等；

#include <iostream>
#include <vector>
#include <queue>

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 isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;
        bool res = dfs(root->left, root->right);
        return res;
    }
    bool dfs(TreeNode *left, TreeNode *right){
        if((left != nullptr && right == nullptr) ||
        (left == nullptr && right != nullptr)) return false;

        if(left == nullptr && right == nullptr) return true;
        if (left->val != right->val) return false;

        bool isSame1 = dfs(left->left, right->right);
        bool isSame2 = dfs(left->right, right->left);
        return isSame1 && isSame2;
    }
};

int main(int argc, char* argv[]){
    // root = [4,2,7,1,3,6,9]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(2);
    TreeNode *Node4 = new TreeNode(3);
    TreeNode *Node5 = new TreeNode(4);
    TreeNode *Node6 = new TreeNode(4);
    TreeNode *Node7 = new TreeNode(3);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;

    Solution S1;
    bool res = S1.isSymmetric(Node1);
    if(res) std::cout << "true" << std::endl;
    else std::cout << "false" << std::endl;
}

6--二叉树最大深度

主要思路：

        递归计算左右子树的深度，选取两者最大值 +1 返回；

#include <iostream>
#include <vector>
#include <queue>

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 maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int res = dfs(root);
        return res;
    }

    int dfs(TreeNode* root){
        if(root == nullptr) return 0;
        int left_height = dfs(root->left);
        int right_height = dfs(root->right);
        int cur_height = std::max(left_height, right_height) + 1;
        return cur_height;
    }
};

int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;

    Solution S1;
    int res = S1.maxDepth(Node1);
    std::cout << res << std::endl;
    return 0;
}

7--二叉树的最小深度

主要思路：

        与上题有点类似，递归返回最小深度即可，但需要剔除根节点一个子树为空的情况；

        对于一个根节点，其中一个子树为空，则其最小深度是不为空的子树的深度；

#include <iostream>
#include <vector>
#include <queue>

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

    int dfs(TreeNode *root){
        if(root == nullptr) return 0;
        // 剔除两种情况
        if(root->left == nullptr) return dfs(root->right) + 1;
        else if(root->right == nullptr) return dfs(root->left) + 1;
        else{
            int left_height = dfs(root->left);
            int right_height = dfs(root->right);
            int cur_min_height = std::min(left_height, right_height) + 1;
            return cur_min_height;
        }
    }
};

int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;

    Solution S1;
    int res = S1.minDepth(Node1);
    std::cout << res << std::endl;
    return 0;
}

8--完全二叉树节点的数量

主要思路：

        普通二叉树可以通过层次遍历来统计节点数目；

        对于本题中的完全二叉树，可以通过 2**k - 1 的公式来计算二叉树节点的数目；

        首先需判断一个子树是否为完全二叉树，如果是则通过上式计算；如果不是完全二叉树，则对于当前子树，需要分别向左右子树递归计算其节点数目（相当于获取信息），最后将结果相加（相当于处理信息），并加上1返回即可；

#include <iostream>
#include <vector>
#include <queue>

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 countNodes(TreeNode* root) {
        if(root == nullptr) return 0;
        return dfs(root);
    }
    int dfs(TreeNode *root){
        if(root == nullptr) return 0;
        TreeNode *left = root->left, *right = root->right;
        int left_height = 0, right_height = 0;
        while(left != nullptr){
            left = left->left;
            left_height++;
        }
        while(right != nullptr){
            right = right->right;
            right_height++;
        }
        if(left_height == right_height) return (2<<left_height) - 1; // 满二叉树
        int left_nums = dfs(root->left);
        int right_nums = dfs(root->right);
        return left_nums + right_nums + 1;
    }
};

int main(int argc, char* argv[]){
    // root = [1,2,3,4,5,6]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(4);
    TreeNode *Node5 = new TreeNode(5);
    TreeNode *Node6 = new TreeNode(6);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;

    Solution S1;
    int res = S1.countNodes(Node1);
    std::cout << res << std::endl;
    return 0;
}

9--平衡二叉树

主要思路：

        通过高度差不大于1，来递归判断子树是否是平衡二叉树，不是则返回-1，是则返回对应的高度；

#include <iostream>
#include <vector>

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 isBalanced(TreeNode* root) {
        if(root == nullptr) return true;
        int height = dfs(root);
        return height == -1 ? false : true;
    }

    int dfs(TreeNode *root){
        if(root == nullptr) return 0;
        int left_height = dfs(root->left);
        if(left_height == -1) return -1;
        int right_height = dfs(root->right);
        if(right_height == -1) return -1;
        if(std::abs(left_height - right_height) > 1) return -1;
        else return std::max(left_height, right_height) + 1;
    }
};

int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;

    Solution S1;
    bool res = S1.isBalanced(Node1);
    if(res) std::cout << "true" << std::endl;
    else std::cout << "false" << std::endl;
    return 0;
}

10--二叉树的所有路径

主要思路：

        递归记录路径；

#include <iostream>
#include <vector>
#include <string>

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:
    std::vector<std::string> binaryTreePaths(TreeNode* root) {
        std::vector<std::string> res;
        if(root == nullptr) return res;
        std::string path = "";
        dfs(root, res, path);
        return res;
    }

    void dfs(TreeNode *root, std::vector<std::string>& res, std::string path){
        if(root == nullptr) return;

        path += std::to_string(root->val);
        if(root->left == nullptr && root->right == nullptr) { // 叶子节点，回收路径
            res.push_back(path);
            return;
        }
        else path += "->";
        dfs(root->left, res, path);
        dfs(root->right, res, path);
    }
};

int main(int argc, char* argv[]){
    // root = [1,2,3,null,5]
    TreeNode *Node1 = new TreeNode(1);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(3);
    TreeNode *Node4 = new TreeNode(5);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->right = Node4;

    Solution S1;
    std::vector<std::string> res = S1.binaryTreePaths(Node1);
    for(auto path : res) std::cout << path << std::endl;
    return 0;
}

11--左叶子之和

主要思路：

        递归到叶子节点的上一层，返回其左叶子之和；

#include <iostream>
#include <vector>
#include <string>

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;
        return dfs(root);
    }
    int dfs(TreeNode* root){
        if(root == nullptr) return 0;
        if(root->left == nullptr && root->right == nullptr) return 0;
        int sum = 0;
        if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr){
            sum = root->left->val;
        }
        int left = dfs(root->left);
        int right = dfs(root->right);
        return left + right + sum;
    }
};

int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(9);
    TreeNode *Node3 = new TreeNode(20);
    TreeNode *Node4 = new TreeNode(15);
    TreeNode *Node5 = new TreeNode(7);

    Node1->left = Node2;
    Node1->right = Node3;
    Node3->left = Node4;
    Node3->right = Node5;

    Solution S1;
    int res = S1.sumOfLeftLeaves(Node1);
    std::cout << res << std::endl;
    return 0;
}

12--找树左下角的值

主要思路：

        递归到最大深度层，优先返回最左边的节点值，即递归时优先搜索左子树；

#include <iostream>
#include <vector>
#include <limits.h>

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) {
        if(root == nullptr) return 0;
        int max_height = INT_MIN;
        int result = 0;
        dfs(root, 0, max_height, result);
        return result;
    }

    void dfs(TreeNode* root, int curheight, int& max_height, int& res){
        if(root == nullptr) return;
        if(root->left == nullptr && root->right == nullptr){ // 叶子节点
            if(curheight + 1 > max_height){
                max_height = curheight + 1;
                res = root->val;
                return;
            }
        }
        dfs(root->left, curheight+1, max_height, res);
        dfs(root->right, curheight+1, max_height, res);  
    }
};

int main(int argc, char* argv[]){
    // root = [3,9,20,null,null,15,7]
    TreeNode *Node1 = new TreeNode(2);
    TreeNode *Node2 = new TreeNode(1);
    TreeNode *Node3 = new TreeNode(3);

    Node1->left = Node2;
    Node1->right = Node3;

    Solution S1;
    int res = S1.findBottomLeftValue(Node1);
    std::cout << res << std::endl;
    return 0;
}

13--路径总和