数据结构程序
数据结构程序填空题
数据结构程序填空题一、问题描述给定一个整数数组nums，编写一个函数，将数组中的所有0移动到数组的末尾，同时保持非零元素的相对顺序不变。
二、解题思路我们可以使用双指针的方法来解决这个问题。
定义两个指针i和j，初始时i和j都指向数组的第一个元素。
我们遍历数组，当遇到一个非零元素时，将其赋值给nums[i]，然后i指针向后移动一位。
当遇到一个零元素时，j指针向后移动一位，直到找到下一个非零元素。
然后将该非零元素赋值给nums[i]，并将nums[j]置为0，i和j指针都向后移动一位。
重复这个过程，直到遍历完整个数组。
三、算法实现下面是使用Python语言实现的算法代码：```pythondef move_zeros(nums):i = 0j = 0while j < len(nums):if nums[j] != 0:nums[i] = nums[j]i += 1j += 1while i < len(nums):nums[i] = 0i += 1return nums```四、算法分析1. 算法的时间复杂度为O(n)，其中n是数组的长度。
我们需要遍历整个数组一次。
2. 算法的空间复杂度为O(1)，我们只需要使用常数级别的额外空间。
五、示例测试我们可以对算法进行一些示例测试，以验证其正确性。
示例1：输入：[0, 1, 0, 3, 12]输出：[1, 3, 12, 0, 0]解释：将所有的0移动到数组的末尾，同时保持非零元素的相对顺序不变。
示例2：输入：[0, 0, 0, 0, 0]输出：[0, 0, 0, 0, 0]解释：数组中所有元素都是0，不需要进行任何操作。
示例3：输入：[1, 2, 3, 4, 5]输出：[1, 2, 3, 4, 5]解释：数组中没有0，不需要进行任何操作。
六、总结本文介绍了如何将一个整数数组中的所有0移动到数组的末尾，同时保持非零元素的相对顺序不变。
我们使用双指针的方法来解决这个问题，通过遍历数组，将非零元素移动到数组的前部分，然后将剩余的位置填充为0。
数据结构程序填空题
数据结构程序填空题一、题目描述编写一个程序，实现对给定数组的排序。
要求使用快速排序算法，并填空完成程序。
二、算法思路快速排序是一种常用的排序算法，其基本思想是通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后分别对这两部分记录继续进行排序，直到整个序列有序。
具体步骤如下：1. 选取一个基准元素pivot，可以是待排序序列的第一个元素。
2. 将序列分为两部分，左边的元素都小于等于pivot，右边的元素都大于pivot。
3. 递归地对左右两部分进行快速排序。
三、程序代码下面是使用C语言编写的快速排序程序的代码，其中的填空部分需要完成。
```c#include <stdio.h>void swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;int partition(int arr[], int low, int high) {int pivot = arr[low];int i = low, j = high + 1;while (1) {while (arr[++i] < pivot && i < high);while (arr[--j] > pivot);if (i >= j) {break;}swap(&arr[i], &arr[j]);}swap(&arr[low], &arr[j]);return j;}void quickSort(int arr[], int low, int high) { if (low < high) {int pivotIndex = partition(arr, low, high); quickSort(arr, low, pivotIndex - 1);quickSort(arr, pivotIndex + 1, high);}int main() {int arr[] = {9, 5, 2, 7, 1, 8, 3};int n = sizeof(arr) / sizeof(arr[0]);printf("Original array: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");quickSort(arr, 0, n - 1);printf("Sorted array: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");return 0;}```四、程序运行结果运行以上程序，输出结果如下：```Original array: 9 5 2 7 1 8 3Sorted array: 1 2 3 5 7 8 9```五、算法分析快速排序算法的时间复杂度为O(nlogn)，其中n为待排序序列的长度。
数据结构程序设计(迷宫问题)
数据结构程序设计(迷宫问题)数据结构程序设计(迷宫问题)一、引言迷宫问题是计算机科学中常见的问题之一，它涉及到了数据结构的设计和算法的实现。
本文将介绍迷宫问题的定义、常见的解决算法和程序设计思路。
二、问题定义迷宫问题可以描述为：给定一个迷宫，迷宫由若干个连通的格子组成，其中有些格子是墙壁，有些格子是路径。
任务是找到一条从迷宫的起点（通常是左上角）到终点（通常是右下角）的路径。
三、基本数据结构1.迷宫表示：迷宫可以使用二维数组来表示，数组中的每个元素代表一个格子，可以用0表示路径，用1表示墙壁。
2.坐标表示：可以使用二维坐标表示迷宫中的每一个格子，使用(x, y)的形式表示。
四、算法设计1.深度优先搜索算法：深度优先搜索算法可以用来解决迷宫问题。
算法从起点开始，尝试向四个方向中的一个方向前进，如果可以移动则继续向前，直到到达终点或无法继续移动。
如果无法继续移动，则回溯到上一个节点，选择另一个方向继续搜索，直到找到一条路径或者所有路径都已经探索完毕。
2.广度优先搜索算法：广度优先搜索算法也可以用来解决迷宫问题。
算法从起点开始，先将起点加入队列，然后不断从队列中取出节点，并尝试向四个方向中的一个方向移动，将新的节点加入队列。
直到找到终点或者队列为空，如果队列为空则表示无法找到路径。
五、程序设计思路1.深度优先搜索算法实现思路：a) 使用递归函数来实现深度优先搜索算法，参数为当前节点的坐标和迷宫数据结构。
b) 判断当前节点是否为终点，如果是则返回成功。
c) 判断当前节点是否为墙壁或已访问过的节点，如果是则返回失败。
d) 将当前节点标记为已访问。
e) 递归调用四个方向，如果存在一条路径则返回成功。
f) 如果四个方向都无法找到路径，则将当前节点重新标记为未访问，并返回失败。
2.广度优先搜索算法实现思路：a) 使用队列保存待访问的节点。
b) 将起点加入队列，并标记为已访问。
c) 不断从队列中取出节点，尝试向四个方向移动，如果新的节点未被访问过且不是墙壁，则将新的节点加入队列，并标记为已访问。
数据结构与程序设计
数据结构与程序设计数据结构与程序设计是计算机科学领域中的两个重要概念，它们紧密相连，共同构成了软件开发的基础。
数据结构提供了组织、管理和存储数据的方式，而程序设计则是利用这些数据结构来解决具体问题的算法和逻辑。
数据结构概述数据结构是计算机科学中用于存储、组织数据的方式，它决定了数据的存储、检索和操作的效率。
常见的数据结构包括：1. 数组：一种线性数据结构，可以存储相同类型的元素，支持快速随机访问。
2. 链表：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
3. 栈：一种后进先出（LIFO）的数据结构，只能在一端（栈顶）进行数据的添加和删除。
4. 队列：一种先进先出（FIFO）的数据结构，数据从一端进入，从另一端退出。
5. 树：一种层次结构的数据组织形式，每个节点有零个或多个子节点，常用于表示具有层次关系的数据。
6. 图：由顶点（节点）和边组成，可以表示复杂的关系和网络。
程序设计基础程序设计是指使用某种编程语言来编写指令，以解决特定问题的过程。
程序设计的基础包括：1. 算法：解决问题或完成任务的一系列有序步骤。
2. 控制结构：程序中用于控制程序流程的语句，如条件语句（if-else）、循环语句（for, while）。
3. 函数：一段具有特定功能的代码块，可以被重复调用。
4. 面向对象编程：一种编程范式，通过类和对象来组织代码，提高代码的重用性和模块化。
数据结构与程序设计的结合数据结构与程序设计之间的关系是相辅相成的。
选择合适的数据结构可以提高程序的效率和性能。
例如：- 在需要快速查找元素的场景中，可以使用哈希表或平衡树。
- 当处理大量数据时，使用数组或链表可以更有效地管理内存。
- 对于需要频繁插入和删除操作的数据，使用栈或队列可能更合适。
程序设计过程中，算法的选择和实现也依赖于数据结构的特性。
例如，排序算法的选择会影响数据的存储方式，图算法的实现则依赖于图的表示方法。
实践应用在实际应用中，数据结构与程序设计的结合体现在各种软件和系统中。
数据结构程序设计
数据结构程序设计数据结构是计算机科学中一个非常重要的概念，它涉及到数据的组织、存储和管理方式。
程序设计则是利用编程语言来实现特定功能的一系列指令和算法。
将数据结构与程序设计结合起来，可以有效地解决各种复杂问题，提高程序的效率和可读性。
数据结构的基本概念数据结构可以分为两大类：线性结构和非线性结构。
线性结构包括数组、链表、栈和队列等，它们的特点在于数据元素之间存在一对一的线性关系。
非线性结构则包括树、图等，数据元素之间存在一对多或多对多的关系。
常见数据结构1. 数组：数组是一种基本的数据结构，用于存储具有相同数据类型的元素集合。
数组的元素可以通过索引来访问，这使得数组在查找和访问数据时非常高效。
2. 链表：链表由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
链表的优点是动态的，可以灵活地添加和删除节点，但访问特定元素时需要遍历链表。
3. 栈：栈是一种后进先出（LIFO）的数据结构，只允许在一端（栈顶）进行数据的添加和删除操作。
栈常用于实现函数调用、表达式求值等。
4. 队列：队列是一种先进先出（FIFO）的数据结构，允许在一端添加数据（队尾），在另一端删除数据（队首）。
队列常用于任务调度和缓冲处理。
5. 树：树是一种层次结构的数据组织形式，每个节点有零个或多个子节点。
树结构广泛应用于数据库索引、文件系统等。
6. 图：图由顶点（节点）和边组成，可以表示复杂的关系和网络结构。
图的应用包括网络流、最短路径算法等。
数据结构的选择在程序设计中，选择合适的数据结构对于提高程序性能至关重要。
选择数据结构时需要考虑以下因素：- 数据操作的类型：插入、删除、查找等操作的频率和复杂度。
- 内存使用：不同数据结构对内存的需求不同，需要根据实际情况进行权衡。
- 时间复杂度：不同数据结构在执行相同操作时的时间效率差异。
- 空间复杂度：数据结构占用的空间大小，尤其是在资源受限的环境中。
程序设计中的数据结构应用1. 排序算法：快速排序、归并排序等算法在实现时会利用数组或链表来存储待排序的数据。
解释名词程序数据数据结构和数据类型
文章标题：程序数据：深度解析数据结构和数据类型在计算机编程中，程序数据是指计算机程序中所涉及的各种数据，包括数据的组织方式、存储形式和操作方法。
数据结构和数据类型是程序中处理数据的重要概念，对程序的性能和功能起着至关重要的作用。
本文将深入探讨数据结构和数据类型的概念、特点和应用，帮助读者更加深入地理解和应用这些概念。
一、数据结构1. 数据结构的定义数据结构是指数据元素之间的关系和操作的集合，它包括数据元素之间的逻辑关系和物理组织方式。
常见的数据结构包括数组、链表、栈、队列、树等，它们各自适用于不同的数据处理场景。
2. 数据结构的特点数据结构的特点包括逻辑结构和物理结构，逻辑结构是指数据元素之间的逻辑关系，如线性结构、非线性结构；物理结构是指数据元素的实际存储方式，如顺序存储、链式存储等。
数据结构的选择应根据实际需求和问题特点来确定，以实现高效的数据处理和存储。
3. 数据结构的应用数据结构在计算机程序中有着广泛的应用，包括数据存储、算法设计、数据库管理等方面。
合理的数据结构设计能够提高程序的效率和可维护性，对程序的性能和功能起着至关重要的作用。
二、数据类型1. 数据类型的定义数据类型是指数据的取值范围和数据的运算规则，它包括基本数据类型和自定义数据类型两种。
基本数据类型包括整型、浮点型、字符型、布尔型等，它们在程序中有着固定的表达形式和运算规则。
自定义数据类型是由基本数据类型或其他自定义数据类型组合而成的数据类型，如结构体、枚举等。
2. 数据类型的特点数据类型的特点包括数据范围和运算规则，不同的数据类型适用于不同的数据处理场景。
合理的数据类型设计能够提高程序的可读性和可维护性，对程序的功能和性能起着至关重要的作用。
3. 数据类型的应用数据类型在计算机程序中有着广泛的应用，包括变量声明、运算操作、函数参数传递等方面。
合理的数据类型选择能够提高程序的可移植性和兼容性，对程序的可移植性和兼容性起着至关重要的作用。
算法+数据结构=程序
算法+数据结构=程序算法＋数据结构＝程序在计算机科学的广袤世界里，有一个简洁而有力的公式：算法＋数据结构＝程序。
这个公式犹如一把神奇的钥匙，能够开启理解计算机程序设计的大门。
让我们先来谈谈算法。
算法，简单来说，就是解决问题的一系列清晰、明确的步骤。
想象一下，你要做一顿丰盛的晚餐，从买菜、洗菜、切菜到烹饪，每一个步骤都有其先后顺序和具体的操作方法，这就是一个“生活中的算法”。
在计算机的世界里，算法的作用也是如此。
比如，当我们要在一个数组中查找某个特定的元素，就需要有一套明确的步骤来实现这个目标。
算法的好坏直接影响着程序的效率和性能。
一个高效的算法能够在短时间内完成复杂的任务，而一个糟糕的算法可能会让计算机陷入漫长的等待，甚至无法完成任务。
那么，什么是数据结构呢？数据结构可以理解为数据的组织和存储方式。
就好像我们整理衣柜，衣服可以挂起来、叠起来或者放在抽屉里，不同的整理方式会影响我们找衣服的效率。
在计算机中，数据也有各种各样的组织方式，比如数组、链表、栈、队列、树、图等等。
每种数据结构都有其特点和适用场景。
比如，数组适合随机访问，但插入和删除元素的操作比较复杂；链表则在插入和删除元素时非常方便，但随机访问的效率较低。
为什么说算法和数据结构的结合就等于程序呢？让我们通过一个简单的例子来理解。
假设我们要编写一个程序，实现对一个班级学生成绩的排序。
首先，我们需要选择一个合适的算法，比如冒泡排序、快速排序或者归并排序等。
然后，我们还需要选择一种合适的数据结构来存储学生的成绩，比如数组或者链表。
如果我们选择了冒泡排序算法和数组数据结构，那么程序就会按照冒泡排序的步骤，对数组中的成绩进行比较和交换，最终实现成绩的排序。
可以说，算法决定了程序的逻辑和流程，而数据结构则为算法提供了操作的数据基础。
再举一个例子，我们要设计一个地图导航的程序。
在这个程序中，算法可以帮助我们计算从起点到终点的最短路径，而数据结构则可以用来存储地图的节点和边的信息。
数据结构程序填空题
数据结构程序填空题一、题目描述：编写一个程序，实现一个简单的链表数据结构，并完成以下操作：1. 初始化链表2. 在链表末尾插入节点3. 在链表指定位置插入节点4. 删除链表指定位置的节点5. 获取链表长度6. 打印链表中的所有节点二、解题思路：1. 定义链表节点结构体Node，包含一个数据域和一个指向下一个节点的指针域。
2. 定义链表结构体LinkedList，包含一个头节点指针和一个记录链表长度的变量。
3. 初始化链表时，将头节点指针置为空，链表长度置为0。
4. 在链表末尾插入节点时，先判断链表是否为空，若为空，则将新节点作为头节点；若不为空，则找到链表最后一个节点，将其指针指向新节点。
5. 在链表指定位置插入节点时，先判断插入位置的合法性，若位置超出链表长度范围，则插入失败；否则，找到插入位置的前一个节点，将新节点插入到其后面。
6. 删除链表指定位置的节点时，先判断删除位置的合法性，若位置超出链表长度范围，则删除失败；否则，找到删除位置的前一个节点，将其指针指向要删除节点的下一个节点，并释放要删除节点的内存空间。
7. 获取链表长度时，直接返回链表结构体中记录的长度变量。
8. 打印链表中的所有节点时，从头节点开始遍历链表，依次输出每个节点的数据域。
三、代码实现：```c#include <stdio.h>#include <stdlib.h>// 定义链表节点结构体typedef struct Node {int data; // 数据域struct Node* next; // 指针域} Node;// 定义链表结构体typedef struct LinkedList {Node* head; // 头节点指针int length; // 链表长度} LinkedList;// 初始化链表void initLinkedList(LinkedList* list) {list->head = NULL; // 头节点指针置为空list->length = 0; // 链表长度置为0}// 在链表末尾插入节点void insertAtEnd(LinkedList* list, int value) {Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = value; // 设置新节点的数据域newNode->next = NULL; // 设置新节点的指针域为NULL if (list->head == NULL) {list->head = newNode; // 若链表为空，将新节点作为头节点} else {Node* current = list->head;while (current->next != NULL) {current = current->next; // 找到链表最后一个节点}current->next = newNode; // 将最后一个节点的指针指向新节点}list->length++; // 链表长度加1}// 在链表指定位置插入节点void insertAtPosition(LinkedList* list, int value, int position) {if (position < 0 || position > list->length) {printf("插入位置不合法！\n");return;}Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = value; // 设置新节点的数据域if (position == 0) {newNode->next = list->head; // 若插入位置为0，将新节点作为头节点 list->head = newNode;} else {Node* current = list->head;for (int i = 0; i < position - 1; i++) {current = current->next; // 找到插入位置的前一个节点}newNode->next = current->next; // 将新节点的指针指向插入位置的节点 current->next = newNode; // 将插入位置的前一个节点的指针指向新节点}list->length++; // 链表长度加1}// 删除链表指定位置的节点void deleteAtPosition(LinkedList* list, int position) {if (position < 0 || position >= list->length) {printf("删除位置不合法！\n");return;}Node* temp;if (position == 0) {temp = list->head; // 记录要删除的节点list->head = list->head->next; // 将头节点指向下一个节点} else {Node* current = list->head;for (int i = 0; i < position - 1; i++) {current = current->next; // 找到删除位置的前一个节点}temp = current->next; // 记录要删除的节点current->next = current->next->next; // 将删除位置的前一个节点的指针指向删除位置的后一个节点}free(temp); // 释放要删除节点的内存空间list->length--; // 链表长度减1}// 获取链表长度int getLength(LinkedList* list) {return list->length;}// 打印链表中的所有节点void printLinkedList(LinkedList* list) { Node* current = list->head;while (current != NULL) {printf("%d ", current->data);current = current->next; // 遍历链表 }printf("\n");}int main() {LinkedList list;initLinkedList(&list);insertAtEnd(&list, 1);insertAtEnd(&list, 2);insertAtEnd(&list, 3);printf("链表中的节点：");printLinkedList(&list); // 链表中的节点：1 2 3insertAtPosition(&list, 4, 1);printf("链表中的节点：");printLinkedList(&list); // 链表中的节点：1 4 2 3deleteAtPosition(&list, 2);printf("链表中的节点：");printLinkedList(&list); // 链表中的节点：1 4 3int length = getLength(&list);printf("链表的长度：%d\n", length); // 链表的长度：3 return 0;}```四、测试结果：运行以上代码，输出结果为：```链表中的节点：1 2 3链表中的节点：1 4 2 3链表中的节点：1 4 3链表的长度：3```五、总结：通过以上程序的实现，我们成功地完成了一个简单的链表数据结构，并实现了初始化链表、在链表末尾插入节点、在链表指定位置插入节点、删除链表指定位置的节点、获取链表长度以及打印链表中的所有节点等操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一：#include<malloc.h>#include<stdio.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{int *elem;int length;int listsize;}SqList; int InitList_Sq(SqList &L){L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int)); if(!L.elem)return 0;L.length=0;L.listsize=LIST_INIT_SIZE;return 1;}int ListInsert_Sq(SqList &L, int i,int e){int *p,*q,*newbase;if(i<1||i>L.length+1)return 0;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCR EMENT)*sizeof(int));if(!newbase) return 0;L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return 1;}int ListDelete_Sq(SqList &L, int i,int& e){int *p,*q,*newbase;if((i<1)||(i>L.length))return 0;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;*q=e;--L.length;return 1;}void print(SqList L){for(int i=0;i<L.length;i++)printf("%d,",L.elem[i]);}void main(){SqList L;int e;InitList_Sq(L);ListInsert_Sq(L,135);ListInsert_Sq(L,134);ListInsert_Sq(L,133);ListInsert_Sq(L,132);ListDelete_Sq(L,2,e);print(L);}实验二：#include <stdio.h>#include <stdlib.h>typedef int Status;typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;Status ListInsert_L(LinkList&L, int i, int e) {LinkList p,s;int j;p=L; j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i-1) return 0;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return 1;}Status ListDelete_L(LinkList&L,int i,int &e) { LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return 0;q=p->next; p->next=q->next;e=q->data; free(q);return 1;}void CreateList_L(LinkList &L, int n){ int i;LinkList p;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;for(i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode)); scanf("%d",&p->data);p->next=L->next;L->next=p; } }Status GetElem_L(LinkList L, int i, int &e) {LinkList p;int j;p=L->next;j=1;while(p&&j<i){ p=p->next; ++j;}if(!p||j>i)return 0;e=p->data; return 1; }void main(){ LinkList L,p; int i,n; int e;printf("请输入你想创建多少个元素的链表"); scanf("%d", &n);CreateList_L(L, n);for(p=L->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n");printf("请输入想查找第几个元素");scanf("%d", &i);GetElem_L(L, i, e);printf("e=%d\n",e);printf("请输入想在第几个元素位置前插入元素"); scanf("%d%d",&i,&e);ListInsert_L(L, i, e);for(p=L->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n");printf("请输入想删除第几个元素");scanf("%d", &i);ListDelete_L(L,i,e);for(p=L->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n");}实验三：#include<stdio.h>#include<stdlib.h>#define MAXNUM 20#define ElemType int/*定义顺序栈的存储结构*/ typedef struct{ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序表*/void InitStack(SqStack *p){if(!p)printf("内存分配失败!");p->top=-1;}/*入栈*/void Push(SqStack*p,ElemType x){if(p->top <MAXNUM-1){p->top =p->top+1;p->stack[p->top]=x;}Elseprintf("Overflow!\n");}/*出栈*/ElemType Pop(SqStack *p){ElemType x;if(p->top>=0){x=p->stack[p->top];printf("以前的栈顶数据元素%d已经被删除!\n",p->stack[p->top]);p->top=p->top-1;return(x);}else{printf("Underflow!?\n");return(0);}}/*获取栈顶元素*/ElemType GetTop(SqStack*p){ElemType x;if(p->top>=0){x=p->stack[p->top];printf("\n栈顶元素为:%d\n",x);return(x);}else{printf("Underflow!\n");return(0);}}/*遍历顺序表*/void OutStack(SqStack *p){int i; printf("\n");if(p->top<0)printf("这是一个空表!");for(i=p->top;i>=0;i--)printf("第%d个数据元素是:?%6d\n",i,p->stack[i]); } /*置空顺序表*/void setEmpty(SqStack *p){p->top=-1;} /*?数值转换*/void shuzhi(SqStack *p,int n,int x){while(n){Push(p,n%x);n=n/x;}}/*判断回文数*/bool huiwen(SqStack *p,int n){int i=0,j=0;int a[MAXNUM];while(n){a[i]=n%10;Push(p,n%10);n=n/10;i++;}while(p->stack[p->top-j]==a[j]) j++;if(j<i)return 0;elsereturn 1;}/*主函数*/void main(){SqStack*q;int cord,x,n,y;ElemType a;printf("第一次使用必须初始!\n");do{printf("\n");printf("\n----------主菜单------------\n");printf("\n 1初始化顺序表\n");printf("\n 2插入一个元素\n");printf("\n 3删除栈顶元素\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空顺序栈\n");printf("\n 6 数制转换\n");printf("\n 7 判断回文数\n");printf("\n 8 结束程序运行\n");printf("\n----------------------------\n"); printf("请输入您的选择(1,2,3,4,5,6,7)"); scanf("%d",&cord);printf("\n");switch(cord){case 1:{q=(SqStack * )malloc(sizeof(SqStack)); InitStack(q);OutStack(q);}break;case 2:{printf("请输入要插入的数据元素:a="); scanf("%d",&a);Push(q,a);OutStack(q);}break;case 3:{Pop(q);OutStack(q);}break;case 4:{GetTop(q);OutStack(q);}break;case 5:{setEmpty(q);printf("\n顺序栈被置空!\n");OutStack(q);}break;case 6:{q=(SqStack*)malloc(sizeof(SqStack));int i;InitStack(q);printf("请输入要转换的数制：\n");scanf("%d",&x);printf("请输入要转换的数：N=");scanf("%d",&n);shuzhi(q,n,x);if(q->top<0)printf("!");for(i=q->top;i>=0;i--)printf("%6d",q->stack[i]);}break;case 7:{q=(SqStack * )malloc(sizeof(SqStack));int s;InitStack(q);printf("请输入要判断的正数：\n");scanf("%d",&y);s=huiwen(q,y);if(s==1)printf("%d是回文数!",y);elseprintf("%d不是回文数!",y);}break;case 8:exit(0);}}while(cord<=8);}实验四：矩阵的转置#include<iostream>#include<stdio.h>using namespace std;#define n1 2#define n2 3int a[n1][n2],b[n2][n1];int main(){int a[n1][n2],b[n2][n1];int i,j;printf("请输入一个%d行%d列的矩阵:",n1,n2); for(i=0;i<n1;i++)for(j=0;j<n2;j++)scanf("%d",*(a+i)+j);//使用元素a[i][j]的地址printf("转置后的矩阵为:\n");for(i=0;i<n2;i++){for(j=0;j<n1;j++){*(*(b+i)+j)=*(*(a+j)+i);//b[i][j]=a[j][i]printf("%d\t",b[i][j]);}printf("\n");}return 0;}/*int chushihua(){int i,j;printf("请输入一个%d行%d列的矩阵:",n1,n2); for(i=0;i<n1;i++) for(j=0;j<n2;j++)scanf("%d",*(a+i)+j);return 0;}int zhuanzhi(){int i,j;printf("转置后的矩阵为:\n");for(i=0;i<n2;i++){for(j=0;j<n1;j++){*(*(b+i)+j)=*(*(a+j)+i);//b[i][j]=a[j][i] printf("%d\t",b[i][j]);}printf("\n");}return 0;}int main(){chushihua();zhuanzhi();return 0;}实验五：遍历二叉树先序二叉树#include<stdio.h>#include<malloc.h> typedef struct BiNode{char data;struct BiNode *lchild,*rchild; }BiNode,*BiTree;int createbiTree(BiTree&T) {char ch;scanf("%c",&ch);if(ch==' ') T=NULL;else{if(!(T=(BiNode*)malloc(sizeof(BiNode))))return 0;T->data=ch;createbiTree(T->lchild);createbiTree(T->rchild);}return 1;}int inorder(BiTree T){if(T){inorder(T->lchild);printf("%c",T->data);inorder(T->rchild);}return 1;}void main(){BiTree T;createbiTree(T);inorder(T);} 中序遍历#include <stdio.h>#include <malloc.h>typedef struct node{int data;struct node *lchl,*rchl;}NODE;void create(NODE **t) //建立{ int a;scanf("%d",&a);if(a){*t=(NODE*)malloc(sizeof(NODE)); (*t)->data=a;create(&((*t)->lchl));create(&((*t)->rchl));}Elset=NULL;} void print(NODE *T) //中序遍历{if(T){print(T->lchl);printf("%4d",T->data);print(T->rchl);}后序二叉树#include<stdio.h>#include<stdlib.h>struct BiTNode//定义结构体{Char data;Struct BiTNode *lchild,*rchild;}V oid l at er(st ru ct Bi TNo d e *&p)//前序创建树{Char c h;s c a n f("%c",&c h);If (c h=='')p=NU L L;E l se{p=(s t r u c t B i T N o d e *)m a l l o c(s i z e o f(s t r u c t B i T N o d e));p->dat a=ch;l at er(p->l chi ld);l a t er(p->r ch i l d);}}V oid print(struct BiTNode *p)//后序遍历（输出二叉树）{if(p!=N U L L){p r i n t(p->l c h i l d);p r i n t(p->r c h i l d);p rint f("%c",p->d at a); }E l sep ri n t f(" ");}void main()//主函数{/*检测：p r i n t f("到了吗");*/ Struct B i T N o d e*p;later(p);print(p);}}int main(){NODE *root;create(&root);print(root);return 0;}.实验六顺序查找#include "stdio.h"#include "malloc.h"#define MAX 100typedef struct sq{int key;//int data;}sqlist;sqlist st[MAX],s[MAX];void creat(sqlist st[MAX],int n){int i;for(i=0;i<n;i++){scanf("%d",&st[i].key);}for(i=0;i<n;i++){printf("%d ",st[i].key);}printf("\n");}//顺序查找int shunxu_search(sqlist st[],int n,int key) {int i=0;for(;i<n;i++){ if((st[i].key==key)&&(i<n))break;}if(i<n) { printf("查找成功!\n");printf("查找次数为:%d\n",i+1);return(1);}else{printf("查找失败!\n");}}void main(){ int f=1,s,p,q;int a,no;while(f){printf("Please input the number which you need\n"); printf("no.1:创建数据\nno.2:按顺序查找\n"); scanf("%d",&no);switch(no){case 1: printf("请输入个数: ");scanf("%d",&a);printf("请输入元素: \n");creat(st,a);break;case 2: printf("请输入要查找的数: ");scanf("%d",&s);q=shunxu_search(st,a,s);break;}printf("do you want to continue ?\nno.1:continue\nno.0:exit\n");scanf("%d",&f);}}//顺序查找int shunxu_search(sqlist st[],int n,int key){int i=0;for(;i<n;i++){ if((st[i].key==key)&&(i<n))break;}if(i<n) { printf("查找成功!\n");printf("查找次数为:%d\n",i+1);return(1);}else{printf("查找失败!\n");}}void main() { int f=1,s,p,q;int a,no;while(f){printf("Please input the number which you need\n"); printf("no.1:创建数据\nno.2:按顺序查找\n");scanf("%d",&no);switch(no){case 1: printf("请输入个数: ");scanf("%d",&a);printf("请输入元素: \n");creat(st,a);break;case 2: printf("请输入要查找的数: ");scanf("%d",&s);q=shunxu_search(st,a,s);break;}printf("do you want to continue ?\nno.1:continue\nno.0:exit\n");scanf("%d",&f);}}折半查找#include <stdio.h>#include <stdlib.h>void main(){int a[10]={1,3,4,6,8,9,10,13,15,18};int n,i,low=0,high=9;int adrress=0,count=0;printf("pelase input the search number:"); scanf("%d",&n);high=high/2;if(n>a[high]){count++; low=high+1;for(i=low;i<10;i++){count++;if(a[i]==n){adrress=i;printf("the number %d is searched,the adrress is %d ,and search numbers is %d \n",n,adrress,count);}}}else if(n<a[high]){count++;high=high-1;for(i=low;i<=high;i++) {count++;if(a[i]==n){adrress=i; printf("the number %d is searched,the adrress is %d ,and search numbers is %d \n",n,adrress,count);}}}else if( a[high]==n)printf("the number %d is searched,the adrress is %d ,and search numbers is 1 \n",n,high); }实验七：二叉树排序#include<iostream>#include<stack>#include<queue>using namespace std; //二叉树结点typedef struct BiTNode{ //数据char data; //左右孩子指针struct BiTNode *lchild,*rchild;}BiTNode,*BiTree; //按先序序列创建二叉树int CreateBiTree(BiTree &T){char data; //按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树scanf("%c",&data);if(data == '#'){T = NULL;}else{T = (BiTree)malloc(sizeof(BiTNode));//生成根结点T->data = data;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);}return 0;}//输出void Visit(BiTree T){if(T->data != '#'){printf("%c ",T->data);}}//先序遍历void PreOrder(BiTree T){if(T != NULL){//访问根节点Visit(T);//访问左子结点PreOrder(T->lchild);//访问右子结点PreOrder(T->rchild);}}//中序遍历void InOrder(BiTree T){if(T != NULL){//访问左子结点InOrder(T->lchild);//访问根节点Visit(T);//访问右子结点InOrder(T->rchild);}}//后序遍历void PostOrder(BiTree T){if(T != NULL){//访问左子结点PostOrder(T->lchild);//访问右子结点PostOrder(T->rchild);//访问根节点Visit(T);}}/* 先序遍历(非递归)思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。