各种排序实验报告
利用指针排序实验报告(3篇)
第1篇一、实验目的1. 理解指针在排序算法中的应用。
2. 掌握几种常见的排序算法（如冒泡排序、选择排序、插入排序等）的指针实现方式。
3. 比较不同排序算法的效率，分析其优缺点。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容本次实验主要实现了以下排序算法：1. 冒泡排序2. 选择排序3. 插入排序以下是对每种排序算法的具体实现和性能分析。
1. 冒泡排序（1）算法原理冒泡排序是一种简单的排序算法。
它重复地遍历待排序的序列，比较每对相邻的元素，如果它们的顺序错误就把它们交换过来。
遍历序列的工作是重复地进行，直到没有再需要交换的元素为止。
（2）指针实现```cppvoid bubbleSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {for (int j = 0; j < len - 1 - i; j++) {if ((arr + j) > (arr + j + 1)) {int temp = (arr + j);(arr + j) = (arr + j + 1);(arr + j + 1) = temp;}}}}```（3）性能分析冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
当待排序序列基本有序时，冒泡排序的性能较好。
2. 选择排序（1）算法原理选择排序是一种简单直观的排序算法。
它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
（2）指针实现```cppvoid selectionSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {int minIndex = i;for (int j = i + 1; j < len; j++) {if ((arr + j) < (arr + minIndex)) {minIndex = j;}}int temp = (arr + i);(arr + i) = (arr + minIndex);(arr + minIndex) = temp;}}```（3）性能分析选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
数据排列实验报告
一、实验目的1. 了解数据排列的基本概念和方法。
2. 掌握常用数据排列算法的原理和实现。
3. 通过实验验证不同排列算法的性能和适用场景。
二、实验原理数据排列是指将一组无序的数据按照一定的顺序进行排序的过程。
常见的排列算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。
本实验主要研究以下几种排序算法：1. 冒泡排序：通过比较相邻元素，将较大的元素交换到后面，直到整个序列有序。
2. 选择排序：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 插入排序：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
4. 快速排序：通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序。
5. 归并排序：将两个或两个以上的有序表合并成一个新的有序表。
三、实验内容1. 编写数据生成函数，生成一定数量的随机数作为待排序数据。
2. 分别实现冒泡排序、选择排序、插入排序、快速排序和归并排序算法。
3. 对每种排序算法进行性能测试，包括排序时间、空间复杂度等。
4. 分析不同排序算法的适用场景和优缺点。
四、实验步骤1. 导入必要的库文件，如random、time等。
2. 编写数据生成函数，生成一定数量的随机数。
3. 编写冒泡排序算法，实现数据排序功能。
4. 编写选择排序算法，实现数据排序功能。
5. 编写插入排序算法，实现数据排序功能。
6. 编写快速排序算法，实现数据排序功能。
7. 编写归并排序算法，实现数据排序功能。
8. 对每种排序算法进行性能测试，记录排序时间和空间复杂度。
9. 分析不同排序算法的适用场景和优缺点。
五、实验结果与分析1. 数据生成函数：生成10000个随机数，范围在0到9999之间。
2. 冒泡排序：- 排序时间：约0.02秒- 空间复杂度：O(1)- 适用场景：数据量较小，几乎可以忽略排序时间。
排序比较的实验报告
一、实验目的1. 了解常见的排序算法及其基本原理。
2. 比较不同排序算法的时间复杂度和空间复杂度。
3. 分析不同排序算法在实际应用中的适用场景。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 数据集：随机生成的10000个整数三、实验内容本次实验主要比较以下排序算法：1. 冒泡排序（Bubble Sort）2. 选择排序（Selection Sort）3. 插入排序（Insertion Sort）4. 快速排序（Quick Sort）5. 归并排序（Merge Sort）四、实验步骤1. 定义排序算法函数。
2. 生成随机整数数据集。
3. 对每个排序算法进行多次测试，记录其时间消耗。
4. 比较不同排序算法的时间复杂度和空间复杂度。
5. 分析不同排序算法在实际应用中的适用场景。
五、实验结果与分析1. 冒泡排序空间复杂度：O(1)冒泡排序是一种简单的排序算法，其基本思想是通过两两比较相邻元素的大小，将较大的元素交换到后面，直到排序完成。
实验结果显示，冒泡排序的时间消耗较高，不适合处理大数据集。
2. 选择排序时间复杂度：O(n^2)空间复杂度：O(1)选择排序的基本思想是每次从待排序的序列中找到最小（或最大）元素，将其放到序列的起始位置，然后继续对剩余未排序的序列进行同样的操作。
实验结果显示，选择排序的时间消耗与冒泡排序相近，同样不适合处理大数据集。
3. 插入排序时间复杂度：O(n^2)空间复杂度：O(1)插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
实验结果显示，插入排序的时间消耗与冒泡排序和选择排序相近，同样不适合处理大数据集。
4. 快速排序时间复杂度：O(nlogn)空间复杂度：O(logn)快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序，以达到整个序列有序。
各种排序实验报告
【一】需求分析课程题目是排序算法的实现，课程设计一共要设计八种排序算法。
这八种算法共包括：堆排序，归并排序，希尔排序，冒泡排序，快速排序，基数排序，折半插入排序，直接插入排序。
为了运行时的方便，将八种排序方法进行编号，其中1为堆排序，2为归并排序，3为希尔排序，4为冒泡排序，5为快速排序，6为基数排序，7为折半插入排序8为直接插入排序。
【二】概要设计1.堆排序⑴算法思想：堆排序只需要一个记录大小的辅助空间，每个待排序的记录仅占有一个存储空间。
将序列所存储的元素A[N]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的元素均不大于(或不小于)其左右孩子(若存在)结点的元素。
算法的平均时间复杂度为0(N log N)。
⑵程序实现及核心代码的注释：for(j=2*i+1; j<=m; j=j*2+1){if(j<m-1 &&( su[j]vsu[j+1]))j++；if(temp>=su[j])break;su[i]=su[j];i=j;}su[i]=temp;}void dpx() // 堆排序{int i,temp;cout<<"排序之前的数组为："vvendl;output();for(i=N/2-1; i>=0; i--){head(i,N);}for(i=N-1; i>0; i--){temp=su[i];su[i]=su[0];su[0]=temp;head(0,i-1);}coutvv"排序之后的数组为："vvendl;output();}2. 归并排序⑴算法思想：先将相邻的个数为1的每两组数据进行排序合并；然后对上次归并所得到的大小为2的组进行相邻归并；如此反复，直到最后并成一组，即排好序的一组数据。
⑵程序实现及核心代码的注释：int is2[1000];void bin(int low,int mid,int high){int i=low,j=mid+1,k=low;while(i<=mid&&jv=hig h)if(su[i]v=su[j])//此处为排序顺序的关键，用小于表示从小到大排序is2[k++]=su[i++];elseis2[k++]=su[j++];while(iv=mid) is2[k++]=su[i++];while(jv=high)is2[k++]=su[j++];for(i=low; iv=high; i++) // 写回原数组su[i]=is2[i];}void g(int a,int b){if(avb){int mid=(a+b)/2;g(a,mid);g(mid+1,b); bin(a,mid,b);}}3. 希尔排序⑴算法思想：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序”时，再对全体记录进行一次直接插入排序。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法，效率较高。
它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。
它的排序时间线性增长，且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。
五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法，适用于各种数据规模。
算法冒泡排序实验报告(3篇)
第1篇一、实验目的本次实验旨在通过实现冒泡排序算法，加深对排序算法原理的理解，掌握冒泡排序的基本操作，并分析其性能特点。
二、实验内容1. 冒泡排序原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行，直到没有再需要交换，也就是说该数列已经排序完成。
2. 实验步骤（1）设计一个冒泡排序函数，输入为待排序的数组，输出为排序后的数组。
（2）编写一个主函数，用于测试冒泡排序函数的正确性和性能。
（3）通过不同的数据规模和初始顺序，分析冒泡排序的性能特点。
3. 实验环境（1）编程语言：C语言（2）开发环境：Visual Studio Code（3）测试数据：随机生成的数组、有序数组、逆序数组三、实验过程1. 冒泡排序函数设计```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```2. 主函数设计```cinclude <stdio.h>include <stdlib.h>include <time.h>int main() {int n;printf("请输入数组长度：");scanf("%d", &n);int arr = (int )malloc(n sizeof(int)); if (arr == NULL) {printf("内存分配失败\n");return 1;}// 生成随机数组srand((unsigned)time(NULL));for (int i = 0; i < n; i++) {arr[i] = rand() % 100;}// 冒泡排序bubbleSort(arr, n);// 打印排序结果printf("排序结果：\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");// 释放内存free(arr);return 0;}```3. 性能分析（1）对于随机生成的数组，冒泡排序的平均性能较好，时间复杂度为O(n^2)。
排序基本算法实验报告
一、实验目的1. 掌握排序算法的基本原理和实现方法。
2. 熟悉常用排序算法的时间复杂度和空间复杂度。
3. 能够根据实际问题选择合适的排序算法。
4. 提高编程能力和问题解决能力。
二、实验内容1. 实现并比较以下排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序。
2. 对不同数据规模和不同数据分布的序列进行排序，分析排序算法的性能。
3. 使用C++编程语言实现排序算法。
三、实验步骤1. 冒泡排序：将相邻元素进行比较，如果顺序错误则交换，直到序列有序。
2. 插入排序：将未排序的元素插入到已排序的序列中，直到序列有序。
3. 选择排序：每次从剩余未排序的元素中选取最小（或最大）的元素，放到已排序序列的末尾。
4. 快速排序：选择一个枢纽元素，将序列分为两部分，一部分比枢纽小，另一部分比枢纽大，递归地对两部分进行排序。
5. 归并排序：将序列分为两半，分别对两半进行排序，然后将两半合并为一个有序序列。
6. 堆排序：将序列构建成一个最大堆，然后依次取出堆顶元素，最后序列有序。
四、实验结果与分析1. 冒泡排序、插入排序和选择排序的时间复杂度均为O(n^2)，空间复杂度为O(1)。
这些算法适用于小规模数据或基本有序的数据。
2. 快速排序的时间复杂度平均为O(nlogn)，最坏情况下为O(n^2)，空间复杂度为O(logn)。
快速排序适用于大规模数据。
3. 归并排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
4. 堆排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
五、实验结论1. 根据不同数据规模和不同数据分布，选择合适的排序算法。
2. 冒泡排序、插入排序和选择排序适用于小规模数据或基本有序的数据。
3. 快速排序、归并排序和堆排序适用于大规模数据。
4. 通过实验，加深了对排序算法的理解，提高了编程能力和问题解决能力。
六、实验总结本次实验通过对排序算法的学习和实现，掌握了常用排序算法的基本原理和实现方法，分析了各种排序算法的性能，提高了编程能力和问题解决能力。
排序的实验报告
排序的实验报告排序的实验报告引言：排序是计算机科学中非常重要的一个概念，它涉及到对一组数据按照一定规则进行重新排列的操作。
在计算机算法中，排序算法的效率直接影响到程序的运行速度和资源利用率。
为了深入了解各种排序算法的原理和性能，我们进行了一系列的排序实验。
实验一：冒泡排序冒泡排序是最简单的排序算法之一。
它的原理是通过相邻元素的比较和交换来实现排序。
我们编写了一个冒泡排序的算法，并使用Python语言进行实现。
实验中，我们分别对10、100、1000个随机生成的整数进行排序，并记录了排序所需的时间。
实验结果显示，随着数据规模的增加，冒泡排序的时间复杂度呈现出明显的增长趋势。
当数据规模为10时，排序所需的时间约为0.001秒；而当数据规模增加到1000时，排序所需的时间则增加到了1.5秒左右。
这说明冒泡排序的效率较低，对大规模数据的排序并不适用。
实验二：快速排序快速排序是一种常用的排序算法，它的核心思想是通过分治的策略将数据分成较小的子集，然后递归地对子集进行排序。
我们同样使用Python语言实现了快速排序算法，并对相同规模的数据进行了排序实验。
实验结果显示，快速排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0005秒；而当数据规模增加到1000时，排序所需的时间仅为0.02秒左右。
这说明快速排序适用于大规模数据的排序，其效率较高。
实验三：归并排序归并排序是一种稳定的排序算法，它的原理是将待排序的数据分成若干个子序列，然后将子序列两两合并，直到最终得到有序的结果。
我们同样使用Python 语言实现了归并排序算法，并进行了相同规模数据的排序实验。
实验结果显示，归并排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0008秒；而当数据规模增加到1000时，排序所需的时间仅为0.03秒左右。
这说明归并排序同样适用于大规模数据的排序，其效率较高。
讨论与结论：通过以上实验，我们可以得出以下结论：1. 冒泡排序虽然简单易懂，但对于大规模数据的排序效率较低，不适用于实际应用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
【一】需求分析课程题目是排序算法的实现，课程设计一共要设计八种排序算法。
这八种算法共包括：堆排序，归并排序，希尔排序，冒泡排序，快速排序，基数排序，折半插入排序，直接插入排序。
为了运行时的方便，将八种排序方法进行编号，其中1为堆排序，2为归并排序，3为希尔排序，4为冒泡排序，5为快速排序，6为基数排序，7为折半插入排序8为直接插入排序。
【二】概要设计1.堆排序⑴算法思想：堆排序只需要一个记录大小的辅助空间，每个待排序的记录仅占有一个存储空间。
将序列所存储的元素A[N]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的元素均不大于(或不小于)其左右孩子(若存在)结点的元素。
算法的平均时间复杂度为O(N log N)。
⑵程序实现及核心代码的注释：for(j=2*i+1; j<=m; j=j*2+1){if(j<m-1&&(su[j]<su[j+1]))j++;if(temp>=su[j])break;su[i]=su[j];i=j;}su[i]=temp;}void dpx() //堆排序{int i,temp;cout<<"排序之前的数组为："<<endl;output();for(i=N/2-1; i>=0; i--){head(i,N);}for(i=N-1; i>0; i--){temp=su[i];su[i]=su[0];su[0]=temp;head(0,i-1);}cout<<"排序之后的数组为："<<endl;output();}2.归并排序⑴算法思想：先将相邻的个数为1的每两组数据进行排序合并；然后对上次归并所得到的大小为2的组进行相邻归并；如此反复，直到最后并成一组，即排好序的一组数据。
⑵程序实现及核心代码的注释：int is2[1000];void bin(int low,int mid,int high){int i=low,j=mid+1,k=low;while(i<=mid&&j<=high)if(su[i]<=su[j]) // 此处为排序顺序的关键，用小于表示从小到大排序is2[k++]=su[i++];elseis2[k++]=su[j++];while(i<=mid)is2[k++]=su[i++];while(j<=high)is2[k++]=su[j++];for(i=low; i<=high; i++) // 写回原数组su[i]=is2[i];}void g(int a,int b){if(a<b){int mid=(a+b)/2;g(a,mid);g(mid+1,b);bin(a,mid,b);}}3.希尔排序⑴算法思想：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
其中，子序列的构成不是简单的“逐段分割”，而是将分隔某个“增量”的记录组成一个子序列。
⑵程序实现及核心代码的注释：while(m){m/=2;if(m!=0){for(i=m; i<N; i++)if(su[i]< su[i-m]){temp=su[i];for(j=i-m; j>=0&&(temp<su[j]); j-=m)su[j+m]=su[j];su[j+m]=temp;}}}4.冒泡排序⑴算法思想：1、先将一组未排序的数组的最后一个数与倒数第二个数进行比较，并将较小的数放于两个数中较前的位置，然后将比较后的较小的数与倒数第三个进行比较，依次比较到第一个数，即可得到第一个数是所有数中最小的数；2、然后再将数组的最后一个数与倒数第二个数进行比较，并将较小的数放于两个数中较前的位置，依次比较到第二个数，3、如此循环到只剩最后两个比较，即得到排好序的一组数。
⑵程序实现及核心代码的注释：for(i=0; i<N; i++){flag=true;for(j=0; j<N-1-i; j++){if(su[j]>su[j+1]){temp=su[j];su[j]=su[j+1];su[j+1]=temp;flag=false;}}break;}cout<<"排序之后的数组为："<<endl;output();}int K;int find(int i,int j){int temp;bool flag=true;temp=su[i];while(i<j){if(flag){while(temp<=su[j]){j--;if(i>=j)break;}if(i>=j)break;su[i]=su[j];while(temp>=su[i]){i++;if(i>=j)break;}if(i>=j)break;su[j]=su[i];}else{while(temp>=su[i]){i++;if(i>=j)break;}su[j]=su[i];if(i>=j)break;while(temp<=su[j]){j--;if(i>=j)break;}su[i]=su[j];flag=true;}}for(i=1; i<N; i++){head=su[i];for(j=0; j<i; j++){if(head<su[j]){for(k=i; k>j; k--){su[k]=su[k-1];}su[j]=head;break;}}}for(i=1; i<N; i++){head=su[i];for(j=0; j<i; j++){if(head<su[j]){for(k=i; k>j; k--){su[k]=su[k-1];}su[j]=head;break;}}}5.快速排序（1）任取待排序记录序列中的某个记录作为基准，按照该记录的关键字大小，将整个记录序列划分为左右两个子序列。
左侧子序列中所有记录的关键字都小于或等于基准记录的关键字。
右侧子序列中所有记录的关键字都大于基准记录的关键字。
取序列第一个记录为枢轴记录，其关键字为Pivotkey；指针low指向序列第一个记录位置（low=1），指针high指向序列最后一个记录位置（High=SeqList.Len） (2) 从high指向的记录开始，向前找到第一个关键字的值小于Pivotkey的记录，将其放到low指向的位置，low++ (3) 从low指向的记录开始，向后找到第一个关键字的值大于Pivotkey的记录，将其放到high指向的位置，high—重复2、3，直到low==high，将枢轴记录放在low（high）指向的位置。
（2）程序实现及核心代码的注释：int find(int i,int j){int temp;bool flag=true;temp=su[i];while(i<j){if(flag){while(temp<=su[j]){j--;if(i>=j)break;}if(i>=j)break;su[i]=su[j];while(temp>=su[i]){i++;if(i>=j)break;}if(i>=j)break;su[j]=su[i];flag=false;}else{while(temp>=su[i]){i++;if(i>=j)break;}su[j]=su[i];if(i>=j)break;while(temp<=su[j]){j--;if(i>=j)break;}su[i]=su[j];flag=true;}}su[i]=temp;cout<<"排完"<<K++<<" 次顺序后的结果"<<endl;output();return i;}void qsort(int low,int high){if(low<high){int mid=find(low,high);qsort(low,mid-1);qsort(mid+1,high);}}6.基数排序（1）算法的基本思想：基数排序是属于“分配式排序”，又称“桶子法”，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用。
最高位优先法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。
再将各组连接起来，便得到一个有序序列。
（2）程序实现及核心代码的注释：for(i=0; i<N; i++){if(max<su[i])max=su[i];a[H(su[i])][b[H(su[i])]++]=su[i];}k=0;for(i=0; i<10; i++){if(b[i]!=0){for(j=0; j<b[i]; j++){su[k++]=a[i][j];}}}cout<<"第一躺排序之后的数组为："<<endl;output();///第二次if(max/10==0)return ;for(i=0; i<10; i++)b[i]=0;for(i=0; i<N; i++){a[HH(su[i])][b[HH(su[i])]++]=su[i];}k=0;for(i=0; i<10; i++){if(b[i]!=0){for(j=0; j<b[i]; j++){su[k++]=a[i][j];}}}cout<<"第二躺排序之后的数组为："<<endl;output();///第三次if(max/100==0)return ;for(i=0; i<10; i++)b[i]=0;for(i=0; i<N; i++){a[HHH(su[i])][b[HHH(su[i])]++]=su[i];}k=0;for(i=0; i<10; i++){if(b[i]!=0){for(j=0; j<b[i]; j++){su[k++]=a[i][j];}}}7.折半排序⑴算法思想：由于折半插入排序的基本操作是在一个有序表中进行查找和插入，这个“查找”操作可利用折半查找来实现，由此进行的插入排序称之为折半插入排序。