遍历的基本算法
数据结构中的图的遍历算法
数据结构中的图的遍历算法图是一种非常重要且广泛应用的数据结构，它由顶点和边组成，可以用来表示各种实际问题，如社交网络、路线规划等。
图的遍历算法是对图中的所有顶点进行系统访问的方法，它可以用来查找、遍历和搜索图中的元素。
本文将介绍图的遍历算法的基本概念和常用的实现方法。
一、图的遍历算法概述图的遍历算法是指按照某种规则遍历图中的所有顶点，以便于查找、遍历和搜索图中的元素。
常用的图的遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）两种。
深度优先搜索（DFS）是一种先访问顶点的所有邻接顶点，再递归访问邻接顶点的邻接顶点的算法。
它以深度为优先级，一直向前走到不能继续为止，然后返回到前一个结点，继续向前走，直到遍历完整个图。
广度优先搜索（BFS）是一种先访问顶点的所有邻接顶点，再访问邻接顶点的邻接顶点，以此类推的算法。
它以广度为优先级，先访问离起始顶点最近的顶点，然后依次访问离起始顶点更远的顶点，直到遍历完整个图。
二、深度优先搜索（DFS）深度优先搜索是一种递归的搜索算法，它的基本思想是从图的某个顶点出发，沿着一条路径一直深入直到不能继续为止，然后返回到前一个结点，继续向前走。
具体实现时，可以使用递归或栈来保存需要访问的顶点。
以下是深度优先搜索的基本步骤：1. 选择一个起始顶点作为当前顶点，将其标记为已访问。
2. 访问当前顶点，并将其加入遍历结果。
3. 从当前顶点的未访问邻接顶点中选择一个作为下一个当前顶点，重复步骤2。
4. 如果当前顶点的所有邻接顶点都已访问，则返回到前一个顶点，重复步骤3。
5. 重复步骤4，直到遍历完整个图。
三、广度优先搜索（BFS）广度优先搜索是一种迭代的搜索算法，它的基本思想是从图的某个顶点出发，依次访问其所有未访问过的邻接顶点，然后再依次访问这些邻接顶点的未访问过的邻接顶点，直到遍历完整个图。
具体实现时，可以使用队列来保存需要访问的顶点。
以下是广度优先搜索的基本步骤：1. 选择一个起始顶点作为当前顶点，将其标记为已访问，并将其加入遍历结果。
实现顺序表的各种基本运算的算法
实现顺序表的各种基本运算的算法顺序表是一种基本的数据结构，它可以存储线性结构，支持随机访问，具有较好的存储效率。
在实际应用中，我们需要实现顺序表的各种基本运算，包括插入、删除、查找、遍历、排序等操作。
下面介绍一些实现顺序表基本运算的算法。
1.插入算法顺序表插入算法的基本思路是：将插入位置之后的所有元素向后移动一位，然后将待插入元素放入插入位置。
具体实现如下：```void Insert(SqList &L, int pos, int data){if (pos < 1 || pos > L.length + 1) // 插入位置非法return;if (L.length == L.MAXSIZE) // 顺序表已满return;for (int i = L.length; i >= pos; i--) // 将pos以后的元素依次后移，腾出pos位置L.data[i] = L.data[i - 1];L.data[pos - 1] = data; // 将新元素插入pos位置L.length++; // 顺序表长度+1}```2.删除算法顺序表删除算法的基本思路是：将待删除元素之后的所有元素向前移动一位，然后将顺序表长度减1。
具体实现如下：```void Delete(SqList &L, int pos){if (pos < 1 || pos > L.length) // 删除位置非法return;for (int i = pos; i < L.length; i++) // 将pos以后的元素依次前移，覆盖pos位置L.data[i - 1] = L.data[i];L.length--; // 顺序表长度-1}```3.查找算法顺序表查找算法的基本思路是：从表头开始逐个比较元素，直到找到目标元素或者搜索到表尾。
具体实现如下：```int Search(SqList L, int data){for (int i = 0; i < L.length; i++){if (L.data[i] == data) // 找到目标元素，返回其下标return i;}return -1; // 未找到目标元素，返回-1}```4.遍历算法顺序表遍历算法的基本思路是：从表头开始依次输出元素。
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法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. 最短路径最短路径是指图中两个顶点之间的最短路径，可以用图的遍历算法来求解。
c++ 遍历所有点且距离最短_最短路径问题dijkstra算法详解
c++ 遍历所有点且距离最短_最短路径问题dijkstra算法详解一、问题概述在图论中，最短路径问题是一个重要的研究课题，它涉及到从一个节点到另一个节点的最短路径的寻找。
Dijkstra算法是一种用于解决最短路径问题的经典算法，它可以高效地遍历图中的所有节点，并找到从起始节点到目标节点的最短路径。
二、Dijkstra算法详解1. 算法思想Dijkstra算法的基本思想是：对于图中的每个节点，选择距离起始节点最近的节点，并将其标记为已访问。
然后，从已访问的节点中选择下一个距离起始节点最近的节点，并将其标记为已访问。
重复这个过程，直到遍历完所有的节点。
在每一步中，算法都会更新节点之间的距离信息，以使得结果更加精确。
2. 算法步骤(1) 初始化：将起始节点的距离设置为0，将所有其他节点的距离设置为无穷大。
将起始节点标记为已访问。
(2) 遍历所有相邻节点：对于每个已访问的节点，遍历其所有相邻节点，并更新它们到起始节点的距离。
对于每个相邻节点，如果通过该相邻节点到达起始节点的距离比当前距离更短，则更新该相邻节点的距离。
(3) 终止条件：当没有未访问的节点时，算法终止。
此时，每个节点的最短路径已经确定。
3. C语言实现以下是一个简单的C语言实现Dijkstra算法的示例代码：```c#include <stdio.h>#include <stdlib.h>#define MAX_VERTICES (100) // 最大顶点数int minDistance[MAX_VERTICES]; // 存储最小距离的数组int dist[MAX_VERTICES]; // 存储每个节点到起点的实际距离的数组bool visited[MAX_VERTICES]; // 标记每个节点是否已访问的数组int src; // 起点int V; // 顶点数void dijkstra(int G[MAX_VERTIXE][MAX_VERTICES], int src) {V = G[0].size(); // 获取顶点数for (int i = 0; i < V; i++) {dist[i] = INT_MAX; // 初始化所有顶点到起点的距离为无穷大visited[i] = false; // 所有顶点未访问}dist[src] = 0; // 起点的距离为0for (int count = 0; count < V - 1; count++) {int u = vertex_selection(G, dist, visited); // 选择当前距离最小的顶点uvisited[u] = true; // 将u标记为已访问for (int v = 0; v < V; v++) { // 遍历u的所有邻居顶点if (!visited[v] && (dist[v] > dist[u] + G[u][v])) { // 如果未访问且通过u到达v的距离更短dist[v] = dist[u] + G[u][v]; // 更新v的距离信息}}}}int vertex_selection(int G[MAX_VERTICES][MAX_VERTICES], int dist[], bool visited[]) {int minIdx = 0, minDist = INT_MAX;for (int v = 0; v < V; v++) { // 遍历所有顶点vif (!visited[v] && minDist > dist[v]) { // 如果未访问且当前距离更短minDist = dist[v];minIdx = v; // 记录最小距离和对应的顶点索引}}return minIdx; // 返回最小距离对应的顶点索引}```三、应用场景与优化方法Dijkstra算法适用于具有稀疏权重的图，它可以高效地找到最短路径。
简要说明树的遍历算法
简要说明树的遍历算法树的遍历算法是指按照一定的规则对树中各个节点进行访问的过程。
常见的树的遍历算法包括先序遍历、中序遍历、后序遍历和层次遍历。
下面将对这四种遍历算法进行详细介绍。
一、先序遍历先序遍历又称前序遍历，是指从根节点开始，按照“根左右”的顺序依次访问每个节点。
具体实现方式可以采用递归或者非递归方式。
1. 递归实现递归实现先序遍历比较简单，只需要按照“根左右”的顺序依次访问每个节点即可。
具体实现代码如下：```pythondef preorder(root):if root:print(root.val)preorder(root.left)preorder(root.right)```2. 非递归实现非递归实现先序遍历需要借助栈来实现。
首先将根节点入栈，然后循环执行以下操作：弹出栈顶元素并访问；如果该节点有右子节点，则将其入栈；如果该节点有左子节点，则将其入栈。
具体实现代码如下：```pythondef preorder(root):if not root:return []stack, res = [root], []while stack:node = stack.pop()res.append(node.val)if node.right:stack.append(node.right)if node.left:stack.append(node.left)return res```二、中序遍历中序遍历是指从根节点开始，按照“左根右”的顺序依次访问每个节点。
具体实现方式同样可以采用递归或者非递归方式。
1. 递归实现递归实现中序遍历也比较简单，只需要按照“左根右”的顺序依次访问每个节点即可。
具体实现代码如下：```pythondef inorder(root):if root:inorder(root.left)print(root.val)inorder(root.right)```2. 非递归实现非递归实现中序遍历同样需要借助栈来实现。
dfsdf (2)
dfsdf介绍在计算机科学中，dfsdf（深度优先搜素dfsd）是一种用于遍历或搜索树或图的算法。
它通过优先访问子结点，而不是同级结点，从而深入到树或图的最深层次，直到遇到无子结点的结点或无法继续搜索为止。
dfsdf 是一种递归算法，它以栈的方式来实现，先进后出。
原理dfsdf 的原理很简单。
它从某个顶点开始，沿着路径访问未访问过的相邻顶点，直到遍历完所有的顶点或找到目标顶点。
这是 dfsdf 的基本过程：1.选择一个起始顶点作为当前节点，并将其标记为已访问。
2.访问当前节点，并将其加入到遍历结果集中。
3.遍历当前节点的相邻节点：–如果相邻节点未被访问过，则递归调用 dfsdf函数，并以相邻节点作为新的当前节点。
–如果所有相邻节点都已访问过，则退回到上一级节点，继续遍历其它相邻节点。
4.重复步骤 3，直到所有节点都被访问完毕。
优缺点dfsdf 算法有以下优点：•简单易实现，只需要使用递归或显示栈来实现。
•消耗的内存较少，因为它只需要保存当前路径上的节点，而不需要保存整个遍历过程中的节点。
•可用于解决许多图论问题，如寻找路径、连通性、图的分割等等。
然而，dfsdf 也有一些缺点：•如果图太大或者递归太深，则可能导致栈溢出。
•由于进入栈的节点越多，dfsdf 遍历的深度也越大，因此它在处理深度较大的图或树时可能不太高效。
•当前节点的选择会影响 dfsdf 的执行效率，因此在某些情况下，它可能会陷入局部最优解。
应用场景dfsdf 算法在许多领域都有广泛的应用，下面给出几个常见的例子：•图的连通性：可以使用 dfsdf 算法来判断两个节点之间是否存在路径，或者找到两个节点之间的最短路径。
•拓扑排序：可以使用 dfsdf 算法进行拓扑排序，找出有向无环图（DAG）中的一个合法拓扑顺序。
•连通分量：可以使用 dfsdf 算法来计算无向图的连通分量，找出图中的强连通分量。
•迷宫求解：可以使用 dfsdf 算法来求解迷宫问题，从入口开始，不断向前探索直到找到出口。
二叉树基本运算算法的实现
二叉树基本运算算法的实现
二叉树是一种常见的数据结构，基本运算算法包括二叉树的遍历、查找、插入、删除等操作。
下面是这些算法的实现：
1. 二叉树遍历：二叉树遍历有三种方式，分别是前序遍历、中序遍历和后序遍历。
其中，前序遍历先访问根节点，再访问左子树和右子树；中序遍历先访问左子树，再访问根节点和右子树；后序遍历先访问左子树，再访问右子树和根节点。
遍历可以使用递归算法或栈实现。
2. 二叉树查找：二叉树查找可以使用递归算法或循环算法实现。
递归算法通过比较节点值实现查找，如果查找值小于当前节点值，则在左子树中查找，否则在右子树中查找。
循环算法使用二叉树的特性，比较查找值和当前节点值的大小，根据大小关系不断移动到左子树或右子树中进行查找，直到找到目标节点或遍历到叶子节点为止。
3. 二叉树插入：二叉树插入需要先查找到插入位置，然后在该位置插入一个新节点。
插入操作可以使用递归算法或循环算法实现。
4. 二叉树删除：二叉树删除分为三种情况：删除叶子节点、删除只有一个孩子的节点和删除有两个孩子的节点。
删除叶子节点很简单，只需要将其父节点的指针设为NULL即可。
删除只有一个孩子的节点需要将父节点的指针指向该节点的
孩子节点。
删除有两个孩子的节点需要找到该节点的后继节点（或前驱节点），将后继节点的值复制到该节点中，然后删除后继节点。
上述算法的实现需要根据具体的编程语言进行调整和实现。
深度优先遍历例题
深度优先遍历例题摘要：1.深度优先遍历基本概念2.深度优先遍历算法实现3.深度优先遍历应用实例正文：【1.深度优先遍历基本概念】深度优先遍历（Depth-First Traversal，简称DFT）是一种遍历树或图的算法。
该算法从某个起始节点开始，沿着树或图的深度优先地访问相邻节点，直到无法继续访问为止。
然后回溯到上一个节点，继续访问其他相邻节点。
重复这个过程，直到访问完所有的节点。
深度优先遍历的特点是简单易懂，实现起来较为直观。
其缺点是可能会出现重复访问节点的情况，尤其是在存在环的情况下。
【2.深度优先遍历算法实现】下面是一个使用递归方法实现的深度优先遍历算法：```void DFS(int node, vector<vector<int>>& adj, vector<bool>& visited) {// 标记当前节点已访问visited[node] = true;// 在此处执行对当前节点的操作（例如输出节点值）// 遍历当前节点的相邻节点for (int neighbor : adj[node]) {// 如果相邻节点未被访问，则继续深度优先遍历if (!visited[neighbor]) {DFS(neighbor, adj, visited);}}}```【3.深度优先遍历应用实例】深度优先遍历广泛应用于各种图算法中，例如寻找连通分量、拓扑排序、寻找最短路径等。
下面是一个简单的实例，展示如何使用深度优先遍历寻找一个无向图中的连通分量：```int main() {int n;cin >> n;vector<vector<int>> adj(n);for (int i = 0; i < n; i++) {cin >> adj[i].size();for (int j = 0; j < adj[i].size(); j++) {cin >> adj[i][j];}}vector<bool> visited(n, false);vector<int> dfn(n, -1);bool connected = true;for (int i = 0; i < n; i++) {if (!visited[i]) {DFS(i, adj, visited);dfn[i] = i;connected = connected && (i == dfn[i]);}}if (!connected) {cout << "The graph is not connected." << endl;} else {cout << "The number of connected components is " << dfn.size() << "." << endl;}return 0;}```这个实例中，我们使用深度优先遍历遍历整个图，标记每个节点的访问情况。
实验四 图的遍历算法
实验四图的遍历算法4.1.实验的问题与要求1.如何对给定图的每个顶点各做一次且仅做一次访问？有哪些方法可以实现图的遍历？2.如何用这些算法解决实际问题？3.熟练掌握图的基本存储方法4.熟练掌握图的两种搜索路径的遍历方法5.掌握有关图的操作算法并用高级语言实现4.2.实验的基本思想和基本原理和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。
它是许多图的算法的基础。
遍历常用两种方法：深度优先搜索遍历；广度优先搜索遍历4.2.1 深度优先搜索（Depth-First Traversal）深度优先搜索是一种递归的过程，正如算法名称那样，深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。
在深度优先搜索中，对于最新发现的顶点，如果它还有以此为起点而未探测到的边，就沿此边继续下去。
当结点v的所有边都己被探寻过，搜索将回溯到发现结点v有那条边的始结点。
这一过程一直进行到已发现从源结点可达的所有结点为止。
如果还存在未被发现的结点，则选择其中一个作为源结点并重复以上过程，整个进程反复进行直到所有结点都被发现为止。
1.图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。
在G中任选一顶点v 为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。
若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。
若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。
图的深度优先遍历类似于树的前序遍历。
采用的搜索方法的特点是尽可能先对纵深方向进行搜索。
这种搜索方法称为深度优先搜索(Depth-First Search)。
相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。
实现顺序表的各种基本运算的算法
实现顺序表的各种基本运算的算法顺序表是一种线性表，可以用数组来实现。
在顺序表中，数据元素在数组中的存储位置是按照逻辑顺序依次排列的。
顺序表中的基本运算包括插入、删除、查找、遍历等。
1. 插入操作顺序表的插入操作是指在顺序表中的指定位置插入一个元素。
插入操作分为两种情况：(1) 在顺序表的末尾插入元素；(2) 在顺序表的中间插入元素。
插入操作算法如下：(1) 在顺序表的末尾插入元素：a. 判断顺序表是否已满，如果已满则输出错误信息；b. 否则将元素插入到顺序表的末尾。
(2) 在顺序表的中间插入元素：a. 判断顺序表是否已满，如果已满则输出错误信息；b. 否则将指定位置之后的元素向后移动一个位置；c. 将新元素插入到指定位置。
2. 删除操作顺序表的删除操作是指删除顺序表中指定位置的元素。
删除操作分为两种情况：(1) 删除顺序表的末尾元素；(2) 删除顺序表的中间元素。
删除操作算法如下：(1) 删除顺序表的末尾元素：a. 判断顺序表是否为空，如果为空则输出错误信息；b. 否则删除顺序表的最后一个元素。
(2) 删除顺序表的中间元素：a. 判断顺序表是否为空，如果为空则输出错误信息；b. 否则将指定位置之后的元素向前移动一个位置；c. 删除指定位置的元素。
3. 查找操作顺序表的查找操作是指在顺序表中查找指定元素的位置。
查找操作分为两种情况：(1) 查找顺序表中第一个符合条件的元素；(2) 查找顺序表中所有符合条件的元素。
查找操作算法如下：(1) 查找顺序表中第一个符合条件的元素：a. 从表头开始遍历顺序表；b. 如果找到符合条件的元素，则返回该元素的位置；c. 如果遍历完整个顺序表都没有找到符合条件的元素，则返回错误信息。
(2) 查找顺序表中所有符合条件的元素：a. 从表头开始遍历顺序表；b. 如果找到符合条件的元素，则输出该元素的位置；c. 如果遍历完整个顺序表都没有找到符合条件的元素，则输出错误信息。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include "stdio.h"#define MAXSIZE 20#define OverFlow -1#define OK 1#define Error -1void Init_SeqList(int *Length_pointer) /*构造一个空表*/ {*Length_pointer=0;}int Insert_Last(int Element[],int *Length_pointer,int x) /*插入一个元素（尾插）*/ {if(*Length_pointer==MAXSIZE-1) /*表满*/{printf("表满");return OverFlow;}else{Element[*Length_pointer]=x;(*Length_pointer)++;return OK;}}int Location_SeqList(int Element[],int Length,int x) /*查找指定元素*/{int i=0;while(i<Length&&Element[i]!=x){i++;}if(i==Length){return -1;}else return i+1;}int Delete_SeqList(int Element[],int *Length_pointer,int i) /*删除指定位置的元素*/ {if(i<1||i>*Length_pointer){printf("不存在第i个元素");return Error;}for(j=i-1;j<=*Length_pointer-1;j++){Element[j]=Element[j+1];}(*Length_pointer)--;return OK;}void Show_SeqList(int Element[],int Length) /*遍历*/{int j;printf("\n");if(Length==0){printf("空表(NULL)!\n");}elsefor(j=0;j<Length;j++){printf("%d ",Element[j]);}}void SetNull_SeqList(int *Length_pointer) /*清空顺序表*/{*Length_pointer=0;}void main(){int x,i,loca;int Element[MAXSIZE]; /*存储线性表的数据元素*/ int Length; /*存储线性表的长度*/ Init_SeqList(&Length); /*构造一个空表*/ do{printf("\n");printf("1---插入一个元素（Insert）\n");printf("2---查询一个元素（Locate）\n");printf("3---删除一个元素（Delete）\n");printf("4---显示所有元素（Show）\n");printf("5---退出\n");scanf("%d",&i);switch(i){case 1:printf("请输入要插入的分数：");scanf("%d",&x);if(Insert_Last(Element,&Length,x)!=OK){printf("插入失败\n");}break;case 2:printf("请输入你要查询的分数：");scanf("%d",&x);loca=Location_SeqList(Element,Length,x);if(loca!=-1){printf("查找成功！存储的位置：%d",loca);}elseprintf("查找失败！");break;case 3:printf("请输入要删除的分数：");scanf("%d",&x);loca=Location_SeqList(Element,Length,x);if(loca!=-1){if(Delete_SeqList(Element,&Length,loca)!=OK){printf("删除失败\n");}}break;case 4:Show_SeqList(Element,Length);break;case 5:break;default:printf("错误选择！请重选：");break;}}while(i!=5);SetNull_SeqList(&Length);}2.3.2 线性表使用结构体的算法实现#include "stdio.h"#define MaxSize 20#define OverFlow -1#define OK 1#define Error -1typedef int ElemType;typedef struct /*数据定义*/{ ElemType Element[MaxSize];int Length; /*线性表的长度*/} SeqList;void Init_SeqList(SeqList *L_pointer) /*构造一个空表*/{L_pointer->Length=0;}int Insert_Last(SeqList *L_pointer,int x) /*插入一个元素（尾插）*/ {if(L_pointer->Length==MaxSize-1){printf("表满");return OverFlow;}else{L_pointer->Element[L_pointer->Length]=x; /*表尾插入一个元素*/(L_pointer->Length)++; /*线性表长度加1*/return OK; /*插入成功，返回OK*/ }}int Location_SeqList(SeqList *L_pointer,int x) /*查找指定元素*/{int i=0;while(i<L_pointer->Length&&L_pointer->Element[i]!=x){i++;}if(i==L_pointer->Length) /*查找失败*/{return -1;}elsereturn i+1; /*查找成功，返回x的逻辑位置*/ }int Delete_SeqList(SeqList *L_pointer,int i) /*删除指定元素*/{int j;if(i<1||i>L_pointer->Length){printf("不存在第i个元素");return Error;}for(j=i-1;j<=L_pointer->Length-1;j++){L_pointer->Element[j]=L_pointer->Element[j+1]; /*数据向左移动*/ }(L_pointer->Length)--; /*长度减1*/return OK;}void Show_SeqList(SeqList *L_pointer) /*遍历线性表*/{int j;printf("\n");if(L_pointer->Length==0){printf("空表(NULL)!\n");}else{for(j=0;j<L_pointer->Length;j++) /*依次输出显示*/{printf("%d ",L_pointer->Element[j]);}}}void SetNull_SeqList(SeqList *L_pointer) /*清空线性表*/{L_pointer->Length=0;}void main(){int x,i,loca;SeqList List;Init_SeqList(&List); /*构造一个空表*/ do{printf("\n");printf("1---插入一个元素（Insert）\n");printf("2---查询一个元素（Locate）\n");printf("3---删除一个元素（Delete）\n");printf("4---显示所有元素（Show）\n");printf("5---退出\n");scanf("%d",&i);switch(i){case 1:printf("请输入要插入的分数：");scanf("%d",&x);if(Insert_Last(&List,x)!=OK){printf("插入失败\n");}break;case 2:printf("请输入你要查询的分数\n");scanf("%d",&x);loca=Location_SeqList(&List,x);if(loca!=-1){printf("查找成功！存储的位置：%d",loca);}elseprintf("查找失败！");break;case 3:printf("请输入要删除的分数：");scanf("%d",&x);loca=Location_SeqList(&List,x);if(loca!=-1){if(Delete_SeqList(&List,loca)!=OK){printf("删除失败\n");}}break;case 4:Show_SeqList(&List);break;case 5:break;default:printf("错误选择！请重选：");break;}}while(i!=5);SetNull_SeqList(&List); /*清空线性表*/ }例2.3#include "stdio.h"#include "string.h"#define MaxSize 20#define OverFlow -1#define OK 1#define Error -1typedef char ElemType[10];typedef struct /*数据定义*/{ElemType Element[MaxSize];int Length; /*线性表的长度*/ } SeqList;void Init_SeqList(SeqList *L_pointer) /*构造一个空表*/{L_pointer->Length=0;}int Insert_Last(SeqList *L_pointer,ElemType x) /*插入一个元素（尾插）*/if(L_pointer->Length==MaxSize-1){printf("表满");return OverFlow;}else{strcpy(L_pointer->Element[L_pointer->Length],x); /*表尾插入一个元素*/(L_pointer->Length)++; /*线性表长度加1*/return OK; /*插入成功，返回OK*/ }}int Location_SeqList(SeqList *L_pointer,ElemType x) /*查找指定元素*/{int i=0;while(i<L_pointer->Length&&strcmp(L_pointer->Element[i],x)!=0){i++;}if(i==L_pointer->Length) /*查找失败*/{return -1;}elsereturn i+1; /*查找成功，返回x的逻辑位置*/ }int Delete_SeqList(SeqList *L_pointer,int i) /*删除指定元素*/{int j;if(i<1||i>L_pointer->Length){printf("不存在第i个元素");return Error;}for(j=i-1;j<=L_pointer->Length-1;j++){strcpy(L_pointer->Element[j],L_pointer->Element[j+1]); /*数据向左移动*/ }(L_pointer->Length)--; /*长度减1*/return OK;}void Show_SeqList(SeqList *L_pointer) /*遍历线性表*/ {int j;printf("\n");if(L_pointer->Length==0){printf("空表(NULL)!\n");}elsefor(j=0;j<L_pointer->Length;j++) /*依次输出显示*/{puts(L_pointer->Element[j]);}}void SetNull_SeqList(SeqList *L_pointer) /*清空线性表*/{L_pointer->Length=0;}void main(){ElemType x;int i,loca;SeqList List;Init_SeqList(&List); /*构造一个空表*/ do{printf("\n");printf("1---插入一个元素（Insert）\n");printf("2---查询一个元素（Find）\n");printf("3---删除一个元素（Delete）\n");printf("4---显示所有元素（Show）\n");printf("5---退出\n");scanf("%d",&i);switch(i){case 1:printf("请输入要插入的名子：");scanf("%s",x);if(Insert_Last(&List,x)!=OK){printf("插入失败\n");}break;case 2:printf("请输入你要查询的名子:");scanf("%s",x);loca=Location_SeqList(&List,x);if(loca!=-1){printf("查找成功！存储的位置：%d",loca);}else printf("查找失败！");break;case 3:printf("请输入要删除的名子：");scanf("%s",x);loca=Location_SeqList(&List,x);if(loca!=-1)if(Delete_SeqList(&List,loca)!=OK)printf("删除失败！\n");break;case 4: Show_SeqList(&List);break;case 5: break;default: printf("错误选择！请重选：");break;}}while(i!=5);SetNull_SeqList(&List); /*清空线性表*/ }例2.13#include "stdio.h"#define MaxSize 80typedef int KeyType;typedef struct list_info{KeyType key;} ElemType;typedef struct{ElemType Element[MaxSize];int Length;} SeqList;void store_SeqList(SeqList * L_pointer){int i;printf("\n请输入钥匙总数:");scanf("%d",&L_pointer->Length);for(i=0;i<L_pointer->Length;i++){printf("\n请输入教室号：");scanf("%d",&L_pointer->Element[i].key);}}int Location_SeqList(SeqList *L_pointer,KeyType x){int i=0;while(i<L_pointer->Length&&L_pointer->Element[i].key!=x) {i++;}if(i==L_pointer->Length)return -1;elsereturn i+1;}void main(){SeqList List;KeyType x;int loca;store_SeqList(&List);printf("\n请输入你要查找的钥匙的教室号：");scanf("%d",&x);loca=Location_SeqList(&List,x);printf("\n请在第%d个钉子上取钥匙：\n",loca);}例2.14#include "stdio.h"#define MaxSize 80typedef int KeyType;typedef struct list_info{KeyType key;} ElemType;typedef struct{ElemType Element[MaxSize];int Length;} SeqList;void store_SeqList(SeqList * L_pointer){int i;printf("\n请输入钥匙总数:");scanf("%d",&L_pointer->Length);for(i=0;i<L_pointer->Length;i++){printf("\n请输入教室号：");scanf("%d",&L_pointer->Element[i].key);}}int Bin_SeqList(SeqList *L_pointer,KeyType x) {int Low=0,High=L_pointer->Length-1,Middle;while(Low<=High){Middle=(Low+High)/2;if(x==L_pointer->Element[Middle].key)return Middle+1;else if(x<L_pointer->Element[Middle].key)High=Middle-1;else Low=Middle+1;}return -1;}void main(){SeqList List;KeyType x;int loca;store_SeqList(&List);printf("\n请输入你要查找的钥匙的教室号：");scanf("%d",&x);loca=Bin_SeqList(&List,x);printf("\n请在第%d个钉子上取钥匙：\n",loca);}算法2.15 程序2.4 第i个元素插入#include "stdio.h"#define MAXSIZE 20#define OverFlow -1#define OK 1#define Error -1void Init_SeqList(int *Length_pointer) /*构造一个空表*/ {*Length_pointer=0;}int Insert_i( int Element[],int *Length_pointer,int i,int x) /*插入一个元素（尾插）*/ {int j;if(*Length_pointer==MAXSIZE) /*表满*/{printf("表满");return OverFlow;}else{if(i<1||i>*Length_pointer+1){printf("\n插入位置错误！\n");return Error;}else{for(j=*Length_pointer;j>=i;j--)Element[j]=Element[j-1];Element[i-1]=x;(*Length_pointer)++;return OK;}}}void Show_SeqList(int Element[],int Length) /*遍历*/{int j;printf("\n");if(Length==0){printf("空表(NULL)!\n");}elsefor(j=0;j<Length;j++){printf("%d ",Element[j]);}printf("\n");}void SetNull_SeqList(int *Length_pointer) /*清空顺序表*/{*Length_pointer=0;}void main(){int i;int Element[MAXSIZE]; /*存储线性表的数据元素*/ int Length; /*存储线性表的长度*/ Init_SeqList(&Length); /*构造一个空表*/ for(i=1;i<=10;i++){if(Insert_i(Element,&Length,1,i)==Error)break;}Show_SeqList(Element,Length);SetNull_SeqList(&Length);}算法2.6 朴素的模式匹配#include "stdio.h"#define MaxSize 100#define OverFlow -1#define OK 1typedef char ElemType; /*顺序表中存的是主,子串的字符*/typedef struct{ElemType Element[MaxSize];int Length;} SeqList;/*说明顺序表的数据类型*/void Init_SeqList(SeqList * L_pointer) /*构造空表*/{L_pointer->Length=0;}int Insert_Last(SeqList * L_pointer,ElemType x) /*尾插，将输入串的字符插入到顺序表中*/ {if(L_pointer->Length==MaxSize-1){printf("表满");return OverFlow;}else{L_pointer->Element[L_pointer->Length]=x;L_pointer->Length++;return OK;}}int index(SeqList *L_pointer1,SeqList *L_pointer2) /*模式匹配，返回匹配位置到loca中*/ {int i,j,k;if(L_pointer2->Length==0)return 0;k=0;i=k;j=0;while(i<L_pointer1->Length&&j<L_pointer2->Length){if(L_pointer1->Element[i]==L_pointer2->Element[j]){i++;j++;}else{k++;i=k;j=0;}}if(j>=L_pointer2->Length)return k+1;elsereturn -1;}void Set_Null_SeqList(SeqList * L_pointer) /*清空顺序表*/{L_pointer->Length=0;}void main(){int i,loca;char s[80];SeqList List1,List2;Init_SeqList(&List1); /*构造空顺序表List1*/ Init_SeqList(&List2); /*构造空顺序表List2*/ printf("请输入主串和字串，用空格分开：");scanf("%s",s); /*读主串*/i=0;while(s[i]!='\0') /*将主串存储到顺序表List1中*/ {Insert_Last(&List1,s[i]);i++;}scanf("%s",s); /*读子串*/i=0;while(s[i]!='\0') /*将子串存储到顺序表List2中*/ {Insert_Last(&List2,s[i]);i++;}loca=index(&List1,&List2); /*调用index函数，得到返回值loca（匹配位置）*/printf("匹配的位置：%d\n",loca);Set_Null_SeqList(&List1);Set_Null_SeqList(&List2);}算法2.17 2.18 程序2.5 顺序表实现大整数相加#include "stdio.h"#define MaxSize 100#define OverFlow -1#define OK 1typedef int ElemType;typedef struct{ElemType Element[MaxSize];int Length;} SeqList;void Init_SeqList(SeqList * L_pointer) /*构造空表*/{L_pointer->Length=0;}int Insert_Last(SeqList * L_pointer,ElemType x) /*尾插，大整数输入到顺序表中*/ {if(L_pointer->Length==MaxSize-1){printf("表满");return OverFlow;}else{L_pointer->Element[L_pointer->Length]=x;L_pointer->Length++;return OK;}}void Add(SeqList *L_pointer1,SeqList *L_pointer2,SeqList *L_pointer3) /*相加函数*/ {int i,j,k;int sum;int flag;i=L_pointer1->Length-1;j=L_pointer2->Length-1;k=0;L_pointer3->Length=0;flag=0;while(i>=0&&j>=0){sum=L_pointer1->Element[i]+L_pointer2->Element[j]+flag;if(sum>9){flag=1;sum=sum%10;}elseflag=0;L_pointer3->Element[k]=sum;L_pointer3->Length++;i--;j--;k++;}while(i>-1){sum=L_pointer1->Element[i]+flag;if(sum>9){flag=1;sum=sum%10;}elseflag=0;L_pointer3->Element[k]=sum;L_pointer3->Length++;i--;k++;}while(j>-1){sum=L_pointer2->Element[j]+flag;if(sum>9){flag=1;sum=sum%10;}elseflag=0;L_pointer3->Element[k]=sum;L_pointer3->Length++;j--;k++;}if(flag==1){L_pointer3->Element[k]=1;L_pointer3->Length++;}}void Reverse(SeqList *L_pointer) /*顺序表逆转*/ {ElemType temp,*p,*q;p=L_pointer->Element;q=L_pointer->Element+L_pointer->Length-1;while(p<=q){temp=*p;*p=*q;*q=temp;p++;q--;}}void Show_SeqList(SeqList *L_pointer){int j;printf("\n");if(L_pointer->Length==0)printf("空表（NULL）！\n");elsefor(j=0;j<L_pointer->Length;j++)printf("%d",L_pointer->Element[j]);printf("\n");}void Set_Null_SeqList(SeqList * L_pointer){L_pointer->Length=0;}void main(){int i;char s[80];SeqList List1,List2,List3;Init_SeqList(&List1); /*构造顺序表*/Init_SeqList(&List2);Init_SeqList(&List3);printf("请输入两个长整数，用空格分开：");scanf("%s",s); /*读被加数*/i=0;while(s[i]!='\0') /*被加数存储到List1中*/ {Insert_Last(&List1,s[i]-'0');i++;}scanf("%s",s); /*读加数*/i=0;while(s[i]!='\0') /*加数存储到List2中*/{Insert_Last(&List2,s[i]-'0');i++;}Add(&List1,&List2,&List3); /*调用Add函数*/Reverse(&List3); /*顺序表List3逆转*/Show_SeqList(&List3); /*显示顺序表List3和内容*/ Set_Null_SeqList(&List1); /*顺序表清空*/Set_Null_SeqList(&List2);Set_Null_SeqList(&List3);}。