数据结构与算法-深度优先搜索

Posted 算法半岛

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构与算法-深度优先搜索相关的知识，希望对你有一定的参考价值。

↑点击上面"算法半岛"

关注"算法半岛"第一时间接收最新文章


DFS理解

    深度优先搜索(Depth First Search, DFS)可以理解为走迷宫，假设当一个人走迷宫的时候，会遇到岔路口，面对多条路选择时，可以先随便选择一条，走着走着发现如果走不通了，可以退回到上一个岔路口，然后重新选择一条，用同样的方法继续走，直到直到出口为止。这样的策略即为DFS。

DFS示意图

    接下来我们将DFS应用到图的搜索中，如下图所示：

DFS代码

    在完成相应的 java代码前，我们先解释相关函数及参数的含义：

  • HashMap<Integer,LinkedList<Integer>>graph：我们使用一个 HashMap来存储图，其中 HashMap中的 key为图的顶点， LinkedList<Integer>>为与该顶点相连的顶点；

  • HashMap<Integer,Boolean>visited：我们使用一个 visited用来记录顶点是否被访问，用来避免顶点被重复访问；

  • visit(HashMap<Integer,LinkedList<Integer>>graph,HashMap<Integer,Boolean>visited,Integerstart)：该函数为DFS的主体部分，用来遍历各个顶点。

    具体 java代码如下所示：

 
   
   
 
    
  
    
    
  
  1. import java.util.HashMap;
    2. 
  
    
    
  
  2. import java.util.LinkedList;
    3. 
  
    
    
  

    4. 
  
    
    
  
  4. public class TestDFS {
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  private static void dfs(HashMap<Integer, LinkedList<Integer>> graph, HashMap<Integer, Boolean> visited){
    7. 
  
    
    
  
  7.  visit(graph, visited, 1);
    8. 
  
    
    
  
  8.  visit(graph, visited, 2);
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  

    11. 
  
    
    
  

    12. 
  
    
    
  
  12.  private static void visit(HashMap<Integer, LinkedList<Integer>> graph, HashMap<Integer, Boolean> visited, Integer start){
    13. 
  
    
    
  
  13.  // 如果该顶点没有被访问，则访问该顶点
    14. 
  
    
    
  
  14.  if (!visited.containsKey(start)){
    15. 
  
    
    
  
  15.  System.out.println("当前进入节点为：" + start);
    16. 
  
    
    
  
  16.  visited.put(start, true);
    17. 
  
    
    
  
  17.  // 访问该顶点的相连顶点
    18. 
  
    
    
  
  18.  for (Integer i : graph.get(start)){
    19. 
  
    
    
  
  19.  if (!visited.containsKey(i)){
    20. 
  
    
    
  
  20.  visit(graph,visited, i); // 递归访问相连顶点
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22.  }
    23. 
  
    
    
  
  23.  System.out.println("当前离开节点为：" + start);
    24. 
  
    
    
  
  24.  }
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  

    27. 
  
    
    
  
  27.  public static void main(String[] args) {
    28. 
  
    
    
  

    29. 
  
    
    
  
  29.  // 构造各个顶点
    30. 
  
    
    
  
  30.  LinkedList<Integer> v1 = new LinkedList<>();
    31. 
  
    
    
  
  31.  v1.add(2);
    32. 
  
    
    
  
  32.  v1.add(3);
    33. 
  
    
    
  
  33.  v1.add(4);
    34. 
  
    
    
  
  34.  LinkedList<Integer> v2 = new LinkedList<>();
    35. 
  
    
    
  
  35.  v2.add(1);
    36. 
  
    
    
  
  36.  v2.add(3);
    37. 
  
    
    
  
  37.  LinkedList<Integer> v3 = new LinkedList<>();
    38. 
  
    
    
  
  38.  v3.add(1);
    39. 
  
    
    
  
  39.  v3.add(2);
    40. 
  
    
    
  
  40.  LinkedList<Integer> v4 = new LinkedList<>();
    41. 
  
    
    
  
  41.  v4.add(1);
    42. 
  
    
    
  
  42.  v4.add(5);
    43. 
  
    
    
  
  43.  v4.add(6);
    44. 
  
    
    
  
  44.  LinkedList<Integer> v5 = new LinkedList<>();
    45. 
  
    
    
  
  45.  v5.add(4);
    46. 
  
    
    
  
  46.  LinkedList<Integer> v6 = new LinkedList<>();
    47. 
  
    
    
  
  47.  v6.add(4);
    48. 
  
    
    
  
  48.  v6.add(7);
    49. 
  
    
    
  
  49.  LinkedList<Integer> v7 = new LinkedList<>();
    50. 
  
    
    
  
  50.  v7.add(6);
    51. 
  
    
    
  

    52. 
  
    
    
  
  52.  // 构造图
    53. 
  
    
    
  
  53.  HashMap<Integer, LinkedList<Integer>> graph = new HashMap<>();
    54. 
  
    
    
  
  54.  graph.put(1, v1);
    55. 
  
    
    
  
  55.  graph.put(2, v2);
    56. 
  
    
    
  
  56.  graph.put(3, v3);
    57. 
  
    
    
  
  57.  graph.put(4, v4);
    58. 
  
    
    
  
  58.  graph.put(5, v5);
    59. 
  
    
    
  
  59.  graph.put(6, v6);
    60. 
  
    
    
  
  60.  graph.put(7, v7);
    61. 
  
    
    
  

    62. 
  
    
    
  
  62.  // visited数组记录被访问的节点
    63. 
  
    
    
  
  63.  HashMap<Integer, Boolean> visited = new HashMap<>();
    64. 
  
    
    
  

    65. 
  
    
    
  
  65.  dfs(graph, visited);
    66. 
  
    
    
  

    67. 
  
    
    
  
  67.  }
    68. 
  
    
    
  
  68. }
    69.

    输出结果：

 
   
   
 
    
  
    
    
  
  1. 当前进入节点为：1
    2. 
  
    
    
  
  2. 当前进入节点为：2
    3. 
  
    
    
  
  3. 当前进入节点为：3
    4. 
  
    
    
  
  4. 当前离开节点为：3
    5. 
  
    
    
  
  5. 当前离开节点为：2
    6. 
  
    
    
  
  6. 当前进入节点为：4
    7. 
  
    
    
  
  7. 当前进入节点为：5
    8. 
  
    
    
  
  8. 当前离开节点为：5
    9. 
  
    
    
  
  9. 当前进入节点为：6
    10. 
  
    
    
  
  10. 当前进入节点为：7
    11. 
  
    
    
  
  11. 当前离开节点为：7
    12. 
  
    
    
  
  12. 当前离开节点为：6
    13. 
  
    
    
  
  13. 当前离开节点为：4
    14. 
  
    
    
  
  14. 当前离开节点为：1
    15.


以上是关于数据结构与算法-深度优先搜索的主要内容，如果未能解决你的问题，请参考以下文章

算法题——深度优先搜索与广度优先搜索

手撸golang 基本数据结构与算法 图的搜索 深度优先/广度优先

代码与算法集锦-归并排序+树状数组+快排+深度优先搜索+01背包（动态规划）

[算法与数据结构] 走迷宫问题（广度与深度优先搜索）

深度优先搜索和广度优先搜索的比较与分（转）

深度优先搜索的理解与实现