最新《数据结构》程序填空复习题
数据结构程序填空题
数据结构程序填空题一、问题描述给定一个整数数组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。
数据结构程序填空题
数据结构程序填空题S设有一个头指针为head的不带头结点单向链表, 且p、q是指向链表中结点类型的指针变量，p指向链表中某结点a（设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句答案（1）q->next=head;（2）p=p->next;（3）q->next=p->next;设有一个头指针为head的不带头结点单向链表，p、q是指向链表中结点类型的指针变量，p指向链表中结点a, （设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句答案：（1）q->next=head (2) p=p->next; （3）q->next=p->next设有一个不带头结点的单向链表，头指针为head，p、prep是指向结点类型的指针，该链表在输入信息时不慎把相邻两个结点的信息重复输入，以下程序段是在该单向链表中查找这相邻两个结点，把该结点的数据域data打印出来，并把其中之一从链表中删除，填写程序中的空格。
（1）p=p->next;（2）p->data或prep->data（3）p->next设线性表为（6，10，16，4），以下程序用说明结构变量的方法建立单向链表，并输出链表中各结点中的数据。
答案：（1）&a（2）（3）p->data（4）p=p->next（5）p!=NULL设线性表为（16，20，26，24），以不带头结点的单向链表存储，链表头指针为head，以下程序的功能是输出链表中各结点中的数据域data。
答案：（1）p->data?（2）p=p->next?（3）p!=NULL?设线性表为（1，3，7，5），以下程序用说明结构变量的方法建立单向链表，并输出链表中各结点中的数据。
答：（1）&a?（2）d->next=NULL?（3）p->data?（4）p=p->next?（5）P指向NULL?X 学生信息存放在结构数组中，每个数组元素存放一个学生的信息，下标从0到n-1。
数据结构程序填空题
数据结构程序填空题一、题目描述编写一个程序，实现对给定数组的排序。
要求使用快速排序算法，并填空完成程序。
二、算法思路快速排序是一种常用的排序算法，其基本思想是通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后分别对这两部分记录继续进行排序，直到整个序列有序。
具体步骤如下：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为待排序序列的长度。
数据结构程序填空题
数据结构程序填空题 Last revision date: 13 December 2020.数据结构程序填空题S设有一个头指针为head的不带头结点单向链表, 且p、q是指向链表中结点类型的指针变量，p指向链表中某结点a（设链表中没有结点的数据域与结点a的数据域相同）, 写出相关语句答案（1）q->next=head;（2）p=p->next;（3）q->next=p->next;设有一个头指针为head的不带头结点单向链表，p、q是指向链表中结点类型的指针变量，p指向链表中结点a, （设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句答案：（1）q->next=head (2) p=p->next; （3）q->next=p->next设有一个不带头结点的单向链表，头指针为head，p、prep是指向结点类型的指针，该链表在输入信息时不慎把相邻两个结点的信息重复输入，以下程序段是在该单向链表中查找这相邻两个结点，把该结点的数据域data打印出来，并把其中之一从链表中删除，填写程序中的空格。
（1）p=p->next;（2）p->data或prep->data（3）p->next设线性表为（6，10，16，4），以下程序用说明结构变量的方法建立单向链表，并输出链表中各结点中的数据。
答案：（1）&a（2）（3）p->data（4）p=p->next（5）p!=NULL设线性表为（16，20，26，24），以不带头结点的单向链表存储，链表头指针为head，以下程序的功能是输出链表中各结点中的数据域data。
答案：（1）p->data（2）p=p->next（3）p!=NULL设线性表为（1，3，7，5），以下程序用说明结构变量的方法建立单向链表，并输出链表中各结点中的数据。
答：（1）&a（2）d->next=NULL（3）p->data（4）p=p->next（5）P指向NULLX 学生信息存放在结构数组中，每个数组元素存放一个学生的信息，下标从0到n-1。
数据结构程序填空题
数据结构程序填空题一、题目描述编写一个程序，实现对数据结构的填空操作。
程序需要实现以下功能：1. 创建一个数据结构，用于存储整数类型的数据。
2. 实现向数据结构中插入数据的功能。
3. 实现从数据结构中删除指定数据的功能。
4. 实现查找数据结构中指定数据的功能。
5. 实现显示数据结构中所有数据的功能。
二、程序设计1. 数据结构设计我们选择使用链表作为数据结构，每一个节点包含一个整数类型的数据和一个指向下一个节点的指针。
```C++struct Node {int data;Node* next;};```2. 创建数据结构首先，我们需要定义一个指向数据结构头节点的指针，并初始化为NULL。
```C++Node* head = NULL;```3. 插入数据实现向数据结构中插入数据的功能，我们需要进行以下步骤：- 创建一个新节点，并为其分配内存。
- 将新节点的数据设置为指定的数值。
- 将新节点的指针指向当前头节点。
- 更新头节点为新节点。
```C++void insert(int value) {Node* newNode = new Node;newNode->data = value;newNode->next = head;head = newNode;}```4. 删除数据实现从数据结构中删除指定数据的功能，我们需要进行以下步骤：- 遍历链表，查找目标数据的前一个节点。
- 将前一个节点的指针指向目标数据的下一个节点。
- 释放目标数据节点的内存。
```C++void remove(int value) {Node* current = head;Node* previous = NULL;while (current != NULL && current->data != value) { previous = current;current = current->next;}if (current != NULL) {if (previous != NULL) {previous->next = current->next;} else {head = current->next;}delete current;}}```5. 查找数据实现查找数据结构中指定数据的功能，我们需要进行以下步骤：- 遍历链表，查找目标数据。
数据结构程序填空题
数据结构程序填空题一、题目描述：编写一个程序，实现一个简单的链表数据结构，并完成以下操作：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.设需要对5个不同的记录关键字进行排序，则至少需要比较________次，至多需要比较__________次。
2.设二叉排序树的高度为h，则在该树中查找关键字key最多需要比较_________次。
3.设在长度为20的有序表中进行二分查找，则比较一次查找成功的结点数有_________个，比较两次查找成功有结点数有_________个。
4.数据结构从逻辑上划分为三种基本类型：___________、__________和___________。
5.在一个具有n个顶点的无向完全图中，包含有________条边，在一个具有n个顶点的有向完全图中，包含有________条边。
6.向一棵B_树插入元素的过程中，若最终引起树根结点的分裂，则新树比原树的高度___________。
7.在堆排序的过程中，对任一分支结点进行筛运算的时间复杂度为________，整个堆排序过程的时间复杂度为________。
8.在快速排序、堆排序、归并排序中，_________排序是稳定的。
9.在有n个叶子结点的哈夫曼树中，总结点数是_______。
10.一棵树T采用二叉链表存储，如果树T中某结点为叶子结点，则在二叉链表BT中所对应的结点一定_______。
11.3.已知数组A［10］［10］为对称矩阵，其中每个元素占5个单元。
现将其下三角部分按行优先次序存储在起始地址为1000的连续的内存单元中，则元素A［5，6］对应的地址是_______。
12.在有n个结点的无向图中，其边数最多为_______。
13.取出广义表A=(x,(a,b,c,d))中原子x的函数是_______。
14.对矩阵采用压缩存储是为了___ ____。
15.带头结点的双循环链表L为空表的条件是_______。
16.设线性表中元素的类型是实型，其首地址为1024，则线性表中第6个元素的存储位置是。
17.对于顺序存储的栈，因为栈的空间是有限的，在进行运算时，可能发生栈的上溢，在进行运算时，可能发生栈的下溢。
数据结构程序填空题
数据结构程序填空题一、问题描述给定一个包含n个元素的整型数组arr，编写一个程序，实现以下功能：1. 将数组arr按照升序排列；2. 统计数组arr中的正整数个数；3. 计算数组arr中所有元素的平均值。
二、解决方案为了解决上述问题，我们可以采用以下步骤进行编程实现：1. 输入数据1.1. 定义一个整型数组arr，长度为n。
1.2. 通过用户输入或其他方式，将n个整数依次存入数组arr中。
2. 数组升序排列2.1. 使用冒泡排序算法对数组arr进行升序排列。
2.2. 冒泡排序算法的基本思想是，通过相邻元素的比较和交换，将较大的元素逐渐交换到数组的末尾。
2.3. 冒泡排序算法的具体实现如下：```for i in range(n-1):for j in range(n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]```3. 统计正整数个数3.1. 定义一个变量count，初始化为0，用于记录正整数的个数。
3.2. 遍历数组arr，对每个元素进行判断：- 如果元素大于0，则将count加1。
3.3. 统计完成后，count即为数组arr中的正整数个数。
4. 计算平均值4.1. 定义一个变量sum，初始化为0，用于记录数组arr中所有元素的和。
4.2. 遍历数组arr，将每个元素累加到sum中。
4.3. 计算平均值avg，即为sum除以数组长度n。
5. 输出结果5.1. 输出数组arr的升序排列结果。
5.2. 输出数组arr中的正整数个数。
5.3. 输出数组arr中所有元素的平均值。
三、示例代码下面是一个示例代码，用于实现上述问题的解决方案：```pythondef bubble_sort(arr):n = len(arr)for i in range(n-1):for j in range(n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j] def count_positive(arr):count = 0for num in arr:if num > 0:count += 1return countdef calculate_average(arr):n = len(arr)if n == 0:return 0else:return sum(arr) / n# 输入数据n = int(input("请输入数组长度n：")) arr = []for i in range(n):num = int(input("请输入第{}个整数：".format(i+1))) arr.append(num)# 数组升序排列bubble_sort(arr)# 统计正整数个数positive_count = count_positive(arr)# 计算平均值average = calculate_average(arr)# 输出结果print("数组升序排列结果：", arr)print("正整数个数：", positive_count)print("所有元素的平均值：", average)```四、测试案例输入：```请输入数组长度n：6请输入第1个整数：-3请输入第2个整数：7请输入第3个整数：0请输入第4个整数：12请输入第5个整数：5请输入第6个整数：-8```输出：```数组升序排列结果： [-8, -3, 0, 5, 7, 12]正整数个数： 3所有元素的平均值： 1.8333333333333333```以上是根据任务名称“数据结构程序填空题”所编写的标准格式文本，详细描述了问题的需求和解决方案。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》程序填空复习题说明：本文档中涉及到的算法并非本书的全部，有些可根据此处的情况自行看书和作业题，黑色为综合练习上的题目，红色为我另增加的题，这些空的选择是根据我个人的经验来决定的并不能完全代表中央电大的出卷老师，因此一定不能有肯定就考这些题目的想法。
不能放弃其他内容的复习，切记！！！一、线性表1.设线性表为（6，10，16，4），以下程序用说明结构变量的方法建立单向链表，并输出链表中各结点中的数据。
#define NULL 0void main( ){NODE a,b,c,d,*head,*p;a.data=6;b.data=10;c.data=16;d.data=4; /*d是尾结点*/head= （1）;a.next=&b;b.next=&c;c.next=&d;（2）; /*以上结束建表过程*/p=head; /*p为工作指针，准备输出链表*/do{printf(“%d\n”, （3）);（4）;}while( （5）);}答案：（1）&a（2）d next=NULL（3）p->data（4）p=p->next（5）p!=NULL2. 以下函数在head为头指针的具有头结点的单向链表中删除第i个结点，struct node{ int data;struct node *next;};typedef struct node NODEint delete(NODE *head,int i ){NODE *p,*q;int j;q=head;j=0;while((q!=NULL)&&( ___(1)_____)){___(2)_____;j++;}if(q==NULL)return(0);p= ___(3)_____;___(4)_____=p->next;free(___(5)_____);return(1);}答案：（1）j<i-1（2）q=q->next（3）q->next（4）q->next（5）p3.将新元素插入到线性表中的第i位，MAX是数组的个数，a[0]用以存放线性表长度，b存放待插入的元素值，i存放插入的位置，n存放线性表长度{int a[MAX];int i,j,b,n;scanf(“%d%d%d”,&b,&i,&n);for(j=1;j<=n;j++)scanf(“%d”,&a[j]);a[0]=n;for(j=n; （1）;j- -)（2）;（3）;（4）;for(j=1;j<=a[0];j++)printf(“%5d\n”,a[j]);}答案：（1）j>=i（2）a[j+1]=a[j]（3）a[i]=b（4）a[0]=n+14.用头插法建立带头结点且有n个结点的单向链表的算法NODE *create(n){NODE *head,*p,*q;int ip=(NODE *)malloc(sizeof(NODE));（1）;（2）;（3）;for(i=1;i<=n;i++){p=(NODE *)malloc(sizeof(NODE));p->data=i;if(i==1)（4）;else{（5）;（6）;}}return(head);}答案：（1）head=p（2）p->next=NULL（3）q=p（4）p->next=NULL（5）p->next=q->next（6）q->next=p一、栈1. 以下函数为链栈的进栈操作，x是要进栈的结点的数据域，top为栈顶指针struct node{ ElemType data;struct node *next;};struct node *top ;void Push(ElemType x){struct node *p;p=(struct node*)malloc(___(1)_____);p->data=x;___(2)_____;}答案：（1）sizeof (struct node)（2）p->next=top（3）top=p二、队列1. 以下函数为链队列的入队操作，x为要入队的结点的数据域的值，front、rear分别是链队列的队头、队尾指针struct node{ ElemType data;struct node *next;};struct node *front，*rear;void InQueue(ElemType x){struct node *p;p= (struct node*) ___(1)_____;p->data=x;p->next=NULL;___(2)_____;rear= ___(3)_____;}答案：（1）malloc(sizeof (struct node))（2）rear->next=p（3）p2. 以下函数为链队列的出队操作（链队列带有头结点），出队结点的数据域的值由x返回，front、rear分别是链队列的队头、队尾指针struct node{ ElemType data;struct node *next;};struct node *front，*rear;ElemType OutQueue(){ElemType x;if(___(1)_____) {printf("队列下溢错误！\n");exit(1);}else {struct node *p=front->next;x=p->data;front->next= ___(2)_____;if(p->next==NULL) rear=front;free(p);___(3)_____;}}答案：（1）front= =rear（2）p->next（3）return(x)三、树1.以下程序是先序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
void Preorder (struct BTreeNode *BT){ if(BT!=NULL){（1）;（2）;（3）;}}答案：（1）printf(“%c”,BT->data)（2）Preorder(BT->left)（3）Preorder(BT->right)2. 以下程序是中序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
void Inorder (struct BTreeNode *BT){ if(BT!=NULL){（1）;（2）;（3）;}}答案：（1）Inorder(BT->left)（2）printf(“%c”,BT->data)（3）Inorder(BT->right)3 以下程序是后序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
void Postorder (struct BTreeNode *BT){ if(BT!=NULL){（1）;（2）;（3）;}}答案：（1）Postorder(BT->left)（2）Postorder(BT->right)（3）printf(“%c”,BT->data);四、图五、排序1．以下冒泡法程序对存放在a[1]，a[2]，……，a[n]中的序列进行排序，完成程序中的空格部分，其中n是元素个数，要求按升序排列。
void bsort (NODE a[ ], int n){ NODE temp;int i,j,flag;for(j=1; （1） ;j++);{flag=0;for(i=1; （2） ;i++)if(a[i].key>a[i+1].key){flag=1;temp=a[i];（3） ;（4） ;}if(flag= =0)break;}}程序中flag的功能是（5）答案：（1）j<=n-1（2）i<=n-j（3）a[i]=a[i+1]（4）a[i+1]=temp（5）当某趟冒泡中没有出现交换则已排好序，结束循环2. 以下函数为直接选择排序算法，对a[1],a[2],…a[n]中的记录进行直接选择排序，完成程序中的空格typedef struct{ int key;……}NODE;void selsort(NODE a[],int n){int i,j,k;NODE temp;for(i=1;i<= ___(1)_____;i++){k=i;for(j=i+1;j<= ___(2)_____;j++)if(a[j].key<a[k].key) __(3)______;if(i!=k){temp=a[i];___(4)_____;____(5)____;}}}答案：（1）n-1（2）n（3）k=j（4）a[i]=a[k]（5）a[k]=temp3.直接插入排序算法Void disort(NODE a[],int n){int I,j;NODE temp;for(i=1;i<n;i++){temp=a[i];（1）;while(j>=0&&temp.key<a[j].key){（2）;（3）;}（4）;}答案：（1）j=i-1（2）a[j+1]=a[j]（3）j--（4）a[j+1]=temp4.快速排序void quicksort(NODE a[],int start,int end){int iI,j;NODE mid;if(start>=end)return;（1）;（2）;mid=a[i];while( （3）){while(i<j)&&a[j].key>mid.key)（4）;;if( （5）;){（6）;;（7）;;}while(i<j&&a[i].key<=mid.key)（8）;;if(i<j){（9）;;（10）;;}}a[i]=mid;（11）;;;}答案：（1）i=start（2）j=end（3）i<j（4）j-- 也可能将此条语句写出，要填写其条件中的a[j].key>mid.key（6）a[i]=a[j]（7）i++（8）i++ 也可能将此条语句写出，要填写其条件中的a[i].key<=mid.key（9）a[j]=a[i]（10）j--（11）quicksort(a,start,i-1)（12）quicksort(a,i+1,end)最后两句要填的概率会很高，要注意快速排序的考点很多，一般只会有三到四个空。