LEETCODE DFS基础篇(已完成)

最新推荐文章于 2025-06-07 15:00:00 发布
原创 最新推荐文章于 2025-06-07 15:00:00 发布 · 173 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#dfs #数据结构 #算法 #二叉树

本文深入探讨了二叉树的多种算法，包括相同树、平衡二叉树、对称二叉树等概念的判断方法，以及二叉树的最大深度、最小深度、路径总和等问题的解决策略，通过实例讲解，帮助读者掌握二叉树的关键操作。

1

  1. 相同的树
    给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入: 1 1
/ \ /
2 3 2 3

    [1,2,3],   [1,2,3]

输出: true
示例 2:

输入: 1 1
/
2 2

    [1,2],     [1,null,2]

输出: false
示例 3:

输入: 1 1
/ \ /
2 1 1 2

    [1,2,1],   [1,1,2]

输出: false

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null)
        return true;
        if(p==null||q==null)
        return false;
        if(p.val!=q.val)
        return false;
        return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }
}

2

  1. 平衡二叉树
    给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

3

/
9 20
/
15 7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

   1
  / \
 2   2
/ \

3 3
/
4 4
返回 false 。

思路：先判断当前节点的左右子树是否满足平衡，具体是取得左右子树的最大深度，若绝对值大于1，则不平衡，返回false；否则认为平衡，继续判断左右子树是否平衡；

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root==null)
        return true;
        int left=getDepth(root.left,0);
        int right=getDepth(root.right,0);
        if(Math.abs(left-right)>1){
            return false;
        }
        return isBalanced(root.left)&&isBalanced(root.right);
    }

    public int getDepth(TreeNode root,int depth){
        if(root==null)
        return depth;
        int left=getDepth(root.left,depth+1);
        int right=getDepth(root.right,depth+1);
        return Math.max(left,right);
    }
}

3

  1. 对称二叉树
    给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

1

/
2 2
/ \ /
3 4 4 3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

1

/
2 2
\
3 3

思路：判断一颗树是否为镜像树的规则是：如果一个树的左子树与右子树镜像对称，那么这个树是对称的。因此，该问题可以转化为：两个树在什么情况下互为镜像？

如果同时满足下面的条件，两个树互为镜像：

它们的两个根结点具有相同的值。
每个树的右子树都与另一个树的左子树镜像对称。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
       return isMirror(root,root);
    }

    public boolean isMirror(TreeNode t1,TreeNode t2){
        if(t1==null&&t2==null)
        return true;
        if(t1==null||t2==null)
        return false;
        return (t1.val==t2.val)&&(isMirror(t1.left,t2.right))&&isMirror(t1.right,t2.left);
    }
}

4

  1. 二叉树的最大深度
    给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

3

/
9 20
/
15 7
返回它的最大深度 3 。

思路：利用一个变量记录最大深度，每当一个节点为null时，比较到该节点的深度与max记录的最大深度，循环即可

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int max = 0;

    public int maxDepth(TreeNode root) {
        if(root==null)
        return max;
        getMax(root,0);
        return max;
    }

    public void getMax(TreeNode root,int depth){
        if(root==null){
            max=Math.max(max,depth);
            return;
        }
        getMax(root.left,depth+1);
        getMax(root.right,depth+1);
    }
}

5

  1. 二叉树的最小深度
    给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

3

/
9 20
/
15 7

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int min=Integer.MAX_VALUE;
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        getMin(root,1);
        return min;
    }

    public void getMin(TreeNode root,int depth){
        if(root.left==null&&root.right==null){
            if(depth<min)
            min=depth;
            return;
        }
        if(root.left!=null)
        getMin(root.left,depth+1);
        if(root.right!=null)
        getMin(root.right,depth+1);
    }
}

6

  1. 路径总和
    给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \      \
    7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null){
            return false;
        }
        return has(root,sum);
    }

    public boolean has(TreeNode root,int sum){
        if(root.left==null&&root.right==null){
            if(root.val==sum){
                return true;
            }
            return false;
        }
        if(root.left!=null&&root.right!=null){
            return has(root.left,sum-root.val)||has(root.right,sum-root.val);
        }else{
            return root.left==null?has(root.right,sum-root.val):has(root.left,sum-root.val);
        }
       
    }
}

7

  1. 二叉树的所有路径
    给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

输入:

1
/
2 3

5

输出: [“1->2->5”, “1->3”]

解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<String> ans = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        if(root==null)
        return ans;
        String tmp = ""+root.val;
        if(root.left==null&&root.right==null){
            ans.add(tmp);
            return ans;
        }
        if(root.left!=null)
        dfs(root.left,tmp);
        if(root.right!=null){
            dfs(root.right,tmp);
        }
        return ans;
    }

    public void dfs(TreeNode root,String tmp){
        tmp+="->"+root.val;
        if(root.left==null&&root.right==null){
            ans.add(new String(tmp));
            return;
        }
        if(root.left!=null){
            dfs(root.left,tmp);
        }
        if(root.right!=null){
            dfs(root.right,tmp);
        }
    }
}

