基于C语言的广度优先搜索
c语言中常用的查找
c语言中常用的查找C语言中常用的查找引言：在编程中，查找是一项非常常见且重要的操作。
无论是在数组、链表、树还是图等数据结构中，都需要进行查找操作来寻找特定的数据或者确定某个元素的存在与否。
C语言提供了多种查找算法和数据结构，本文将介绍C语言中常用的查找方法。
一、线性查找线性查找是最简单的查找方法之一，也称为顺序查找。
其基本思想是从数据集合的起始位置开始逐个比较待查找元素与集合中的元素，直到找到目标元素或者遍历完整个集合。
在C语言中，可以使用for循环或者while循环实现线性查找。
线性查找的时间复杂度为O(n)，其中n为数据集合中元素的个数。
二、二分查找二分查找又称为折半查找，是一种高效的查找算法，但要求数据集合必须是有序的。
其基本思想是将数据集合分为两部分，然后通过与目标元素的比较来确定目标元素在哪个部分中，从而缩小查找范围。
重复这个过程直到找到目标元素或者确定目标元素不存在于数据集合中。
二分查找的时间复杂度为O(logn)，其中n为数据集合中元素的个数。
三、哈希表查找哈希表是一种通过哈希函数将关键字映射到存储位置的数据结构，它能够以常数时间复杂度O(1)进行查找操作。
在C语言中，可以使用数组和链表的结合来实现哈希表。
哈希表的关键之处在于哈希函数的设计，良好的哈希函数能够将关键字均匀地映射到不同的存储位置，从而提高查找效率。
四、二叉搜索树查找二叉搜索树是一种常用的数据结构，它满足以下性质：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。
在C语言中，可以使用指针和递归的方式来实现二叉搜索树。
通过比较目标值与当前节点的值，可以确定目标值位于左子树还是右子树中，从而缩小查找范围。
五、图的遍历在图的数据结构中，查找操作通常是指遍历操作。
图的遍历有两种方式：深度优先搜索（DFS）和广度优先搜索（BFS）。
深度优先搜索通过递归的方式依次访问图中的每个节点，直到找到目标节点或者遍历完整个图。
c语言洪泛算法
c语言洪泛算法洪泛算法是一种常见的搜索算法，也称为广度优先搜索（BFS）。
它是一种用来遍历或搜索图形或树的算法，从一个起始节点开始，逐层地向外扩展，直到找到目标节点为止。
洪泛算法的基本思想是通过维护一个队列来实现。
首先，将起始节点放入队列中，然后不断从队列中取出节点，并将其未被访问过的邻居节点加入队列。
这样一层层地扩展，直到找到目标节点或者队列为空为止。
在实际应用中，洪泛算法有很多用途。
例如，在地图导航中，可以使用洪泛算法来找到从起点到终点的最短路径；在社交网络中，可以使用洪泛算法来寻找两个人之间的最短关系链；在迷宫游戏中，可以使用洪泛算法来找到从起点到终点的通路等等。
下面以一个迷宫游戏为例来说明洪泛算法的应用。
我们需要构建一个迷宫地图，可以使用二维数组表示。
其中，0表示墙壁，1表示通路，起点用S表示，终点用E表示。
接下来，我们需要实现洪泛算法的代码。
首先，我们定义一个队列，用来存储待访问的节点。
然后，将起点入队，并标记为已访问。
接着，开始循环，直到队列为空为止。
在每次循环中，取出队首节点，并找到它的所有邻居节点。
如果邻居节点未被访问过且是通路，则将其入队，并标记为已访问。
重复这个过程，直到找到终点或者队列为空。
我们可以根据访问记录来还原路径。
从终点开始，逆向遍历每个节点的访问记录，直到回到起点。
这样就得到了从起点到终点的最短路径。
洪泛算法的时间复杂度为O(V+E)，其中V表示节点的数量，E表示边的数量。
在实际应用中，由于需要访问每个节点和其邻居节点，所以洪泛算法的时间复杂度通常是线性的。
洪泛算法的优点是简单易懂，适用于大多数图形或树的搜索问题。
然而，由于需要访问所有节点和边，所以在大规模图形中效率较低。
此外，洪泛算法没有考虑权重，无法解决带权重的最短路径问题。
洪泛算法是一种常见的搜索算法，广泛应用于图形和树的遍历和搜索问题。
它通过维护一个队列，逐层扩展，实现从起点到目标节点的搜索。
虽然洪泛算法简单易懂，但在大规模图形中效率较低，无法解决带权重的最短路径问题。
迪杰斯特拉算法c语言
迪杰斯特拉算法c语言一、什么是迪杰斯特拉算法？迪杰斯特拉算法（Dijkstra algorithm）是一种用于解决图的最短路径问题的贪心算法。
它采用了广度优先搜索的策略，每次找到当前节点到其他所有节点中距离最短的一个节点，并将该节点加入到已访问的集合中，直到所有节点都被访问为止。
二、迪杰斯特拉算法的原理1. 初始化首先，我们需要对图进行初始化。
设定一个起点，并将该点距离源点的距离设置为0，其他点距离源点的距离设置为无穷大。
2. 找到最小距离接下来，我们需要从未访问过的节点中找到距离源点最近的一个节点。
这个过程可以通过建立一个优先队列来实现。
在每次找到最小值后，我们需要将该节点标记为已访问，并更新与该节点相邻的所有未访问过的节点的最小距离值。
3. 更新最短路径在更新与当前节点相邻的所有未访问过的节点之后，我们需要重新寻找未访问过的节点中距离源点最近的一个。
这个过程会不断重复直至所有节点都被访问过。
4. 输出结果当所有节点都被访问过之后，我们就可以得到从源点到其他所有节点的最短路径。
三、迪杰斯特拉算法的实现以下是一个使用C语言实现的简单示例代码：```c#define INF 1000000 // 定义无穷大int dist[MAX_VERTEX_NUM]; // 存储距离源点的距离int visited[MAX_VERTEX_NUM]; // 标记是否已访问过// 初始化图void init_graph(Graph G, int start) {for (int i = 0; i < G.vertex_num; i++) {dist[i] = INF;visited[i] = 0;}dist[start] = 0;}// 找到距离源点最近的节点int find_min(Graph G) {int min_dist = INF, min_index = -1;for (int i = 0; i < G.vertex_num; i++) {if (!visited[i] && dist[i] < min_dist) {min_dist = dist[i];min_index = i;}}return min_index;}// 更新与当前节点相邻的节点的最短距离值void update_dist(Graph G, int index) {for (EdgeNode* p = G.adj_list[index].first_edge; p != NULL; p= p->next_edge) {int v = p->adjvex;if (!visited[v] && dist[index] + p->weight < dist[v]) {dist[v] = dist[index] + p->weight;}}}// 迪杰斯特拉算法void dijkstra(Graph G, int start) {init_graph(G, start);for (int i = 0; i < G.vertex_num; i++) {int index = find_min(G);visited[index] = 1;update_dist(G, index);}}```四、迪杰斯特拉算法的应用迪杰斯特拉算法可以用于解决许多实际问题，如路由选择、网络优化等。
c语言常用算法集
c语言常用算法集
以下是一些常用的C语言算法集合：
1. 排序算法：
- 冒泡排序(Bubble Sort)
- 选择排序(Selection Sort)
- 插入排序(Insertion Sort)
- 归并排序(Merge Sort)
- 快速排序(Quick Sort)
2. 搜索算法：
- 二分查找(Binary Search)
- 线性搜索(Linear Search)
3. 图算法：
- 深度优先搜索(Depth First Search, DFS)
- 广度优先搜索(Breadth First Search, BFS)
- 最短路径算法(例如：Dijkstra算法、Floyd-Warshall算法) - 最小生成树算法(例如：Prim算法、Kruskal算法)
4. 动态规划：
- 背包问题(Knapsack Problem)
- 最长公共子序列(Longest Common Subsequence)
- 最长递增子序列(Longest Increasing Subsequence)
5. 数学算法：
- 斐波那契数列(Fibonacci Sequence)
- 素数判断(Prime Number Check)
- 阶乘(Factorial)
- 快速幂算法(Fast Exponentiation)
这些算法只是常用的一部分，还有很多其他种类的算法。
掌握这些基本的算法可以帮助你更好地理解和解决各种问题。
C语言中的算法实现
C语言中的算法实现算法是计算机科学中非常重要的概念，它是解决问题的一系列步骤或指令集。
在C语言中，我们可以使用不同的方法来实现算法。
本文将介绍一些常见的C语言算法实现方式。
一、排序算法1. 冒泡排序冒泡排序是一种简单但效率较低的排序算法。
它通过不断比较相邻的元素，并按照规则交换它们的位置，直到整个序列排序完成。
2. 选择排序选择排序是一种简单而直观的排序算法。
它每次从未排序的序列中选择最小（或最大）的元素，并将其放置在已排序序列的末尾。
3. 插入排序插入排序是一种简单且高效的排序算法。
它通过构建有序序列，对未排序的元素逐个插入到已排序的序列中，直到所有元素都被插入完成。
二、查找算法1. 顺序查找顺序查找是一种简单的查找算法。
它从列表的开头开始逐个比较元素，直到找到目标元素或查找完整个列表。
2. 二分查找二分查找是一种高效的查找算法，但要求列表必须是有序的。
它通过将待查找区域分成两部分，判断目标元素落在哪一部分，从而缩小查找范围，直到找到目标元素或确定不存在。
三、递归算法递归是一种常用的算法设计技巧。
它通过在函数内调用自身来解决相同问题的不同实例。
在C语言中，递归函数需要定义出口条件，以避免无限递归。
四、动态规划算法动态规划是一种用于解决具有重叠子问题和最优子结构性质的问题的方法。
它将问题分解为一系列子问题，并以自底向上的方式求解子问题，最终得到整体问题的解。
在C语言中，可以使用循环、数组和指针等特性来实现动态规划算法，从而有效地解决问题。
五、图算法图是一种用于描述对象之间关系的数据结构，图算法是解决图相关问题的一类算法。
常见的图算法包括深度优先搜索（DFS）和广度优先搜索（BFS）。
六、字符串算法字符串算法用于处理字符串相关的问题，如字符串匹配、编辑距离等。
C语言提供了一系列字符串处理函数，如strlen、strcpy等，可以方便地实现字符串算法。
七、数学算法C语言在数学算法方面提供了丰富的库函数支持，如求平方根、对数、指数等。
栈和队列的应用——迷宫问题（深度、广度优先搜索）
栈和队列的应⽤——迷宫问题（深度、⼴度优先搜索）⼀、迷宫问题 给⼀个⼆维列表，表⽰迷宫（0表⽰通道，1表⽰围墙）。
给出算法，求⼀条⾛出迷宫的路径。
maze = [[1,1,1,1,1,1,1,1,1,1],[1,0,0,1,0,0,0,1,0,1],[1,0,0,1,0,0,0,1,0,1],[1,0,0,0,0,1,1,0,0,1],[1,0,1,1,1,0,0,0,0,1],[1,0,0,0,1,0,0,0,0,1],[1,0,1,0,0,0,1,0,0,1],[1,0,1,1,1,0,1,1,0,1],[1,1,0,0,0,0,0,0,0,1],[1,1,1,1,1,1,1,1,1,1]] 1代表墙，0代表路，图⽰如下：⼆、栈——深度优先搜索 应⽤栈解决迷宫问题，叫做深度优先搜索（⼀条路⾛到⿊），也叫做回溯法。
1、⽤栈解决的思路 思路：从上⼀个节点开始，任意找下⼀个能⾛的点，当找不到能⾛的点时，退回上⼀个点寻找是否有其他⽅向的点。
使⽤栈存储当前路径。
后进先出，⽅便回退到上⼀个点。
2、⽤栈代码实现maze = [[1,1,1,1,1,1,1,1,1,1],[1,0,0,1,0,0,0,1,0,1],[1,0,0,1,0,0,0,1,0,1],[1,0,0,0,0,1,1,0,0,1],[1,0,1,1,1,0,0,0,0,1],[1,0,0,0,1,0,0,0,0,1],[1,0,1,0,0,0,1,0,0,1],[1,0,1,1,1,0,1,1,0,1],[1,1,0,0,0,0,0,0,0,1],[1,1,1,1,1,1,1,1,1,1]]# 四个移动⽅向dirs = [lambda x,y: (x+1, y), # 下lambda x,y: (x-1, y), # 上lambda x,y: (x, y-1), # 左lambda x,y: (x, y+1) # 右]def maze_path(x1, y1, x2, y2): # (x1,y1)代表起点；(x2,y2)代表终点stack = []stack.append((x1, y1))while(len(stack)>0):curNode = stack[-1] # 当前的节点(栈顶)if curNode[0] ==x2 and curNode[1] == y2: # 判断是否⾛到终点# ⾛到终点，遍历栈输出路线for p in stack:print(p)return True"""搜索四个⽅向"""for dir in dirs:nextNode = dir(curNode[0], curNode[1])# 如果下⼀个阶段能⾛if maze[nextNode[0]][nextNode[1]] == 0:stack.append(nextNode) # 将节点加⼊栈maze[nextNode[0]][nextNode[1]] = 2 # 将⾛过的这个节点标记为2表⽰已经⾛过了break # 找到⼀个能⾛的点就不再遍历四个⽅向else:# ⼀个都找不到，将该位置标记并该回退maze[nextNode[0]][nextNode[1]] = 2stack.pop()else:print("没有路")return Falsemaze_path(1,1,8,8)"""(1, 1) (2, 1) (3, 1) (4, 1) (5, 1) (5, 2) (5, 3) (6, 3) (6, 4)(6, 5) (7, 5) (8, 5) (8, 6) (8, 7) (8, 8)""" 总结算法就是：创建⼀个空栈，⾸先将⼊⼝位置进栈。
数据结构(c语言版)第三版习题解答
数据结构(c语言版)第三版习题解答数据结构（C语言版）第三版习题解答1. 栈(Stack)1.1 栈的基本操作栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作。
栈的基本操作有：（1）初始化栈（2）判断栈是否为空（3）将元素入栈（4）将栈顶元素出栈（5）获取栈顶元素但不出栈1.2 栈的实现栈可以使用数组或链表来实现。
以数组为例，声明一个栈结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储栈中的元素int top; // 栈顶指针} Stack;```1.3 栈的应用栈在计算机科学中有广泛的应用，例如计算表达式的值、实现函数调用等。
下面是一些常见的栈应用：（1）括号匹配：使用栈可以检查一个表达式中的括号是否匹配。
（2）中缀表达式转后缀表达式：栈可以帮助我们将中缀表达式转换为后缀表达式，便于计算。
（3）计算后缀表达式：使用栈可以方便地计算后缀表达式的值。
2. 队列(Queue)2.1 队列的基本操作队列是一种按照先进先出（FIFO）原则的线性表，常用的操作有：（1）初始化队列（2）判断队列是否为空（3）将元素入队（4）将队头元素出队（5）获取队头元素但不出队2.2 队列的实现队列的实现一般有循环数组和链表两种方式。
以循环数组为例，声明一个队列结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储队列中的元素int front; // 队头指针int rear; // 队尾指针} Queue;```2.3 队列的应用队列在计算机科学中也有广泛的应用，例如多线程任务调度、缓存管理等。
下面是一些常见的队列应用：（1）广度优先搜索：使用队列可以方便地实现广度优先搜索算法，用于解决图和树的遍历问题。
（2）生产者-消费者模型：队列可以用于实现生产者和消费者之间的数据传输，提高系统的并发性能。
广度优先搜索算法利用广度优先搜索解决的最短路径问题
广度优先搜索算法利用广度优先搜索解决的最短路径问题广度优先搜索算法（BFS）是一种图算法，用于解决最短路径问题。
其主要思想是从起始节点开始，不断扩展和访问其邻居节点，直到找到目标节点或者遍历完所有节点。
BFS算法可以用于解决许多问题，其中包括最短路径问题。
下面将介绍广度优先搜索算法的基本原理及其应用于最短路径问题的具体步骤。
同时，通过示例来进一步说明算法的执行过程和实际应用。
一、广度优先搜索算法原理广度优先搜索算法是一种层次遍历的算法，它从起始节点开始，按照距离递增的顺序，依次遍历节点。
在遍历的过程中，任意两个节点之间的距离不超过2，因此，BFS算法可以用于求解最短路径问题。
二、广度优先搜索算法的具体步骤1. 创建一个队列，用于存储待访问的节点。
2. 将起始节点放入队列中，并将其标记为已访问。
3. 当队列不为空时，执行以下步骤：a. 从队列中取出一个节点。
b. 访问该节点，并根据需求进行相应操作。
c. 将该节点的所有未访问过的邻居节点放入队列中，并将它们标记为已访问。
d. 重复步骤a~c，直到队列为空。
4. 完成以上步骤后，如果找到目标节点，则算法终止；否则，表示目标节点不可达。
三、广度优先搜索算法在最短路径问题中的应用最短路径问题是指从一个节点到另一个节点的最短路径，其长度可以通过广度优先搜索算法得到。
考虑以下示例：假设有一个迷宫，迷宫由多个格子组成，其中一些格子是墙壁，不可通过，而其他格子可以自由通行。
任务是找到从起始格子到达目标格子的最短路径。
利用广度优先搜索算法解决最短路径问题的具体步骤如下：1. 创建一个队列，并将起始格子放入队列中。
2. 将起始格子标记为已访问。
3. 当队列不为空时，执行以下步骤：a. 从队列中取出一个格子。
b. 如果该格子是目标格子，则算法终止。
c. 否则，获取该格子的邻居格子，并将未访问过的邻居格子放入队列中。
d. 将该格子的邻居格子标记为已访问。
e. 重复步骤a~d，直到队列为空。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于C语言的广度优先搜素算法的实现1.算法说明广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：（1）把根节点放到队列的末尾。
（2）每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。
并把这个元素记为它下一级元素的前驱。
（3）找到所要找的元素时结束程序。
（4）如果遍历整个树还没有找到，结束程序。
本次算法的应用中，我用这个队列来保存最短路径。
首先我定义队列为“真进假出”，所谓“真进”就是当添加一个元素时，把元素放置队尾，然后rear++,而“假出”就是当删除一个元素时，并没有真的删除队首元素，只是front++。
通过比较搜索所得的所有可行路径的长度，这样我们就可以从队列中获取一条最短路径！2.代码及结果#include<stdio.h>#define N 20typedef struct{int x;int y;}Node;/*队ï元a素?类え?型í*/typedef struct{int parent; /*双?亲×的?序î号?*/int child; /*双?亲×的?序î号?*/Node childpos; /*孩￠子哩?的?坐?标括?/}QType;int Maze[N][N] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1,1,1,0,0,0,0,1,1,0,1,0,0,1,0,1,0,1,0,0,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,0,1,1,1,1,1,0,1,0,0,1,0,1,0,0,0,1,1,1,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,0,1,1,1,1,1,0,0,0,1,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};int visited[N][N] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1,1,1,0,0,0,0,1,1,0,1,0,0,1,0,1,0,1,0,0,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,0,1,1,1,1,1,0,1,0,0,1,0,1,0,0,0,1,1,1,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,0,1,1,1,1,1,0,0,0,1,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,0,1,1,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};QType Q[N * N];int front = 0,rear = 0; /*队ï列 头 ?指?针?和í尾2指?针?*//************************************************************************************** *************************************//*获?取?下?一?个?邻ⅷ?接ï点?*//************************************************************************************** *************************************/int GetNextPos(int *i ,int *j,int count) // i行D j列{switch(count){case 1:(*j)++; //rightreturn 1;case 2:(*i)++; //downreturn 1;case 3:(*j)--; //leftreturn 1;case 4:(*i)--; //upreturn 1;default:return 0;}}/************************************************************************************** *************************************//*入?队ï*//************************************************************************************** *************************************/void EnQueue(int i,int j,int k){Q[rear].childpos.x = i;Q[rear].childpos.y = j; /*孩￠子哩?位?置?*/Q[rear].parent = k; /*双?亲×序î号?*/Q[rear].child = rear; /*孩￠子哩?序î号?*/rear++;}/************************************************************************************** *************************************//*出?队ï*//************************************************************************************** *************************************/void DeQueue(int *i,int *j,int *k){*i = Q[front].childpos.x;*j = Q[front].childpos.y;*k = Q[front].child;front++;}/************************************************************************************** *************************************//*通 ?过y广?度è优?先è遍括?历え?求ï最?短ì路·径?*//************************************************************************************** *************************************/void ShortestPath_BFS(){int i,j,k,count,n,m;EnQueue(1,1,-1); visited[1][1] = 1; /*起e点?入?队ï*/while(1){count = 1;DeQueue(&i,&j,&k);n = i,m = j; //保馈?存?当獭?前°位?置?while(GetNextPos(&i,&j,count)){count++;if(! visited[i][j]){EnQueue(i,j,k); visited[i][j] = 1;if(i == N-2 && j ==N-2) /*到?达?终?点?*/return;}i = n; j = m;}}}/************************************************************************************** *************************************//*输?出?*//************************************************************************************** *************************************/void OutPut(){int i,j,k;/*输?出?原-始?迷?宫?*/puts("原-始?迷?宫?...");for(i = 0;i < N;i++){for(j = 0;j < N;j++)printf("%d ",Maze[i][j]);printf("\n");}/*为a最?短ì路·径?着?色?*/k = rear - 1;while(k != -1){i = Q[k].childpos.x; j = Q[k].childpos.y;Maze[i][j] = 5;k = Q[k].parent;}/*输?出?最?短ì路·径?*/puts("最?短ì路·径?...");for(i = 0;i < N;i++){for(j = 0;j < N;j++)printf("%d ",Maze[i][j]);printf("\n");}}int main(void){ShortestPath_BFS();OutPut();getchar();return0;}说明：在这里我定义一个20*20的原始迷宫，1点代表障碍，0点代表空。