Leetcode算法系列五（二叉树与图）

最新推荐文章于 2022-07-13 22:33:28 发布
最新推荐文章于 2022-07-13 22:33:28 发布
阅读量148 收藏
点赞数
分类专栏： leetcode 编程算法 文章标签： 二叉树 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44337475/article/details/109550926
版权

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) (二叉树性质)

  1. 二叉树的最近公共祖先
    难度中等
    给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
    百度百科中最近公共祖先的定义为：“对于有根树 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. 二叉树展开为链表
    难度中等
    给定一个二叉树，原地将它展开为一个单链表。

例如，给定二叉树
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. 二叉树的右视图
    难度中等
    给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
    示例:
    输入: [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)

  1. 课程表
    难度中等
    你这个学期必须选修 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;
    }
}
weixin_Akian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题型分析《图》
陌上烟雨遥的博客
08-22 342
图 1)图的搜索 广度优先搜索和深度优先搜索 剑指offer II 105:最大岛屿面积 step1 找出图的节点和边，将为1的岛屿视为图的节点，上下左右相邻格子为1的节点之间有条边。 step 2 逐一扫描每一个节点，当遇到节点为1，且不在已知岛屿表明到达一个新的岛屿并重新计算岛屿面积。定义一个visited二维数组，存到被访问过的节点。 step 3比较所有岛屿面积，求出面积最大那个。 广度优先搜索具体实现：定义一个queue，首先将起始节点加入队列中，然后取出队列中节点并访问其相邻节点，
【LeetCode 图论 一】初探有向图Directed Graph
Bismarckczy的博客
04-17 628
由于搜索是从随机的点开始的，我们将没有相邻节点的点入栈之后，再回溯到初始节点，将它入栈，但是后面的搜索也可能会碰到它。所以要给已经搜索的节点打上标签。
【Leetcode】图算法总结
小朱小朱绝不认输的博客
07-13 1576
Leetcode中图的算法是比较常见的类型，比如无向图的单源最短路径，有向图的单源最短路径，多源最短路径等问题，下面就对图的算法进行总结。
LeetCode总结 -- 图篇
热门推荐
Code Ganker
09-18 2万+
图的算法跟树一样是准备面试中必不可少的一块，不过图的方法很容易概括，面试中考核的无非就是两种搜索算法：深度优先搜索和广度优先搜索。LeetCode中关于图的问题有以下几个：Clone GraphWord LadderWord Ladder IILongest Consecutive SequenceWord SearchSurrounded Regions先来看看最基础的Clone Graph，很
LeetCode 图相关知识
Robin_812656252的博客
08-07 222
图论知识点众多，LeetCode最常涉及的便是有向图与无向图的遍历算法。 例如下有向图，使用 邻接矩阵 与 邻接表 存储。 邻接矩阵 使用N*N的二维数组存储，a[i][j] = 1意思着 i -> j存在连接，也可以用来存权。 邻接表 使用N个元素的一维数组分别存储一个列表，列表中存储与第i个元素相连的所有元素。 构造邻接矩阵与邻接表 构造邻接矩阵 public int[][] assemMap(){ ...
php-leetcode题解之合并二叉树.zip
最新发布
06-09
本压缩包文件"php-leetcode题解之合并二叉树.zip"显然是关于PHP语言实现的LeetCode算法问题——合并二叉树的解决方案集。 首先，我们要理解什么是二叉树。二叉树是数据结构的一种，每个节点最多有两个子节点，通常...
php-leetcode题解之翻转二叉树.zip
06-08
“翻转二叉树”这个问题通常出现在数据结构与算法的学习中，它的目标是将一个给定的二叉树的所有节点的左右子节点进行交换，从而得到一个新的二叉树。这个问题可以使用递归、迭代等多种方法来解决。 首先，我们来...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
python 数据结构与算法 leetcode 算法题与书籍 刷算法全靠套路与总结
12-27
本资源包针对的是想要提升这方面能力的Python开发者，尤其是那些热衷于刷LeetCode算法题的朋友们。 LeetCode是一个在线平台，提供了大量的算法题目供程序员练习，它涵盖了从基础到高级的各种算法问题，是准备面试和...
Leetcode刷题总结--基本图算法
qq_41283672的博客
07-13 1501
Leetcode刷题总结 基本图算法 图的问题算是比较复杂的类型的题目了，我觉得需要把握住的有几点。 首先是要学会构建图，如何从题目给你的信息中，抽象出图的关系。 其次是要会表示图，邻接表，邻接矩阵至少要会（特定题目条件下要使用特殊的数据机构） 然后是要会遍历图，DFS, BFS是最基本的算法，很多图的题目都是从遍历而来的。 最后，要回一些特定问题的特定解决方法。图的问题，使用遍历方法，基本都可以得到简单问题的解，但是当数据规模上去以后，这种遍历问题很容易变成NP问题，此时就要考虑使用特定的算法或者思想，达
leetcode(图论专题)
qq_46517733的博客
12-17 1689
图论1.导论2.编程题2.1 127. 单词接龙 1.导论 2.编程题 2.1 127. 单词接龙 字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列： 序列中第一个单词是 beginWord 。 序列中最后一个单词是 endWord 。 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典 wordList 中的单词。 给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到
LeetCode 克隆图
hestyle的博客
02-22 590
克隆一张无向图，图中的每个节点包含一个 label （标签）和一个 neighbors （邻接点）列表 。 OJ的无向图序列化： 节点被唯一标记。 我们用 # 作为每个节点的分隔符，用 , 作为节点标签和邻接点的分隔符。 例如，序列化无向图 {0,1,2#1,2#2,2}。 该图总共有三个节点, 被两个分隔符 # 分为三部分。 第一个节点的标签为 0，存在从节点 0 到节点 1 和节点 2 的...
LeetCode310-图
mingrizhixin的博客
03-16 172
最小高度树 树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，一个任何没有简单环路的连通图都是一棵树。 给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。 可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称.
[leetcode]高级算法——树和图
weixin_40649618的博客
07-08 430
被围绕的区域Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.A region is captured by flipping all 'O's into 'X's in that surrounded region.Example:X X X X X O O ...
[leetcode]中级算法——树和图
weixin_40649618的博客
06-28 251
二叉树的中序遍历Given a binary tree, return the inorder traversal of its nodes' values.Example:Input: [1,null,2,3] 1 \ 2 / 3 Output: [1,3,2]Code(By myself):# Definition for a binary tree n...
Leetcode常用五大算法思想
坐而言不如起而行
06-14 2686
算法 目录(?)[-] 分治算法动态规划贪心算法回溯法分支限界法 分治算法 一、基本概念    在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算
LeetCode刷题解题思路以及算法实现——图—寻找路径（BFS）
欢迎来到我的知识星球！！！
06-21 1477
目录前言题目描述解题思路算法法实现TIPS:最后，更多关于数据结构和算法知识请参考我其他的文章哦！！！希望大家有所收获！对于图的基础知识不了解的可以参考数据结构和算法---图---概念入门（一）这篇文章。详细介绍关于图的基本知识点，有助于小伙伴们刷题哦！1971. 寻找图中是否有路径有一个具有 n个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含 0 和 n - 1）。图中的边用一个二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示顶点 ui 和顶点 vi 之间
leetcode 133 clone-graph 克隆图（图的遍历算法）
bw_yyziq的博客
04-03 1235
题目描述 克隆一个无向图. 图中每个节点包括一个 label 和一个放置其邻居的 list. 节点结构体定义如下：class UndirectedGraphNode { int label; ArrayList&lt;UndirectedGraphNode&gt; neighbors; UndirectedGraphNode(int x) { label = x; nei...
leetcode图解算法数据结构---动态规划
小卜妞的博客
03-09 265
2 动态规划复习 2.1 动规基本原理 2.2 动规解题思路 2.3 动规适合题型 * 实战例题 剑指 Offer 10- I. 斐波那契数列 剑指 Offer 10- II. 青蛙跳台阶问题 剑指 Offer 19. 正则表达式匹配 剑指 Offer 42. 连续子数组的最大和 剑指 Offer 46. 把数字翻译成字符串 剑指 Offer 47.礼物的最大价值 剑指 Offer 48. 最长不含重复字符的子字符串 剑指 Offer 49. 丑数 剑指 Offer 63. 股票的最大利润 ...
LeetCode 热题 HOT 100 （4）1
08-04
1. 在队列内自己左边的数就是数组中左边第一个比自己小的元素 2. 当被弹出时，遇到的就是数组中右边第一个比自己小的元素 3. 队头到队尾单调递增，队首元素为

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值