c++排序算法
C程序经典算法50例

C程序经典算法50例1.二分查找算法:在有序数组中查找指定元素。
2.冒泡排序算法:通过不断比较相邻元素并交换位置,将较大的元素向后冒泡。
3.快速排序算法:通过选择一个基准元素,将数组分割为左右两部分,并递归地对两部分进行快速排序。
4.插入排序算法:将数组划分为已排序和未排序两部分,每次从未排序中选择一个元素插入到已排序的合适位置。
5.选择排序算法:遍历数组,每次选择最小元素并放置在已排序部分的末尾。
6.希尔排序算法:将数组按照一定间隔进行分组并分别进行插入排序,然后逐步减小间隔并重复这个过程。
7.归并排序算法:将数组递归地划分为两部分,然后将两个有序的部分进行合并。
8.桶排序算法:将元素根据特定的映射函数映射到不同的桶中,然后对每个桶分别进行排序。
9.计数排序算法:统计每个元素的出现次数,然后根据计数进行排序。
10.基数排序算法:从低位到高位依次对元素进行排序。
11.斐波那契数列算法:计算斐波那契数列的第n项。
12.阶乘算法:计算给定数字的阶乘。
13.排列问题算法:生成给定数组的全排列。
14.组合问题算法:生成给定数组的所有组合。
15.最大连续子序列和算法:找出给定数组中和最大的连续子序列。
16.最长递增子序列算法:找出给定数组中的最长递增子序列。
17.最长公共子序列算法:找出两个给定字符串的最长公共子序列。
18.最短路径算法:计算给定有向图的最短路径。
19.最小生成树算法:构建给定连通图的最小生成树。
20.汉诺塔算法:将n个圆盘从一个柱子移动到另一个柱子的问题。
21.BFS算法:广度优先算法,用于图的遍历和查找最短路径。
22.DFS算法:深度优先算法,用于图的遍历和查找连通分量。
23.KMP算法:字符串匹配算法,用于查找一个字符串是否在另一个字符串中出现。
24.贪心算法:每次都选择当前情况下最优的方案,适用于求解一些最优化问题。
25.动态规划算法:将一个大问题划分为多个子问题,并通过子问题的解求解整个问题,适用于求解一些最优化问题。
C语言经典算法大全

C语言经典算法大全1.冒泡排序算法冒泡排序是一种简单但低效的排序算法,它通过多次遍历列表,比较相邻元素并交换位置,直到整个列表有序。
冒泡排序的时间复杂度为O(n^2)。
```void 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;}}}```2.选择排序算法选择排序是一种简单但高效的排序算法,它通过多次遍历列表,找到最小元素并将其放置在正确的位置上。
选择排序的时间复杂度也为O(n^2)。
```void selectionSort(int arr[], int n)int minIndex, temp;for (int i = 0; i < n-1; i++)minIndex = i;for (int j = i+1; j < n; j++)if (arr[j] < arr[minIndex])minIndex = j;}}//交换元素temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}```3.插入排序算法插入排序是一种简单但高效的排序算法,它通过将未排序的元素插入到已排序的列表中,逐步构建排序好的列表。
插入排序的时间复杂度为O(n^2)。
```void insertionSort(int arr[], int n)int i, key, j;for (i = 1; i < n; i++)key = arr[i];j=i-1;while (j >= 0 && arr[j] > key)arr[j + 1] = arr[j];j=j-1;}arr[j + 1] = key;}```4.快速排序算法快速排序是一种高效的排序算法,它通过选择一个主元,将列表分割为两个子列表,其中一个子列表的所有元素都小于主元,另一个子列表的所有元素都大于主元。
C语言--常见排序算法

49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例:
1.1.5 选择排序
49 2
08 0
25 1 i
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
算法实现:
08 5 temp
16 21 25 25* 49 08 0 1 2 3 4 5
算法实现:
1.1.3 直接插入排序
void InsertSort (int r[ ], int n ) { // 假设关键字为整型,放在向量r[]中 int i, j, temp; for (i = 1;i< n;i++ ) { temp = r[i]; for(j = i;j>0;j- -) {//从后向前顺序比较,并依次后移 if ( temp < r[j-1] ) r[j] = r[j-1]; else break; } r[j] = temp; } }
输入n 个数给a[1] 到 a[n]
for j=1 to n-1
for i=1 to n-j
真 a[i]>a[i+1]
a[i]a[i+1]
输出a[1] 到 a[n]
main() { int a[11],i,j,t; printf("Input 10 numbers:\n"); for(i=1;i<11;i++) scanf("%d",&a[i]); printf("\n"); 假 for(j=1;j<=9;j++) for(i=1;i<=10-j;i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1]; a[i+1]=t;} printf("The sorted numbers:\n"); for(i=1;i<11;i++) printf("%d ",a[i]); }
C语言常用算法总结

