513. 找树左下角的值

广度优先搜索，循环获取每一层第一个的值，然后返回最后一次的值

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     int findBottomLeftValue(TreeNode* root) {
15         int result = root->val;
16         queue<TreeNode*> que;
17         que.push(root);
18         while(!que.empty()){
19             int count = que.size();
20             result = que.front()->val;
21             for(int i = 0; i < count; i++){
22                 TreeNode* node = que.front();
23                 que.pop();
24                 if(node->left != nullptr)   que.push(node->left);
25                 if(node->right != nullptr)  que.push(node->right);
26             }
27         }
28         return result;
29     }
30 };

112. 路径总和

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     bool hasPathSum(TreeNode* root, int targetSum) {
15         if(root == nullptr) return false;
16         if(root->val == targetSum && root->left == nullptr && root->right == nullptr)  return true;
17         return hasPathSum(root->left, targetSum - root->val) 
18                 || hasPathSum(root->right, targetSum - root->val);
19     }
20 };

113. 路径总和 II

深度优先搜索 + 回溯

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
15         vector<vector<int>> result;
16         vector<int> vec;
17         dfs(root,targetSum,vec,result);
18         return result;
19     }
20 private:
21     void dfs(TreeNode* root, int targetSum, vector<int>& vec, vector<vector<int>>& result){
22         if(root == nullptr)     return;
23         vec.push_back(root->val);
24         if(root->left == nullptr && root->right == nullptr){
25             if(root->val == targetSum){
26                 result.push_back(vec);
27             }
28         }else{
29             dfs(root->left,targetSum - root->val, vec, result);
30             dfs(root->right, targetSum - root->val, vec, result);
31         }
32         vec.pop_back();
33     }
34 };

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

先找到根节点（续遍历最后一个），然后切割，分别找到左右子树的中序和后续遍历，然后递归

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
15         if(postorder.size() == 0)   return nullptr;
16         // 根节点
17         TreeNode* root = new TreeNode(postorder.back());
18         if(inorder.size() == 1) return root;
19         // 左子树
20         int index = 0;
21         for(int i = 0; i < inorder.size(); i++){
22             if(inorder[i] == root->val) index = i;
23         }
24         postorder.resize(postorder.size() - 1);
25         vector<int> leftInorder(inorder.begin(),inorder.begin()+index);
26         vector<int> leftPostorder(postorder.begin(),postorder.begin()+index);
27         // 右子树.
28         vector<int> rightInorder(inorder.begin()+index+1,inorder.end());
29         vector<int> rightPostorder(postorder.begin()+index,postorder.end());
30         root->left = buildTree(leftInorder, leftPostorder);
31         root->right = buildTree(rightInorder, rightPostorder);
32         return root;
33     }
34 };

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

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
15         if(preorder.size() == 0)    return nullptr;
16         TreeNode* root = new TreeNode(preorder.front());
17         if(inorder.size() == 1) return root;
18         int index = 0;
19         for(int i = 0; i < inorder.size(); i++){
20             if(inorder[i] == root->val) index = i;
21         }
22         // 子树中序
23         vector<int> leftInorder(inorder.begin(),inorder.begin()+index);
24         vector<int> rightInorder(inorder.begin()+index+1,inorder.end());
25         // 子树前序
26         vector<int> leftPreorder(preorder.begin()+1,preorder.begin()+1+index);
27         vector<int> rightPreorder(preorder.begin()+1+index,preorder.end());
28         root->left = buildTree(leftPreorder, leftInorder);
29         root->right = buildTree(rightPreorder, rightInorder);
30         return root;
31     }
32 };