基本搜索与遍历方法
数据结构中的图的遍历算法
数据结构中的图的遍历算法图是一种非常重要且广泛应用的数据结构，它由顶点和边组成，可以用来表示各种实际问题，如社交网络、路线规划等。
图的遍历算法是对图中的所有顶点进行系统访问的方法，它可以用来查找、遍历和搜索图中的元素。
本文将介绍图的遍历算法的基本概念和常用的实现方法。
一、图的遍历算法概述图的遍历算法是指按照某种规则遍历图中的所有顶点，以便于查找、遍历和搜索图中的元素。
常用的图的遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）两种。
深度优先搜索（DFS）是一种先访问顶点的所有邻接顶点，再递归访问邻接顶点的邻接顶点的算法。
它以深度为优先级，一直向前走到不能继续为止，然后返回到前一个结点，继续向前走，直到遍历完整个图。
广度优先搜索（BFS）是一种先访问顶点的所有邻接顶点，再访问邻接顶点的邻接顶点，以此类推的算法。
它以广度为优先级，先访问离起始顶点最近的顶点，然后依次访问离起始顶点更远的顶点，直到遍历完整个图。
二、深度优先搜索（DFS）深度优先搜索是一种递归的搜索算法，它的基本思想是从图的某个顶点出发，沿着一条路径一直深入直到不能继续为止，然后返回到前一个结点，继续向前走。
具体实现时，可以使用递归或栈来保存需要访问的顶点。
以下是深度优先搜索的基本步骤：1. 选择一个起始顶点作为当前顶点，将其标记为已访问。
2. 访问当前顶点，并将其加入遍历结果。
3. 从当前顶点的未访问邻接顶点中选择一个作为下一个当前顶点，重复步骤2。
4. 如果当前顶点的所有邻接顶点都已访问，则返回到前一个顶点，重复步骤3。
5. 重复步骤4，直到遍历完整个图。
三、广度优先搜索（BFS）广度优先搜索是一种迭代的搜索算法，它的基本思想是从图的某个顶点出发，依次访问其所有未访问过的邻接顶点，然后再依次访问这些邻接顶点的未访问过的邻接顶点，直到遍历完整个图。
具体实现时，可以使用队列来保存需要访问的顶点。
以下是广度优先搜索的基本步骤：1. 选择一个起始顶点作为当前顶点，将其标记为已访问，并将其加入遍历结果。
c语言中常用的查找
c语言中常用的查找C语言中常用的查找引言：在编程中，查找是一项非常常见且重要的操作。
无论是在数组、链表、树还是图等数据结构中，都需要进行查找操作来寻找特定的数据或者确定某个元素的存在与否。
C语言提供了多种查找算法和数据结构，本文将介绍C语言中常用的查找方法。
一、线性查找线性查找是最简单的查找方法之一，也称为顺序查找。
其基本思想是从数据集合的起始位置开始逐个比较待查找元素与集合中的元素，直到找到目标元素或者遍历完整个集合。
在C语言中，可以使用for循环或者while循环实现线性查找。
线性查找的时间复杂度为O(n)，其中n为数据集合中元素的个数。
二、二分查找二分查找又称为折半查找，是一种高效的查找算法，但要求数据集合必须是有序的。
其基本思想是将数据集合分为两部分，然后通过与目标元素的比较来确定目标元素在哪个部分中，从而缩小查找范围。
重复这个过程直到找到目标元素或者确定目标元素不存在于数据集合中。
二分查找的时间复杂度为O(logn)，其中n为数据集合中元素的个数。
三、哈希表查找哈希表是一种通过哈希函数将关键字映射到存储位置的数据结构，它能够以常数时间复杂度O(1)进行查找操作。
在C语言中，可以使用数组和链表的结合来实现哈希表。
哈希表的关键之处在于哈希函数的设计，良好的哈希函数能够将关键字均匀地映射到不同的存储位置，从而提高查找效率。
四、二叉搜索树查找二叉搜索树是一种常用的数据结构，它满足以下性质：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。
在C语言中，可以使用指针和递归的方式来实现二叉搜索树。
通过比较目标值与当前节点的值，可以确定目标值位于左子树还是右子树中，从而缩小查找范围。
五、图的遍历在图的数据结构中，查找操作通常是指遍历操作。
图的遍历有两种方式：深度优先搜索（DFS）和广度优先搜索（BFS）。
深度优先搜索通过递归的方式依次访问图中的每个节点，直到找到目标节点或者遍历完整个图。
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法1. 深度优先搜索（DFS）深度优先搜索是一种常用的图遍历算法，其基本思想是从一个顶点出发，沿着一条路径向来向下访问，直到无法继续为止，然后回溯到前一个顶点，再选择此外一条路径继续访问。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问。
（2）从v出发，选择一个未被访问的邻接顶点w，将w标记为已访问，并将w入栈。
（3）如果不存在未被访问的邻接顶点，则出栈一个顶点，继续访问其它未被访问的邻接顶点。
（4）重复步骤（2）和（3），直到栈为空。
2. 广度优先搜索（BFS）广度优先搜索是另一种常用的图遍历算法，其基本思想是从一个顶点出发，挨次访问其所有邻接顶点，然后再挨次访问邻接顶点的邻接顶点，以此类推，直到访问完所有顶点。
具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问，并将v入队。
（2）从队首取出一个顶点w，访问w的所有未被访问的邻接顶点，并将这些顶点标记为已访问，并将它们入队。
（3）重复步骤（2），直到队列为空。
三、图的遍历应用图的遍历算法在实际应用中有广泛的应用，下面介绍两个典型的应用场景。
1. 连通分量连通分量是指图中的一个子图，其中的任意两个顶点都是连通的，即存在一条路径可以从一个顶点到达另一个顶点。
图的遍历算法可以用来求解连通分量的个数及其具体的顶点集合。
具体步骤如下：（1）对图中的每一个顶点进行遍历，如果该顶点未被访问，则从该顶点开始进行深度优先搜索或者广度优先搜索，将访问到的顶点标记为已访问。
（2）重复步骤（1），直到所有顶点都被访问。
2. 最短路径最短路径是指图中两个顶点之间的最短路径，可以用图的遍历算法来求解。
遍历路径算法
遍历路径算法遍历路径算法是一种计算机科学中的算法，用于在图或树等数据结构中遍历或搜索路径，以找到特定节点、确定连通性或执行其他操作。
以下是一些常见的遍历路径算法：1. 深度优先搜索（Depth-First Search，DFS）：DFS 是一种递归或堆栈（栈）驱动的算法，用于遍历树或图中的节点。
它首先探索一个节点的所有子节点，然后再递归地继续向下探索，直到到达叶子节点，然后返回上一级节点，继续探索其他子节点。
DFS 可以用于寻找路径、检测环、拓扑排序等问题。
2. 广度优先搜索（Breadth-First Search，BFS）：BFS 以层次方式遍历图或树，从根节点开始，首先探索所有直接相邻的节点，然后再逐层向外扩展。
BFS 通常用于寻找最短路径或解决距离相关问题。
3. Dijkstra 算法：Dijkstra 算法用于寻找从一个起点到图中所有其他节点的最短路径。
它通过不断选择距离最短的节点来构建最短路径树。
4. A 搜索算法*：A* 搜索算法是一种启发式搜索算法，用于寻找从一个起点到目标节点的最短路径。
它使用启发式函数来评估节点的价值，并选择具有最小总代价的节点进行探索。
5. 贪婪搜索算法：贪婪搜索算法是一种启发式搜索算法，它总是选择最有希望的节点进行探索，但不一定能够找到全局最优解。
它通常用于解决某些优化问题，如旅行推销员问题。
6. 递归算法：递归算法是一种通过递归调用自身的方法，来遍历树或图中的路径。
递归算法可以用于深度优先搜索和其他遍历任务。
这些算法的选择取决于具体的问题和数据结构。
不同的遍历路径算法适用于不同类型的问题，因此需要根据问题的性质来选择适当的算法。
第一讲 图的搜索算法
算法框架
1．算法的基本思路 算法设计的基本步骤为：
1）确定图的存储方式； 2）图的遍历过程中的操作，其中包括为输 出问题解而进行的存储操作；
3）输出问题的结论。
dfs与bfs 深度搜索与广度搜索的相近，最终都要扩展 一个结点的所有子结点. 区别在于对扩展结点过程，深度搜索扩 展的是E-结点的邻接结点中的一个，并将其 作为新的E-结点继续扩展，当前E-结点仍为 活结点，待搜索完其子结点后，回溯到该结 点扩展它的其它未搜索的邻接结点。而广度 搜索，则是扩展E-结点的所有邻接结点，E结点就成为一个死结点。
或改造，加入了一定的“智能因素”，使搜索能尽快接近目标结点，减少了在空间和 时间上的复杂度。 )
二、分支定界 三、A*算法 第三部分 搜索与动态规划的结合 （包括与其他算法的联系和对比）
初级的图搜索算法
• 包括 深度优先遍历,广度优先遍历和双向广度优先遍历 • 图的两种遍历算法：深度优先搜索和广度优先搜索算法 • BFS是一种盲目搜寻法，目的是系统地展开并检查图中 的所有节点，以找寻结果。换句话说，它并不考虑结果 的可能位址，彻底地搜索整张图，直到找到结果为止。 BFS并不使用经验法则算法。
广度优先搜索的应用
【例1】已知若干个城市的地图，求从一个 城市到另一个城市的路径，要求路径中经过的 城市最少 【例2】走迷宫问题
·
【例1】已知若干个城市的地图，求从一个城市到 另一个城市的路径，要求路径中经过的城市最少。
算法设计：
图的广度优先搜索类似与树的层次遍 历，逐层搜索正好可以尽快找到一个结点 与另一个结点相对而言最直接的路径。
如图5-6表示的是从城市A到城市H的交通图。从图中可 以看出，从城市A到城市H要经过若干个城市。现要找出一条 经过城市最少一条路线。 (提示：看到这图很容易想到用邻接距阵来表示，0
树的遍历的三种方法
树的遍历的三种方法树是一种非线性的数据结构，由节点和边组成的集合，节点代表实体，边代表节点之间的连接关系。
在树的操作中，遍历是一种重要的基本操作，它用于按照一定的顺序访问树中的所有节点。
树的遍历方法主要有三种：前序遍历、中序遍历和后序遍历。
下面将对这三种遍历方法进行详细的介绍。
一、前序遍历（Preorder Traversal）前序遍历是从根节点开始，按照根节点-左子树-右子树的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.访问当前节点。
3.递归地前序遍历左子树。
4.递归地前序遍历右子树。
前序遍历的代码示例：```pythondef preorder(root):if root is None:returnprint(root.val)preorder(root.left)preorder(root.right)```二、中序遍历（Inorder Traversal）中序遍历是从左子树开始，按照左子树-根节点-右子树的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.递归地中序遍历左子树。
3.访问当前节点。
4.递归地中序遍历右子树。
中序遍历的代码示例：```pythondef inorder(root):if root is None:returninorder(root.left)print(root.val)inorder(root.right)```三、后序遍历（Postorder Traversal）后序遍历是从左子树开始，按照左子树-右子树-根节点的顺序访问所有节点。
具体步骤如下：1.若树为空，则直接返回。
2.递归地后序遍历左子树。
3.递归地后序遍历右子树。
4.访问当前节点。
后序遍历的代码示例：```pythondef postorder(root):if root is None:returnpostorder(root.left)postorder(root.right)print(root.val)```以上是树的三种遍历方法的详细介绍及示例代码。
数据结构查找知识点总结
数据结构查找知识点总结查找是在一组数据中寻找特定元素或特定条件的操作。
1. 线性查找：从列表、数组或链表的头部开始逐个检查元素，直到找到目标元素或搜索结束。
最坏情况下需要遍历整个数据集。
- 特点：简单易懂但效率低。
- 时间复杂度：O(n)。
2. 二分查找：对有序的列表、数组或链表，采用分治思想，通过比较目标元素和中间元素的大小关系，缩小搜索范围，直到找到目标元素或搜索结束。
- 前提条件：数据必须有序。
- 特点：效率高，但要求数据有序，且适用于静态数据集。
- 时间复杂度：O(log n)。
3. 哈希查找：通过将元素进行哈希函数映射，将元素存储在哈希表中，以快速定位目标元素。
- 特点：查找速度快，适用于动态数据集。
- 时间复杂度：平均情况下是O(1)，最坏情况下是O(n)（哈希冲突）。
4. 二叉查找树：一种有序的二叉树结构，左子树的所有节点的值都小于根节点的值，右子树的所有节点的值都大于根节点的值。
- 特点：可用于快速插入、删除和查找元素。
- 时间复杂度：平均情况下是O(log n)，最坏情况下是O(n)（树退化为链表）。
5. 平衡二叉查找树：通过在二叉查找树的基础上对树进行平衡操作，使得树的高度保持在较小范围，从而提高查找效率。
- 特点：保持查找性能稳定，适用于动态数据集。
- 时间复杂度：平均情况下是O(log n)，最坏情况下是O(log n)（由于树平衡操作的代价，最坏情况下仍可达到O(n)）。
6. B树/B+树：一种多路搜索树，通过增加每个节点的子节点数目，减少树的高度，从而提高查找效率。
常用于磁盘索引等场景。
- 特点：适用于大规模数据集以及磁盘访问等场景，对于范围查找尤为高效。
- 时间复杂度：平均情况下是O(log n)，最坏情况下是O(log n)。
7. 字典树（Trie树）：一种通过字符串的前缀来组织和查找数据的树形数据结构。
- 特点：适用于按前缀匹配查找、排序等操作。
- 时间复杂度：查找操作的时间复杂度与字符串长度有关。
Java常见的七种查找算法
Java常见的七种查找算法1. 基本查找也叫做顺序查找，说明：顺序查找适合于存储结构为数组或者链表。
基本思想：顺序查找也称为线形查找，属于无序查找算法。
从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。
示例代码：public class A01_BasicSearchDemo1 {public static void main(String[] args){//基本查找/顺序查找//核心：//从0索引开始挨个往后查找//需求：定义一个方法利用基本查找，查询某个元素是否存在//数据如下：{131, 127, 147, 81, 103, 23, 7, 79}int[] arr ={131,127,147,81,103,23,7,79};int number =82;System.out.println(basicSearch(arr, number));}//参数：//一：数组//二：要查找的元素//返回值：//元素是否存在public static boolean basicSearch(int[] arr,int number){//利用基本查找来查找number在数组中是否存在for(int i =0; i < arr.length; i++){if(arr[i]== number){return true;}}return false;}}2. 二分查找也叫做折半查找，说明：元素必须是有序的，从小到大，或者从大到小都是可以的。
如果是无序的，也可以先进行排序。
但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。
基本思想：也称为是折半查找，属于有序查找算法。
用给定值先与中间结点比较。
比较完之后有三种情况：•相等说明找到了•要查找的数据比中间节点小说明要查找的数字在中间节点左边•要查找的数据比中间节点大说明要查找的数字在中间节点右边代码示例：package com.itheima.search;public class A02_BinarySearchDemo1 {public static void main(String[] args){//二分查找/折半查找//核心：//每次排除一半的查找范围//需求：定义一个方法利用二分查找，查询某个元素在数组中的索引//数据如下：{7, 23, 79, 81, 103, 127, 131, 147}int[] arr ={7,23,79,81,103,127,131,147};System.out.println(binarySearch(arr,150));}public static int binarySearch(int[] arr,int number){//1.定义两个变量记录要查找的范围int min =0;int max = arr.length-1;//2.利用循环不断的去找要查找的数据while(true){if(min > max){return-1;}//3.找到min和max的中间位置int mid =(min + max)/2;//4.拿着mid指向的元素跟要查找的元素进行比较if(arr[mid]> number){//4.1 number在mid的左边//min不变，max = mid - 1；max = mid -1;}else if(arr[mid]< number){//4.2 number在mid的右边//max不变，min = mid + 1;min = mid +1;}else{//4.3 number跟mid指向的元素一样//找到了return mid;}}}}3. 插值查找在介绍插值查找之前，先考虑一个问题：为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？二分查找中查找点计算如下：mid=(low+high)/2, 即mid=low+1/2*(high-low);我们可以将查找的点改进为如下：mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
12
4.2.3 广度优先搜索（准备工作）
结点用编号0,1,…连续数字表示 定义一个指针数组a[n],其第i个元素存储有向图 中第i个结点的地址 定义一个数组color[n],元素color[i]可取的值为 white,gray,black,分别表示结点i处于未访问,未 检测,已检测三种不同状态. 定义一个数组parent[n],元素parent[i]的值表示 节点i的双亲结点编号,如parent[3]=2,表明结点3 的双亲结点是2
6
广度优先搜索
对于一个未检测结点,访问完其全部后继结点后才 访问其他未检测结点
深度优先搜索:如果一个算法一旦访问某个结 点，该结点成为未检测结点后，便立即被算 法检测，成为E-结点，而此时，原E-结点尚 未检测完毕，仍处于检测状态，需要在以后 适当时候才能继续检测，这种做法成为深度 优先搜索
14
【程序4-2】
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.
图的广度优先遍历
void Graph::BFS_Traversal(int* parent) { //将在parent数组中返回以双亲表示法表示的BFS生成森林 ColorType* color=new ColorType[n]; //颜色数组 cout<<endl<<"BFS:"; for(int u=0; u<n; u++) { color[u]=White; parent[u]=-1; } for (u=0; u<n; u++) if (color[u]==White) BFS(u, parent, color); //调用BFS，从未标记的结点出发，遍历其后继结点 delete[ ] color; cout<<endl; }
已知的信息为指导，排除一部分状态空间。 有时可能找不到解，比如指导搜索的信息是错误的，则会误 入歧途。
启发式搜索
使用经验法则，边搜索边评估到达目标状态的剩余距离。
3
4.2 图的搜索和遍历
遍历:遵循某种次序,系统地访问一个数据 结构的全部元素,每个元素只访问一次.
实现遍历的关键是规定结点被访问的次序
13
4.2.3 广度优先搜索（解决思路）
一个结点一旦成为E-结点,将依次访问完它的全部未 访问后继结点. 每访问一个结点，就把它加入活结点表 使用队列作为活结点表。 初始,图的所有结点均为white,即color[0..n]=white
从某个结点u开始，访问u，置color[u]=gray，然后 依次访问u的各个白色邻接点，当u的所有邻接点访 问完后， color[u]=black，u结点成为死结点
深度优先搜索使用堆栈作为活结点表
18
1.深度优先遍历算法 假定初始时，图G的所有结点都为白色，从 图的某个结点u出发的深度优先遍历搜索的 递归过程DFS可描述如下： 1)访问结点u，将color[u]置成gray； 2)依次从u的邻接点出发，深度优先搜索。
19
【程序4-3】 图的深度优先搜索
7
图1 深度优先搜索
图2 广度优先搜索
8
活结点—未检测结点 死结点—其后续结点已全部访问过
9
4.2.2 邻接表类
有向图
指针数组，第i个元素 存储有向图中结点i的地址
10
【程序4-1】 ENode类 1. enum ColorType{ White, Gray, Black }; 2. struct ENode 3. { 4. int adjVex; 5. ENode* nextArc; 6. };
16
2.广度优先树(略) 3.时间分析
邻接表表示时,O(n+e)， 邻接矩阵表示时,O(n2)
BFS算法的正确性(略)
17
4.2.4 深度优先搜索
如果一个遍历算法在访问了E-结点x 的某个后继 结点y后，立即把y做为新的E-结点，去访问y的后 继结点，直到y检测完后，x才能再次成为E-结点， 继续访问x的其他未被访问过的后继结点。
15
1. 2.
3.
4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.
void Graph::BFS(int u, int* parent, ColorType* color) { //u =起始节点编号, parent=记录双亲结点,color=结点的访问状态 Queue<int> q(QSize); color[u]=Gray; cout<<" "<<u; //标记起始结点u为活结点 q.Append(u); //将起始结点u加入队列q while (！q.IsEmpty()) //循环次数=结点个数 { u=q.Front(); q.Serve(); //选择一个活结点为E-结点 for (ENode *w=a[u]; w; w=w->nextArc) { //检测E-结点u的全部邻接点，总循环次数=图中总边数 int v=w->adjVex; a[u]存放的结点u的首个 if (color[v]==White) 后继结点的存放地址 { color[v]=Gray; cout<<" "<<v; parent[v]=u; //构造BFS生成森林 q.Append(v); //新的活结点进入活结点表q } } color[u]=Black; //将编号为u的结点标记为死结点 } }
1.
2. 3. 4. 5. 6. 7. 8. 9. 10.
11.
12. 13.
void Graph::DFS(int u, int* parent, ColorType* color) { 结点号 color[u]=Gray; cout<<" "<<u; d[u]=time++; //记录第1个时间 for (ENode* w=a[u]; w; w=w->nextArc){ int v=w->adjVex; if (color[v]==White) { parent[v]=u; DFS(v, parent, color); } } color[u]=Black; f[u]=time++; //记录第2个时间 }
20
2.深度优先树(略) 3.时间分析
邻接表表示时,O(n+e) 邻接矩阵表示时,O(n2)
4.深度优先搜寻的性质(略)
21
图 有向图
4
4.2.1 后继结点
在树形结构，一个结点的直接后继结点是他的孩子结点 在图中，一个结点的后继结点是邻接于该结点的所有邻接点。
5
4.2.1 搜索方法
结点的被访问状态： 1. 未访问：一个结点x若尚未访问 2. 未检测：若结点x自身已访问,但其后继结点尚 未全部访问 3. 已检测：若结点x的后继结点全部被访问过 4. 所谓检测一个结点x是指算法正从x出发，访问 x的某个结点y，x被称为扩展结点，简称E-结 点。
分为：初始状态—代表搜索开始, 目标（答案）状态—代表已求得问题的解
2
问题的求解过程：从初始状态出发，以某种次序系统地检查 状态空间的每一个状态，搜索答案状态的状态空间常用树或图表示,树或图中的一个结点 代表问题的一个状态. 穷举搜索=盲目搜索=无知搜索，把所有的状态逐个检查， 直到找到解或者检查完。 深度搜索和广度搜索都是无知搜索 有知搜索
11
class Graph //邻接表类 { public: Graph(int mSize) //构造仅有n个结点的图的邻接表 { n=mSize; a=new ENode* [n]; for (int i=0; i<n; i++) a[i]=NULL; } void DFS_Traversal(int* parent); //数组parent保存DFS生成森林 void BFS_Traversal(int* prarent); //数组parent保存BFS生成森林 protected: void DFS(int u, int* parent, ColorType* color);//深度优先访问从u可达结点 void BFS(int u, int* parent, ColorType* color);//广度优先访问从u可达结点 ENode** a; //生成指向ENode类对象的指针数组 int n; //图中结点数目 };
第4章 基本搜索与遍历
1
4.1 基本概念
搜索: 一种通过系统地检查给定数据对象的每个 结点,寻找一条从开始结点到答案结点的路径,最 终输出问题解的求解方法. 遍历:要求系统地检查数据对象的每个结点.
分为：树遍历和图遍历
状态空间:用于描述所求问题的各种可能的情况。 每一种情况对应状态空间的一个状态。