C语言常用算法总结1、冒泡排序算法:冒泡排序是一种简单的排序算法,它重复地遍历要排序的序列,一次比较两个相邻的元素如果他们的顺序错误就把他们交换过来。
时间复杂度为O(n^2)。
2、快速排序算法:快速排序是一种基于分治的排序算法,通过递归的方式将数组划分为两个子数组,然后对子数组进行排序最后将排好序的子数组合并起来。
时间复杂度为O(nlogn)。
3、插入排序算法:插入排序是一种简单直观的排序算法,通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描找到相应位置并插入。
时间复杂度为O(n^2)。
4、选择排序算法:选择排序是一种简单的排序算法,每次循环选择未排序部分的最小元素,并放置在已排序部分的末尾。
时间复杂度为O(n^2)。
5、归并排序算法:归并排序是一种稳定的排序算法,基于分治思想,将数组递归地分为两个子数组,将子数组排序后再进行合并最终得到有序的数组。
时间复杂度为O(nlogn)。
6、堆排序算法:堆排序是一种基于完全二叉堆的排序算法,通过构建最大堆或最小堆,然后依次将堆顶元素与末尾元素交换再调整堆,得到有序的数组。
时间复杂度为O(nlogn)。
7、二分查找算法:二分查找是一种在有序数组中查找目标元素的算法,每次将待查找范围缩小一半,直到找到目标元素或范围为空。
时间复杂度为O(logn)。
8、KMP算法:KMP算法是一种字符串匹配算法,通过利用模式字符串的自重复性,避免不必要的比较提高匹配效率。
时间复杂度为O(m+n),其中m为文本串长度,n为模式串长度。
9、动态规划算法:动态规划是一种通过将问题分解为子问题,并通过组合子问题的解来求解原问题的方法。
动态规划算法通常使用内存空间来存储中间结果,从而避免重复计算。
时间复杂度取决于问题规模。
10、贪心算法:贪心算法是一种通过选择局部最优解来构建全局最优解的算法并以此构建最终解。
时间复杂度取决于问题规模。
11、最短路径算法:最短路径算法用于求解图中两个节点之间的最短路径,常见的算法包括Dijkstra算法和Floyd-Warshall算法。
C语言八大排序算法

C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法,附动图和详细代码解释!来源:C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式,那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码,不通过不断的锤炼,是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分,系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作,其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序。
反之,若参加排序的记录数量很⼤,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类,⼤致可分为:交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰:3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序:简单选择排序,快速排序,希尔排序,堆排序稳定排序:冒泡排序,直接插⼊排序,归并排序,奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序,然后将第3个元素插⼊到已经排好序的元素中,依次类推(插⼊排序最好的情况就是数组已经有序了)因为插⼊排序每次只能操作⼀个元素,效率低。
元素个数N,取奇数k=N/2,将下标差值为k的数分为⼀组(⼀组元素个数看总元素个数决定),在组内构成有序序列,再取k=k/2,将下标差值为k的数分为⼀组,构成有序序列,直到k=1,然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换,再在剩余的数中⼜选择最⼩的和第⼆个数交换,依次类推4、堆排序以升序排序为例,利⽤⼩根堆的性质(堆顶元素最⼩)不断输出最⼩元素,直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶,再重新构造成⼩根堆,再输出堆顶元素,以此类推5、冒泡排序改进1:如果某次冒泡不存在数据交换,则说明已经排序好了,可以直接退出排序改进2:头尾进⾏冒泡,每次把最⼤的沉底,最⼩的浮上去,两边往中间靠16、快速排序选择⼀个基准元素,⽐基准元素⼩的放基准元素的前⾯,⽐基准元素⼤的放基准元素的后⾯,这种动作叫分区,每次分区都把⼀个数列分成了两部分,每次分区都使得⼀个数字有序,然后将基准元素前⾯部分和后⾯部分继续分区,⼀直分区直到分区的区间中只有⼀个元素的时候,⼀个元素的序列肯定是有序的嘛,所以最后⼀个升序的序列就完成啦。
简单算法c语言

简单算法c语言
C语言中的算法是程序设计的基础,也是我们在编写程序时必须掌握
的技能之一。
简单算法是指那些基本的、常用的、易于理解和实现的
算法,如排序、查找、递归等。
一、排序算法
1.冒泡排序
冒泡排序是一种简单的排序算法,其思想是将相邻两个元素比较大小,如果前面比后面大,则交换位置,直到整个序列有序为止。
2.选择排序
选择排序是一种简单直观的排序算法,其思想是从未排序序列中找到
最小元素,放到已排好序列的末尾。
3.插入排序
插入排序是一种简单直观的排序算法,其思想是将未排好序列中每一
个元素插入到已排好序列中正确位置上。
二、查找算法
1.线性查找
线性查找又称顺序查找,其思想是从头到尾遍历整个数组或列表,逐个比较每一个元素是否与目标相同。
2.二分查找
二分查找又称折半查找,其思想是先将数组或列表按照大小顺序排好序,然后通过不断地折半缩小范围来寻找目标元素。
三、递归算法
递归算法是指在程序中调用自身的一种算法,其思想是将问题分解成更小的子问题,并不断地递归调用自身来解决这些子问题。
例如,计算阶乘可以使用递归算法来实现:
int factorial(int n)
{
if(n == 0 || n == 1)
return 1;
else
return n * factorial(n-1);
}
以上就是C语言中的简单算法,虽然它们看起来很简单,但是它们在实际编程中却有很大的作用。
掌握这些基本的、常用的、易于理解和实现的算法,可以提高我们编写程序的效率和质量。
C语言常用算法大全

