1.5道经典 二叉树与图 图的相关题目
预备知识:二叉树基础知识
例1:路径之和2(medium) (二叉树深搜)
例2:最近的公共祖先(medium) (二叉树性质)
例3:二叉树转链表(medium) (二叉树与链表)
预备知识:二叉树层次遍历
例4:侧面观察二叉树(medium) (二叉树宽搜)
预备知识:图的基础知识
例5:课程安排(有向图判断环)(medium)
例1:路径之和2(medium) (二叉树深搜)
113.路径总和 II
难度中等
给定一个二叉树和一个目标和,找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树,以及目标和 sum = 22,
5
/
4 8
/ /
11 13 4
/ \ /
7 2 5 1
返回:
[
[5,4,11,2],
[5,8,4,5]
]
public class Solution {
public List<List<Integer>> pathSum(TreeNode root, int sum) {
List<List<Integer>> result=new ArrayList<>();
int pre_value=0;
List<Integer> path=new ArrayList<>();
preOrder(root,pre_value,sum,path,result);
return result;
}
public void preOrder(TreeNode root,int pre_value,int sum,List<Integer> path, List<List<Integer>> result){
if(root==null){
return;
}
pre_value+=root.val;
path.add(root.val);
if(root.left==null&&root.right==null&&sum==pre_value){
result.add(new ArrayList<>(path));
}
preOrder(root.left,pre_value,sum,path,result);
preOrder(root.right,pre_value,sum,path,result);
pre_value-=root.val;
path.remove(path.size()-1);
}
}
例2:最近的公共祖先(medium) (二叉树性质)
- 二叉树的最近公共祖先
难度中等
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 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 为不同节点且均存在于给定的二叉树中。
public class Solution {
//int finish=0;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
TreeNode result=null;
List<TreeNode> path=new ArrayList<>();
List<TreeNode> path_p=new ArrayList<>();
List<TreeNode> path_q=new ArrayList<>();
int finish=0;
preOrder(root,p,path,path_p,finish);
finish=0;
path.clear();
preOrder(root,q,path,path_q,finish);
int path_len=0;
if(path_p.size()<path_q.size()){
path_len=path_p.size();
}else{
path_len=path_q.size();
}
for(int i=0;i<path_len;i++){
if(path_p.get(i).val==path_q.get(i).val){
result=path_p.get(i);
}
}
return result;
}
public void preOrder(TreeNode root,TreeNode search,List<TreeNode> path,List<TreeNode> result,int finish){
//已找到路径或者搜索到了末尾
if(root==null||finish==1){
return;
}
path.add(root);
if(root.val==search.val){
finish=1;
//result=new ArrayList<>(path);
for(TreeNode node:path){
result.add(new TreeNode(node.val));
}
//return;
}
preOrder(root.left,search,path,result,finish);
preOrder(root.right,search,path,result,finish);
path.remove(path.size()-1);
}
}
例3:二叉树转链表(medium) (二叉树与链表)
- 二叉树展开为链表
难度中等
给定一个二叉树,原地将它展开为一个单链表。
例如,给定二叉树
1
/
2 5
/ \
3 4 6
将其展开为:
1
2
3
4
5
6
public class Solution {
public void flatten(TreeNode root) {
generate(root);
return;
}
public void generate(TreeNode root){
if(root==null){
return;
}
TreeNode temp=null;
temp=root.right;
root.right=root.left;
root.left=null;
generate(root.right);
generate(temp);
while(root.right!=null){
root=root.right;
}
root.right=temp;
}
}
例4:侧面观察二叉树(medium) (二叉树宽搜)
- 二叉树的右视图
难度中等
给定一棵二叉树,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <—
/
2 3 <—
\
5 4 <—
public class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> view=new ArrayList<>();
if(root==null){
return view;
}
LinkedList<Pair<TreeNode,Integer>> queue=new LinkedList<>();
generate(root,view,queue);
return view;
}
public void generate(TreeNode root,List<Integer> view,LinkedList<Pair<TreeNode,Integer>> queue){
queue.addLast(new Pair<>(root,0));
//System.out.println(queue.size());
while(!queue.isEmpty()){
//System.out.println(queue.size());
TreeNode temp=queue.getFirst().getKey();
int depth=queue.getFirst().getValue();
queue.removeFirst();
if(view.size()==depth){
view.add(temp.val);
}else{
view.set(depth,temp.val);
}
if(temp.left!=null){
//System.out.println(queue.size());
queue.addLast(new Pair<>(temp.left,depth+1));
//System.out.println(queue.size());
}
if(temp.right!=null){
queue.addLast(new Pair<>(temp.right,depth+1));
}
}
}
}
例5:课程安排(有向图判断环)(medium)
- 课程表
难度中等
你这个学期必须选修 numCourse 门课程,记为 0 到 numCourse-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。这是不可能的。
提示:
输入的先决条件是由 边缘列表 表示的图形,而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5
1.拓扑排序
class GrapeNode{
int value;
List<GrapeNode> neighbor;
GrapeNode(int x){
this.value=x;
neighbor=new ArrayList<>();
}
}
public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
ArrayList<GrapeNode> grape=new ArrayList<>();//邻接表
ArrayList<Integer> degree=new ArrayList<>();//入度表
for(int i=0;i<numCourses;i++){
grape.add(new GrapeNode(i));
degree.add(0);
}
for(int i=0;i<prerequisites.length;i++){
GrapeNode begin=grape.get(prerequisites[i][1]);
GrapeNode end=grape.get(prerequisites[i][0]);
begin.neighbor.add(end);
degree.set(prerequisites[i][0],degree.get(prerequisites[i][0])+1);
}
LinkedList<GrapeNode> queue=new LinkedList<>();
for(int i=0;i<degree.size();i++){
if(degree.get(i)==0){
queue.addLast(grape.get(i));
}
}
while(!queue.isEmpty()){
GrapeNode node=queue.getFirst();
queue.removeFirst();
for(int i=0;i<node.neighbor.size();i++){
int temp=node.neighbor.get(i).value;
degree.set(temp,degree.get(temp)-1);
if(degree.get(temp)==0){
queue.addLast(grape.get(temp));
}
}
}
for(int i=0;i<degree.size();i++){
if(degree.get(i)!=0){
return false;
}
}
return true;
}
}
2.深度优先搜索
import java.util.ArrayList;
import java.util.List;
class GrapeNode{
int value;
List<GrapeNode> neighbor;
GrapeNode(int x){
this.value=x;
neighbor=new ArrayList<>();
}
}
public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
List<GrapeNode> group=new ArrayList<>();//邻接表
List<Integer> visit=new ArrayList<>();//节点访问状态。-1未访问,0正在访问,1已经访问
for(int i=0;i<numCourses;i++){
group.add(new GrapeNode(i));//创建图的结点
visit.add(-1);
}
//将边的关系加入邻接表
for(int i=0;i<prerequisites.length;i++){
GrapeNode begin=group.get(prerequisites[i][1]);
GrapeNode end=group.get(prerequisites[i][0]);
begin.neighbor.add(end);
}
for(int i=0;i<numCourses;i++){
if(visit.get(i)==-1&&!DFS(group.get(i),visit)){
return false;
}
}
return true;
}
boolean DFS(GrapeNode node,List<Integer> visit){
visit.set(node.value,0);//正在访问
for(int i=0;i<node.neighbor.size();i++){
if(visit.get(node.neighbor.get(i).value)==-1){
if(!DFS(node.neighbor.get(i),visit)){
return false;
}
}else if(visit.get(node.neighbor.get(i).value)==0){//成环了,回到起点
return false;
}
}
visit.set(node.value,1);//访问结束
return true;
}
}