8

  1. 图像渲染
    有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例 1:

输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

class Solution {

    int[] dx={-1,0,1,0};
    int[] dy={0,1,0,-1};
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        if(image==null)
        return image;
        int row=image.length;
        int col=image[0].length;
        if(sr>=row||sc>=col)
        return image;
        int color=image[sr][sc];
        if(color==newColor)
        return image;
        //image[sr][sc]=newColor;
        dfs(image,sr,sc,newColor,color);
        return image;
    }

    public void dfs(int[][] image,int x,int y,int newColor,int color){
        if(image[x][y]!=color){
            return;
        }
        image[x][y]=newColor;
        for(int i=0;i<4;i++){
            int a=x+dx[i];
            int b=y+dy[i];
            if(a>=0&&a<image.length&&b>=0&&b<image[0].length&&image[a][b]==color){

                dfs(image,a,b,newColor,color);
            }
        }
    }
}

9

  1. 叶子相似的树
    请考虑一颗二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一颗叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两颗二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个头结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        List<Integer> list1=new ArrayList<>();
        List<Integer> list2=new ArrayList<>();
        dfs(root1,list1);
        dfs(root2,list2);
        if(list1.size()==list2.size()){
            for(int i=0;i<list1.size();i++){
                if(list1.get(i)!=list2.get(i))
                return false;
            }
            return true;
        }else
        return false;
    }

    public void dfs(TreeNode root,List<Integer> list){
        if(root==null)
        return;
        if(root.left==null&&root.right==null){
            list.add(root.val);
            return;
        }
        dfs(root.left,list);
        dfs(root.right,list);
    }
}

10

  1. 递增顺序查找树
    给你一个树，请你 按中序遍历 重新排列树，使树中最左边的结点现在是树的根，并且每个结点没有左子结点，只有一个右子结点。

示例 ：

输入：[5,3,6,2,4,null,8,1,null,null,null,7,9]

   5
  / \
3    6

/ \
2 4 8
/ / \
1 7 9

输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

1

2

3

4

5

6

7

8