C语言常用算法大全1.排序算法-冒泡排序:依次比较相邻的两个元素,如果顺序不对则交换,每轮找出一个最大或最小的元素-选择排序:从未排序的元素中选择最小或最大的放到已排序的最后,以此类推-插入排序:将未排序的元素插入到已排序的合适位置,从后向前进行比较和交换-快速排序:选择一个基准元素,将小于基准元素的放在左边,大于基准元素的放在右边,然后对左右两边递归地进行快速排序-归并排序:将待排序的序列不断划分为左右两部分,分别排序后再将排序好的左右两部分按顺序合并-堆排序:构建大顶堆,将堆顶元素与末尾元素交换,然后重新调整堆,重复这个过程直到排序完成2.查找算法-顺序查找:从给定的元素序列中逐个比较,直到找到目标元素或遍历完整个序列-二分查找:对于有序序列,在序列的中间位置比较目标元素和中间元素的大小关系,通过每次缩小一半的范围来查找目标元素-插值查找:根据目标元素与有序序列的最小值和最大值的比例推测目标元素所在的位置,然后递归地进行查找-斐波那契查找:根据斐波那契数列的性质来确定目标元素所在的位置,然后递归地进行查找3.图算法-深度优先(DFS):从图的一些顶点出发,依次访问其未被访问过的邻接顶点,直到所有顶点都被访问过为止-广度优先(BFS):从图的一些顶点出发,逐层遍历图的顶点,直到所有顶点都被访问过为止- 最小生成树算法:Prim算法和Kruskal算法,用于找到连接图中所有顶点的最小权值边,构成一棵包含所有顶点的生成树- 最短路径算法:Dijkstra算法和Floyd-Warshall算法,用于找到图中两个顶点之间的最短路径-拓扑排序:用于有向无环图(DAG)中的顶点排序,确保排序后的顶点满足所有依赖关系-关键路径算法:找出网络中的关键路径,即使整个工程完成的最短时间4.字符串算法- KMP算法:通过预处理模式串构建next数组,利用next数组在匹配过程中跳过一部分不可能匹配的子串- Boyer-Moore算法:从模式串的末尾开始匹配,利用坏字符和好后缀规则进行跳跃匹配- Rabin-Karp算法:利用哈希函数对主串和匹配串的子串进行哈希计算,然后比较哈希值是否相等- 字符串匹配算法:BM算法、Shift-And算法、Sunday算法等,用于寻找模式串在主串中的出现位置5.动态规划算法-最长公共子序列(LCS):用于寻找两个序列中最长的公共子序列-最长递增子序列(LIS):用于寻找给定序列中最长的递增子序列-0-1背包问题:将有限的物品放入容量为C的背包中,使得物品的总价值最大-最大子数组和:用于求解给定数组中连续子数组的最大和-最大正方形:在给定的0-1矩阵中,找出只包含1的最大正方形的边长这些算法是在C语言中常用的算法,它们涵盖了排序、查找、图、字符串和动态规划等多个领域。
c语言几种数组排序方法

常用的c语言排序算法主要有三种即冒泡法排序、选择法排序、插入法排序。
一、冒泡排序冒泡排序:是从第一个数开始,依次往后比较,在满足判断条件下进行交换。
代码实现(以降序排序为例)#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp;for (int i = 0; i < 10; i++){//循环次数for (int j = 0; j <10 - i-1; j++){if (array[j] < array[j+1]){//前面一个数比后面的数大时发生交换temp = array[j];array[j] = array[j+1];array[j + 1] = temp;}}} //打印数组for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}二、选择排序以升序排序为例:就是在指定下标的数组元素往后(指定下标的元素往往是从第一个元素开始,然后依次往后),找出除指定下标元素外的值与指定元素进行对比,满足条件就进行交换。
与冒泡排序的区别可以理解为冒泡排序是相邻的两个值对比,而选择排序是遍历数组,找出数组元素与指定的数组元素进行对比。
(以升序为例)#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp, index;for (int i = 0; i < 9; i++) {index = i;for (int j = i; j < 10; j++){if (array[j] < array[index])index = j;}if(i != index){temp = array[i]; array[i] = array[index]; array[index] = temp; }for(int i=0;i<10:i++) printf("%2d"array[i])return 0;}三、快速排序是通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
C语言常用的入门算法

