无向图的深度优先和广度优先遍历

合集下载

深度优先算法和广度优先算法的时间复杂度

深度优先算法和广度优先算法的时间复杂度深度优先算法和广度优先算法是在图论中常见的两种搜索算法，它们在解决各种问题时都有很重要的作用。

本文将以深入浅出的方式从时间复杂度的角度对这两种算法进行全面评估，并探讨它们在实际应用中的优劣势。

1. 深度优先算法的时间复杂度深度优先算法是一种用于遍历或搜索树或图的算法。

它从图中的某个顶点出发，沿着一条路径一直走到底，直到不能再前进为止，然后回溯到上一个节点，尝试走其他的路径，直到所有路径都被走过为止。

深度优先算法的时间复杂度与图的深度有关。

在最坏情况下，深度优先算法的时间复杂度为O(V+E)，其中V表示顶点的数量，E表示边的数量。

2. 广度优先算法的时间复杂度广度优先算法也是一种用于遍历或搜索树或图的算法。

与深度优先算法不同的是，广度优先算法是从图的某个顶点出发，首先访问这个顶点的所有邻接节点，然后再依次访问这些节点的邻接节点，依次类推。

广度优先算法的时间复杂度与图中边的数量有关。

在最坏情况下，广度优先算法的时间复杂度为O(V+E)。

3. 深度优先算法与广度优先算法的比较从时间复杂度的角度来看，深度优先算法和广度优先算法在最坏情况下都是O(V+E)，并没有明显的差异。

但从实际运行情况来看，深度优先算法和广度优先算法的性能差异是显而易见的。

在一般情况下，广度优先算法要比深度优先算法快，因为广度优先算法的搜索速度更快，且能够更快地找到最短路径。

4. 个人观点和理解在实际应用中，选择深度优先算法还是广度优先算法取决于具体的问题。

如果要找到两个节点之间的最短路径，那么广度优先算法是更好的选择；而如果要搜索整个图，那么深度优先算法可能是更好的选择。

要根据具体的问题来选择合适的算法。

5. 总结和回顾本文从时间复杂度的角度对深度优先算法和广度优先算法进行了全面评估，探讨了它们的优劣势和实际应用中的选择。

通过对两种算法的时间复杂度进行比较，可以更全面、深刻和灵活地理解深度优先算法和广度优先算法的特点和适用场景。

第7章图的深度和广度优先搜索遍历算法

