113. 路径总和 II
给定一个二叉树和一个目标和,找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树,以及目标和 sum = 22,
5
/ \
4 8
/ / \
11 13 4
/ \ / \
7 2 5 1
返回:
[
[5,4,11,2],
[5,8,4,5]
]
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/path-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ void pre_order(TreeNode *node, int sum,int value, vector<vector<int> > &result, vector<int> &road) { if(node == nullptr) return; value += node->val; road.push_back(node->val); if(node->left == nullptr && node->right == nullptr && value == sum) { result.push_back(road); } pre_order(node->right,sum,value,result,road); pre_order(node->left,sum,value,result,road); road.pop_back(); } class Solution { public: vector<vector<int>> pathSum(TreeNode* root, int sum) { vector<vector<int> > result; vector<int>road; pre_order(root,sum,0,result,road); return result; } };
236. 二叉树的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ void pre_order(TreeNode *node,TreeNode*isearch,vector<TreeNode*> &path,vector <TreeNode*> &result,int &finish) { if(node == NULL ||finish == 1) { return; } path.push_back(node); if(node == isearch) { finish = 1; result = path; } pre_order(node->left,isearch,path,result,finish); pre_order(node->right,isearch,path,result,finish); path.pop_back(); } class Solution { public: TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { vector<TreeNode*> p_path; vector<TreeNode*> q_path; vector<TreeNode*> path; int finish =0; int len; pre_order(root,p,path,p_path,finish); path.clear(); finish = 0; pre_order(root,q,path,q_path,finish); if(p_path.size() > q_path.size()) { len = q_path.size(); } else { len = p_path.size(); } TreeNode * result; for(int i=0 ; i< len;i++) { if(p_path[i] == q_path[i]) { result = p_path[i]; } } return result; } };
114. 二叉树展开为链表
给定一个二叉树,原地将它展开为链表。
例如,给定二叉树
1
/ \
2 5
/ \ \
3 4 6
将其展开为:
1
\
2
\
3
\
4
\
5
\
6
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: void flatten(TreeNode* root) { TreeNode*last = NULL; preorder(root,last); } private: void preorder(TreeNode*node,TreeNode *&last) { if(node == NULL) return; if(node->left == NULL && node->right == NULL) { last = node; return; } TreeNode *left = node->left; TreeNode *right = node->right; TreeNode *left_last = NULL; TreeNode *right_last = NULL; if(left) { preorder(node->left,left_last); node->left = NULL; node->right = left; left_last->right = right; last = left_last; } if(right) { preorder(node->right,right_last); if(left_last) { left_last->right = right; } last = right_last; } } };
插播一个层序遍历 也就是bfs
void bfs_print(TreeNode* root) { queue<TreeNode*> Q; Q.push(root); while(!Q.empty()) { TreeNode *node = Q.front(); Q.pop(); cout<<node->val<<" "; if(node->left != NULL) Q.push(node->left); if(node->right != NULL) Q.push(node->right); } }
199. 二叉树的右视图
给定一棵二叉树,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <---
/ \
2 3 <---
\ \
5 4 <---
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/binary-tree-right-side-view
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: vector<int> rightSideView(TreeNode* root) { vector<int> result; queue<pair<TreeNode*,int> > Q; if(root!= NULL) { Q.push(make_pair(root,0)); } while(!Q.empty()) { TreeNode* node = Q.front().first; int deep = Q.front().second; Q.pop(); if(result.size() == deep) { result.push_back(node->val); } else//不是新层,只更新当前层的val { result[deep] = node->val; } if(node->left) { Q.push(make_pair(node->left,deep+1)); } if(node->right) { Q.push(make_pair(node->right,deep+1)); } } return result; } };