C语言常用的入门算法C语言是一门广泛应用于计算机科学和软件开发领域的编程语言。
作为一门通用的编程语言,C语言提供了丰富的算法和数据结构库,使得开发人员能够解决各种不同类型的问题。
下面是C语言入门算法的一些常见示例:1.排序算法:-冒泡排序:通过不断比较相邻的元素,并交换它们的位置来排序。
-插入排序:将未排序的元素逐一插入已排序的列表中。
-选择排序:通过重复找到最小的元素并将其放置在已排序序列的末尾来排序。
-快速排序:通过选择一个基准元素,将列表划分成较小和较大的两部分,然后对其进行递归排序。
-归并排序:将列表分成较小的子列表,然后逐个合并这些子列表。
2.查找算法:-顺序查找:逐个比较列表中的元素,直到找到匹配的元素为止。
-二分查找:在已排序的列表中通过递归或循环的方式,将待查找的元素与中间元素进行比较,以确定它可能在哪一半中。
-哈希表:通过散列函数将元素映射到一个较小的固定大小的数组(哈希表)中,并通过索引快速查找。
3.字符串算法:-字符串长度:使用循环逐个字符遍历,直到遇到字符串结束符'\0'为止,统计字符个数。
-字符串比较:逐个字符比较两个字符串的对应位置,直到遇到不相等的字符或字符串结束符。
-字符串拼接:将一个字符串的字符逐个复制到另一个字符串的末尾,直到遇到字符串结束符'\0'。
-子字符串匹配:在一个较长的字符串中查找一个较短的子字符串,常用的算法有朴素算法和KMP算法。
4.数值算法和运算:-求和、平均值、最大/最小值:循环遍历列表,累加求和,计算平均值,找出最大/最小值。
-阶乘和斐波那契数列:使用循环或递归计算给定数字的阶乘和斐波那契数列。
-幂运算和开方:通过循环或递归计算给定数字的幂和开方。
- 线性方程求解:求解形如ax + b = 0的一元线性方程。
5.图算法:-广度优先(BFS):通过遍历图的邻居节点来逐层扩展区域,通常用于查找最短路径。
-深度优先(DFS):通过遍历图的邻居节点来递归到达所有可能的节点,通常用于查找所有路径、拓扑排序等。
c语言选择排序算法

c语言选择排序算法摘要:一、选择排序算法简介1.选择排序算法的概念2.选择排序算法的原理二、选择排序算法的实现1.基本思想2.具体实现步骤3.代码展示三、选择排序算法的特点及应用场景1.特点2.应用场景四、选择排序算法的优缺点分析1.优点2.缺点五、总结正文:一、选择排序算法简介选择排序算法是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。
二、选择排序算法的实现1.基本思想选择排序算法的基本思想是在未排序序列中找到最小值,将其放到已排序序列的末尾。
以此类推,直到全部待排序的数据元素排完。
2.具体实现步骤(1)首先从第一个元素开始,找到未排序序列中最小的元素,存放在序列的起始位置。
(2)然后从第二个元素开始,在未排序序列中继续寻找最小元素,将其放到已排序序列的末尾。
(3)重复以上过程,直到全部待排序的数据元素排完。
3.代码展示```c#include <stdio.h>void selectionSort(int arr[], int n) {int i, j, minIndex;for (i = 0; i < n-1; i++) {minIndex = i;for (j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}if (minIndex != i) {int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}}}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr)/sizeof(arr[0]);selectionSort(arr, n);printf("Sorted array is:");for (int i=0; i < n; i++) {printf("%d ", arr[i]);}printf("");return 0;}```三、选择排序算法的特点及应用场景1.特点选择排序算法的特点是简单直观,易于理解。
C语言经典算法大全精选

C语言经典算法大全精选1.排序算法1.1冒泡排序:通过不断交换相邻元素的位置,将最大(最小)值“冒泡”到序列的末尾(开头)。
1.2插入排序:将未排序的元素逐个插入已排序的序列中,保持序列始终有序。
1.3选择排序:每次从未排序的元素中选择最小(最大)的元素,放到已排序序列的末尾(开头)。
1.4快速排序:通过递归地将序列分割为较小和较大的两部分,然后分别对两部分进行排序。
1.5归并排序:将序列递归地分割为两个子序列,分别排序后再将结果合并。
1.6堆排序:构建最大(最小)堆,然后逐步将堆顶元素与最后一个元素交换,并调整堆结构。
2.查找算法2.1顺序查找:逐个比较元素,直到找到目标元素或遍历完整个序列。
2.2二分查找:在有序序列中,通过不断缩小查找范围,找到目标元素。
2.3插值查找:根据目标元素与序列中最大、最小元素的关系,按比例选择查找范围。
2.4哈希查找:利用哈希函数将目标元素映射到一个唯一的位置,从而快速定位目标元素。
3.字符串算法3.1字符串匹配算法:在文本串中查找给定的模式串,并返回匹配位置。
3.2字符串翻转:将一个字符串逆序输出。
3.3字符串压缩:将连续出现多次的字符压缩为一个字符,并输出压缩后的字符串。
3.4字符串拆分:按照指定的分隔符将字符串拆分为多个子串,并返回子串列表。
3.5字符串反转单词:将一个句子中的单词顺序逆序输出。
4.图算法4.1深度优先:从起始顶点出发,递归地访问所有能到达的未访问顶点。
4.2广度优先:从起始顶点出发,逐层地访问与当前层相邻的未访问顶点。
4.3最小生成树:找到连接所有顶点的具有最小权值的无环边集合。
4.4最短路径:找到两个顶点之间最短路径的权值和。
4.5拓扑排序:找到一个顶点的线性序列,满足所有有向边的起点在终点之前。
5.数学算法5.1质数判断:判断一个数是否为质数(只能被1和自身整除)。
5.2求最大公约数:找到两个数的最大公约数。
5.3求最小公倍数:找到两个数的最小公倍数。
C语言排序算法大全综合排序

