力扣技巧-dfs

已于 2022-09-06 16:06:12 修改
阅读量159 收藏 1
点赞数
分类专栏： leetCode 文章标签： 深度优先 leetcode 算法
于 2022-09-04 01:34:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41282486/article/details/126684853
版权

树

104. 二叉树的最大深度

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        return dfs(root);
    }

    private int dfs(TreeNode root) {
        if (null == root) {
            return 0;
        }
        return Math.max(dfs(root.left), dfs(root.right)) + 1;
    }
}
111. 二叉树的最小深度

错误解法：

class Solution {
    public int minDepth(TreeNode root) {
        if (null == root) {
            return 0;
        }
        if (null == root.left && null == root.right) {
            return 1;
        }
        int leftStep = minDepth(root.left);
        int rightStep = minDepth(root.right);
        return Math.min(leftStep, rightStep) + 1;
    }
}

正确解法：
1.自底向上

class Solution {
    public int minDepth(TreeNode root) {
        if (null == root) {
            return 0;
        }
        if (null == root.left && null == root.right) {
            return 1;
        }
        int leftStep = minDepth(root.left);
        if (null == root.right) {
            return leftStep + 1;
        }
        int rightStep = minDepth(root.right);
        if (null == root.left) {
            return rightStep + 1;
        }

        return Math.min(leftStep, rightStep) + 1;
        
    }
}

2.自顶向下

class Solution {

    private int ans = Integer.MAX_VALUE;

    public int minDepth(TreeNode root) {
        if (null == root) {
            return 0;
        }
        dfs(root, 1);
        return ans;
    }

    private void dfs(TreeNode root, int step) {
        if (null == root) {
            return;
        }
        if (null == root.left && null == root.right) {
            ans = Math.min(ans, step);
            return;
        }
        dfs(root.left, step + 1);
        dfs(root.right, step + 1);
    }
}
112. 路径总和

题解：

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        return dfs(root, targetSum);
    }

    private boolean dfs(TreeNode root, int targetSum) {

        if (null == root) {
            return false;
        }
        
        if (null == root.left && null == root.right) {
            if (targetSum == root.val) {
                return true;
            } else {
                return false;
            }
        }

        int temp = targetSum - root.val;
        return dfs(root.left, temp) || dfs(root.right, temp);
    }
}
113. 路径总和 II

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        Deque<Integer> path = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        dfs(root, targetSum, path, res);
        return res;
    }

    private void dfs(TreeNode root, int targetSum, Deque<Integer> path, List<List<Integer>> res) {

        if (null == root) {
            return;
        }

        if (null == root.left && null == root.right && root.val == targetSum) {
            path.addLast(root.val);
            res.add(new ArrayList<>(path));
            path.removeLast();
            return;
        }

        int temp = targetSum - root.val;
        path.addLast(root.val);
        dfs(root.left, temp, path, res);
        dfs(root.right, temp, path, res);
        path.removeLast();
    }
}
437. 路径总和 III

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        int res = 0;
        if (null == root) {
            return res;
        }
        // 易错
        res = rootSum(root, (long)targetSum) + pathSum(root.left, targetSum) + pathSum(root.right, targetSum);
        return res;
    }

    private int rootSum(TreeNode root, long targetSum) {

        int res = 0;

        if (null == root) {
            return res;
        }

        long val = (long)root.val;
        if (val == targetSum) {
            res ++;
        }
        res += rootSum(root.left, targetSum - val);
        res += rootSum(root.right, targetSum - val);
        return res;
    }
}
226. 翻转二叉树

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        return dfs(root);
    }

    private TreeNode dfs(TreeNode root) {

        if (null == root) {
            return null;
        }

        TreeNode leftNode = dfs(root.left);
        TreeNode rightNode = dfs(root.right);

        root.left = rightNode;
        root.right = leftNode;

        return root;
    }
}
100. 相同的树

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        return dfs(p, q);
    }

    private boolean dfs(TreeNode p, TreeNode q) {
        
        if (null == p && null == q) {
            return true;
        }

        if (null == p) {
            return false;
        }

        if (null == q) {
            return false;
        }

        if (p.val != q.val) {
            return false;
        }

        return dfs(p.left, q.left) && dfs(p.right, q.right);
    }
}
101. 对称二叉树