9

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> list = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root) {
        if(root==null)
        return root;
        dfs(root,list);
        TreeNode ans = new TreeNode(list.get(0));
        TreeNode cur = ans;
        int index=1;
        while(index<list.size()){
            TreeNode tmp=new TreeNode(list.get(index));
            cur.right=tmp;
            cur=tmp;
            index++;
        }
        return ans;
    }
    public void dfs(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
     
            dfs(root.left,list);

        list.add(root.val);
        dfs(root.right,list);
    }
}
写给零基础的前端算法入门指南，acmer带女友刷80+【递归与回溯篇】｜牛气冲天新年征文
超逸の学习技术博客
02-16 3551
前言 各位小伙伴们新年好呀，时隔一周，俺又回来更新文章啦！在上一篇发出去之后，虽然没有得到很多的阅读量，但是后面几篇文章还是得要更新出来，我想总能够帮助一小部分人咯~ 现在和大家分享一下我们是如何准备算法这一块的，春招即将开启，还能最后准备一下，希望对大家有所帮助。 原本打算通过一篇文章介绍一下，推荐一下自己的刷题方式和刷题路线，得到一些伙伴的反馈：最好还是更加详细，面向零基础，小白这些，还有github访问速度也是一方面问题，可能图片都加载不出来。 因此，我打算分模块出几期文章，这样你只用通过首发在.
算法复习笔记 (LeetCode Hot 100)
最新发布
falldeep的算法世界
09-30 1128
这篇博客将hot100按照该学习计划中的类型进行划分，总结了分类型算法的总体思想和每道题的思想，并不包含代码，非常适合复习。
LeetCode【DFS】
耀的博客
05-20 683
/* 回溯算法思路 */ LinkedList<Integer> res = new LinkedList<>(); // 返回前序遍历结果 public List<Integer> inorderTraversal2(TreeNode root) { traverse(root); return res; } // 二叉树遍历函数 void traverse(TreeNode ...
leetcode DFS
qq_33755214的博客
10-07 266
图的遍历为从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次的过程。
LeetCode (dfs)
qq_45260619的博客
08-06 238
第一题 class Solution { String[] mapping = {"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; public List<String> letterCombinations(String digits) { List<String> state = new ArrayList<>(); //对空字符串进行特判 i
LeetCode-DFS
茧
02-28 403
加起来和为目标值的组合： 给定一个由不同整数构成的数组 nums 和一个整数 target ，请你从 nums 找出总和是 target 的组合的个数。解集中可以重复使用 nums 中的元素。且解集中数字顺序不同视为不同的组合。 解法一、DFS out=0 class Solution: def combination(self , nums , target ): nums.sort() numlen=len(nums) def dfs(t)
leetcode-DFS
xiaonuanhu的博客
03-31 105
转载来自：https://www.bilibili.com/video/BV1qE411E7di?from=search&seid=13624967053223072523 dfs三个重要的点： 截止条件 遍历候选节点 对候选节点的筛选 例题一： 输入： p = ‘A’,‘B’,‘C’ 输出：ABC ACB BAC BCA CAB CBA 截止条件：level==p.length()+1 遍历候选节点：for(var i=0; i<p.length; i++) 筛选候选节点：pb=【fa
LeetCode算法动画天花板，让你直通Offer！
wylee的博客
06-07 2235
通过本文的深入解析，相信你已经对这个GitHub项目有了全面而深刻的认识。它不仅仅是一个开源项目，更是算法学习领域的一次革新，为你提供了前所未有的可视化学习体验。算法和数据结构是计算机科学的基石，也是通往高级开发、架构师以及各大互联网公司Offer的必经之路。而掌握它们最有效的方式，就是从理解其内在运行机制开始。正是这样一把钥匙，它能打开你对算法理解的全新大门。所以，不要再犹豫了！立即行动起来：将项目拉取到本地，离线也能随时学习。告别枯燥的文字，迎接生动的动画，让算法在你眼前“跳舞”！
LeetCode刷题笔记
qq_40088655的博客
10-14 2328
LeetCode刷题笔记！
leetcode.zip
09-30
《LeetCode刷题总结——算法篇》 在编程领域，LeetCode是一个广为人知的在线平台，它提供了大量的编程题目，旨在帮助开发者提升算法技能，准备面试，以及深入理解计算机科学的基本概念。这个名为"leetcode.zip"的...
LeetCode——DFS
努力努力再努力L
12-05 313
DFS 目录 DFS 查找最大的连通面积 矩阵中的连通分量数目 好友关系的连通分量数目 填充封闭区域 能到达的太平洋和大西洋的区域 1. DFS 广度优先遍历一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。 而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如果...
LeetCode中的DFS
qq_41643443的博客
07-08 250
BFS 深度优先遍历算法，一般使用递归实现，注意递归结束条件 464. 我能赢吗 在 “100 game” 这个游戏中，两名玩家轮流选择从 1 到 10 的任意整数，累计整数和，先使得累计整数和达到 100 的玩家，即为胜者。 如果我们将游戏规则改为 “玩家不能重复使用整数” 呢？ 例如，两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数（不放回），直到累计整数和 >= 100。 给定一个整数 maxChoosableInteger （整数池中可选择的最大数）和另一个整数 desiredTot
LeetCode基础-图-DFS
gnimgnot
11-05 657
DFS：Depth First Search，深度优先搜索。走迷宫的过程： 选择一条没有标记过的通道，在走过的路上铺一条绳子。 标记所有你第一次路过的路口和通道。 当到达一个标记过的路口时（用绳子）回退到上个路口。 当回退到的路口已经没有可走的通道时继续回退。 绳子可以保证你总能找到一条出路，标记则能保证你不会两次经过同一条通道或同一个路口。 深度优先遍历的具体实现思路是：用一个递归方法遍历所有顶
LeetCode-深度优先遍历（DFS）
wangdsdasdasdas的博客
09-13 488
LeetCode 深度优先遍历（DFS）相关题目
LeetCode刷题 -- DFS
qq_43325216的博客
10-31 906
深度优先搜索算法，depth-first-search DFS，是一种用于遍历或者搜索树、图的算法，这个算法会尽可能深的去搜索树的分支。
leetcode DFS专题
陌上烟雨遥的博客
02-05 295
1 DFS 框架 result = [] void backtrack(路径，选择列表) { if (满足条件) { result.add(路劲); return; } for 选择 in 选择列表 做选择 backtrack(路径，选择列表); 撤销选择 } ...
LeetCode专题----DFS
changetocs的博客
03-21 621
207. Course ScheduleThere are a total of n courses you have to take, labeled from 0 to n - 1.Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is
leetcode DFS系列
xiaomimi1993的博客
08-14 869
这个系列放在leetcode上刷到用DFS解的题，不断扩充，我自己遇到就会加进来。 题目均来自leetcode，括号内是题目标号 1. Number of Islands(200) Given a 2d grid map of ‘1’s (land) and ‘0’s (water), count the number of islands. An island is surrounde...
LeetCode - DFS (depth-first-search) 总结
real_lisa的博客
10-11 271
每行选一题先感受一下～   基础 Subset I, II (contain duplicates) Combinations Permutation I, II (contain duplicates) Combinations Sum I, II (can only be used once), III 一维 Generate Parentheses Letter Combi...
leetcode dfs
02-03
### 关于LeetCode上的深度优先搜索（DFS）算法 #### 解决方案结构化分析 在解决LeetCode中的DFS问题时，通常会采用递归方法来遍历树或图的数据结构。对于每一个节点，程序先尽可能深地探索其子节点直到达到叶节点...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值