c++常见排序算法
c算法技巧
c算法技巧
1. 递归：递归是一种通过函数自身不断调用自身来解决问题的方法。
它在处理阶乘、斐波那契数列等问题时非常有效。
2. 动态规划：动态规划是一种通过把问题分解为相互联系的子问题，并保存子问题的解，以避免重复计算的算法技巧。
它常用于求解背包问题、最长回文子串等问题。
3. 贪心算法：贪心算法是一种在每一步选择当前看起来最优的解决方案，而不考虑整体问题的最优解的算法技巧。
它在找零、最小生成树等问题中有应用。
4. 回溯法：回溯法是一种通过递归和回溯技巧来搜索问题的所有可能解的算法技巧。
它常用于解决数独、八皇后问题等。
5. 排序算法：排序算法是一种将一组数据按照特定顺序进行排列的算法技巧。
常见的排序算法有冒泡排序、插入排序、选择排序、快速排序等。
6. 图算法：图算法是用于处理图结构的算法技巧，如图的遍历、最短路径、最小生成树等。
7. 字符串算法：字符串算法是用于处理字符串的算法技巧，如字符串匹配、字符串查找、字符串拼接等。
这些只是 C 算法技巧的一部分，还有许多其他的算法技巧可以在特定的问题中发挥作用。
选择合适的算法技巧需要根据问题的特点和要求进行分析和考虑。
c语言对double数组排序
c语言对double数组排序C语言对double数组进行排序有多种方法，包括冒泡排序、选择排序、插入排序、快速排序等。
本文将介绍其中几种常见的排序方法。
首先是冒泡排序，它是一种简单直观的排序算法。
冒泡排序的基本思想是通过相邻元素的比较和交换来将数组中较大的元素逐步“冒泡”到末尾。
下面是使用C语言实现的冒泡排序算法：```cvoid bubble_sort(double arr[], int n) {for (int i = 0; i < n-1; ++i) {for (int j = 0; j < n-i-1; ++j) {if (arr[j] > arr[j+1]) {double temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```其次是选择排序，它是一种简单且不稳定的排序算法。
选择排序的基本思想是每次从未排序的部分选择最小（或最大）的元素放到已排序部分的末尾。
下面是使用C语言实现的选择排序算法：```cvoid selection_sort(double arr[], int n) {int min_idx;for (int i = 0; i < n-1; ++i) {min_idx = i;for (int j = i+1; j < n; ++j) {if (arr[j] < arr[min_idx]) {min_idx = j;}}double temp = arr[i];arr[i] = arr[min_idx];arr[min_idx] = temp;}}```接下来是插入排序，它是一种稳定的排序算法。
插入排序的基本思想是将数组分成已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的正确位置。
下面是使用C语言实现的插入排序算法：```cvoid insertion_sort(double arr[], int n) {int i, j;double key;for (i = 1; i < n; ++i) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j+1] = arr[j];--j;}arr[j+1] = key;}}```最后是快速排序，它是一种常用且高效的排序算法。
起泡法排序c语言
起泡法排序c语言起泡法排序c语言起泡法排序是一种基本的排序算法，也称为冒泡排序。
它的原理是不断比较相邻两个元素的大小，如果前面的元素大于后面的元素，则交换它们。
这样一趟下来，最大（或最小）的元素就会被排到最后（或最前）。
1. 算法步骤起泡法排序算法步骤如下：1. 从数组的第一个元素开始，依次比较相邻两个元素的大小。
2. 如果前面的元素大于后面的元素，则交换它们。
3. 继续比较下一对相邻元素，直到比较到数组末尾。
4. 重复上述步骤，直到所有元素都被排好序。
2. 代码实现以下是使用C语言实现起泡法排序算法的代码：```cvoid bubbleSort(int arr[], int n){int i, j;for(i = 0; i < n-1; i++){for(j = 0; j < n-i-1; j++){if(arr[j] > arr[j+1]){int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```该函数接受一个整数数组和数组长度作为参数，并将数组按升序排序。
它使用两个嵌套的循环来比较相邻的元素，并在必要时交换它们。
3. 时间复杂度起泡法排序算法的时间复杂度为O(n^2)，其中n是数组中元素的数量。
这是因为该算法需要进行n-1趟排序，每趟排序需要比较n-i-1对相邻元素，并在必要时交换它们。
4. 稳定性起泡法排序算法是一种稳定的排序算法。
这意味着如果数组中有两个相等的元素，它们在排序后仍然保持原来的顺序。
5. 优化虽然起泡法排序算法是一种简单而有效的算法，但它也有一些缺点。
其中最明显的缺点是它的时间复杂度较高，当数组规模很大时，效率会非常低下。
为了提高效率，可以对起泡法排序算法进行一些优化。
以下是几种常见的优化方法：（1）加入标志位：如果某一趟扫描没有发生任何交换，则说明数组已经排好序了，可以直接退出循环。
（2）记录最后一次交换位置：由于每一趟扫描都会将当前未排好序部分中最大（或最小）值移到末尾（或开头），因此可以记录最后一次交换位置，以此来确定下一趟扫描的范围。
C语言基本算法
C语言基本算法C语言是一种广泛使用的编程语言，用于开发各种应用程序和系统。
算法是编程的核心部分，是解决问题的方法和步骤的描述。
在C语言中，有许多基本算法可以用来解决简单级别的问题。
下面我将介绍几种常见的C语言基本算法。
1.线性查找算法线性查找算法是一种简单的查找算法，它从数组的第一个元素开始顺序地比较，直到找到目标元素或遍历完整个数组。
这个算法的时间复杂度是O(n)。
```cint linearSearch(int arr[], int n, int target)for (int i = 0; i < n; i++)if (arr[i] == target)return i;}}return -1;```这个算法接受一个整数数组arr、数组的大小n和目标元素target 作为输入，并返回目标元素在数组中的索引，如果未找到则返回-12.冒泡排序算法冒泡排序是一种简单的排序算法，它通过多次循环比较和交换相邻元素来排序。
每次循环都将最大的元素冒泡到数组的末尾。
这个算法的时间复杂度是O(n^2)。
```cvoid bubbleSort(int arr[], int n)for (int i = 0; i < n-1; i++)for (int j = 0; j < n-i-1; j++)if (arr[j] > arr[j+1])int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}```这个算法接受一个整数数组arr和数组的大小n作为输入，并将数组按升序排序。
3.二分查找算法二分查找算法是一种高效的查找算法，它使用分治策略将有序数组分为两部分，并选择中间元素进行比较。
如果中间元素等于目标元素，则返回中间元素的索引；否则，如果中间元素大于目标元素，则在左侧部分继续查找；如果中间元素小于目标元素，则在右侧部分继续查找。
这个算法的时间复杂度是O(logn)。
C语言常用简单算法
C语言常用简单算法C语言是一门功能强大的编程语言，其算法也是很多的。
下面是一些常用的简单算法：1.二分查找算法：二分查找是一种在有序数组中查找特定元素的算法。
它的基本思想是首先在数组的中间位置找到待查找的元素，如果该元素等于目标值，则查找成功；如果该元素大于目标值，说明目标值在数组的前半部分，则在前半部分继续进行查找；如果该元素小于目标值，则说明目标值在数组的后半部分，则在后半部分继续进行查找。
重复以上步骤，直到找到目标值或者确定目标值不存在。
2.冒泡排序算法：冒泡排序是一种简单直观的排序算法。
它的基本思想是通过反复交换相邻的两个元素，将较大的元素逐渐往后移动，从而实现排序的目的。
具体实现时，每一轮比较都会使最大的元素移动到最后。
3.插入排序算法：插入排序是一种简单直观的排序算法。
它的基本思想是将数组分成已排序部分和未排序部分，每次从未排序部分取出一个元素，然后将该元素插入到已排序部分的合适位置，从而实现排序的目的。
4.选择排序算法：选择排序是一种简单直观的排序算法。
它的基本思想是每次选择一个最小（或最大）的元素放到已排序部分的末尾，从而实现排序的目的。
具体实现时，每一轮选择都通过比较找出未排序部分的最小（或最大）元素。
5.快速排序算法：快速排序是一种高效的排序算法。
它的基本思想是通过选取一个基准元素，将数组分成两个子数组，一个子数组中的元素都小于基准元素，另一个子数组中的元素都大于基准元素，然后对这两个子数组分别进行快速排序，最终实现排序的目的。
6.斐波那契数列算法：斐波那契数列是一列数字，其中每个数字都是前两个数字之和。
常见的斐波那契数列算法有递归算法和迭代算法。
递归算法通过反复调用自身来计算斐波那契数列的值，而迭代算法则通过循环来计算。
7.求最大公约数算法：求两个数的最大公约数是一种常见的问题。
常见的求最大公约数的算法有欧几里得算法和辗转相除法。
欧几里得算法通过不断用较小数除以较大数的余数，直到余数为0，得到最大公约数。
数据结构(C语言版)实验报告 (内部排序算法比较)
《数据结构与算法》实验报告一、需求分析问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
基本要求：（l）对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
（2）待排序表的表长不小于100000；其中的数据要用伪随机数程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。
（3）最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。
数据测试：二．概要设计1.程序所需的抽象数据类型的定义：typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData { int num; //存放关键字}Data; typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE]; //用数组存放所有的随机数} LinkList int RandArray[MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum() //随机生成函数void InitLinkList(LinkList* L) //初始化链表BOOL LT(int i, int j,int* CmpNum) //比较i和j 的大小void Display(LinkList* L) //显示输出函数void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) //希尔排序void QuickSort (LinkList* L, int* CmpNum, int* ChgNum) //快速排序void HeapSort (LinkList* L, int* CmpNum, int* ChgNum) //堆排序void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) //冒泡排序void SelSort(LinkList* L, int* CmpNum, int* ChgNum) //选择排序void Compare(LinkList* L,int* CmpNum, int* ChgNum) //比较所有排序2 .各程序模块之间的层次（调用）关系：二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num; //定义关键字类型}Data; //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length; //定义表长Data Record[MAXSIZE]; //表长记录最大值}LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE]; //定义随机数组类型及最大值/******************随机生成函数********************/void RandomNum(){int i; srand((int)time(NULL)); //用伪随机数程序产生伪随机数for(i=0; i小于MAXSIZE; i++) RandArray[i]<=(int)rand(); 返回;}/*****************初始化链表**********************/void InitLinkList(LinkList* L) //初始化链表{int i;memset(L,0,sizeof(LinkList));RandomNum();for(i=0; i小于<MAXSIZE; i++)L->Record[i].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
C语言常用的入门算法
C语言常用的入门算法C语言是一种广泛应用的编程语言，主要用于开发系统软件和应用程序。
对于初学者来说，了解一些常用的入门算法可以帮助他们掌握基本的编程技巧和思维方式。
以下是C语言常用的入门算法。
1.顺序结构：按照顺序执行代码。
这是C语言中最基础的算法结构。
例如，计算两个数的和：先输入两个数，然后将它们相加。
2. 分支结构：根据条件选择执行不同的代码块。
这是通过if-else语句实现的。
例如，判断一个数是奇数还是偶数：如果数除以2的余数为0，则为偶数，否则为奇数。
3. 循环结构：重复执行一段代码，直到满足一些条件。
这是通过for、while或do-while语句实现的。
例如，打印1到10的所有整数：使用for循环从1到10循环遍历，并打印每个数。
4.数组：一组相同类型的数据的集合。
可以使用循环结构对数组进行遍历和操作。
例如，计算一个数组的总和：使用循环遍历数组的每个元素，并将它们相加。
5.字符串操作：处理文本的一系列算法。
C语言中字符串是以字符数组的形式存储和操作的。
例如，计算字符串的长度：使用循环遍历字符串，直到找到字符串的结束符'\0'。
6.排序算法：将一组数据按照一定的顺序排列的算法。
常用的排序算法有冒泡排序、插入排序和快速排序等。
例如，使用冒泡排序对一组数进行排序：比较相邻的两个数，如果它们的顺序不正确，则交换位置。
7.查找算法：在一组数据中查找一些特定值的算法。
常用的查找算法有线性查找和二分查找等。
例如，使用线性查找在数组中查找一个数：遍历数组，逐个比较每个元素，直到找到目标数或遍历结束。
8.递归：一个函数调用自身的过程，可以用来解决一些重复性的问题。
例如，计算阶乘：使用递归调用函数自身，直到达到基本情况并返回结果。
10.文件操作：C语言中可以使用文件操作来读写文件。
例如，读取文件中的内容并打印：打开文件，逐行读取文件内容，然后打印。
这些算法只是C语言中的一小部分，但对于初学者来说足够入门，并可以帮助他们培养基本的编程思维和解决问题的能力。
快速排序（C语言）-解析
快速排序（C语⾔）-解析快速排序快速排序是⼀种排序算法，对包含 n 个数的输⼊数组，最坏情况运⾏时间为O（n2）。
虽然这个最坏情况运⾏时间⽐较差，但快速排序通常是⽤于排序的最佳的实⽤选择，这是因为其平均性能相当好：期望的运⾏时间为O（nlgn），且O（nlgn）记号中隐含的常数因⼦很⼩。
另外，它还能够进⾏就地排序，在虚存环境中也能很好的⼯作。
快速排序（Quicksort）是对的⼀种改进。
快速排序由C. A. R. Hoare在1962年提出。
它的基本思想是：通过⼀趟排序将要排序的数据分割成独⽴的两部分，其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩，然后再按此⽅法对这两部分数据分别进⾏快速排序，整个排序过程可以进⾏，以此达到整个数据变成有序。
像合并排序⼀样，快速排序也是采⽤分治模式的。
下⾯是对⼀个典型数组A[p……r]排序的分治过程的三个步骤：分解：数组 A[p……r]被划分为两个（可能空）⼦数组 A[p……q-1] 和 A[q+1……r] ，使得 A[p……q-1] 中的每个元素都⼩于等于 A(q) , ⽽且，⼩于等于 A[q+1……r] 中的元素。
⼩标q也在这个划分过程中进⾏计算。
解决：通过递归调⽤快速排序，对于数组 A[p……q-1] 和 A[q+1……r] 排序。
合并：因为两个⼦数组是就地排序的，将它们的合并不需要操作：整个数组 A[p……r] 已排序。
下⾯的过程实现快速排序(伪代码)：QUICK SORT（A，p，r）1if p<r2 then q<-PARTITION(A,p,r)3 QUICKSORT(A,p,q-1)4 QUICKSORT(A,q+1,r)为排序⼀个完整的数组A，最初的调⽤是QUICKSORT（A，1，length[A]）。
数组划分： 快速排序算法的关键是PARTITION过程，它对⼦数组 A[p……r]进⾏就地重排(伪代码)：PARTITION（A，p，r）1 x <- A[r]2 i <- p-13for j <- p to r-14do if A[j]<=x5 then i <- i+16 exchange A[i] <-> A[j]7 exchange A[i + 1] <-> A[j]8return i+1排序演⽰⽰例假设⽤户输⼊了如下数组：下标012345数据627389创建变量i=0（指向第⼀个数据）, j=5(指向最后⼀个数据), k=6(为第⼀个数据的值)。
动画演示C语言冒泡排序算法精品PPT课件(绝对精品)
第五趟比较
第五趟比较结束找到第五大数5，两两比较1次。
提出问题 填流程图
5 >2
67 89
点击开始
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
算法思想 动画演示 提出问题 填流程图
结论
6个数据排序，需要比较5趟，每趟比 较的次数分别是5、4、3、2、1次。
那么N个数据排序，又该比较几趟，每 趟比较几次呢？
点击开始
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
算法思想 动画演示
第二趟比较
第二趟比较结束找到第二大数8，两两比较4次。
提出问题 填流程图
5 <7 >6 <8 >2 9
点击开始
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
算法思想 动画演示
第三趟比较
第三趟比较结束找到第三大数7，两两比较3次。
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
算法思想 动画演示 提出问题 填流程图
初始数据
587692
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
ห้องสมุดไป่ตู้
算法思想 动画演示
第一趟比较
第一趟比较结束找到最大数9，两两比较5次。
< > > < > 提出问题
填流程图
5 8 78 6 9 2
提出问题 填流程图
5 <6 <7 >2
89
点击开始
语言程序设计——排序算法
情景导入 冒泡排序 编写程序 调试程序
算法思想 动画演示
C语言快速排序算法
C语言快速排序算法用快速排序法对一组数据由小到大进行排序，数据分别为99、45、12、36、69、22、62、796、4、696。
实现过程：(1)自定义一个函数qusort()，实现快速排序。
(2) main() 函数为程序的入口函数。
程序代码如下：1.#include<stdio.h>2.int qusort(int s[],int start,int end)//自定义函数 qusort()3.{4.int i,j;//定义变量为基本整型5. i=start;//将每组首个元素赋给i6. j = end;//将每组末尾元素赋给j7. s[0]=s[start];//设置基准值8.while(i<j)9.{10.while(i<j&&s[0]<s[j])11. j--;//位置左移12.if(i<j)13.{14. s[i]=s[j];//将s[j]放到s[i]的位置上15. i++;//位置右移16.}17.while(i<j&&s[i]<=s[0])18. i++;//位置左移19.if(i<j)20.{21. s[j]=s[i];//将大于基准值的s[j]放到s[i]位置22. j--;//位置左移23.}24.}25. s[i]=s[0];//将基准值放入指定位置26.if(start<i)27.qusort(s,start,j-1);//对分割出的部分递归调用qusort()函数28.if(i<end)29.qusort(s,j+1,end);30.return0;31.}32.33.int main()34.{35.int a[11], i;//定义数组及变量为基本整型36.printf("请输入10个数：\n");37.for(i=1;i<=10;i++)38.scanf("%d",&a[i]);//从键盘中输入10个要进行排序的数39.qusort(a,1,10);//调用qusort()函数进行排序40.printf("排序后的顺序是：\n");41.for(i=1;i<=10;i++)42.printf("%5d",a[i]);//输出排好序的数组43.printf("\n");44.return0;45.}运行结果：。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
/**< 气泡排序，快速排序，插入排序，希尔排序， 选择排序，堆排序 ，归并排序，基数排序*/ #include #include
#define Max 100000000 using namespace std;
template class SortR { public: SortR() { arr = new T[Max]; } ~SortR(){ delete[]arr; } void InputValue(); void BubbleSort(); //冒泡排序 void QuickSort(); //快速排序 void InsertSort(); //插入排序 void HillSort(); //希尔排序 void SelectSort(); //选择排序 void HeapSort(); //堆排序 void MergeSort(); //归并排序 void BaseSort(); //基数排序 void Display(T*); //输出排序结果 private: void Swap(T*, T*)const;
int findPivot(int, int, T*)const; int Partition(int, int, T, T*)const; void QuickSortRev(int, int, T*); //快排递归
void PushDown(int, int,T*)const; //堆排序，整理堆 void Merge_array(T*,int,int,int,T*); //合并两个数组 void merge_sort(T*, int, int, T*); //归并排序，递归实现
T GetDigit(T x, int d); void msdradix_sort(T*,int,int,int); T *arr; int n; };
template void SortR::InputValue() { cout <<"输入数组大小："; //cin >> n; n = 10000; cout <<"输入数组元素："; srand((T)time(NULL)); for (int i = 0; i < n; i++) //cin >> arr[i]; arr[i] = rand() %100000; }
template void SortR::Swap(T*t1, T*t2)const //交换 { T temp; temp = *t1; *t1 = *t2; *t2 = temp; }
/**< --------冒泡排序------- */ template void SortR::BubbleSort() { //---时间测试 clock_t start, finish; double totaltime; start = clock(); //---------------------------------------------------- T *bubble_arr = new T[n]; for (int i = 0; i < n; i++) bubble_arr[i] = arr[i];
for (int i = 0; i{ for (int j = n - 1; j>i; j--) { if (bubble_arr[j]Swap(&bubble_arr[j], &bubble_arr[j - 1]); } }
finish = clock(); totaltime = (double)(finish - start) / CLOCKS_PER_SEC; cout <<"运行时间："<< totaltime <<"秒"<< endl;
//Display(bubble_arr); //Display(arr);
} /**< -------快速排序-------- */ template int SortR::findPivot(int i, int j, T*quick_arr)const { T firstkey; int k; firstkey = quick_arr[i]; for (k = i + 1; k <= j; k++) { if (quick_arr[k]>firstkey) return k; else if (quick_arr[k]else return -1; //没有不同关键字 } return 0; }
template int SortR::Partition(int i, int j, T piovt, T *quick_arr)const { int l = i, r = j; do{ Swap(&quick_arr[l], &quick_arr[r]); while (quick_arr[l]while (quick_arr[r] >= piovt) r--; } while (l <= r); return l; }
template void SortR::QuickSortRev(int i, int j, T *quick_arr) { T piovt; int piovtindex; int k; piovtindex = findPivot(i, j, quick_arr); if (piovtindex >= 0) { piovt = quick_arr[piovtindex]; k = Partition(i, j, piovt, quick_arr); //Display(quick_arr); //输出 return; QuickSortRev(i, k - 1, quick_arr); QuickSortRev(k, j, quick_arr); } }
template void SortR::QuickSort() { //---时间测试 clock_t start, finish; double totaltime; start = clock();
T *quick_arr = new T[n]; for (int i = 0; i < n; i++) quick_arr[i] = arr[i];
QuickSortRev(0, n - 1, quick_arr); //----------- finish = clock(); totaltime = (double)(finish - start) / CLOCKS_PER_SEC; cout <<"运行时间："<< totaltime <<"秒"<< endl; //Display(arr); } /*------插入排序------*/ template void SortR::InsertSort() //插入排序 { //---时间测试 clock_t start, finish; double totaltime; start = clock();
T *insert_arr = new T[n]; for (int i = 0; i < n; i++) insert_arr[i+1] = arr[i]; insert_arr[0] = -1; for (int i = 1; i{ int j = i; while (insert_arr[j]{ Swap(&insert_arr[j], &insert_arr[j - 1]); j--; } } //----------- finish = clock(); totaltime = (double)(finish - start) / CLOCKS_PER_SEC; cout <<"运行时间："<< totaltime <<"秒"<< endl;
//for (int i = 1; i <= 20; i++) // cout << insert_arr[i] <<""; //cout << endl; //Display(arr);
} /*-------希尔排序-----------*/ template void SortR::HillSort() {
//---时间测试 clock_t start, finish; double totaltime; start = clock();
T *hill_arr = new T[n]; for (int i = 0; ihill_arr[i] = arr[i];
int j, gap; for (gap = n / 2; gap > 0;gap/=2) for (j = gap; j < n; j++) { if (hill_arr[j] < hill_arr[j - gap]) {