7.3 图的遍历
和树的遍历类似，我们希望从图中某顶点出发对图中每个顶点访问一次，而且只访问一次，这一过程称为图的遍历(traversing graph)。本节介绍两种遍历图的规则：深度优先搜索和广度优先搜索。这两种方法既适用于无向图，也适用于有向图。
7.3.1 深度优先搜索遍历一．思路：从图中某一点（如A）开始，先访问这一点，然后任选它的一个邻点（如V0）访问，访问完该点后，再任选这个点V0的一个邻点（如 W ）访问，如此向纵深方向访问。直到某个点没有其他未访问的邻点为止，则返回到前一个点。再任选它的另一个未访问过的邻点（如X ）继续重复上述过程的访问，直到全部点访问完为止。图(a)的遍历的结果:V1V2V4V8V5V3V6V7 或V1V3V7V6V2V5V8V4
p
v0 w x v 1
V
0
v 2
V
0
typedef struct {VEXNODE adjlist［MAXLEN］; // 邻接链表表头向量 int vexnum, arcnum; // 顶点数和边数 int kind; // 图的类型 }ADJGRAPH;
W W
X
X
7.3.2 广度优先搜索遍历一.思路：
V
0
A V
0
W W
XXΒιβλιοθήκη 二．深度优先搜索算法的文字描述：算法中设一数组visited，表示顶点是否访问过的标志。数组长度为图的顶点数，初值均置为0，表示顶点均未被访问，当Vi被访问过，即将visitsd对应分量置为1。将该数组设为全局变量。 { 确定从G中某一顶点V0出发，访问V0； visited［V0］ = 1；找出G中V0的第一个邻接顶点->w； while (w存在) do { if visited［w］ == 0 继续进行深度优先搜索；找出G中V0的下一个邻接顶点->w；} }

深度优先算法和广度优先算法的时间复杂度

深度优先算法和广度优先算法都是图搜索中常见的算法，它们具有不同的特点和适用场景。

在进行全面评估之前，让我们先来了解一下深度优先算法和广度优先算法的基本概念和原理。

### 1. 深度优先算法（Depth-First Search, DFS）深度优先算法是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发，沿着一条路径直到末端，然后回溯，继续搜索下一条路径，直到所有路径都被探索。

在实际应用中，深度优先算法常常通过递归或栈来实现。

### 2. 广度优先算法（Breadth-First Search, BFS）广度优先算法也是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发，依次遍历该顶点的所有相邻顶点，然后再以这些相邻顶点作为起点，继续遍历它们的相邻顶点，以此类推，直到所有顶点都被遍历。

在实际应用中，广度优先算法通常通过队列来实现。

### 3. 深度优先算法和广度优先算法的时间复杂度在实际应用中，我们经常需要对算法的时间复杂度进行分析。

针对深度优先算法和广度优先算法，它们的时间复杂度并不相同。

- 深度优先算法的时间复杂度：O(V + E)，其中V为顶点数，E为边数。

在最坏的情况下，如果采用邻接矩阵来表示图的话，深度优先算法的时间复杂度为O(V^2)；如果采用邻接表来表示图的话，时间复杂度为O(V + E)。

- 广度优先算法的时间复杂度：O(V + E)，其中V为顶点数，E为边数。

无论采用邻接矩阵还是邻接表表示图，广度优先算法的时间复杂度都是O(V + E)。

### 4. 个人理解和观点在实际应用中，我们在选择使用深度优先算法还是广度优先算法时，需要根据具体的问题场景来进行选择。

如果要寻找图中的一条路径，或者判断两个节点之间是否存在路径，通常会选择使用深度优先算法；如果要寻找最短路径或者进行层次遍历，通常会选择使用广度优先算法。

深度优先算法和广度优先算法都是非常重要的图搜索算法，它们各自适用于不同的场景，并且具有不同的时间复杂度。

dfs和bfs算法

dfs和bfs算法深度优先搜索（DFS）和广度优先搜索（BFS）是图论中常用的两种搜索算法，也是许多算法题中的基础算法。

本文将从什么是图、什么是搜索算法开始介绍DFS、BFS的基本原理以及应用场景。

一、图的概念图是由节点集合以及它们之间连线所组成的数据结构。

图分为有向图和无向图两种，有向图中的边具有一定的方向性，而无向图中的边是没有方向的。

二、DFS（深度优先搜索）深度优先搜索从一个点开始，根据规定的遍历方式始终向着深度方向搜索下去，直到到达目标节点或者无法继续搜索为止。

具体实现可以用递归或者非递归的方式进行。

1、深度优先搜索的框架def dfs(v,visited,graph):visited[v] = True #将节点v标记为已经被访问#遍历v的所有连接节点for w in graph[v]:if not visited[w]:dfs(w,visited,graph)2、深度优先搜索的应用DFS常用来解决最长路径问题、拓扑排序问题以及判断图是否存在环。

三、BFS（广度优先搜索）广度优先搜索是从一个点开始，逐层扩散的搜索方式。

具体实现可以用队列实现。

1、广度优先搜索的框架def bfs(start,graph):visited = [False] * len(graph) #标记所有节点为未访问queue = [start] #队列存储已经访问过的节点visited[start] = True #起始点被标记为已经访问过while queue:v = queue.pop(0) #弹出队列首节点#遍历该节点的所有连接节点for w in graph[v]:if not visited[w]:visited[w] = True #标记该节点已经被访问queue.append(w) #加入队列2、广度优先搜索的应用BFS常用来解决最短路径问题，如迷宫问题、网络路由问题等。

四、DFS和BFS的区别DFS从一个节点开始，向下深度优先搜索，不断往下搜索直到无路可走才返回，因此将搜索过的节点用栈来存储。

深度优先搜索和广度优先搜索

深度优先搜索和广度优先搜索一、深度优先搜索和广度优先搜索的深入讨论(一)深度优先搜索的特点是无论问题的内容和性质以及求解要求如何不同，它们的程序结构都是相同的，即都是深度优先算法(一)和深度优先算法(二)中描述的算法结构，不相同的仅仅是存储结点数据结构和产生规则以及输出要求。

(2)深度优先搜索法有递归以及非递归两种设计方法。

一般的，当搜索深度较小、问题递归方式比较明显时，用递归方法设计好，它可以使得程序结构更简捷易懂。

当搜索深度较大时，当数据量较大时，由于系统堆栈容量的限制，递归容易产生溢出，用非递归方法设计比较好。

(3)深度优先搜索方法有广义和狭义两种理解。

广义的理解是，只要最新产生的结点(即深度最大的结点)先进行扩展的方法，就称为深度优先搜索方法。

在这种理解情况下，深度优先搜索算法有全部保留和不全部保留产生的结点的两种情况。

而狭义的理解是，仅仅只保留全部产生结点的算法。

本书取前一种广义的理解。

不保留全部结点的算法属于一般的回溯算法范畴。

保留全部结点的算法，实际上是在数据库中产生一个结点之间的搜索树，因此也属于图搜索算法的范畴。

(4)不保留全部结点的深度优先搜索法，由于把扩展望的结点从数据库中弹出删除，这样，一般在数据库中存储的结点数就是深度值，因此它占用的空间较少，所以，当搜索树的结点较多，用其他方法易产生内存溢出时，深度优先搜索不失为一种有效的算法。

(5)从输出结果可看出，深度优先搜索找到的第一个解并不一定是最优解.如果要求出最优解的话，一种方法将是后面要介绍的动态规划法，另一种方法是修改原算法：把原输出过程的地方改为记录过程，即记录达到当前目标的路径和相应的路程值，并与前面已记录的值进行比较，保留其中最优的，等全部搜索完成后，才把保留的最优解输出。

二、广度优先搜索法的显著特点是：(1)在产生新的子结点时，深度越小的结点越先得到扩展，即先产生它的子结点。

为使算法便于实现，存放结点的数据库一般用队列的结构。

深度优先搜索和广度优先搜索

深度优先搜索和⼴度优先搜索深度优先搜索和⼴度优先搜索都是图的遍历算法。

⼀、深度优先搜索（Depth First Search） 1、介绍深度优先搜索（DFS），顾名思义，在进⾏遍历或者说搜索的时候，选择⼀个没有被搜过的结点（⼀般选择顶点），按照深度优先，⼀直往该结点的后续路径结点进⾏访问，直到该路径的最后⼀个结点，然后再从未被访问的邻结点进⾏深度优先搜索，重复以上过程，直⾄所有点都被访问，遍历结束。

⼀般步骤：（1）访问顶点v；（2）依次从v的未被访问的邻接点出发，对图进⾏深度优先遍历；直⾄图中和v有路径相通的顶点都被访问；（3）若此时图中尚有顶点未被访问，则从⼀个未被访问的顶点出发，重新进⾏深度优先遍历，直到图中所有顶点均被访问过为⽌。

可以看出，深度优先算法使⽤递归即可实现。

2、⽆向图的深度优先搜索下⾯以⽆向图为例，进⾏深度优先搜索遍历：遍历过程：所以遍历结果是：A→C→B→D→F→G→E。

3、有向图的深度优先搜索下⾯以有向图为例，进⾏深度优先遍历：遍历过程：所以遍历结果为：A→B→C→E→D→F→G。

⼆、⼴度优先搜索（Breadth First Search） 1、介绍⼴度优先搜索（BFS）是图的另⼀种遍历⽅式，与DFS相对，是以⼴度优先进⾏搜索。

简⾔之就是先访问图的顶点，然后⼴度优先访问其邻接点，然后再依次进⾏被访问点的邻接点，⼀层⼀层访问，直⾄访问完所有点，遍历结束。

2、⽆向图的⼴度优先搜索下⾯是⽆向图的⼴度优先搜索过程：所以遍历结果为：A→C→D→F→B→G→E。

3、有向图的⼴度优先搜索下⾯是有向图的⼴度优先搜索过程：所以遍历结果为：A→B→C→E→F→D→G。

三、两者实现⽅式对⽐深度优先搜索⽤栈（stack）来实现，整个过程可以想象成⼀个倒⽴的树形：把根节点压⼊栈中。

每次从栈中弹出⼀个元素，搜索所有在它下⼀级的元素，把这些元素压⼊栈中。

并把这个元素记为它下⼀级元素的前驱。

广度优先和深度优先的例子

广度优先和深度优先的例子广度优先搜索(BFS)和深度优先搜索(DFS)是图遍历中常用的两种算法。

它们在解决许多问题时都能提供有效的解决方案。

本文将分别介绍广度优先搜索和深度优先搜索，并给出各自的应用例子。

一、广度优先搜索(BFS)广度优先搜索是一种遍历或搜索图的算法，它从起始节点开始，逐层扩展，先访问起始节点的所有邻居节点，再依次访问其邻居节点的邻居节点，直到遍历完所有节点或找到目标节点。

例子1：迷宫问题假设有一个迷宫，迷宫中有多个房间，每个房间有四个相邻的房间：上、下、左、右。

现在我们需要找到从起始房间到目标房间的最短路径。

可以使用广度优先搜索算法来解决这个问题。

例子2：社交网络中的好友推荐在社交网络中，我们希望给用户推荐可能认识的新朋友。

可以使用广度优先搜索算法从用户的好友列表开始，逐层扩展，找到可能认识的新朋友。

例子3：网页爬虫网页爬虫是搜索引擎抓取网页的重要工具。

爬虫可以使用广度优先搜索算法从一个网页开始，逐层扩展，找到所有相关的网页并进行抓取。

例子4：图的最短路径在图中，我们希望找到两个节点之间的最短路径。

可以使用广度优先搜索算法从起始节点开始，逐层扩展，直到找到目标节点。

例子5：推荐系统在推荐系统中，我们希望给用户推荐可能感兴趣的物品。

可以使用广度优先搜索算法从用户喜欢的物品开始，逐层扩展，找到可能感兴趣的其他物品。

二、深度优先搜索(DFS)深度优先搜索是一种遍历或搜索图的算法，它从起始节点开始，沿着一条路径一直走到底，直到不能再继续下去为止，然后回溯到上一个节点，继续探索其他路径。

例子1：二叉树的遍历在二叉树中，深度优先搜索算法可以用来实现前序遍历、中序遍历和后序遍历。

通过深度优先搜索算法，我们可以按照不同的遍历顺序找到二叉树中所有节点。

例子2：回溯算法回溯算法是一种通过深度优先搜索的方式，在问题的解空间中搜索所有可能的解的算法。

回溯算法常用于解决组合问题、排列问题和子集问题。

例子3：拓扑排序拓扑排序是一种对有向无环图(DAG)进行排序的算法。

深度优先和广度优先比较

深度优先和⼴度优先⽐较区别：1）⼆叉树的深度优先遍历的⾮递归的通⽤做法是采⽤栈，⼴度优先遍历的⾮递归的通⽤做法是采⽤队列。

2）深度优先遍历：对每⼀个可能的分⽀路径深⼊到不能再深⼊为⽌，⽽且每个结点只能访问⼀次。

要特别注意的是，⼆叉树的深度优先遍历⽐较特殊，可以细分为先序遍历、中序遍历、后序遍历。

具体说明如下：先序遍历：对任⼀⼦树，先访问根，然后遍历其左⼦树，最后遍历其右⼦树。

中序遍历：对任⼀⼦树，先遍历其左⼦树，然后访问根，最后遍历其右⼦树。

后序遍历：对任⼀⼦树，先遍历其左⼦树，然后遍历其右⼦树，最后访问根。

⼴度优先遍历：⼜叫层次遍历，从上往下对每⼀层依次访问，在每⼀层中，从左往右（也可以从右往左）访问结点，访问完⼀层就进⼊下⼀层，直到没有结点可以访问为⽌。

3）深度优先搜素算法：不全部保留结点，占⽤空间少；有回溯操作(即有⼊栈、出栈操作)，运⾏速度慢。

⼴度优先搜索算法：保留全部结点，占⽤空间⼤；⽆回溯操作(即⽆⼊栈、出栈操作)，运⾏速度快。

通常深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，⼀般在数据库中存储的结点数就是深度值，因此它占⽤空间较少。

所以，当搜索树的结点较多，⽤其它⽅法易产⽣内存溢出时，深度优先搜索不失为⼀种有效的求解⽅法。

　⼴度优先搜索算法，⼀般需存储产⽣的所有结点，占⽤的存储空间要⽐深度优先搜索⼤得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。

但⼴度优先搜索法⼀般⽆回溯操作，即⼊栈和出栈的操作，所以运⾏速度⽐深度优先搜索要快些深度优先：前序遍历：35,20,15,16,29,28,30,40,50,45,55中序遍历：15,16,20,28,29,30,35,40,45,50,55后序遍历：16,15,28,30,29,20,45,55,50,40,35⼴度优先遍历：35 20 40 15 29 50 16 28 30 45 55代码：package www.hhy;import java.beans.beancontext.BeanContextChild;import java.util.*;class Binarytree {class TreeNode{int value;TreeNode left;TreeNode right;public TreeNode(int value) {this.value = value;}}//⽤递归创建⼆叉树public int i = 0;TreeNode creatTesttree(String s){TreeNode root = null;if (s.charAt(i)!='#') {root = new TreeNode(s.charAt(i));i++;root.left = creatTesttree(s);root.right = creatTesttree(s);}else{i++;}return root;}//⼆叉树的前序遍历递归void binaryTreePrevOrder(TreeNode root){if(root==null){return;}System.out.println(root.value+" ");binaryTreePrevOrder(root.left);binaryTreePrevOrder(root.right);}//⼆叉树的中序遍历递归void binaryTreeInOrder(TreeNode root){if(root==null){return;}binaryTreeInOrder(root.left);System.out.println(root.value+" ");binaryTreeInOrder(root.right);}//⼆叉树的后续遍历递归void binaryTreePostOrder(TreeNode root){if(root==null){return;}binaryTreePostOrder(root.left);binaryTreePostOrder(root.right);System.out.println(root.value+" ");}//层序遍历void binaryTreeLevelOrder(TreeNode root,int level){if(root ==null||level<1){return;}if(level==1){System.out.print(root.value+" ");}binaryTreeLevelOrder(root.left,level-1);binaryTreeLevelOrder(root.right,level-1);}void BTreeLevelOrder(TreeNode root){if (root == null)return;int dep = getHeight(root);for (int i = 1; i <= dep; i++){binaryTreeLevelOrder(root,i);}}//⼆叉树的层序遍历⾮递归void binaryTreeLevelOrder(TreeNode root) {Queue<TreeNode> queue = new LinkedList<>();if(root != null) {queue.offer(root);//LinkedList offer add}while (!queue.isEmpty()) {//1、拿到队头的元素把队头元素的左右⼦树⼊队 TreeNode cur = queue.poll();System.out.print(cur.value+" ");//2、不为空的时候才能⼊队if(cur.left != null) {queue.offer(cur.left);}if(cur.right != null) {queue.offer(cur.right);}}}//⼆叉树的前序遍历⾮递归void binaryTreePrevOrderNonR(TreeNode root){Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;TreeNode top = null;while (cur != null || !stack.empty()) {while (cur != null) {stack.push(cur);System.out.print(cur.value + " ");cur = cur.left;}top = stack.pop();cur = top.right;}System.out.println();}//⼆叉树的中序遍历⾮递归void binaryTreeInOrderNonR(TreeNode root){Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;TreeNode top = null;while (cur != null || !stack.empty()) {while (cur != null) {stack.push(cur);cur = cur.left;}top = stack.pop();System.out.print(top.value+" ");cur = top.right;}System.out.println();}//⼆叉树的后序遍历⾮递归void binaryTreePostOrderNonR(TreeNode root) {Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;TreeNode prev = null;while (cur != null || !stack.empty()) {while (cur != null) {stack.push(cur);cur = cur.left;}cur = stack.peek();//L D//cur.right == prev 代表的是 cur的右边已经打印过了if(cur.right == null || cur.right == prev) {stack.pop();System.out.println(cur.value);prev = cur;cur = null;}else {cur = cur.right;}}}//⼆叉树的节点个数递归int getSize(TreeNode root){if(root==null){return 0;}return getSize(root.left)+getSize(root.right)+1;}//⼆叉树的叶⼦节点的个数递归int getLeafSize(TreeNode root){if(root==null){return 0;}if(root.left==null && root.right==null){return 1;}return getLeafSize(root.left)+getLeafSize(root.right); }//⼆叉树得到第K层结点的个数int getKlevelSize(TreeNode root ,int k){if(root==null){return 0;}if(k == 1){return 1;}return getKlevelSize(root.left,k-1)+getKlevelSize(root.right,k-1);}//⼆叉树查找并返回该结点递归// 查找，依次在⼆叉树的根、左⼦树、// 右⼦树中查找 value，如果找到，返回结点，否则返回 nullTreeNode find(TreeNode root, int value){if(root == null) {return null;}if(root.value == value){return root;}TreeNode ret = find(root.left,value);if(ret != null) {return ret;}ret = find(root.right,value);if(ret != null) {return ret;}return null;}//⼆叉树的⾼度int getHeight(TreeNode root){if(root==null){return 0;}int leftHeight = getHeight(root.left);int rightHeight = getHeight(root.right);return leftHeight>rightHeight ? leftHeight+1:rightHeight+1;}//判断⼀个树是不是完全⼆叉树public int binaryTreeComplete(TreeNode root) {Queue<TreeNode> queue = new LinkedList<TreeNode>();if(root != null) {queue.add(root);//offer}while(!queue.isEmpty()) {TreeNode cur = queue.peek();queue.poll();if(cur != null) {queue.add(cur.left);queue.add(cur.right);}else {break;}}while(!queue.isEmpty()) {TreeNode cur = queue.peek();if (cur != null){//说明不是满⼆叉树return -1;}else{queue.poll();}}return 0;//代表是完全⼆叉树}//检查两棵树是否是相同的，如果两棵树结构相同，并且在结点上的值相同，那么这两棵树是相同返回true public boolean isSameTree(TreeNode p,TreeNode q){if((p==null&&q!=null)||(p!=null&&q==null)){}if(p==null && q==null){return true;}if(p.value!=q.value){return false;}return isSameTree(p.left,q.left)&&isSameTree(p.right,q.left);}//检查是否为⼦树public boolean isSubTree(TreeNode s,TreeNode t){if(s==null||t==null){return false;}if(isSameTree(s,t)){return true;}else if (isSubTree(s.left,t)){return true;}else if(isSubTree(s.right,t)){return true;}else{return false;}}//1.判断是否为平衡⼆叉树，左右⼦树的⾼度之差不超过 "1"(⼤根本⾝是平衡⼆叉树，左右⼦树也必须是平衡⼆叉树) // 时间复杂度为n^2//2.求复杂度为O(n)的解法public boolean isBanlanced(TreeNode root){if(root==null){return true;}else{int leftHeight = getHeight(root.left);int rightHeight = getHeight(root.right);return Math.abs(leftHeight-rightHeight)<2&&isBanlanced(root.left)&&isBanlanced(root.right);}}//判断是否为对称⼆叉树public boolean isSymmetric(TreeNode root){if(root==null){return true;}return isSymmetric(root.left,root.right);}public boolean isSymmetric(TreeNode lefttree,TreeNode righttree){if((lefttree==null && righttree!=null)||(lefttree!=null && righttree ==null)){return false;}if(lefttree == null && righttree == null){return true;}return lefttree.value == righttree.value && isSymmetric(lefttree.left,righttree.right)&& isSymmetric(lefttree.right,righttree.left);}//⼆叉树创建字符串⾮递归写法public String tree2str(TreeNode t){StringBuilder sb = new StringBuilder();tree2strchild(t,sb);return sb.toString();}public void tree2strchild(TreeNode t ,StringBuilder sb){if (t==null){}sb.append(t.value);if (t.left!=null){sb.append("(");tree2strchild(t.left,sb);sb.append(")");}else {if (t.right==null){}}}//⼆叉树字符串递归写法public String CreateStr(TreeNode t){if(t==null){return "";}if(t.left==null&&t.right==null){return t.value+"";}if(t.left==null){return t.value+"()"+"("+CreateStr(t.right)+")";}if(t.right==null){return t.value+"("+CreateStr(t.left)+")";}return t.value+"("+CreateStr(t.left)+")"+"("+CreateStr(t.right)+")";}public int rob(TreeNode root) {if (root == null) return 0;return Math.max(robOK(root), robNG(root));}private int robOK(TreeNode root) {if (root == null) return 0;return root.value + robNG(root.left) + robNG(root.right);}private int robNG(TreeNode root) {if (root == null) return 0;return rob(root.left) + rob(root.right);}//⼆叉树的公共祖先public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if(root==null){return null;}if(root==p||root==q){return root;}TreeNode leftTree = lowestCommonAncestor(root.left,p,q);//p||q nullTreeNode rightTree = lowestCommonAncestor(root.right,p,q);//p||q null//3if(leftTree!=null && rightTree!=null){return root;}//左边找到else if (leftTree!=null ){return leftTree;}//右边找到else if(rightTree!=null){return rightTree;}//都没找到的情况下return null;}//⼆叉搜索树，若他的左⼦树不为空，左⼦树上的所有节点都⼩于根节点，//如果他的右⼦树不为空，右⼦树上的所有节点都⼤于根节点//最终他的中序排列都是有序结果//输⼊⼀棵⼆叉搜索树，将该⼆叉搜索树转换成⼀个排序的双向链表。

算法设计：深度优先遍历和广度优先遍历

算法设计：深度优先遍历和广度优先遍历实现深度优先遍历过程1、图的遍历和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。

它是许多图的算法的基础。

深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。

它们对无向图和有向图均适用。

注意：以下假定遍历过程中访问顶点的操作是简单地输出顶点。

2、布尔向量visited[0．．n-1]的设置图中任一顶点都可能和其它顶点相邻接。

在访问了某顶点之后，又可能顺着某条回路又回到了该顶点。

为了避免重复访问同一个顶点，必须记住每个已访问的顶点。

为此，可设一布尔向量visited[0．．n-1]，其初值为假，一旦访问了顶点Vi之后，便将visited[i]置为真。

--------------------------深度优先遍历(Depth-First Traversal)1．图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。

在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。

若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。

若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。

图的深度优先遍历类似于树的前序遍历。

采用的搜索方法的特点是尽可能先对纵深方向进行搜索。

这种搜索方法称为深度优先搜索(Depth-First Search)。

相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。

2、深度优先搜索的过程设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。

若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。

广度优先算法和深度优先算法

广度优先算法和深度优先算法
广度优先算法和深度优先算法是最常用的两种图遍历算法，它们都能
够遍历整个图的节点，但在具体应用场景中选择哪种算法需要根据实
际需求来判断。

广度优先算法（BFS）将当前节点的所有邻居节点都遍历一遍后再遍历下一层，可以确保找到最短路径。

具体实现方式是使用一个队列来存
储被访问过但还未被遍历过的节点，同一层的节点都在队列中，不同
层的节点通过队列的先进先出特性被访问。

BFS遍历图通常需要记录
每个节点是否被访问过，以防止重复遍历。

深度优先算法（DFS）是一种递归算法，从某一节点出发一直向下遍
历到底（即遍历到一个叶子节点），然后返回到上一层节点继续遍历，直到遍历完整个图。

DFS相较于BFS具有更好的空间复杂度，但不能
保证找到最短路径。

DFS遍历图时通常需要记录每个节点是否被访问过，并保证不重复访问。

广度优先算法和深度优先算法在选择上需要根据具体算法应用需求。

如果需要找到最短路径，则选择广度优先算法，如果需要搜索所有可
能路径，则选择深度优先算法。

例如，在迷宫的寻找最短路径场景中，BFS可以从迷宫入口出发，按照层级一层一层的向外扩展搜索，最终
一定能够找到终点，但会消耗较大的空间；而DFS则可以搜索所有可能的路径，但不能确保找到最短路径。

综上所述，广度优先算法和深度优先算法都各有优缺点，在选择上需要根据实际应用场景判断。

图的遍历算法实验报告

图的遍历算法实验报告
《图的遍历算法实验报告》
在计算机科学领域，图的遍历算法是一种重要的算法，它用于在图数据结构中
访问每个顶点和边。

图的遍历算法有两种常见的方法：深度优先搜索（DFS）
和广度优先搜索（BFS）。

在本实验中，我们将对这两种算法进行实验，并比较
它们的性能和应用场景。

首先，我们使用深度优先搜索算法对一个简单的无向图进行遍历。

通过实验结
果可以看出，DFS算法会首先访问一个顶点的所有邻居，然后再递归地访问每
个邻居的邻居，直到图中所有的顶点都被访问到。

这种算法在一些应用场景中
非常有效，比如寻找图中的连通分量或者寻找图中的环路。

接下来，我们使用广度优先搜索算法对同样的无向图进行遍历。

通过实验结果
可以看出，BFS算法会首先访问一个顶点的所有邻居，然后再按照距离递增的
顺序访问每个邻居的邻居。

这种算法在一些应用场景中也非常有效，比如寻找
图中的最短路径或者寻找图中的最小生成树。

通过对比实验结果，我们可以发现DFS和BFS算法各自的优势和劣势。

DFS算
法适合用于寻找图中的连通分量和环路，而BFS算法适合用于寻找最短路径和
最小生成树。

因此，在实际应用中，我们需要根据具体的需求来选择合适的算法。

总的来说，图的遍历算法是计算机科学中非常重要的算法之一，它在许多领域
都有着广泛的应用。

通过本次实验，我们对DFS和BFS算法有了更深入的了解，并且对它们的性能和应用场景有了更清晰的认识。

希望通过这篇实验报告，读
者们也能对图的遍历算法有更深入的理解和认识。

图的遍历(深度优先遍历和广度优先遍历)

遍历规则从图中某结点v0出发，深度优先遍历（DFS: Depth First Search）图的规则为：访问v0；对v0的各个出点v01，v02，…，v0m，每次从它们中按一定方式（也可任选）选取一个未被访问过的结点，从该结点出发按深度优先遍历方式遍历。然，因为我们没有规定对出点的遍历次序，所以，图的深度优先遍历结果一般不唯一。
20.2 深度优先遍历
例如，对图 20‑1给出的有向图与无向图，一些遍历结果（结点访问次序）为：左图：从1出发：1，2，4，5；或1，5，2，4 从2出发：2，1，5，4；或2，4，1，5 右图：从a出发：a，b，c，d；或a，b，d，c; … …
A 如果不想让visited或top做为函数参数，也可以在函数中将其定义为static型量。但是，这样的程序是不可再入的，即函数再次被调用时，static型的量也不重新初始化，造成错误！
上面函数中的参数visited和top实质上是中间变量，只是为了避免在递归调用时重新初始化而放在参数表中，造成使用的不方便，为此，做个包装程序： long DFS1(int g[][CNST_NumNodes], long n, long v0, long *resu ) { char *visited; long top=0; visited = new char[n]; for (long i=0; i<n; i++) visited[i]=0; long num=DFS1( g, n, v0, visited, resu, top ); delete visited; return num; }
深度优先遍历非递归算法的一般性描述。
long DFS_NR(图g，结点v0)
单击此处可添加副标题

如果从无向图的任一顶点出发进行一次深度优先遍历

如果从无向图的任一顶点出发进行一次深度优先遍历无向图是二元关系被抽象表示的结构，它由若干个顶点构成，每一对顶点之间有一种关系，此关系叫做“边”，每一条边有一个起始点，也有一个终止点，这条边把这两个顶点相连。

深度优先遍历（Depth-First Search, DFS）是一种重要的搜索算法，它可以用来解决遍历图中所有顶点的问题。

深度优先遍历是从一个顶点开始，沿着某一条边一直走到最深处，然后回溯，再沿着另外一条边走到最深处，以此类推。

当我们从图的任一顶点出发，想要进行一次深度优先遍历时，主要有三个步骤：1. 从某一个顶点出发，首先把这个顶点标记为“经访问过，然后把它放入一个“经访问顶点的队列中。

2.次从“经访问顶点的队列中取出一个顶点v，然后依次检查v 的相邻顶点，如果有任意一个顶点没有被访问过，就把它标记为“经访问过，然后放入“经访问顶点的队列中。

3.复检查和标记的过程，直到“经访问顶点的队列中不再有顶点为止，此时可以保证图中的所有顶点都已经被访问过，即完成了一次深度优先遍历。

深度优先遍历的过程中，会出现回溯的情况：当访问到某个顶点时发现它所有的相邻顶点都被访问过了，就会将这个顶点从“经访问顶点的队列中出队列，从而回到它的上一个顶点，继续检查未被访问过的相邻顶点，直到队列中的所有顶点都被访问过为止。

深度优先遍历算法的时间复杂度通常为O(n+m)，其中n是顶点数，m是边数。

深度优先遍历的空间复杂度通常为O(n+m)，其中n是顶点数，m是边数。

由此可见，深度优先遍历比广度优先遍历（BFS）的时间和空间复杂度要小，因此使用在搜索路径比较短的图中时，深度优先遍历更加有效。

深度优先遍历可以用来解决图论中的许多问题，例如：拓扑排序、无环图的组成判断、最大匹配问题等等。

深度优先遍历的算法简单易实现，在算法应用中也非常重要。

总之，从图的任一顶点出发，进行一次深度优先遍历是一种重要的算法，它被广泛用于图论中的一些问题的求解，在算法应用中也同样重要，可以用来求解一些图的特殊问题，这也是它所备受重视的原因。

深度优先和广度优先算法

深度优先和广度优先算法深度优先和广度优先算法深度优先遍历和广度优先遍历是两种常用的图遍历算法。

它们的策略不同，各有优缺点，可以在不同的场景中使用。

一、深度优先遍历深度优先遍历（Depth First Search，DFS）是一种搜索算法，它从一个顶点开始遍历，尽可能深地搜索图中的每一个可能的路径，直到找到所有的路径。

该算法使用栈来实现。

1. 算法描述深度优先遍历的过程可以描述为：- 访问起始顶点v，并标记为已访问； - 从v的未被访问的邻接顶点开始深度优先遍历，直到所有的邻接顶点都被访问过或不存在未访问的邻接顶点； - 如果图中还有未被访问的顶点，则从这些顶点中任选一个，重复步骤1。

2. 算法实现深度优先遍历算法可以使用递归或者栈来实现。

以下是使用栈实现深度优先遍历的示例代码：``` void DFS(Graph g, int v, bool[] visited) { visited[v] = true; printf("%d ", v);for (int w : g.adj(v)) { if(!visited[w]) { DFS(g, w,visited); } } } ```3. 算法分析深度优先遍历的时间复杂度为O(V+E)，其中V是顶点数，E是边数。

由于该算法使用栈来实现，因此空间复杂度为O(V)。

二、广度优先遍历广度优先遍历（Breadth First Search，BFS）是一种搜索算法，它从一个顶点开始遍历，逐步扩展到它的邻接顶点，直到找到所有的路径。

该算法使用队列来实现。

1. 算法描述广度优先遍历的过程可以描述为：- 访问起始顶点v，并标记为已访问； - 将v的所有未被访问的邻接顶点加入队列中； - 从队列头取出一个顶点w，并标记为已访问； - 将w的所有未被访问的邻接顶点加入队列中； - 如果队列不为空，则重复步骤3。

2. 算法实现广度优先遍历算法可以使用队列来实现。

深度优先算法与广度优先算法的比较

深度优先算法与广度优先算法的比较深度优先算法以深度为优先，从一个节点开始，逐个遍历其邻居节点直至最深处，然后回溯到上一个节点，再继续遍历其他分支。

它是通过栈来实现的，先进后出的特性决定了深度优先算法是一个递归算法。

深度优先算法在过程中，不需要记住所有的路径，只需要记住当前路径上的节点即可。

对于树而言，深度优先算法通常沿着左子树一直深入，直到最深的叶节点，然后再回溯到前一个节点继续右子树的遍历。

广度优先算法以广度为优先，从一个节点开始，逐层遍历其所有邻居节点，然后再遍历下一层的节点，直至遍历完所有节点。

它是通过队列来实现的，先进先出的特性决定了广度优先算法是一个非递归算法。

广度优先算法在过程中，需要记住每一层的节点，并且按照先进先出的顺序进行遍历。

对于树而言，广度优先算法会先遍历根节点，然后是根节点的子节点，再然后是子节点的子节点，按照层次逐层遍历。

以下是深度优先算法和广度优先算法的比较：1.方式：深度优先算法通过一条路径一直遍历到最深处，然后回溯到上一个节点，再继续遍历其他分支。

广度优先算法逐层遍历，先遍历当前层的节点，再遍历下一层的节点。

2.存储结构：深度优先算法使用栈进行遍历，而广度优先算法使用队列进行遍历。

3.内存占用：深度优先算法只需要记住当前路径上的节点，所以内存占用较小。

而广度优先算法需要记住每一层的节点，所以内存占用较大。

4.时间效率：深度优先算法通常适用于解决单个解或路径的问题，因为它首先深入其中一个分支，整个分支再回溯，因此它可能会浪费一些时间在不必要的路径上。

而广度优先算法通常适用于解决最短路径或最小步数的问题，因为它遍历一层后再遍历下一层，所以找到的解很可能是最优解。

5.应用场景：深度优先算法适用于解决迷宫问题、拓扑排序和连通性等问题。

广度优先算法适用于解决最短路径、社交网络中的人际关系、图的遍历和等问题。

总结起来，深度优先算法和广度优先算法都有各自的特点和适用场景。

深度优先算法适合解决单个解或路径的问题，而广度优先算法适合解决最短路径或最小步数的问题。

深度优先搜索和广度优先搜索

深度优先搜索和广度优先搜索深度优先搜索（DFS）和广度优先搜索（BFS）是图论中常用的两种搜索算法。

它们是解决许多与图相关的问题的重要工具。

本文将着重介绍深度优先搜索和广度优先搜索的原理、应用场景以及优缺点。

一、深度优先搜索（DFS）深度优先搜索是一种先序遍历二叉树的思想。

从图的一个顶点出发，递归地访问与该顶点相邻的顶点，直到无法再继续前进为止，然后回溯到前一个顶点，继续访问其未被访问的邻接顶点，直到遍历完整个图。

深度优先搜索的基本思想可用以下步骤总结：1. 选择一个初始顶点；2. 访问该顶点，并标记为已访问；3. 递归访问该顶点的邻接顶点，直到所有邻接顶点均被访问过。

深度优先搜索的应用场景较为广泛。

在寻找连通分量、解决迷宫问题、查找拓扑排序等问题中，深度优先搜索都能够发挥重要作用。

它的主要优点是容易实现，缺点是可能进入无限循环。

二、广度优先搜索（BFS）广度优先搜索是一种逐层访问的思想。

从图的一个顶点出发，先访问该顶点，然后依次访问与该顶点邻接且未被访问的顶点，直到遍历完整个图。

广度优先搜索的基本思想可用以下步骤总结：1. 选择一个初始顶点；2. 访问该顶点，并标记为已访问；3. 将该顶点的所有邻接顶点加入一个队列；4. 从队列中依次取出一个顶点，并访问该顶点的邻接顶点，标记为已访问；5. 重复步骤4，直到队列为空。

广度优先搜索的应用场景也非常广泛。

在求最短路径、社交网络分析、网络爬虫等方面都可以使用广度优先搜索算法。

它的主要优点是可以找到最短路径，缺点是需要使用队列数据结构。

三、DFS与BFS的比较深度优先搜索和广度优先搜索各自有着不同的优缺点，适用于不同的场景。

深度优先搜索的优点是在空间复杂度较低的情况下找到解，但可能陷入无限循环，搜索路径不一定是最短的。

广度优先搜索能找到最短路径，但需要保存所有搜索过的节点，空间复杂度较高。

需要根据实际问题选择合适的搜索算法，例如在求最短路径问题中，广度优先搜索更加合适；而在解决连通分量问题时，深度优先搜索更为适用。

深度优先遍历算法和广度优先遍历算法实验小结

深度优先遍历算法和广度优先遍历算法实验小结一、引言在计算机科学领域，图的遍历是一种基本的算法操作。

深度优先遍历算法（Depth First Search，DFS）和广度优先遍历算法（Breadth First Search，BFS）是两种常用的图遍历算法。

它们在解决图的连通性和可达性等问题上具有重要的应用价值。

本文将从理论基础、算法原理、实验设计和实验结果等方面对深度优先遍历算法和广度优先遍历算法进行实验小结。

二、深度优先遍历算法深度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历，沿着一条路径一直向前直到不能再继续前进为止，然后退回到上一个节点，尝试下一个节点，直到遍历完整个图。

深度优先遍历算法通常使用栈来实现。

以下是深度优先遍历算法的伪代码：1. 创建一个栈并将起始节点压入栈中2. 将起始节点标记为已访问3. 当栈不为空时，执行以下步骤：a. 弹出栈顶节点，并访问该节点b. 将该节点尚未访问的邻居节点压入栈中，并标记为已访问4. 重复步骤3，直到栈为空三、广度优先遍历算法广度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历，先访问起始节点的所有相邻节点，然后再依次访问这些相邻节点的相邻节点，依次类推，直到遍历完整个图。

广度优先遍历算法通常使用队列来实现。

以下是广度优先遍历算法的伪代码：1. 创建一个队列并将起始节点入队2. 将起始节点标记为已访问3. 当队列不为空时，执行以下步骤：a. 出队一个节点，并访问该节点b. 将该节点尚未访问的邻居节点入队，并标记为已访问4. 重复步骤3，直到队列为空四、实验设计本次实验旨在通过编程实现深度优先遍历算法和广度优先遍历算法，并通过对比它们在不同图结构下的遍历效果，验证其算法的正确性和有效性。

具体实验设计如下：1. 实验工具：使用Python编程语言实现深度优先遍历算法和广度优先遍历算法2. 实验数据：设计多组图结构数据，包括树、稠密图、稀疏图等3. 实验环境：在相同的硬件环境下运行实验程序，确保实验结果的可比性4. 实验步骤：编写程序实现深度优先遍历算法和广度优先遍历算法，进行多次实验并记录实验结果5. 实验指标：记录每种算法的遍历路径、遍历时间和空间复杂度等指标，进行对比分析五、实验结果在不同图结构下，经过多次实验，分别记录了深度优先遍历算法和广度优先遍历算法的实验结果。

数据结构与算法(13)：深度优先搜索和广度优先搜索

因此访问顺序是：A => C => D => F => B => G => E
2.2.2 有向图的广广度优先搜索
下面面以“有向图”为例例，来对广广度优先搜索进行行行演示。还是以上面面的图G2为例例进行行行说明。
第1步：访问A。第2步：访问B。第3步：依次访问C,E,F。在访问了了B之后，接下来访问B的出边的另一一个顶点，即C,E,F。前面面已经说过，在本文文实现中，顶点ABCDEFG按照顺序存储的，因此会先访问C，再依次访问E,F。第4步：依次访问D,G。在访问完C,E,F之后，再依次访问它们的出边的另一一个顶点。还是按照C,E,F的顺序访问，C的已经全部访问过了了，那么就只剩下E,F；先访问E的邻接点D，再访问F的邻接点G。
if(mVexs[i]==ch)
return i;
return -1;
}
/* * 读取一一个输入入字符
*/
private char readChar() {
char ch='0';
do {
try {
ch = (char)System.in.read();
} catch (IOException e) {
数据结构与算法（13）：深度优先搜索和广广度优先搜索
BFS和DFS是两种十十分重要的搜索算法，BFS适合查找最优解，DFS适合查找是否存在解(或者说能找到任意一一个可行行行解)。用用这两种算法即可以解决大大部分树和图的问题。
一一、深度优先搜索（DFS）
1.1 介绍
图的深度优先搜索（Depth First Search），和树的先序遍历比比较类似。它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点V出发，首首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至至图中所有和V有路路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一一个未被访问的顶点作起始点，重复上述过程，直至至图中所有顶点都被访问到为止止。显然，深度优先搜索是一一个递归的过程。

深度优先搜索和广度优先搜索的比较和应用场景

深度优先搜索和广度优先搜索的比较和应用场景在计算机科学中，深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图搜索算法。

它们在解决许多问题时都能够发挥重要作用，但在不同的情况下具有不同的优势和适用性。

本文将对深度优先搜索和广度优先搜索进行比较和分析，并讨论它们在不同应用场景中的使用。

一、深度优先搜索（DFS）深度优先搜索是一种通过遍历图的深度节点来查找目标节点的算法。

它的基本思想是从起始节点开始，依次遍历该节点的相邻节点，直到到达目标节点或者无法继续搜索为止。

如果当前节点有未被访问的相邻节点，则选择其中一个作为下一个节点继续进行深度搜索；如果当前节点没有未被访问的相邻节点，则回溯到上一个节点，并选择其未被访问的相邻节点进行搜索。

深度优先搜索的主要优势是其在搜索树的深度方向上进行，能够快速达到目标节点。

它通常使用递归或栈数据结构来实现，代码实现相对简单。

深度优先搜索适用于以下情况：1. 图中的路径问题：深度优先搜索能够在图中找到一条路径是否存在。

2. 拓扑排序问题：深度优先搜索能够对有向无环图进行拓扑排序，找到图中节点的一个线性排序。

3. 连通性问题：深度优先搜索能够判断图中的连通分量数量以及它们的具体节点组合。

二、广度优先搜索（BFS）广度优先搜索是一种通过遍历图的广度节点来查找目标节点的算法。

它的基本思想是从起始节点开始，先遍历起始节点的所有相邻节点，然后再遍历相邻节点的相邻节点，以此类推，直到到达目标节点或者无法继续搜索为止。

广度优先搜索通常使用队列数据结构来实现。

广度优先搜索的主要优势是其在搜索树的广度方向上进行，能够逐层地搜索目标节点所在的路径。

它逐层扩展搜索，直到找到目标节点或者遍历完整个图。

广度优先搜索适用于以下情况：1. 最短路径问题：广度优先搜索能够在无权图中找到起始节点到目标节点的最短路径。

2. 网络分析问题：广度优先搜索能够在图中查找节点的邻居节点、度数或者群组。

三、深度优先搜索和广度优先搜索的比较深度优先搜索和广度优先搜索在以下方面有所不同：1. 搜索顺序：深度优先搜索按照深度优先的顺序进行搜索，而广度优先搜索按照广度优先的顺序进行搜索。

数据结构之的遍历深度优先搜索和广度优先搜索的实现和应用

数据结构之的遍历深度优先搜索和广度优先搜索的实现和应用深度优先搜索和广度优先搜索是数据结构中重要的遍历算法，它们在解决各种问题时起着关键作用。

本文将介绍深度优先搜索和广度优先搜索的实现方法以及它们的应用。

一、深度优先搜索的实现和应用深度优先搜索（Depth First Search，DFS）是一种用于图或树的遍历算法。

它的基本思想是从起始节点开始，一直沿着某一分支深入直到不能再深入为止，然后回溯到前一个节点，再沿另一分支深入，直到遍历完所有节点。

深度优先搜索可以通过递归或者栈来实现。

在实现深度优先搜索时，可以采用递归的方式。

具体的实现步骤如下：1. 创建一个访问数组，用于标记节点是否已经被访问过。

2. 从起始节点开始，将其标记为已访问。

3. 遍历当前节点的邻接节点，对于每个邻接节点，如果该节点未被访问过，则递归调用深度优先搜索函数。

4. 重复步骤3，直到所有节点都被访问过。

深度优先搜索的应用非常广泛，以下是几个常见的应用场景：1. 图的连通性判断：深度优先搜索可以用于判断图中的两个节点是否连通。

2. 拓扑排序：深度优先搜索可以用于对有向无环图进行拓扑排序，即按照一种特定的线性顺序对节点进行排序。

3. 岛屿数量计算：深度优先搜索可以用于计算给定矩阵中岛屿的数量，其中岛屿由相邻的陆地单元组成。

二、广度优先搜索的实现和应用广度优先搜索（Breadth First Search，BFS）是一种用于图或树的遍历算法。

它的基本思想是从起始节点开始，逐层遍历，先访问当前节点的所有邻接节点，然后再依次访问下一层的节点，直到遍历完所有节点。

广度优先搜索可以通过队列来实现。

在实现广度优先搜索时，可以采用队列的方式。

具体的实现步骤如下：1. 创建一个访问数组，用于标记节点是否已经被访问过。

2. 创建一个空队列，并将起始节点入队。

3. 当队列不为空时，取出队首节点，并标记为已访问。

4. 遍历当前节点的邻接节点，对于每个邻接节点，如果该节点未被访问过，则将其入队。