数据结构程序填空题
数据结构程序填空题
数据结构程序填空题一、问题描述给定一个整数数组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为待排序序列的长度。
数据结构程序填空题
数据结构程序填空题一、题目描述编写一个程序，实现对数据结构的填空操作。
程序需要实现以下功能：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. 初始化链表2. 在链表头部插入元素3. 在链表尾部插入元素4. 在指定位置插入元素5. 删除链表头部元素6. 删除链表尾部元素7. 删除指定位置元素8. 查找链表中指定元素的位置9. 获取链表长度10. 打印链表中的所有元素二、解题思路：1. 初始化链表：创建一个头结点，并将头结点的指针域置为空。
2. 在链表头部插入元素：创建一个新节点，将新节点的指针域指向头结点的下一个节点，再将头结点的指针域指向新节点。
3. 在链表尾部插入元素：创建一个新节点，遍历链表找到最后一个节点，将最后一个节点的指针域指向新节点。
4. 在指定位置插入元素：创建一个新节点，遍历链表找到指定位置的前一个节点，将新节点的指针域指向前一个节点的下一个节点，再将前一个节点的指针域指向新节点。
5. 删除链表头部元素：将头结点的指针域指向头结点的下一个节点。
6. 删除链表尾部元素：遍历链表找到倒数第二个节点，将倒数第二个节点的指针域置为空。
7. 删除指定位置元素：遍历链表找到指定位置的前一个节点，将前一个节点的指针域指向指定位置的下一个节点。
8. 查找链表中指定元素的位置：遍历链表，逐个比较节点的值与指定元素的值，直到找到匹配的节点，返回其位置。
9. 获取链表长度：遍历链表，计数器加一，直到遍历到链表尾部。
10. 打印链表中的所有元素：遍历链表，逐个打印节点的值。
三、代码实现：```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextclass LinkedList:def __init__(self):self.head = ListNode()def insert_at_head(self, val):new_node = ListNode(val)new_node.next = self.head.nextself.head.next = new_nodedef insert_at_tail(self, val):new_node = ListNode(val)curr = self.headwhile curr.next:curr = curr.nextcurr.next = new_nodedef insert_at_position(self, val, position): new_node = ListNode(val)curr = self.headfor _ in range(position):curr = curr.nextnew_node.next = curr.nextcurr.next = new_nodedef delete_at_head(self):if self.head.next:self.head.next = self.head.next.nextdef delete_at_tail(self):curr = self.headwhile curr.next.next:curr = curr.nextcurr.next = Nonedef delete_at_position(self, position): curr = self.headfor _ in range(position):curr = curr.nextcurr.next = curr.next.nextdef find_position(self, val):curr = self.head.nextposition = 0while curr:if curr.val == val:return positioncurr = curr.nextposition += 1return -1def get_length(self):curr = self.head.nextlength = 0while curr:curr = curr.nextlength += 1return lengthdef print_list(self):curr = self.head.nextwhile curr:print(curr.val, end=" ")curr = curr.nextprint()# 测试代码linked_list = LinkedList()linked_list.insert_at_head(3) linked_list.insert_at_head(2) linked_list.insert_at_head(1) linked_list.insert_at_tail(4) linked_list.insert_at_position(5, 2) linked_list.delete_at_head() linked_list.delete_at_tail()linked_list.delete_at_position(1)print("链表中元素的位置：", linked_list.find_position(4))print("链表的长度：", linked_list.get_length())print("链表中的元素：", end="")linked_list.print_list()```四、运行结果：链表中元素的位置： 2链表的长度： 3链表中的元素：1 3 4五、解题总结：本题通过使用链表数据结构和相应的操作方法，实现了对链表的初始化、插入、删除、查找、获取长度和打印等功能。
数据结构程序填空题
程序填空题C语言基础1．下列程序的功能是输出一个整数x的绝对值。
将程序补充完整，填在空内。
#include <stdio.h>main(){ int x, ;scanf("%d",&x);y= ;printf("%d\n",y);}2. 以下程序的功能是:输出a、b、c三个变量中的最小值，请填空。
main(){ int a,b,c,t1, ;scanf("%d%d%d",&a,&b,&c);t1=a<b?a:b;t2= ;printf("%d\n",t2);}3. 下列程序的功能是将值为三位正整数的变量x中的数值按照个位、十位、百位的顺序拆分并输出。
将程序补充完整，填在空内。
#include <stdio.h>main(){ int =123;printf("%d,%d,%d\n", ,x/10%10,x/100);}4. 下列程序的功能是输出一个整数x的绝对值。
将程序补充完整，填在空内。
#include <stdio.h>main(){ int x, ;scanf("%d",&x);y= ;printf("%d\n",y);}5. 下列程序的功能是实现两个变量x和y的值的交换。
将程序补充完整，填在空内。
main(){ int x=10, =20;x+=y;y=x-y;;printf("\n%d,%d",x,y);}6. 下列程序的功能是实现两个变量x 和y 的值的交换。
main(){ int =10,y=20;x+=y;y=x-y;;printf("\n%d,%d",x,y);}分支语句1. 根据以下函数关系，对输入的x 值，计算出相应的y 值。
数据结构克鲁斯卡尔算法程序填空题及答案
数据结构克鲁斯卡尔算法程序填空题及答案
一、填空题
1.在数据结构中，______与数据元素本身的内容和形式无关。
正确答案数据逻辑结构
2.数据的逻辑结构分为集合、线性结构、______和图形结构4种基本类型。
正确答案树形结构
3.在树形结构中，树根结点没有______结点，其余每个结点有且只有______个前趋结点；叶子结点没有______结点，其余每个结点的后继结点可以有______。
正确答案前趋;1;后继;任意多个
4.在数据结构中，各个结点按逻辑关系互相缠绕，任意两个结点可以邻接的结构称为______。
正确答案图形结构
5.结点按逻辑关系依次排列形成一条"锁链"的数据结构是______。
正确答案线形结构
6.数据的存储结构包括______的表示和______的表示。
正确答案数据元素;数据元素之间关系
7.数据的存储构分为顺序、______、索引和哈希表4种基本类型。
正确答案链式
8.所有存储结点存放在一个连续的存储区里，利用结点在存储器
中的相对位置来表示数据元素之间的逻辑关系。
这种存储方式是_______。
正确答案顺序存储结构
9. 顺序表中逻辑上相邻的元素的物理位置___相邻。
单链表中逻辑上相邻的元素的物理位置___相邻。
正确答案必定;不一定
10. 栈是一种具有___特性的线性表。
正确答案后进先出[或者]先进后出。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构程序填空题 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指向NULL
X 学生信息存放在结构数组中，每个数组元素存放一个学生的信息，下标从0到n-1。
数组元素按学号num由小到大有序排列，以下函数在a[0]到a[n-1]
中，用折半查找算法查找关键字num等于k的记录，查找成功返回该记录的下标（数组元素的下标）。
失败时返回-1，完成程序中的空格。
（1）low<=high（2）mid（3）a[mid].num<k（4）high=mid-1
Y以下函数是二叉排序树的查找算法，若二叉树为空，则返回根结点的指针，否则，返回值是指向树结点的结构指针p（查找成功p指向查到的树结点，不成功p指向为NULL）答案：（1）NULL（2）k（3）p=p->left（4）p=p->rig（5）p
以下函数是二叉排序树的查找算法，若二叉树为空，则返回根结点的指针，否则，返回值是指向树结点的结构指针p（查找成功p指向查找到的树结点，不成功，则p指向为NULL），完成程序中的空格。
（1）p=bt（2）k（3）p=p->left（4）p=p->right
以下程序是折半插入排序的算法=设待排序的记录序列存放在a[1],…a[n]中，以a[0]作为辅助工作单元，以下程序是要把a[i] 插入到已经有序的序列
a[1],…a[i-1]中。
答案：(1) n (2) (s+j)/2; (3) j=m-1; (4) s=m+1; (5) a[k+1] 以下函数为直接选择排序算法，对a[1],a[2],a[n]中的记录进行直接选择排序，完成程序中的空格
答案：（1）n-1 （2）n （3）k=j （4）a[i]=a[k] （5）a[k]=temp 以下函数为链栈的进栈操作，x是要进栈的结点的数据域，top为栈顶指针struct node
答（1）sizeof (struct node) （2）p->next=top （3）top=p
以下函数在a[0]到a[n-1]中，用折半查找算法查找关键字等于k的记录，查找成功返回该记录的下标，失败时返回-1，完成程序中的空格：
答：（1）low<=high（2）mid（3）a[mid].key<k（4）high=mid-1
（5）不能，因为不是有序序列，不能用折半查找。
以下程序是快速排序的算法设待序的记录序列存放在a[start],…a[end]中，按记录的关键字进行快速排序，先进行一次划分，再分别进行递归调用
答：2.(1) i++; (2) i ++; (3) a[j]=a[i]; (4) j--; (5) (a,
i+1,end);
以下程序是折半插入排序的算法（按记录中关键字key排序）设待排序的记录序列存放在a[1]，…，a[n]中，以a[0]作为辅助工作单元，以下程序是要把a[i] 插入到已经有序的序列a[1]，…，a[i-1]中。
（1）n（2）(s+j)/2（3）j=m-1（4）s=m+1（5）a[k+1]
以下程序是后序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中，左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
答案：（1）Postorder(BT->left)（2）printf("%c",BT->data)（3）
f,d,e,b,c,a
以下是用尾插法建立带头结点且有n个结点的单向链表的程序，结点中的数据域从前向后依次为1,2,3,……,n，完成程序中空格部分。
答案：（1）p （2）q=p （3）(NODE*)malloc(sizeof(NODE)) （4）p
（5）q=p
以下是中序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
答案：（1）Inorder(BT->left)（2）printf("%c",BT->data)（3）d b f e
a c
以下程序是中序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。
答案：（1）Inorder(BT->left)（2）printf(“%c”,BT->data)（3）
Inorder(BT->right)
以下函数为链队列的入队操作，x为要入队的结点的数据域的值，front、rear 分别是链队列的队头、队尾指针
答：（1）malloc(sizeof (struct node)) （2）rear->next=p （3）p
以下冒泡法程序对存放在a[1]，a[2]，……，a[n]中的序列进行排序，完成程序中的空格部分，其中n是元素个数，要求按升序排列。
答：（1）j<=n-1（2）i<=n-j（3）a[i]=a[i+1]（4）a[i+1]=temp （5）4，5，2，1，6，8。