(算法)深度优先搜索

dinl_vin

于 2021-02-22 17:23:09 发布

阅读量1.7k

点赞数

分类专栏：算法与数据结构

本文链接：https://blog.csdn.net/dinl_vin/article/details/113945011

版权

算法与数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

深度优先搜索

概述

[一条路走到底,不撞南墙不回头]
[撞南墙]有两种情况:①遇到了边界条件,②遇到了已经走过的路
深度优先的另一种结束条件,就是找到了目标出口
深度优先遍历的本质就是穷举

常见的深度优先搜索

树的深度优先遍历

[二叉树最大深度][https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/]

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

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

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

class Solution{
  public int maxDepth(TreeNode root){
    if(null==root) return 0;
    return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
  }
}

[二叉树最小深度][https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/]

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

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

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

class Solution{
  public int minDepth(TreeNode root){
    if(null==root) return 0;
    int leftH = minDepth(root.left);
    int rightH = minDepth(root.right);
    if(0==rightH||0==leftH){
      return rightH+leftH+1;
    }else{
      return Math.min(leftH,rightH)+1;
    }
  }
}

[路径总和][https://leetcode-cn.com/problems/path-sum/]

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(null==root) return false;
        if(null==root.left && null==root.right){
            return targetSum==root.val;
        }
        return hasPathSum(root.left, targetSum-root.val) || hasPathSum(root.right, targetSum-root.val);
    }
}

[翻转二叉树][https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof/]

输入一个二叉树，该函数输出它的镜像。

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null) return null;
        TreeNode left = root.left;
        TreeNode right = root.right;
        if(left==null && right==null){
            return root;
        }
        root.left = mirrorTree(right);
        root.right = mirrorTree(left);
        return root;
    }
}

[相同的树][https://leetcode-cn.com/problems/same-tree/]

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

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

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); 
    }
}

[对称二叉树][https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/]

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的.

class Solution {
    private boolean dfs(TreeNode left,TreeNode right){
        if(left==null && right==null) return true;
        if(left==null || right==null) return false;
        if(left.val!=right.val) return false;
        return dfs(left.right,right.left) && dfs(left.left,right.right);
     }

    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return dfs(root.left,root.right);
    }
}

[求根到叶子节点数字之和][https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/]

给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 1->2->3 代表数字 123。

计算从根到叶子节点生成的所有数字之和。

class Solution {
    public int sumNumbers(TreeNode root) {
        return dfs(root,0);
    }
    private int dfs(TreeNode root,int fromNums){
        if(root==null) return 0;
        fromNums = fromNums*10 + root.val;
        if(root.left==null &&root.right==null) return fromNums;
        return   dfs(root.right,fromNums)+ dfs(root.left,fromNums);
    }
}

[二叉树的公共祖先][https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/]

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null || root==p ||root ==q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left==null) return right;
        if(right==null) return left;
        return root;
    }
}

[从前序跟中序遍历序列构造二叉树][https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/]

根据一棵树的前序遍历与中序遍历构造二叉树

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length>0&&inorder.length>0){
        TreeNode root = new TreeNode(preorder[0]);
        int num=0;
        //从中序遍历序列中查找根节点位置
        for(int i =0; i<inorder.length; i++){
            if(inorder[i]==root.val){
                num=i;
            }
        }
        int[] preLeft = Arrays.copyOfRange(preorder,1,num+1);
        int[] preRight = Arrays.copyOfRange(preorder,num+1,preorder.length);
                  
        int[] inoLeft = Arrays.copyOfRange(inorder,0,num);
        int[] inoRight = Arrays.copyOfRange(inorder,num+1,inorder.length);
        root.left=buildTree(preLeft,inoLeft);
        root.right=buildTree(preRight,inoRight);
        return root;
        }else{
           return null;
        }

    }
}

[从中序跟后序遍历序列构造二叉树][https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/submissions/]

#由于python数组索引切片跟数组的index非常方便,感受一下python的魅力
class Solution(object):
    def buildTree(self, inorder, postorder):
        if postorder:
            root=TreeNode(postorder[-1])
            index = inorder.index(postorder[-1])
            root.left = self.buildTree(inorder[:index],postorder[:index])
            root.right = self.buildTree(inorder[index+1:],postorder[index:-1]) 
            return root

