掌握图的两种遍历算法深度优先搜索和广度优先搜索算
第五章 图
1．
掌握图的两种遍历算法：深度优先搜索和广度优先搜索算法，
2．求解连通性问题的方法。
教学重点：
图的两种遍历算法：深度优先搜索和广度优先搜索算法
教学难点：
图的两种遍历算法：深度优先搜索和广度优先搜索算法
授课内容
5.3 图的遍历
和树的遍历类似，在此，我们希望从图中某一顶点出发访遍图中其余顶点，且使每一个
顶点仅被访问一次。这一过程就叫做图的遍历(TraversingGraph)。图的遍历算法是求解图
的连通性问题、拓扑排序和求关键路径等算法的基础。
然而，图的遍历要比树的遍历复杂得多。因为图的任一顶点都可能和其余的顶点相邻接。
所以在访问了某个顶点之后，可能沿着某条路径搜索之后，又回到该顶点上。[例如]图7.1(b)
中的G2，由于图中存在回路，因此在访问了v1,v2,v3,v4之后，沿着边(v4 , v1)又可访问
到v1。为了避免同一顶点被访问多次，在遍历图的过程中，必须记下每个已访问过的顶点。
为此，我们可以设一个辅助数组visited[0..n-1]，它的初始值置为“假”或者零，一旦访
问了顶点vi，便置visited[i]为“真”或者为被访问时的次序号。
通常有两条遍历图的路径：深度优先搜索和广度优先搜索。它们对无向图和有向图都
适用。
5.3.1 深度优先搜索
深度优先搜索(Depth-First Search)遍历类似于树的先根遍历，是树的先根遍历的推
广。
其基本思想如下：假定以图中某个顶点vi为出发点，首先访问出发点，然后选择一个
vi的未访问过的邻接点vj，以vj为新的出发点继续进行深度优先搜索，直至图中所有顶点
都被访问过。显然，这是一个递归的搜索过程。
第十七讲 图的遍历
第五章 图
现以图5-3-1中G为例说明深度优先搜索过程。假定v0是出发点，首先访问v0。因v0
有两个邻接点v1、v2均末被访问过，可以选择v1作为新的出发点，访问v1之后，再找v1
的末访问过的邻接点。同v1邻接的有v0、v3和v4，其中v0已被访问过，而v3、v4尚未
被访问过，可以选择v3作为新的出发点。重复上述搜索过程，继续依次访问v7、v4 。访
问v4之后，由于与v4相邻的顶点均已被访问过，搜索退回到v7。由于v7、v3和v1都是
没有末被访问的邻接点，所以搜索过程连续地从v7退回到v3，再退回v1，最后退回到v0。
这时再选择v0的末被访问过的邻接点v2，继续往下搜索，依次访问v2、v5和v6，止此图
中全部顶点均被访问过。遍历过程见图5-3-1（b），得到的顶点的访问序列为：v0 → v1 →
v3 → v7 → v4 → v2 → v5 → v7。
（a）无向图G (b) G的深度优先搜索过程
图5-3-1 深度优先搜索遍历过程示例
因为深度优先搜索遍历是递归定义的，故容易写出其递归算法。下面的算法5.3是以
邻接矩阵作为图的存储结构下的深度优先搜索遍历算法；算法5.4是以邻接表作为图的存储
结构下的深度优先搜索遍历算法。
算法5.3
int visited[NAX_VEX]={0};
void Dfs_m( Mgraph *G,int i){
/* 从第i个顶点出发深度优先遍历图G，G以邻接矩阵表示*/
printf("%3c",G->vexs[i]);
visited[i]=1;
for (j=0;j
Dfs_m(G,j);
} /*Dfs_m */
算法5.4
int visited[VEX_NUM]={0};
void Dfs_L(ALgraph G,int i){
/* 从第i个顶点出发深度优先遍历图G，G以邻接表表示 */
printf("%3c",G[i].data);
visited[i]=1;
p=G[i].firstarc;
while (p!=NULL)
{ if(visited[p->adjvex]==0)
第五章 图
Dfs_L(G,p->adjvex);
p=p->nextarc;
}
} /*dfs_L*/
分析上述算法得知，遍历图的过程实质上是对每个顶点搜索其邻接点的过程。其耗费的
时间取决于所采用的存储结构。假设图有>n个顶点，那么，当用邻接矩阵表示图时，搜索
一个顶点的所有邻接点需花费的时间为>O(n)，则从>n个顶点出发搜索的时间应为>O(n2)，
所以算法>5.1的时间复杂度是>O(n2)；如果使用邻接表来表示图时，需花费时间为>O（n+e)，
其中>e为无向图中边的数目或有向图中弧的数目。算法>5.4的时间复杂度为>O（n+e)。
5.3.2 广度优先搜索
连通图的广度优先搜索(Breadth_FirstSearch)遍历图类似于树的按层次遍历。其基本
思想是：首先访问图中某指定的起始点Vi并将其标记为已访问过，然后由Vi出发访问与它
相邻接的所有顶点Vj、 Vk„„，并均标记为已访问过，然后再按照Vj、Vk„„的次序，访
问每一个顶点的所有未被访问过的邻接顶点，并均标记为已访问过，下一步再从这些顶点出
发访问与它们相邻接的尚未被访问的顶点，如此做下去，直到所有的顶点均被访问过为止。
在广度优先搜索中，若对顶点V1的访问先于顶点V2的访问，则对V1邻接顶点的访问
也先于V2邻接顶点的访问。就是说广度优先搜索中对邻接点的寻找具有“先进先出”的特
性。因此，为了保证访问顶点的这种先后关系，需借助一个队列暂存那些刚访问过的顶点。
[例如]，下面以图5-3-1种G为例说明广度优先搜索的过程。假设从起点v0出
发，那么首先访问vo和行动两个未访问的邻接点v1和v2；然后依次访问v1的邻接点v3
和v4以及v2的邻接点v5和v6；最后访问v3的未曾访问的邻接点v7。此图中所有顶点均
已被访问过，由此完成了图的遍历。遍历过程见图5-3-2，得到的顶点访问序列为：
v0→v1→v2→v3→v4→v5→v6→v7
在广度优先搜索中，若顶点v在顶点u之前访问，则v的邻接点也将在u的邻接点之前
访问。由此，可采用对列qu来暂存那些刚访问过并且可能还有未访问的邻接点的顶点。
图5－3－2 广度优先搜索遍历过程
算法5.5
int visited[VEX_NUM]={0};
void Bfs(Mgraph G,int k){
int qu[20],f=0,r=0;
v0
V1 V3 V7 V4 V
2
V5 V
6
第五章 图
printf(“%3c”,G.vexs[k]);
visited[k]=1;
r++;qu[r]=k;
while (r!=f)
{ f++;i=qu[f];
for(j=p;j
printf(“%3c”,G.vexs[j]);
visited[j]=I;
r++;qu[r]=j;
}
}
} /*Bfs*/
分析上述算法，一个有n个顶点、e条边的图，在广度优先搜索图的过程中，每个顶点至
多进一次队列，所以算法中的内外循环次数均为n次，故算法Bfs的时间复杂度为O（n2）；
若采用邻接链表存储结构，广度优先搜索遍历图的时间复杂度与深度优先搜索是相同的。
5.5.3 求图的连通分量
求图的连通分量是图的遍历的一种简单应用。当无向图是连通图是，只需要调用一次
Dfs（或Bfs）算法，便可访问图中的所有顶点。但无向图是非连通图时，从图中某顶点V
出发遍历图，不能访问到图的所有顶点，而只能访问到包含V所在的最大连通子图（连通分
量）中的所有顶点。若从非连通图中每一个连通分量中的一个顶点出发遍历图，则可求出无
向图的所有连通分量。
为了求得非连通图的所有的连通分量，只需要调用Dfs或Bfs，并对图中每个顶点进行
检测。若某顶点已被访问，则该顶点落在图中已求得的连通分量上；若某顶点未被访问，则
从该顶点出发遍历图，便可求得图的另已连通分量，调用Dfs或Bfs的次数就是连通分量的
个数。下面以临界矩阵为存储结构，给出通过深度优先搜索算法实现求非连通图的连通分量
的算法。
算法5.6
Int visited[vex_num]={0}
Void component(mgraph g){
/*求图的连通分量，G以邻接矩阵表示*/
Count=0; /*统计连通分量的个数*/
For(j=0;j
Count++;
Printf(“\n第%d个连通分量是：”,count);
Dfs_m(g,j); /*从Vj出发遍历一个连通分量*/
}
Printf(“\n共有%d个连通分量。\n”,count);
} /*conpont*/
如对图5-1-5中（a）所示的非连通图G3执行算法Conponent,可得到以下输出结果：
第五章 图
第1个连通分量是：V0 V1 V4 V5
第2个连通分量是：V2 V3
共有2个连通分量。
图的遍历算法
1图的遍历问题在实践中常常遇到这样的问题：给定n个点，从任一点出发对所有的点访问一次并且只访问一次。
如果用图中的顶点表示这些点，图中的边表示可能的连接，那么这个问题就可以表示成图的遍历问题，即从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。
图的遍历操作和树的遍历操作功能相似，是图的一种基本操作，图的许多其它操作都是建立在遍历操作的基础上。
由于图结构本身的复杂性，所以图的遍历操作也比较复杂，主要表现在以下几个方面：(1) 在图结构中，没有一个确定的首结点，图中任意一个顶点都可以作为第一个被访问的结点。
(2) 在非连通图中，从一个顶点出发，只能够访问它所在的连通分量上的所有顶点，因此，还需要考虑如何选取下一个出发点以访问图中其余的连通分量。
(3) 在图结构中，如果有回路存在，那么一个顶点被访问后，有可能沿回路又回到该顶点。
⑷在图结构中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，存在如何选取下一个要访问的顶点的问题。
基于以上分析，图的遍历方法目前有深度优先搜索(DFS)和广度优先搜索(BFS)两种算法。
下面将介绍两种算法的实现思路，分析算法效率并编程实现。
1.1深度优先搜索算法深度优先搜索算法是树的先根遍历的推广，它的实现思想是：从图G的某个顶点V o出发，访问V o,然后选择一个与V o相邻且没被访问过的顶点V i访问，再从V i出发选择一个与V i相邻且未被访问的顶点V j进行访问，依次继续。
如果当前被访问过的顶点的所有邻接顶点都已被访问，贝U退回已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W，从W出发按同样的方法向前遍历，直到图中所有顶点都被访问。
其递归算法如下：Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组Status (*VisitFunc)(int v); //VisitFunc是访问函数，对图的每个顶点调用该函数void DFSTraverse (Graph G Status(*Visit)(i nt v)){VisitF unc = Visit;for(v=0; vvG.vex num; ++v)visited[v] = FALSE; //访问标志数组初始化for(v=0; v<G .vex num; ++v)if(!visited[v])DFS(G v); //对尚未访问的顶点调用DFS}void DFS(Graph G int v){ //从第v个顶点出发递归地深度优先遍历图Gvisited[v]=TRUE; VisitFunc(v); // 访问第v 个顶点for(w=FirstAdjVex(G ,v); w>=0;w=NextAdjVex(G ,v,w))//FirstAdjVex返回v的第一个邻接顶点，若顶点在G中没有邻接顶点，则返回空(0)。
BFS与DFS常考算法整理
BFS与DFS常考算法整理BFS与DFS常考算法整理PrefaceBFS（Breath-First Search，⼴度优先搜索）与DFS（Depth-First Search，深度优先搜索）是两种针对树与图数据结构的遍历或搜索算法，在树与图相关算法的考察中是⾮常常见的两种解题思路。
Definition of DFS and BFSDFS的:Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.BFS的:Breadth-first search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree root (orsome arbitrary node of a graph, sometimes referred to as a ‘search key’[1]), and explores all of the neighbor nodes at thepresent depth prior to moving on to the nodes at the next depth level.It uses the opposite strategy as depth-first search, which instead explores the highest-depth nodes first before being forced tobacktrack and expand shallower nodes.So obviously, as their name suggest, DFS focuses on ‘depth’ when searching or traversing while BFS focuses on ‘breath’.By the way, because of DFS’s feature, it’s easy to relate it with ‘Backtracking’ algorithm as the wiki definition mentions. The relationship between DFS and backtracking is well explained by :Backtracking is a more general purpose algorithm.Depth-First search is a specific form of backtracking related to searching tree structures. From Wikipedia:One starts at the root (selecting some node as the root in the graph case) and explores as far as possible along eachbranch before backtracking.It uses backtracking as part of its means of working with a tree, but is limited to a tree structure.Backtracking, though, can be used on any type of structure where portions of the domain can be eliminated - whether or not it isa logical tree. The Wiki example uses a chessboard and a specific problem - you can look at a specific move, and eliminate it,then backtrack to the next possible move, eliminate it, etc.How to Implement DFS and BFSDFSIn tree structure, DFS means we always start from a root node and try to reach the leaf node as direct as possible before we have to backtrack.Order in which the nodes are visitedIn graph, DFS means we start from a random assigned node in the graph, and explores as far as possible along the branch before we have to backtrack.So the key points for DFS are:- How to explore as far as possible?- How to backtrack?How to explore as far as possibleNormally, for tree node, it would have left child or right child, so we would continuously go on exploring current node’s child node until we encounter a null node, then we go back to last node. Repeat above procedures until all nodes have been visited.for graph node, we do the similar exploration: explore as further as possible according to the representation of graph (adjacency list, adjacency matrix or incidence matrix) until we find no more node that hasn’t been visited and connected with current node, then we go back to last node. Repeat above procedures until all nodes have been visited.How to backtrack/go back?‘Go back’ generally can be realized using data structure ——stack—— or by recursion. And if we use stack, it means we would need to push each node we visited in the process of exploring each branch, and pop when we can’t explore further starting from current node. BFSIn tree structure, BFS means we always start from a root node and try to all the other nodes in the same breath before we further try exploring nodes at next depth level. (The same explanation for graph)Order in which the nodes are visitedSo the key points for BFS are:How to explore all nodes of same depth level?How to explore all nodes of same depth level?We can use a queue to do this: Starting from root node of a tree (Or a random node in a graph), we add visit all nodes connected with the starting node and add them to the queue. Then, we poll node from queue one by one and repeat above procedures until all nodes have been visited.Typical Leetcode PrbolemsDFSPath Sum IIGiven a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.Note: A leaf is a node with no children.Example:Given the below binary tree and sum = 22,5/ \4 8/ / \11 13 4/ \ / \7 2 5 1Return:[[5,4,11,2],[5,8,4,5]]My Answerpackage medium2;import java.util.ArrayList;import java.util.List;/*** @author Tom Qian* @email tomqianmaple@* @github https:///bluemapleman* @date 2018年6⽉7⽇*/public class PathSumII{// DFS: make use of recursion to backtrackpublic List<List<Integer>> pathSum(TreeNode root, int sum) {List<List<Integer>> ans=new ArrayList<List<Integer>>();if(root==null)return ans;int goal=sum-root.val;if(goal==0) {if(root.left==null && root.right==null) {List<Integer> tempList=new ArrayList<>();tempList.add(root.val);ans.add(tempList);return ans;}}List<List<Integer>> temp;if((temp=pathSum(root.left, goal)).size()!=0) {for(List<Integer> list:temp) {list.add(0, root.val);ans.add(list);}}if((temp=pathSum(root.right, goal)).size()!=0) {for(List<Integer> list:temp) {list.add(0,root.val);ans.add(list);}}return ans;}}Convert Sorted List to Binary Search TreeGiven a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.Example:Given the sorted linked list: [-10,-3,0,5,9],One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:/ \-3 9/ /-10 5My Answerpackage medium2;/*** @author Tom Qian* @email tomqianmaple@* @github https:///bluemapleman* @date 2018年6⽉11⽇*/public class ConvertSortedListtoBinarySearchTree{// DFS: make use of recursion to backtrack// find the middle node of sorted linked list, and take it as the root node of the BST.public TreeNode sortedListToBST(ListNode head) {if(head==null)return null;ListNode slow=head,fast=head,followSlow=head;boolean moveFlag=false;while(fast!=null && fast.next!=null) {if(moveFlag)followSlow=followSlow.next;moveFlag=true;slow=slow.next;fast=fast.next.next;}TreeNode root=new TreeNode(slow.val);if(moveFlag) {followSlow.next=null;root.left=sortedListToBST(head);root.right=sortedListToBST(slow.next);}return root;}}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 expressed as a pair: [0,1] Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?Example 1:Input: 2, [[1,0]]Output: trueExplanation: There are a total of 2 courses to take.To take course 1 you should have finished course 0. So it is possible.Example 2:Input: 2, [[1,0],[0,1]]Output: falseExplanation: There are a total of 2 courses to take.To take course 1 you should have finished course 0, and to take course 0 you shouldalso have finished course 1. So it is impossible.Note:1.The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.2.You may assume that there are no duplicate edges in the input prerequisites.My Answer// DFSpublic boolean canFinish(int numCourses, int[][] prerequisites) {Map<Integer, List<Integer>> map=new HashMap<>();for(int i=0;i<numCourses;i++)map.put(i, new ArrayList<>());for(int i=0;i<prerequisites.length;i++) {map.get(prerequisites[i][0]).add(prerequisites[i][1]);}// start DFS: detect if there is any circle in course graph, i.e. whether DFS starting from certain start point i would lead to the start point again. for(int i=0;i<numCourses;i++) {// Use a set to avoid infinite loop: when met same node twice, ignore it.Set<Integer> set=new HashSet<>();// Use a stack to backtrackArrayDeque<Integer> stack=new ArrayDeque<>();List<Integer> preCourseList=map.get(i);for(Integer preCourse:preCourseList)stack.push(preCourse);while(!stack.isEmpty()) {int preCourse=stack.pop();if(set.contains(preCourse))continue;elseset.add(preCourse);if(preCourse==i)return false;else {preCourseList=map.get(preCourse);for(Integer tempPreCourse:preCourseList) {stack.push(tempPreCourse);}}}}return true;}BFSCourse ScheduleMy Answer// BFSpublic boolean canFinish(int numCourses, int[][] prerequisites) {Map<Integer, List<Integer>> map=new HashMap<>();for(int i=0;i<numCourses;i++)map.put(i, new ArrayList<>());for(int i=0;i<prerequisites.length;i++) {map.get(prerequisites[i][0]).add(prerequisites[i][1]);}// start DFS: detect if there is any circle in course graph, i.e. whether BFS starting from certain start point i would lead to the start point again. for(int i=0;i<numCourses;i++) {// Use a set to avoid infinite loop: when met same node twice, ignore it.Set<Integer> set=new HashSet<>();// Use a queue to remember nodes of same depth levelArrayDeque<Integer> queue=new ArrayDeque<>();List<Integer> preCourseList=map.get(i);for(Integer preCourse:preCourseList)queue.add(preCourse);while(!queue.isEmpty()) {int preCourse=queue.poll();if(set.contains(preCourse))continue;elseset.add(preCourse);if(preCourse==i)return false;else {preCourseList=map.get(preCourse);for(Integer tempPreCourse:preCourseList) {queue.add(tempPreCourse);}}}}return true;}Binary Tree Right Side ViewGiven a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom. Example:Input: [1,2,3,null,5,null,4]Output: [1, 3, 4]Explanation:1 <---/ \2 3 <---\ \5 4 <---My Answerpackage medium2;import java.util.ArrayDeque;import java.util.ArrayList;import java.util.List;/*** @author Tom Qian* @email tomqianmaple@* @github https:///bluemapleman* @date 2018年6⽉12⽇*/public class BinaryTreeRightSideView{public List<Integer> rightSideView(TreeNode root) {List<Integer> ans=new ArrayList<>();if(root==null)return ans;ans.add(root.val);ArrayDeque<TreeNode> queue1=new ArrayDeque<>(),queue2=new ArrayDeque<>();;queue1.add(root);while(!queue1.isEmpty() || !queue2.isEmpty()){TreeNode rightestNode=null;if(!queue1.isEmpty()) {while(!queue1.isEmpty()) {TreeNode fatherNode=queue1.poll();if(fatherNode.right!=null) {queue2.add(fatherNode.right);if(rightestNode==null)rightestNode=fatherNode.right;}if(fatherNode.left!=null) {queue2.add(fatherNode.left);if(rightestNode==null)rightestNode=fatherNode.left;}}}else{while(!queue2.isEmpty()) {TreeNode fatherNode=queue2.poll();if(fatherNode.right!=null) {queue1.add(fatherNode.right);if(rightestNode==null)rightestNode=fatherNode.right;}if(fatherNode.left!=null) {queue1.add(fatherNode.left);if(rightestNode==null)rightestNode=fatherNode.left;}}}if(rightestNode!=null)ans.add(rightestNode.val);}return ans; }}.。
dfs序列和bfs序列
dfs序列和bfs序列dfs序列和bfs序列是图遍历算法中的两种常见序列。
它们分别代表了深度优先搜索（Depth-First Search）和广度优先搜索（Breadth-First Search）在图中遍历节点的顺序。
1. DFS序列深度优先搜索是一种以深度为优先级的遍历算法。
它从图的起始节点开始，一直沿着一个分支遍历到底，然后回溯到前一个节点，再遍历下一个分支。
这样直到遍历完所有的节点。
DFS序列的生成是通过递归或栈的方式完成的。
在递归实现中，每次深入某个节点时，都对其邻接节点进行深度优先遍历，直到遍历完所有节点为止。
生成的DFS序列可以用一个数组来表示，序列中每个节点的顺序即为其被遍历到的顺序。
2. BFS序列广度优先搜索是一种以广度为优先级的遍历算法。
它从图的起始节点开始，首先遍历其所有的邻接节点，然后再逐层遍历下一个邻接节点的邻接节点。
这样依次遍历完所有的节点。
BFS序列的生成是通过队列的方式完成的。
首先将起始节点入队，然后从队列中依次取出节点，并将其所有未被访问的邻接节点入队，直到队列为空为止。
生成的BFS序列可以用一个数组来表示，序列中每个节点的顺序即为其被遍历到的顺序。
3. DFS序列和BFS序列的应用DFS序列和BFS序列在图遍历算法中具有不同的应用场景。
DFS适用于解决一些涉及路径搜索、连通性、拓扑排序等问题。
由于DFS的特点是往深层次搜索，因此在找到目标节点后可以停止搜索，适合在有限深度的图中应用。
而BFS适用于解决一些涉及最短路径、最小生成树、社交网络分析等问题。
由于BFS的特点是逐层遍历，因此可以保证找到的路径是最短路径，并且可以用于计算节点之间的距离。
总结：DFS序列和BFS序列是图遍历算法中常见的两种序列。
DFS以深度为优先级，递归或栈实现，适合解决路径搜索等问题。
BFS以广度为优先级，队列实现，适合解决最短路径等问题。
对于不同的应用场景，可以选择使用适合的算法序列来进行图遍历。
深度优先和广度优先比较
深度优先和⼴度优先⽐较区别：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;}//⼆叉搜索树，若他的左⼦树不为空，左⼦树上的所有节点都⼩于根节点，//如果他的右⼦树不为空，右⼦树上的所有节点都⼤于根节点//最终他的中序排列都是有序结果//输⼊⼀棵⼆叉搜索树，将该⼆叉搜索树转换成⼀个排序的双向链表。
树的最短路径算法
树的最短路径算法树的最短路径算法树是一种重要的数据结构，它在计算机科学中扮演着重要的角色。
在树上进行最短路径算法可以用于许多应用场景，如网络路由、图像处理和人工智能等领域。
本文将介绍树的最短路径算法，并分别介绍深度优先搜索（DFS）和广度优先搜索（BFS）两种常见的树遍历方式。
一、最短路径定义在讨论树的最短路径算法之前，我们需要先了解什么是最短路径。
在图论中，最短路径是指连接两个节点之间权值和最小的路径。
对于无向图和有向图来说，都存在多种不同的最短路径。
而在树上，由于没有回路，因此只存在唯一一条连接两个节点之间的简单路径。
二、深度优先搜索深度优先搜索是一种常见的遍历方式，在树上也可以用来寻找最短路径。
其基本思想是从某个节点出发，沿着其子节点不断向下搜索直到叶子节点为止，然后返回到父节点继续搜索其他子节点。
1. 递归实现深度优先搜索可以通过递归实现。
具体步骤如下：（1）从根节点开始遍历，对于每个节点，先访问它的左子树。
（2）如果左子树为空，则返回到父节点，访问右子树。
（3）如果右子树也为空，则返回到父节点的父节点，继续遍历其他子树。
递归实现深度优先搜索的代码如下：```void dfs(TreeNode* root) {if (root == nullptr) {return;}// 访问当前节点visit(root);// 遍历左子树dfs(root->left);// 遍历右子树dfs(root->right);}```2. 迭代实现深度优先搜索还可以通过迭代实现。
具体步骤如下：（1）将根节点入栈。
（2）当栈不为空时，取出栈顶元素并访问它。
（3）将当前节点的右子节点入栈。
（4）将当前节点的左子节点入栈。
迭代实现深度优先搜索的代码如下：```void dfs(TreeNode* root) {if (root == nullptr) {return;}stack<TreeNode*> s;s.push(root);while (!s.empty()) {TreeNode* cur = s.top();s.pop();// 访问当前节点visit(cur);// 将右子节点入栈if (cur->right != nullptr) {s.push(cur->right);}// 将左子节点入栈if (cur->left != nullptr) {s.push(cur->left);}}}```三、广度优先搜索广度优先搜索是另一种常见的遍历方式，在树上也可以用来寻找最短路径。
广度优先实验报告
一、实验目的1. 了解广度优先搜索（BFS）算法的基本原理和步骤。
2. 掌握使用广度优先搜索算法解决图的遍历问题的方法。
3. 比较广度优先搜索算法与深度优先搜索算法的优缺点。
二、实验原理广度优先搜索（BFS）是一种图遍历算法，它按照从源点到目标点的距离来搜索图中的节点。
在BFS中，算法首先访问源点，然后将其邻接点按照距离顺序访问，接着访问邻接点的邻接点，以此类推，直到找到目标点或遍历完所有节点。
BFS算法的基本步骤如下：1. 创建一个队列，用于存储待访问的节点。
2. 将源点入队。
3. 当队列不为空时，执行以下操作：a. 从队列中取出一个节点，访问它。
b. 将该节点的邻接点按照距离顺序入队。
4. 重复步骤3，直到找到目标点或遍历完所有节点。
三、实验环境与工具1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 20194. 图表示方法：邻接表四、实验内容与步骤1. 创建一个图的邻接表表示。
2. 使用广度优先搜索算法遍历图，并记录遍历过程。
3. 比较广度优先搜索算法与深度优先搜索算法的遍历结果。
五、实验结果与分析1. 实验结果以下是一个图的邻接表表示，以及使用广度优先搜索算法遍历图的结果：```图：A --B -- C| |D --E -- F邻接表表示：Graph g;g.addVertex('A');g.addVertex('B');g.addVertex('C');g.addVertex('D');g.addVertex('E');g.addVertex('F');g.addEdge('A', 'B');g.addEdge('B', 'C');g.addEdge('A', 'D');g.addEdge('D', 'E');g.addEdge('E', 'F');g.addEdge('B', 'E');g.addEdge('E', 'F');广度优先搜索遍历结果：A ->B ->C ->D ->E -> F```2. 分析（1）广度优先搜索算法的优点：- 按照距离顺序遍历图中的节点，便于理解节点之间的层次关系。
数据结构学位考3
V1
V2
V3
V4
有向图
V1 V2
V3 V4 V5
无向图
顶点数n和边(弧)的数目e：
无向图：
0e
有向图： e n(n 1) 0
1 n(n 1) 2
完全图：有n(n-1)/2条边的无向图; 有向完全图：有n(n-1)条弧的有向图; 稀疏图、稠密图 子图：G=(V,{E}),G’=(V’,{E’})，若V’ V,且E’ E,则称G’为 G的子图 邻接点：无向图中，(v,v’)∈E，则v,v’互为邻接点； 顶点v的度：与v相关联的边的数目，TD(v) 有向图中,若<v,v’>∈A，则顶点v邻接到顶点v’，而顶点v’邻接 自v 出度：以v为尾的弧的数目，OD(v) 入度：以v为头的弧的数目，ID(v) TD(v)=OD(v)+ID(v)
有向图：如果有一个顶点的入度为0，其余顶点的入 度都为1，则是一棵有向树。
A C F B
J L M
图的存储结构
数组表示法（邻接矩阵）： 用两个数组分别存放顶点信息和边 （弧）信息
V1 V2
G1.VEXS[4]=[V1 V2 V3 V4]
G1.arcs=
0 0 0 1
0 1 0 1 0 1 0 1 0 1
路径：
回路（环） 简单路径：顶点序列中顶点不重复的路径。
连通图、连通分量、强连通图、强连通分量：
A C F G I L H K D E
B
A
C
B
D
E
F
I J M L M
G
H
K
J
生成树算法的三个步骤
生成树算法的三个步骤生成树是图论中的重要概念，它描述了一个连通图的一个子图，该子图包含了图中的所有顶点，并且是无环的。
生成树算法是用来找到一个连通图的生成树的一种方法。
本文将介绍生成树算法的三个步骤：图的遍历、边的选择和生成树的构建。
一、图的遍历图的遍历是生成树算法的第一步，它的目的是将图中的所有顶点访问一遍。
常用的图的遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）。
深度优先搜索是通过递归的方式进行遍历，从某个顶点开始，先访问它的一个邻接顶点，然后再递归地访问该邻接顶点的邻接顶点，直到所有顶点都被访问过。
广度优先搜索是通过队列的方式进行遍历，从某个顶点开始，先访问它的所有邻接顶点，然后再依次访问这些邻接顶点的邻接顶点，直到所有顶点都被访问过。
二、边的选择边的选择是生成树算法的第二步，它的目的是选择一些边，使得这些边构成一个连通图的生成树。
常用的边的选择算法有最小生成树算法和最大生成树算法。
最小生成树算法的目标是选择一些边，使得这些边的权值之和最小。
常用的最小生成树算法有普里姆算法和克鲁斯卡尔算法。
普里姆算法是从一个顶点开始，每次选择一条最小权值的边，将该边连接的顶点加入到生成树中，直到所有顶点都被加入到生成树中。
克鲁斯卡尔算法是先将所有边按照权值从小到大排序，然后依次选择权值最小的边，如果这条边连接的两个顶点不在同一个连通分量中，则将这条边加入到生成树中。
最大生成树算法的目标是选择一些边，使得这些边的权值之和最大。
常用的最大生成树算法有逆克鲁斯卡尔算法和逆普里姆算法。
逆克鲁斯卡尔算法和逆普里姆算法的原理与克鲁斯卡尔算法和普里姆算法相反。
三、生成树的构建生成树的构建是生成树算法的第三步，它的目的是根据选择的边构建一个生成树。
生成树可以用邻接矩阵或邻接表来表示。
邻接矩阵是一个二维数组，其中的元素表示两个顶点之间是否有边。
邻接表是一种链表的数据结构，其中的每个节点表示一个顶点，节点的值表示该顶点的邻接顶点。
算法描述的三种方法
算法描述的三种方法
1. 深度优先搜索算法：
通过递归的方式遍历图或树的每个节点，先访问当前节点，然后依次递归访问当前节点的每个邻接节点。
该算法使用栈来记录遍历的节点顺序。
示例：
对于以下图结构，初始节点为A：
A ->
B -> D
| |
V V
C E
通过深度优先搜索算法的结果为：A -> B -> D -> E -> C
2. 广度优先搜索算法：
通过迭代的方式遍历图或树的每个节点，先访问当前节点的所有邻接节点，然后将邻接节点加入队列尾部，依次访问队列中的节点。
该算法使用队列来记录遍历的节点顺序。
示例：
对于以下图结构，初始节点为A：
A ->
B -> D
| |
V V
C E
通过广度优先搜索算法的结果为：A -> B -> C -> D -> E
3. 贪心算法：
在每一步选择中，贪心算法选择当前状态下最优的选择，不考虑未来的后果。
贪心算法通常用于求解最优解问题，但并不
能保证一定能得到全局最优解。
示例：
如果要在一组物品中选择总重量不超过背包容量的物品，可以用贪心算法选择具有最高价值重量比的物品放入背包，直到背包无法再放入物品为止。
但是这种选择方式并不一定能得到真正的最优解。
dfs和bfs题目整理和分类
DFS和BFS是图论中常用的两种遍历算法，它们在解决各种图论问题和编程竞赛中都有着重要的应用。
以下是对一些经典的DFS和BFS题目进行整理和分类。
一、DFS题目1. 树的遍历（1）给定一棵树，要求按照先序、中序、后序的方式遍历这棵树。
2. 深度优先搜索（1）给定一个有向图，从起点开始进行深度优先搜索，找出所有可达的节点。
（2）给定一个有向图，判断该图中是否存在环。
3. 拓扑排序（1）给定一个有向无环图，对图中的节点进行拓扑排序。
4. 连通分量（1）给定一个无向图，求图中的连通分量个数。
（2）给定一个无向图，求图中的每个连通分量包含的节点个数。
5. 非递归DFS（1）给定一个有向图，使用非递归的方式进行深度优先搜索。
二、BFS题目1. 广度优先搜索（1）给定一个有向图，从起点开始进行广度优先搜索，找出所有可达的节点。
（2）给定一个无向图，从起点开始进行广度优先搜索，找出所有可达的节点。
2. 最短路径（1）给定一个无向图，求从起点到终点的最短路径。
（2）给定一个有向图，求从起点到终点的最短路径。
3. 01矩阵（1）给定一个01矩阵，每个元素是0或1，求从左上角到右下角的最短路径长度。
4. 笛卡尔积（1）给定两个集合A和B，求它们的笛卡尔积。
5. 层次遍历（1）给定一棵树，使用广度优先搜索进行层次遍历。
以上是对一些常见的DFS和BFS题目进行整理和分类。
在解决这些问题时，可以根据具体情况选择合适的算法来进行求解，有效地应用DFS和BFS算法来解决实际问题。
希望以上内容对大家有所帮助。
对于DFS和BFS这两种遍历算法来说，在实际应用中有许多题目是可以通过它们来解决的。
下面继续介绍一些与DFS和BFS相关的经典问题及其解决方法。
6. 单词接龙（1）给定两个单词beginWord和endWord，以及一个字典，找出从beginWord到endWord的最短转换序列的长度。
每次转换只能改变一个字母，并且转换后的单词必须存在于字典中。