C语言排序算法大全综合排序利用随机函数产生N个随机整数(20000以上),对这些数进行多种方法进行排序。
基本要求:(1) 至少采用三种方法实现上述问题求解(提示,可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序)。
并把排序后的结果保存在不同的文件中。
(2) 统计每一种排序方法的性能(以上机运行程序所花费的时间为准进行对比),找出其中两种较快的方法。
问题补充:要纯C语言版,不含C++语言/*================================================================相关知识介绍(所有定义只为帮助理解相关概念,并非严格定义):1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,我们就说这种排序方法是稳定的。
反之,就是非稳定的。
比如:一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后为a1,a2,a4,a3,a5,则我们说这种排序是稳定的,因为a2排序前在a4的前面,排序后它还是在a4的前面。
假如变成a1,a4,a2,a3,a5就不是稳定的了。
2、内排序和外排序在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序;在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度,是指执行算法所需要的计算工作量。
一个算法的空间复杂度,一般是指执行这个算法所需要的内存空间。
==================================================================*/ /*================================================================== 功能:选择排序输入:数组名称(也就是数组首地址)、数组中元素个数==================================================================*/ /*================================================================== 算法思想简单描述:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。
c语言各种排序法详解

一插入排序1.1 直接插入排序基本思想:每次将一个待排序额记录按其关键码的大小插入到一个已经排好序的有序序列中,直到全部记录排好序。
图解:代码实现:[cpp]view plaincopy1.//直接顺序排序2.void InsertSort(int r[],int n)3.{4.for(int i=2;i<n;i++)5.{6.r[0]=r[i];//设置哨兵7.for(int j=i-1;r[0]<r[j];j--)//寻找插入位置8.r[j+1]=r[j];//记录后移9.r[j+1]=r[0];10.}11.for(int k=1;k<n;k++)12.cout<<r[k]<<"";13.cout<<"\n";14.}1.2 希尔排序基本思想是:先将整个待排序记录序列分割成若干个子序列,在在序列内分别进行直接插入排序,待整个序列基本有序时,再对全体记录进行一次直接插入排序。
图解:代码实现:[cpp]view plaincopy1.<spanstyle="font-size:14px;">//希尔排序2.void ShellSort(int r[],int n)3.{4.int i;5.int d;6.int j;7.for(d=n/2;d>=1;d=d/2)//以增量为d进行直接插入排序8.{9.for(i=d+1;i<n;i++)10.{11.r[0]=r[i];//暂存被插入记录12.for(j=i-d;j>0&&r[0]<r[j];j=j-d)13.r[j+d]=r[j];//记录后移d个位置14.r[j+d]=r[0];15.}16.}17.for(i=1;i<n;i++)18.cout<<r[i]<<"";19.cout<<"\n";20.}</span>二交换排序2.1 起泡排序起泡排序是交换排序中最简单的排序方法,其基本思想是:两两比较相邻记录的关键码,如果反序则交换,直到没有反序的记录为止。
c语言常见排序算法

常见的C语言排序算法有以下几种:
1. 冒泡排序(Bubble Sort):比较相邻的元素,如果前一个元素大于后一个元素,则交换它们的位置,重复这个过程直到整个序列有序。
2. 插入排序(Insertion Sort):将未排序的元素逐个插入到已排序序列中的正确位置,直到整个序列有序。
3. 选择排序(Selection Sort):每次从未排序的元素中选择最小的元素,将其放到已排序序列的末尾,重复这个过程直到整个序列有序。
4. 快速排序(Quick Sort):选择一个基准元素,将序列分成两部分,一部分小于等于基准元素,一部分大于基准元素,然后对两部分递归地进行快速排序。
5. 归并排序(Merge Sort):将序列分成两部分,分别对两部分进行归并排序,然后将两个有序的子序列合并成一个有序的序列。
6. 堆排序(Heap Sort):将序列构建成一个最大堆,然后将堆顶元素与堆末尾元素交换,重复这个过程直到整个序列有序。
7. 希尔排序(Shell Sort):将序列按照一定的间隔分成若干个子序列,对每个子序列进行插入排序,然后逐渐减小间隔直到间隔为1,最后对整个序列进行插入排序。
8. 计数排序(Counting Sort):统计序列中每个元素出现的次数,然后按照元素的大小顺序将它们放入一个新的序列中。
9. 基数排序(Radix Sort):按照元素的个位、十位、百位等依次进行排序,直到所有位数都排完为止。
以上是常见的C语言排序算法,每种算法都有其特点和适用场景,选择合适的排序算法可以提高排序效率。
c语言常用算法

c语言常用算法一、前言C语言是一种高效、快速的编程语言,被广泛应用于各种领域。
在C 语言中,算法是非常重要的部分,因为它们能够帮助我们解决许多实际问题。
本文将介绍C语言中常用的算法。
二、排序算法1.冒泡排序冒泡排序是一种简单的排序算法,它通过不断交换相邻两个元素的位置来将最大的元素放到最后。
具体实现如下:```void bubble_sort(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];}}}}```2.选择排序选择排序也是一种简单的排序算法,它通过不断选择最小元素并放到前面来完成排序。
具体实现如下:```void selection_sort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {int min_index = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[min_index]) {min_index = j;}}int temp = arr[i];arr[i] = arr[min_index];}}```3.插入排序插入排序是一种简单的排序算法,它通过将元素逐个插入到已排好序的序列中来完成排序。
具体实现如下:```void insertion_sort(int arr[], int n) {for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}}```4.快速排序快速排序是一种高效的排序算法,它通过选取一个基准元素并将数组分为两部分来完成排序。
C语言常见排序算法.ppt

1.1.2 快速排序
算法实例:
始关键字
pivotkey 21 25 low
49 25* 16 08 high
一次交换
21
二次交换
三次交换
high-1 完成一趟排序
08 25 low
49 25* 16
high
08
49 25* 16 25
low
high
08 16 49 25*
25
low
08 16
low
常见排序算法
1.1 常见的排序算法
冒泡排序 快速排序 直接插入排序 希尔排序 选择排序 堆排序 归并排序
1.1.1 冒泡排序
算法描述
设待排序记录序列中的记录个数为n 一般地,第i趟起泡排序从1到n-i+1 依次比较相邻两个记录的关键字,如果发生逆序,则交换之 其结果是这n-i+1个记录中,关键字最大的记录被交换到第n-i+1的位 置上,最多作n-1趟。
08 16
21
high 25* 49 25
high 25* 49 25
low high
1.1.2 快速排序
算法实例:
完成一趟排序
08 16
21 25* 49 25
分别进行快速排序 有序序列
08 16
21 25* 25 49
08 16
21 25* 25 49
11
1.1.2 快速排序
算法分析:
快速排序是一个递归过程; 利用序列第一个记录作为基准,将整个序列划分为左右两个子序列。只要 是关键字小于基准记录关键字的记录都移到序列左侧; 快速排序的趟数取决于递归树的高度。 如果每次划分对一个记录定位后, 该记录的左侧子序列与右侧子序列的长 度相同, 则下一步将是对两个长度减半的子序列进行排序, 这是最理想的情 况
c语言排序的几种算法

c语言排序的几种算法c语言排序的几种算法用C语言总结一下常用排序算法,虽然大多数语言里已经提供了排序算法,比如C函数库中提供了qsort排序函数(内部为快速排序实现),但理解排序算法的思想的意义远远超过了实用的价值。
这里我总结了常用的排序算法,并用C语言实现。
这些算法的书写顺序也有一定的关联,比如希尔排序是对插入算法的改进,快速排序是对冒泡排序的改进,快速排序和归并排序都用递归实现。
c语言排序的几种算法注:每种方法的实现尽量提供了相同的形参列表。
这里并没用涉及堆排序,箱排序等算法的实现。
今天先讲2种排序方式。
以后持续跟上。
记得注意这几天的.排序算法。
插入排序算法概要:插入排序依据遍历到第N个元素的时候前面的N-1个元素已经是排序好的,那么就查找前面的N-1个元素把这第N个元素放在合适的位置,如此下去直到遍历完序列的元素为止。
Code:voidSort(intarray[],intlength){intkey;for(inti=1; i<length; i++){key = array[i];for(intj=i-1; j>=0 && array[j] > key; j--){array[j+1] = array[j];}array[j+1] = key;}}希尔排序算法概要:shell排序是对插入排序的一个改装,它每次排序排序根据一个增量获取一个序列,对这这个子序列进行插入排序,然后不断的缩小增量扩大子序列的元素数量,直到增量为1的时候子序列就和原先的待排列序列一样了,此时只需要做少量的比较和移动就可以完成对序列的排序了。
Code:voidshellSort(intarray[],intlength){intkey;intincrement;for(increment = length/2; increment>0; increment /= 2){for(inti=increment; i<length; i++){key = array[i];for(intj = i-increment; j>=0 && array[j] > key; j -= increment) {array[j+increment] = array[j];}array[j+increment]=key;}}}【c语言排序的几种算法】。
C语言经典算法C语言代码大全

C语言经典算法C语言代码大全一、排序算法1、冒泡排序它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
设数组为a[0…n-1]C语言实现如下://冒泡排序void bubbleSort(int arr[], int n)int i, j, temp;bool flag;//表示n次排序过程for(i = 0; i < n - 1; i++)//每次排序将最大的数放到最右边flag = false;for(j= 0; j< n-1-i; j++)if(arr[j] > arr[j+1])temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;flag = true;}}//如果趟排序没有进行数据交换,说明数据已经有序if (flag == false)break;}}2、快速排序它采用了分治法的思想,基于快速排序的思想,可以对数组进行非常快速的排序。
设数组为a[0…n-1]C语言实现如下://快速排序// arr[left] 为起始值,arr[right] 为末尾值void quickSort(int arr[], int left, int right)int i, j, base;if (left > right)return;}i = left;j = right;base = arr[left];//定义基准值,可以是数组的第一个值while (i != j)// 因为基准值是 arr[left],所以左边右移,直到找到小于基准值的值while (arr[j] >= base && i < j)j--;}// 因为基准值是 arr[left],所以右边左移while (arr[i] <= base && i < j)i++;}//如果i<j,表示找到了,交换位置if (i < j)int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}//将基准值放到i位置arr[left] = arr[i];。
c语言的排序方法

c语言的排序方法C语言的排序方法排序是计算机科学中常见的操作,它的作用是将一组数据按照特定的规则进行重新排列。
在C语言中,有多种排序方法可以实现这个目标。
本文将介绍几种常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
一、冒泡排序冒泡排序是一种简单但效率较低的排序算法。
它的基本思想是多次遍历待排序的数据,每次比较相邻的两个元素,如果它们的顺序不对就交换它们的位置。
通过多次遍历,最大(或最小)的元素会逐渐“冒泡”到最后。
二、插入排序插入排序是一种稳定且效率较高的排序算法。
它的基本思想是将待排序的数据分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的正确位置。
通过多次插入操作,最终得到完全有序的数据。
三、选择排序选择排序是一种简单但效率较低的排序算法。
它的基本思想是每次从待排序的数据中选择最小(或最大)的元素,然后放到已排序部分的末尾。
通过多次选择操作,最终得到完全有序的数据。
四、快速排序快速排序是一种常用且高效的排序算法。
它的基本思想是通过递归地将待排序的数据分为两部分,一部分小于某个基准值,另一部分大于该基准值。
然后对这两部分分别进行快速排序,直到每个部分只有一个元素或为空。
最后将所有部分合并起来,即得到完全有序的数据。
五、归并排序归并排序是一种稳定且效率较高的排序算法。
它的基本思想是将待排序的数据分成若干个长度相等(或接近)的子序列,然后对每个子序列进行排序。
最后将排好序的子序列两两合并,直到所有子序列合并成一个有序的序列。
不同的排序算法适用于不同的场景。
冒泡排序和选择排序适用于数据量较小的情况,插入排序适用于数据基本有序的情况,快速排序适用于数据量较大且无序的情况,归并排序适用于数据量较大且需要稳定排序的情况。
在C语言中,实现这些排序算法并不复杂。
通过使用循环和条件语句,可以很容易地编写出排序的代码。
同时,为了提高排序算法的效率,还可以使用一些优化技巧,例如设置哨兵、使用递归等。
c语言十大排序算法

c语言十大排序算法C语言是一种广泛应用于计算机领域的编程语言,在数据处理过程中,排序算法是最常用的操作之一。
在C语言中,有许多经典的排序算法,下面将介绍十大排序算法并讨论其特点和适用场景。
1.冒泡排序算法冒泡排序算法是一种简单的排序方法,其基本思想是将要排序的数组分为两部分:已排序部分和未排序部分。
进入排序过程后,每一次排序将未排序部分中的第一个数与第二个数进行比较,若第二个数小于第一个数,则交换它们的位置,依次往后,直到最后一个未排序的数。
冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1),适用于数据量较小的排序场景。
2.插入排序算法插入排序算法是一种稳定的排序方法,其中以第一个元素作为基准,与后面的元素进行比较,若后面的元素小于前一个元素,则将其插入到合适位置,依次往后,直到最后一个元素。
插入排序的时间复杂度为O(n^2),空间复杂度为O(1),适用于数据量较小的排序场景。
3.选择排序算法选择排序算法是一种简单的排序算法,其基本思想是每次选择一个最小(或最大)的元素,在未排序部分找出最小的元素,并放到已排序部分的最后一个位置。
选择排序的时间复杂度为O(n^2),空间复杂度为O(1),适用于数据量较小的排序场景。
4.归并排序算法归并排序算法是一种稳定的排序算法,其基本思想是将数组分成两半,然后递归地将每个子数组排序,最后将两个排好序的子数组归并到一起。
归并排序的时间复杂度为O(nlogn),空间复杂度为O(n),适用于数据量较大的排序场景。
5.快速排序算法快速排序算法是一种常用的排序算法,其基本思想是将待排序的数组分为两个子数组,设置一个基准值,小于基准值的元素放到左边,大于基准值的元素放到右边,然后递归地对左右两个子数组进行排序。
快速排序的时间复杂度为O(nlogn),空间复杂度为O(nlogn),适用于数据量较大的排序场景。
6.计数排序算法计数排序算法是一种稳定的排序算法,其基本思想是先统计序列中每个元素出现的次数,将其存入临时数组中,然后从临时数组中按照顺序取出元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
当n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序、堆排序或归并排序序。
快速排序:是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速排序的平均时间最短;1. 插入排序—直接插入排序(Straight Insertion Sort)基本思想:将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表。
即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。
要点:设立哨兵,作为临时存储和判断数组边界之用。
直接插入排序示例:如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面。
所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定的。
算法的实现:效率:时间复杂度:O(n^2).其他的插入排序有二分插入排序,2-路插入排序。
2. 插入排序—希尔排序(Shell`s Sort)希尔排序是1959 年由D.L.Shell 提出来的,相对直接排序有较大的改进。
希尔排序又叫缩小增量排序基本思想:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。
操作方法:1.选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;2.按增量序列个数k,对序列进行k 趟排序;3.每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。
仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
希尔排序的示例:算法实现:我们简单处理增量序列:增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数即:先将要排序的一组记录按某个增量d(n/2,n为要排序数的个数)分成若干组子序列,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。
继续不断缩小增量直至为1,最后使用直接插入排序完成排序希尔排序时效分析很难,关键码的比较次数与记录移动次数依赖于增量因子序列d的选取,特定情况下可以准确估算出关键码的比较次数和记录的移动次数。
目前还没有人给出选取最好的增量因子序列的方法。
增量因子序列可以有各种取法,有取奇数的,也有取质数的,但需要注意:增量因子中除1 外没有公因子,且最后一个增量因子必须为1。
希尔排序方法是一个不稳定的排序方法。
3. 选择排序—简单选择排序(Simple Selection Sort)基本思想:在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。
简单选择排序的示例:操作方法:第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换;第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换;以此类推.....第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换,直到整个序列按关键码有序。
算法实现:简单选择排序的改进——二元选择排序简单选择排序,每趟循环只能确定一个元素排序后的定位。
我们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的位置,从而减少排序所需的循环次数。
改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。
具体实现如下:4. 选择排序—堆排序(Heap Sort)堆排序是一种树形选择排序,是对直接选择排序的有效改进。
基本思想:堆的定义如下:具有n个元素的序列(k1,k2,...,kn),当且仅当满足时称之为堆。
由堆的定义可以看出,堆顶元素(即第一个元素)必为最小项(小顶堆)。
若以一维数组存储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的值均不大于(或不小于)其子女的值,根结点(堆顶元素)的值是最小(或最大)的。
如:(a)大顶堆序列:(96, 83,27,38,11,09)(b) 小顶堆序列:(12,36,24,85,47,30,53,91)初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树(一维数组存储二叉树),调整它们的存储序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的元素,这时堆的根节点的数最小(或者最大)。
然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的元素。
依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。
称这个过程为堆排序。
因此,实现堆排序需解决两个问题:1. 如何将n 个待排序的数建成堆;2. 输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。
首先讨论第二个问题:输出堆顶元素后,对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法:1)设有m 个元素的堆,输出堆顶元素后,剩下m-1 个元素。
将堆底元素送入堆顶((最后一个元素与堆顶进行交换),堆被破坏,其原因仅是根结点不满足堆的性质。
2)将根结点与左、右子树中较小元素的进行交换。
3)若与左子树交换:如果左子树堆被破坏,即左子树的根结点不满足堆的性质,则重复方法(2).4)若与右子树交换,如果右子树堆被破坏,即右子树的根结点不满足堆的性质。
则重复方法(2).5)继续对不满足堆性质的子树进行上述交换操作,直到叶子结点,堆被建成。
称这个自根结点到叶子结点的调整过程为筛选。
如图:再讨论对n 个元素初始建堆的过程。
建堆方法:对初始序列建堆的过程,就是一个反复进行筛选的过程。
1)n 个结点的完全二叉树,则最后一个结点是第个结点的子树。
2)筛选从第个结点为根的子树开始,该子树成为堆。
3)之后向前依次对各结点为根的子树进行筛选,使之成为堆,直到根结点。
如图建堆初始过程:无序序列:(49,38,65,97,76,13,27,49)算法的实现:从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。
所以堆排序有两个函数组成。
一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。
分析:设树深度为k,。
从根到叶的筛选,元素比较次数至多2(k-1)次,交换记录至多k 次。
所以,在建好堆后,排序过程中的筛选次数不超过下式:而建堆时的比较次数不超过4n 次,因此堆排序最坏情况下,时间复杂度也为:O(nlogn )。
5. 交换排序—冒泡排序(Bubble Sort)基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。
即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
冒泡排序的示例:算法的实现:[cpp]view plaincopyprint?1.void bubbleSort(int a[], int n){2. for(int i =0 ; i< n-1; ++i) {3. for(int j = 0; j < n-i-1; ++j) {4. if(a[j] > a[j+1])5. {6. int tmp = a[j] ; a[j] = a[j+1] ; a[j+1] = tmp;7. }8. }9. }10.}冒泡排序算法的改进对冒泡排序常见的改进方法是加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换,如果进行某一趟排序时并没有进行数据交换,则说明数据已经按要求排列好,可立即结束排序,避免不必要的比较过程。
本文再提供以下两种改进算法:1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。
由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
改进后算法如下:2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。
改进后的算法实现为:6. 交换排序—快速排序(Quick Sort)基本思想:1)选择一个基准元素,通常选择第一个元素或者最后一个元素,2)通过一趟排序讲待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。
另一部分记录的元素值比基准值大。
3)此时基准元素在其排好序后的正确位置4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。
快速排序的示例:(a)一趟排序的过程:(b)排序的全过程算法的实现:递归实现:分析:快速排序是通常被认为在同数量级(O(nlog2n))的排序方法中平均性能最好的。
但若初始序列按关键码有序或基本有序时,快排序反而蜕化为冒泡排序。
为改进之,通常以“三者取中法”来选取基准记录,即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。
快速排序是一个不稳定的排序方法。
快速排序的改进在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。
实践证明,改进后的算法时间复杂度有所降低,且当k取值为8 左右时,改进算法的性能最佳。
算法思想如下:7. 归并排序(Merge Sort )基本思想:归并(Merge )排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。
然后再把有序子序列合并为整体有序序列。
归并排序示例:合并方法:设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成,两个子表长度分别为n-i +1、n-m。
1.j=m+1;k=i;i=i; //置两个子表的起始下标及辅助数组的起始下标2.若i>m 或j>n,转⑷ //其中一个子表已合并完,比较选取结束3.//选取r[i]和r[j]较小的存入辅助数组rf如果r[i]<r[j],rf[k]=r[i]; i++; k++;转⑵否则,rf[k]=r[j]; j++; k++;转⑵4.//将尚未处理完的子表中元素存入rf如果i<=m,将r[i…m]存入rf[k…n] //前一子表非空如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空5.合并结束。
归并的迭代算法1 个元素的表总是有序的。
所以对n 个元素的待排序列,每个元素可看成1 个有序子表。
对子表两两合并生成n/2个子表,所得子表除最后一个子表长度可能为1 外,其余子表长度均为2。