树/图的练习
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; } };
207. 课程表
现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/course-schedule
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
dfs
struct GraphNode { int lable; vector<GraphNode*> neighbors; GraphNode(int x):lable(x){}; }; bool DFS_graph(GraphNode*node,vector<int> &visit) { visit[node->lable] = 0; for(int i = 0; i < node->neighbors.size();i++) { if(visit[node->neighbors[i]->lable] == -1) { if(!DFS_graph(node->neighbors[i],visit)) { return false; } } else if(visit[node->neighbors[i]->lable] == 0) { return false; } } visit[node->lable] = 1; return true; } class Solution { public: bool canFinish(int numCourses, vector<vector<int> >& prerequisites) { vector<GraphNode*> graph;//邻接表 vector<int> visit;//-1表示未访问，0表示正在访问，1表示已经访问 for(int i = 0; i < numCourses;i++) { graph.push_back(new GraphNode(i));//创建图的节点，并赋值访问状态为空 visit.push_back(-1); } for(int i = 0; i <prerequisites.size();i++) { GraphNode *begin = graph[prerequisites[i][1]]; GraphNode *end = graph[prerequisites[i][0]]; begin->neighbors.push_back(end); } for(int i = 0; i < prerequisites.size();i++) { if(visit[i] == -1 && !DFS_graph(graph[i],visit))//在节点没有访问过且遇到环的情况下返回false return false; } for(int i = 0; i < numCourses;i++) { delete graph[i]; } return true; } };
bfs
struct GraphNode { int lable; vector<GraphNode*> neighbors; GraphNode(int x):lable(x){}; }; class Solution { public: bool canFinish(int numCourses, vector<vector<int> >& prerequisites) { vector<GraphNode*> graph;//邻接表 vector<int> degree;//入度数组 for(int i = 0; i < numCourses;i++) { degree.push_back(0); graph.push_back(new GraphNode(i)); } for(int i = 0; i <prerequisites.size();i++) { GraphNode*begin = graph[prerequisites[i][1]]; GraphNode*end = graph[prerequisites[i][0]]; begin->neighbors.push_back(end); degree[prerequisites[i][0]]++; } queue<GraphNode*> Q; for(int i = 0; i < numCourses;i++) { if(degree[i] == 0) Q.push(graph[i]); } while(!Q.empty()) { GraphNode*node = Q.front(); Q.pop(); for(int i = 0; i <node->neighbors.size();i++) { degree[node->neighbors[i]->lable]--; if(degree[node->neighbors[i]->lable] == 0) Q.push(node->neighbors[i]); } } for(int i = 0; i < degree.size();i++) delete graph[i]; for(int i = 0; i < degree.size();i++) { if(degree[i]) return false; } return true; } };
posted on 2020-03-07 16:09 KID_XiaoYuan 阅读(153) 评论(0) 编辑 收藏 举报