题解：

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

    private boolean isSymmetricTwo(TreeNode root1, TreeNode root2) {

        if (null == root1 && null == root2) {
            return true;
        }

        if (null == root1) {
            return false;
        }

        if (null == root2) {
            return false;
        }

        if (root1.val != root2.val) {
            return false;
        }

        return isSymmetricTwo(root1.left, root2.right) && isSymmetricTwo(root1.right, root2.left);
    }
}
129. 求根节点到叶节点数字之和

题解：

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

    private int sum = 0;

    public int sumNumbers(TreeNode root) {
        dfs(root);
        return sum;
    }

    private void dfs(TreeNode root) {

        if (null == root.left && null == root.right) {
            sum += root.val;
            return;
        }

        if (null != root.left) {
            root.left.val += (root.val * 10);
            dfs(root.left);
        }

        if (null != root.right) {
            root.right.val += (root.val * 10);
            dfs(root.right);
        }
    }
}
236. 二叉树的最近公共祖先

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        
        if (null == root || p == root || q == root) {
            return root;
        }

        TreeNode leftNode = lowestCommonAncestor(root.left, p, q);
        TreeNode rightNode = lowestCommonAncestor(root.right, p, q);

        if (null != leftNode && null != rightNode) {
            return root;
        }

        return leftNode == null ? rightNode : leftNode;
    }

    
}
105. 从前序与中序遍历序列构造二叉树

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return dfs(preorder, inorder);
    }

    private TreeNode dfs(int[] preorder, int[] inorder) {
        final int preLen = preorder.length;
        final int inLen = inorder.length;
        if (0 == preLen && 0 == inLen) {
            return null;
        }
        int val = preorder[0];
        int index = findIndex(inorder, val);
        TreeNode root = new TreeNode(val);
        TreeNode leftNode = dfs(Arrays.copyOfRange(preorder, 1, 1 + index), 
        Arrays.copyOfRange(inorder, 0, index));
        TreeNode rightNode = dfs(Arrays.copyOfRange(preorder, 1 + index, preLen), 
        Arrays.copyOfRange(inorder, index + 1, inLen));
        root.left = leftNode;
        root.right = rightNode;
        return root;

    }

    private int findIndex(int[] inorder, int target) {
        final int n = inorder.length;
        for (int i = 0; i < n; i ++) {
            if (target == inorder[i]) {
                return i;
            }
        }
        return -1;
    }
}
106. 从中序与后序遍历序列构造二叉树

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return dfs(inorder, postorder);
    }

    private TreeNode dfs(int[] inorder, int[] postorder) {
        final int m = inorder.length;
        final int n = postorder.length;
        if (0 == n && 0 == m) {
            return null;
        }
        int val = postorder[n - 1];
        TreeNode root = new TreeNode(val);
        int index = findIndex(inorder, val);
        TreeNode leftNode = dfs(Arrays.copyOfRange(inorder, 0, index), 
        Arrays.copyOfRange(postorder, 0, index));
        TreeNode rightNode = dfs(Arrays.copyOfRange(inorder, index + 1, m), 
        Arrays.copyOfRange(postorder, index, n - 1));
        root.left = leftNode;
        root.right = rightNode;
        return root;
    }

    private int findIndex(int[] inorder, int target) {
        final int n = inorder.length;
        for (int i = 0; i < n; i ++) {
            if (target == inorder[i]) {
                return i;
            }
        }
        return -1;
    }
}
1008. 前序遍历构造二叉搜索树