[前序遍历构造二叉搜索树][https://leetcode-cn.com/problems/construct-binary-search-tree-from-preorder-traversal/]

返回与给定前序遍历 preorder 相匹配的二叉搜索树（binary search tree）的根结点。

(回想一下，二叉搜索树是二叉树的一种，其每个节点都满足以下规则，对于 node.left 的任何后代，值总 < node.val，而 node.right 的任何后代，值总 > node.val。此外，前序遍历首先显示节点 node 的值，然后遍历 node.left，接着遍历 node.right。）

题目保证，对于给定的测试用例，总能找到满足要求的二叉搜索树。

class Solution(object):
    def bstFromPreorder(self, preorder):
        if preorder:
            root = TreeNode(preorder[0])
            root.left = self.bstFromPreorder([x for x in preorder[1:] if x<preorder[0] ])
            root.right = self.bstFromPreorder([x  for x in preorder[1:] if x>preorder[0]])
            return root

图的深度优先遍历

[无向图中连接分量的数目][https://leetcode-cn.com/problems/number-of-connected-components-in-an-undirected-graph/]

class Solution {
    public int countComponents(int n, int[][] edges) {
        // 所有节点都没被访问
        boolean[] visited = new boolean[n];

        //构建邻接表
        List<Integer> [] adj = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            adj[i] = new ArrayList<>();
        }
        for(int[] edge: edges){
            adj[edge[0]].add(edge[1]);
            adj[edge[1]].add(edge[0]);
        }

        //深度优先遍历
        int count=0;
        for(int i=0;i<n;i++){
            if(!visited[i]){
                dfs(adj,i,visited);
                count++;
            }
        }
        return count;
    }

    private void dfs(List<Integer> [] adj,int u,boolean[] visited){
        visited[u] = true;
        List<Integer> path = adj[u];
        for(int p:path){
            if(!visited[p]){
                dfs(adj,p,visited);
            }
        }
    }
}

[冗余连接][https://leetcode-cn.com/problems/redundant-connection/]

在本问题中, 树指的是一个连通且无环的无向图。

输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。

返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。

class Solution {
    private Map<Integer, List<Integer>> adj; //保存每个顶点能到达的所有顶点
    private Set<Integer> visited; //为了减少dfs次数,没有出现过的节点直接add这条边

    public int[] findRedundantConnection(int[][] edges) {
        this.adj = new HashMap<>();
        this.visited = new HashSet<>();
        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            if (adj.containsKey(u) && adj.containsKey(v)) {
                visited.clear();
                if (dfs(u, v)) {
                    return edge;
                }
            }
            addEdg(v, u);
            addEdg(u, v);
        }
        return null;
    }

    private void addEdg(int u, int v) {
        if (adj.containsKey(u)) {
            adj.get(u).add(v);
            return;
        }
        List<Integer> successors = new ArrayList<>();
        successors.add(v);
        adj.put(u, successors);
    }

    private boolean dfs(int from, int to) {
        if (to == from) return true;
        visited.add(from);
        for (Integer point : adj.get(from)) {
            if (!visited.contains(point)) {
                if (dfs(point, to)) return true;
            }
        }
        return false;
    }
}

[找到最终安全状态][https://leetcode-cn.com/problems/find-eventual-safe-states/]

public class Solution {
    private Boolean[] visited;
    public List<Integer> eventualSafeNodes(int[][] graph) {
        int len = graph.length;
        visited = new Boolean[len];
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < len; ++i) {
            if (dfs(i, graph)) {
                continue;
            }
            res.add(i);
        }
        return res;
    }

    /**
     * @param u
     * @param graph
     * @return 从顶点 u 出发的所有路径是不是有一条能够回到 u，有回路就返回 true
     */
    private boolean dfs(int u, int[][] graph) {
        if (visited[u] != null) {
            return visited[u];
        }
        // 先默认从 u 出发的所有路径有回路
        visited[u] = true;
        // 结点 u 的所有后继结点都不能回到自己，才能认为结点 u 是安全的
        for (int successor : graph[u]) {
            if (dfs(successor, graph)) {
                return true;
            }
        }
        visited[u] = false;
        return false;
    }
}

栈与深度优先搜索

栈这种后进先出的数据结构,对于迭代法写深度优先搜索有很重要的作用,同样,栈也被用于回溯算法,先看一看,怎么样使用栈来迭代深度优先算法吧:

前序遍历二叉树的迭代写法

//前序遍历的迭代写法
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        while (!stack.isEmpty() || null != root) {
            while (null != root) {
                stack.push(root);
              //由于前序遍历是先遍历根节点,所以在压入栈的时候就可以输出该节点的值
                res.add(root.val);
              // 根->左节点
                root = root.left;
            }
          //因为是从根节点过来的 pop出栈之后即可获得上一层节点
            root = stack.pop();
            root = root.right;
        }
        return res;
    }

中序遍历二叉树的迭代写法

//中序遍历的迭代写法
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        while (!stack.isEmpty() || null != root) {
            while (null != root) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
          //最下面的左节点先输出
            res.add(root.val);
            root = root.right;
        }
        return res;
 }

后序遍历二叉树的迭代写法

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode prev = null;
        while (!stack.isEmpty() || null != root) {
            while (null != root) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if(root.right == null || root.right==prev){
              //先输出左节点
                res.add(root.val);
                prev = root;
                root = null;
            }else{
                stack.push(root);
               //再输出右节点
                root = root.right;
            }
        }
        return res;
 }

dinl_vin

关注

0
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
(算法)深度优先搜索

深度优先搜索概述[一条路走到底,不撞南墙不回头][撞南墙]有两种情况:①遇到了边界条件,②遇到了已经走过的路深度优先的另一种结束条件,就是找到了目标出口深度优先遍历的本质就是穷举常见的深度优先搜索接下来根据刷题记录,来学习深度优先搜索算法:树的深度优先遍历[二叉树最大深度][https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/]给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点
复制链接

扫一扫