深度优先与广度优先
深度优先算法和广度优先算法的时间复杂度
深度优先算法和广度优先算法的时间复杂度深度优先算法和广度优先算法是在图论中常见的两种搜索算法，它们在解决各种问题时都有很重要的作用。
本文将以深入浅出的方式从时间复杂度的角度对这两种算法进行全面评估，并探讨它们在实际应用中的优劣势。
1. 深度优先算法的时间复杂度深度优先算法是一种用于遍历或搜索树或图的算法。
它从图中的某个顶点出发，沿着一条路径一直走到底，直到不能再前进为止，然后回溯到上一个节点，尝试走其他的路径，直到所有路径都被走过为止。
深度优先算法的时间复杂度与图的深度有关。
在最坏情况下，深度优先算法的时间复杂度为O(V+E)，其中V表示顶点的数量，E表示边的数量。
2. 广度优先算法的时间复杂度广度优先算法也是一种用于遍历或搜索树或图的算法。
与深度优先算法不同的是，广度优先算法是从图的某个顶点出发，首先访问这个顶点的所有邻接节点，然后再依次访问这些节点的邻接节点，依次类推。
广度优先算法的时间复杂度与图中边的数量有关。
在最坏情况下，广度优先算法的时间复杂度为O(V+E)。
3. 深度优先算法与广度优先算法的比较从时间复杂度的角度来看，深度优先算法和广度优先算法在最坏情况下都是O(V+E)，并没有明显的差异。
但从实际运行情况来看，深度优先算法和广度优先算法的性能差异是显而易见的。
在一般情况下，广度优先算法要比深度优先算法快，因为广度优先算法的搜索速度更快，且能够更快地找到最短路径。
4. 个人观点和理解在实际应用中，选择深度优先算法还是广度优先算法取决于具体的问题。
如果要找到两个节点之间的最短路径，那么广度优先算法是更好的选择；而如果要搜索整个图，那么深度优先算法可能是更好的选择。
要根据具体的问题来选择合适的算法。
5. 总结和回顾本文从时间复杂度的角度对深度优先算法和广度优先算法进行了全面评估，探讨了它们的优劣势和实际应用中的选择。
通过对两种算法的时间复杂度进行比较，可以更全面、深刻和灵活地理解深度优先算法和广度优先算法的特点和适用场景。
深度优先搜索和广度优先搜索的深入讨论
一、深度优先搜索和广度优先搜索的深入讨论（一）深度优先搜索的特点是：（1）从上面几个实例看出，可以用深度优先搜索的方法处理的题目是各种各样的。
有的搜索深度是已知和固定的，如例题2-4，2-5，2-6；有的是未知的，如例题2-7、例题2-8；有的搜索深度是有限制的，但达到目标的深度是不定的。
但也看到，无论问题的内容和性质以及求解要求如何不同，它们的程序结构都是相同的，即都是深度优先算法（一）和深度优先算法（二）中描述的算法结构，不相同的仅仅是存储结点数据结构和产生规则以及输出要求。
（2）深度优先搜索法有递归以及非递归两种设计方法。
一般的，当搜索深度较小、问题递归方式比较明显时，用递归方法设计好，它可以使得程序结构更简捷易懂。
当搜索深度较大时，如例题2-5、2-6。
当数据量较大时，由于系统堆栈容量的限制，递归容易产生溢出，用非递归方法设计比较好。
（3）深度优先搜索方法有广义和狭义两种理解。
广义的理解是，只要最新产生的结点（即深度最大的结点）先进行扩展的方法，就称为深度优先搜索方法。
在这种理解情况下，深度优先搜索算法有全部保留和不全部保留产生的结点的两种情况。
而狭义的理解是，仅仅只保留全部产生结点的算法。
本书取前一种广义的理解。
不保留全部结点的算法属于一般的回溯算法范畴。
保留全部结点的算法，实际上是在数据库中产生一个结点之间的搜索树，因此也属于图搜索算法的范畴。
（4）不保留全部结点的深度优先搜索法，由于把扩展望的结点从数据库中弹出删除，这样，一般在数据库中存储的结点数就是深度值，因此它占用的空间较少，所以，当搜索树的结点较多，用其他方法易产生内存溢出时，深度优先搜索不失为一种有效的算法。
（5）从输出结果可看出，深度优先搜索找到的第一个解并不一定是最优解。
例如例题2-8得最优解为13，但第一个解却是17。
如果要求出最优解的话，一种方法将是后面要介绍的动态规划法，另一种方法是修改原算法：把原输出过程的地方改为记录过程，即记录达到当前目标的路径和相应的路程值，并与前面已记录的值进行比较，保留其中最优的，等全部搜索完成后，才把保留的最优解输出。
深度优先搜索和广度优先搜索
二、 重排九宫问题游戏
在一个 3 乘 3 的九宫中有 1-8 的 8 个数及一个空格随机摆放在其中的格子里。如下面 左图所示。现在要求实现这样的问题：将该九宫调整为如下图右图所示的形式。调整规则是： 每次只能将与空格（上，下或左，右）相临的一个数字平移到空格中。试编程实现。
|2|8 |3|
|1|2|3|
from = f; to = t; distance = d; skip = false; } } class Depth { final int MAX = 100; // This array holds the flight information. FlightInfo flights[] = new FlightInfo[MAX]; int numFlights = 0; // number of entries in flight array Stack btStack = new Stack(); // backtrack stack public static void main(String args[]) {
下面是用深度优先搜索求解的程序:
// Find connections using a depth-first search. import java.util.*; import java.io.*; // Flight information. class FlightInfo {
String from; String to; int distance; boolean skip; // used in backtracking FlightInfo(String f, String t, int d) {
int dist; FlightInfo f; // See if at destination. dist = match(from, to); if(dist != 0) {
二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）
⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。
对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。
由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。
⽐⽅堆了。
所以。
对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。
四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。
求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。
然后在訪问左⼦树和右⼦树。
所以。
对于随意结点node。
第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。
若为空。
则须要訪问右⼦树。
注意。
在訪问过左孩⼦之后。
深度优先和广度优先比较
深度优先和⼴度优先⽐较区别：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（Depth First Search），⼴度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种⽅式。
这两种遍历⽅式有什么不同呢？我们来举个栗⼦： 我们来到⼀个游乐场，游乐场⾥有11个景点。
我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？1、深度优先遍历 第⼀种是⼀头扎到底的玩法。
我们选择⼀条⽀路，尽可能不断地深⼊，如果遇到死路就往回退，回退过程中如果遇到没探索过的⽀路，就进⼊该⽀路继续深⼊。
在图中，我们⾸先选择景点1的这条路，继续深⼊到景点7、景点8，终于发现⾛不动了： 于是，我们退回到景点7，然后探索景点10，⼜⾛到了死胡同。
于是，退回到景点1，探索景点9： 按照这个思路，我们再退回到景点0，后续依次探索景点2、3、5、4、发现相邻的都玩过了，再回退到3，再接着玩6，终于玩遍了整个游乐场： 具体次序如下图，景点旁边的数字代表探索次序。
当然还可以有别的排法。
像这样先深⼊探索，⾛到头再回退寻找其他出路的遍历⽅式，就叫做深度优先遍历（DFS）。
这⽅式看起来很像⼆叉树的前序遍历。
没错，其实⼆叉树的前序、中序、后序遍历，本质上也可以认为是深度优先遍历。
2、⼴度优先遍历 除了像深度优先遍历这样⼀头扎到底的玩法以外，我们还有另⼀种玩法：⾸先把起点相邻的⼏个景点玩遍，然后去玩距离起点稍远⼀些（隔⼀层）的景点，然后再去玩距离起点更远⼀些（隔两层）的景点… 在图中，我们⾸先探索景点0的相邻景点1、2、3、4： 接着，我们探索与景点0相隔⼀层的景点7、9、5、6： 最后，我们探索与景点0相隔两层的景点8、10： 像这样⼀层⼀层由内⽽外的遍历⽅式，就叫做⼴度优先遍历（BFS）。
这⽅式看起来很像⼆叉树的层序遍历。
没错，其实⼆叉树的层序遍历，本质上也可以认为是⼴度优先遍历。
广度和深度优先搜索
深度优先搜索和广度优先搜索一、产生式系统首先通过一个具体事例说明什么是产生式系统。
[例题4-1八数码难题]在3X3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。
棋盘中留有一个空格。
空格周围的棋子可以移到空格中。
要求解的问题是：找到一种移动方法，实现从初始布局到目标布局的转变。
例如输入：（代表从前一布局到后一布局）2 83 1 64 7 05 1 2 3 8 0 4 76 5[分析]状态表示：用二维数组来表示布局。
(s i,s j)表示第i行、第j列上放的棋子数字。
空格用0表示。
产生规则：原规则规定空格周围的棋子可以向空格移动。
但如果换一种角度观察，也可看做空格向四周移动。
这样处理更便于编程。
如果空格位置在(s i,s j)，则有四条规则：(1)空格向上移动: If s i-1>=1 then ch(s i,s j):=ch(s i-1,s j);ch(s i-1,s j):=0(2)空格向下移动: If s i+1<=3 then ch(s i,s j):=ch(s i+1,s j);ch(s i+1,s j):=0(3)空格向左移动: If s j-1>=1 then ch(s i,s j):=ch(s i,s j-1);ch(s i,s j-1):=0(4)空格向右移动: If s j+1<=3 then ch(s i,s j):=ch(s i,s j+1);ch(s i,s j+1):=0搜索策略：(1)把初始状态作为当前状态；(2)从当前状态出发，运用四条移动规则，产生新的状态；(3)判断新的状态是否达到目的状态，如果是，转(5)；(4)把新的状态记录下来，取出下一个中间状态作为当前状态，返回(2)；(5)输出从初始状态到目标状态的路径，结束。
这个例子就是产生式系统。
产生式系统的组成：产生式系统是由三个基本要素组成的：一个综合数据库（GOLBLE DA TABASE），一组产生式规则（Set of rules），和一个控制系统（Control System）。
深度优先和广度优先算法
深度优先和广度优先算法深度优先和广度优先算法深度优先遍历和广度优先遍历是两种常用的图遍历算法。
它们的策略不同，各有优缺点，可以在不同的场景中使用。
一、深度优先遍历深度优先遍历（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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
深度优先与广度优先
（一）深度优先搜索的特点是：（1）从上面几个实例看出，可以用深度优先搜索的方法处理的题目是各种各样的。
有的搜索深度是已知和固定的，如例题2-4，2-5，2-6；有的是未知的，如例题2-
7、例题2-8；有的搜索深度是有限制的，但达到目标的深度是不定的。
但也看到，无论问题的内容和性质以及求解要求如何不同，它们的程序结构都是相同的，即都是深度优先算法（一）和深度优先算法
（二）中描述的算法结构，不相同的仅仅是存储结点数据结构和产生规则以及输出要求。
（2）深度优先搜索法有递归以及非递归两种设计方法。
一般的，当搜索深度较小、问题递归方式比较明显时，用递归方法设计好，它可以使得程序结构更简捷易懂。
当搜索深度较大时，如例题2-
5、2-6。
当数据量较大时，由于系统堆栈容量的限制，递归容易产生溢出，用非递归方法设计比较好。
（3）深度优先搜索方法有广义和狭义两种理解。
广义的理解是，只要最新产生的结点（即深度最大的结点）先进行扩展的方法，就称为深度优先搜索方法。
在这种理解情况下，深度优先搜索算法有全部保留和不全部保留产生的结点的两种情况。
而狭义的理解是，仅仅只保留全部产生结点的算法。
本书取前一种广义的理解。
不保留全部结点
的算法属于一般的回溯算法范畴。
保留全部结点的算法，实际上是在数据库中产生一个结点之间的搜索树，因此也属于图搜索算法的范畴。
（4）不保留全部结点的深度优先搜索法，由于把扩展望的结点从数据库中弹出删除，这样，一般在数据库中存储的结点数就是深度值，因此它占用的空间较少，所以，当搜索树的结点较多，用其他方法易产生内存溢出时，深度优先搜索不失为一种有效的算法。
（5）从输出结果可看出，深度优先搜索找到的第一个解并不一定是最优解。
例如例题2-8得最优解为13，但第一个解却是17。
如果要求出最优解的话，一种方法将是后面要介绍的动态规划法，另一种方法是修改原算法：把原输出过程的地方改为记录过程，即记录达到当前目标的路径和相应的路程值，并与前面已记录的值进行比较，保留其中最优的，等全部搜索完成后，才把保留的最优解输出。
二、广度优先搜索法的显著特点是：（1）在产生新的子结点时，深度越小的结点越先得到扩展，即先产生它的子结点。
为使算法便于实现，存放结点的数据库一般用队列的结构。
（2）无论问题性质如何不同，利用广度优先搜索法解题的基本算法是相同的，但数据库中每一结点内容，产生式规则，根据不同的问题，有不同的内容和结构，就是同一问题也可以有不同的表示方法。
（3）当结点到跟结点的费用（有的书称为耗散值）和结点的深度成正比时，特别是当每一结点到根结点的费用等于深度时，用广度优先法得到的解是最优解，但如果不成正比，则得到的解不一
定是最优解。
这一类问题要求出最优解，一种方法是使用后面要介绍的其他方法求解，另外一种方法是改进前面深度（或广度）优先搜索算法：找到一个目标后，不是立即退出，而是记录下目标结点的路径和费用，如果有多个目标结点，就加以比较，留下较优的结点。
把所有可能的路径都搜索完后，才输出记录的最优路径。
（4）广度优先搜索算法，一般需要存储产生的所有结点，占的存储空间要比深度优先大得多，因此程序设计中，必须考虑溢出和节省内存空间得问题。
（5）比较深度优先和广度优先两种搜索法，广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索算法法要快些。
总之，一般情况下，深度优先搜索法占内存少但速度较慢，广度优先搜索算法占内存多但速度较快，在距离和深度成正比的情况下能较快地求出最优解。
因此在选择用哪种算法时，要综合考虑。
决定取舍。