题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        return dfs(preorder);
    }

    private TreeNode dfs(int[] preorder) {
        final int n = preorder.length;
        if (0 == n) {
            return null;
        }
        if (1 == n) {
            return new TreeNode(preorder[0]);
        }
        int val = preorder[0];
        int index = findIndex(preorder);
        TreeNode leftNode = dfs(Arrays.copyOfRange(preorder, 1, index));
        TreeNode rightNode = dfs(Arrays.copyOfRange(preorder, index, n));
        TreeNode root = new TreeNode(val);
        root.left = leftNode;
        root.right = rightNode;
        return root;
    }

    private int findIndex(int[] preorder) {
        final int n = preorder.length;
        for (int i = 1; i < n; i ++) {
            if (preorder[i] > preorder[0]) {
                return i;
            }
        }
        return n;
    }
}
远腾飞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode 797：所有可能的路径
可能是一只知更鸟
08-25 688
1. 题目描述 给定一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）。 二维数组的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些节点，空就是没有下一个结点了。 输入：graph = [[1,2,3],[2],[3],[]] 输出：[[0,1,2,3],[0,2,3],[0,3]] 2. 题目分析 首先我们根据题目描述画出图，并分析输入输出，输入输出都是二维数组，根据题目描述，我们采用深度优先搜索遍历图，求出所有可能的路径。
力扣刷题：DFS篇
轻松的小希
05-29 3958
目录112. 路径总和题目介绍题目实现113. 路径总和 II题目介绍题目实现17. 电话号码的字母组合题目介绍题目实现22. 括号生成题目介绍题目实现39. 组合总和题目介绍题目实现46. 全排列题目介绍题目实现47. 全排列 II题目介绍题目实现 112. 路径总和 题目介绍 给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。 叶子节点 是指没有子节点的节点。 示例 1：
【力扣】dfs(深度优先搜索)
最新发布
qq_66228897的博客
09-22 212
​ 当我像一只无头苍蝇时，不妨试试爆搜，剩下的交给奇迹 ​ - - - 五星上将麦克阿瑟
力扣第139题：单词拆分（DFS，BFS，动态规划）
sjl20021006的博客
10-24 533
一、题目内容 二、题目分析 对于这道题目我们首先要从头开始判断，一直到字符串结束为止。如下图一般，从0开始，读取c，发现并不在wordDict中，就继续读取a，直到读取到s之后，发现现在的字符串是cats，正好在给定的wordDict中，那么就从a开始，进行递归，递归的出口是当前的字符的个数是否等于给定字符串的长度，如果结果为是，就返回true。 那么我们将会得到这样一串代码 public boolean dfs(String s, Li...
力扣---深度优先遍历DFS（python实现）
一夜奈何梁山
03-08 1602
一： 二： 三：
力扣DFS题目汇总
To the beyond and infinity!
07-03 643
39. 组合总和 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ] 示例 2： 输入：candidates = [2,3,5]
js代码-力扣第七题
07-16
力扣（LeetCode）是程序员常用来练习编程技能的一个在线平台，它提供了各种算法和数据结构问题供用户解决。在本压缩包中，我们有两个...这对于提升你的数据结构和算法能力，特别是树相关问题的处理技巧，非常有帮助。
leetcode答案-LeetCode:力扣答案
06-30
- 图：用于表示网络结构，可以是有向或无向，可以有环或无环，常用算法有深度优先搜索（DFS）和广度优先搜索（BFS）。 2. **算法**： - 排序：快速排序、归并排序、冒泡排序、插入排序、堆排序等。 - 搜索：二分...
leetcode题库-LeetCode:力扣题库
06-29
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。它包含了各种难度级别的编程问题，涵盖了多种编程语言，如Java、Python、C++等。LeetCode题库提供了丰富的算法题目，...
leetcode卡-LeetCode:力扣解决方案
07-06
6. **回溯和深度优先搜索（DFS）**：在图或树结构中寻找所有可能的解决方案。 7. **动态规划**：通过状态转移方程求解最优化问题。 8. **贪心算法**：局部最优解以达到全局最优解。 9. **哈希表**：快速查找、去重、...
力扣刷题——DFS深度优先搜索算法
how的博客
09-14 1098
岛屿数量 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格， 请你计算网格中岛屿的数量。 岛屿总是被水包围， 并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: [ [‘1’,‘1’,‘1’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘1’,‘0’], [‘1’,‘1’,‘0’,‘0’,‘0’], [‘0’,‘0’,‘0’,‘0’,‘0’] ] 输出: 1 示例 2: 输入: [ [‘1’,‘1’,‘0’,..
力扣刷题----组合总和(39、40) 回溯+递归算法
qq_38235017的博客
10-15 386
一、组合总和(可重复选取) 给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。 candidates中的数字可以无限制重复被选取。 说明：所有数字（包括target）都是正整数。解集不能包含重复的组合。 示例1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [[7],[2,2,3]] 示例2： 输入：candidates = [2,3,5...
力扣dfs
qq_45598881的博客
11-15 705
DFS（深度优先搜索） 深度优先搜索也可以用来检测环路：记录每个遍历过的节点的父节点，若一个节点被再次遍历且父节点不同，则说明有环。我们也可以用之后会讲到的拓扑排序判断是否有环路，若最后存在入度不为零的点，则说明有环。 有时我们可能会需要对已经搜索过的节点进行标记，以防止在遍历时重复搜索某个节点，这种做法叫做状态记录或记忆化（memoization）。 给定一个二维的 0-1 矩阵，其中 0 表示海洋，1 表示陆地。单独的或相邻的陆地可以形成岛屿，每个格子只与其上下左右四个格子相邻。求最大的岛屿面积。 In
dfs-力扣-java
a716121的专栏
05-23 185
class Solution { public int numSquares(int n) { int []dp=new int[n+1]; Arrays.fill(dp,Integer.MAX_VALUE); dp[0]=0; for(int i=1;i<=n;i++){ for(int j=1;j*j<=i;j++){ dp[i]=Math.min(dp[i]...
力扣学习-DFS
weixin_43748296的博客
04-25 472
99. 恢复二叉搜索树 题目： 二叉搜索树中的两个节点被错误地交换。 请在不改变其结构的情况下，恢复这棵树。 示例： 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,null,null,2] 3 / 1 \ 2 思路： 指针数组交换法 因为题目中说树中只有两个点错了，所以我们其实只要交换这两个节点的值就ok了。方法先设一个指针数组err，保存节点的指针，找...
力扣——dfs和回溯（17题 电话号码的字母组合）
wcy8733996wcy的博客
04-05 464
一、前言 其实，自我感觉，回溯法和dfs算法没什么特别大的区别，dfs里渗透着回溯，回溯的前提是dfs(目前从所刷的题目上来看是这样的)。但是，我从别人的博客上了解到： 1.概述： (1)回溯法： 是一种选优搜索法（试探法），被称为通用的解题方法，这种方法适用于解一些组合数相当大的问题。通过剪枝（约束+限界）可以大幅减少解决问题的计算量（搜索量）。 (2)DFS： 是一种用于遍历或搜索树或图的算法...
力扣刷题：N皇后问题和岛屿的最大面积(DFS)
qq_16215221的博客
03-31 237
1. DFS的重复遍历 对DFS而言，必然是需要标记数组的，也就是当前单位是否被遍历过，否则DFS将不会停止。但有一个非常特别的不同，就是当前单位是否被遍历过是对于下层单位来说的，还是对于全局来说的，这将取决于题目的性质，也决定了标记数组不同的使用方法，下面将通过举两个例子来说明这个点。 2. N皇后问题 2.1 题目分析 很明显的一道回溯的题目，这里我们假设已经放了k-1个皇后，对于第k个的放置...
LeetCode77.组合
Ember_Sky
05-23 584
力扣（leetcode）77.组合——深搜（DFS） 原题传送门 题解： 排列组合+dfs：从n个不同的数字中找出k个不同的数字，一共有C(n，k)中情况；这道题需要全排列，用深度优先搜索（dfs）就能搞定。 上代码。 class Solution { public: int n,k; vector <vector <int>>ans; vector...
力扣刷题系列——BFS和DFS
qq_43568704的博客
08-25 2084
BFS与DFS相关算法题 BFS 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历算法这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值