c语言实现简单排序(8种方法)

合集下载

c语言中排序的各种方法解析

c语言中排序的各种方法解析

c语言中排序的各种方法解析一、引言在计算机编程中,排序是一个重要的操作,它按照一定的顺序排列数据元素,使得数据元素按照从小到大的顺序排列。

在C语言中,有多种方法可以实现排序,包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

这些排序算法都有各自的优缺点,适合不同的应用场景。

二、冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。

遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

算法步骤:1. 比较相邻的元素。

如果第一个比第二个大(升序),就交换它们两个。

2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。

这步做完后,最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤,除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

三、选择排序选择排序是一种简单直观的排序算法。

它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

算法步骤:1. 在未排序序列中找到最小元素,存放到排序序列的起始位置。

2. 再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。

3. 以此类推,直到所有元素均排序完毕。

四、插入排序插入排序的工作方式是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

插入排序在实现上通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

五、快速排序快速排序使用了分治的原则,它在每一层划分都比前面方法有所改进和精进,当切分到两边的子序列长度都大于某个值时,或者一个大于一个小于这个值时再进行交换的操作来结束此层的递归过程。

这层的结果又成为下一层的两个子数组来处理,最后就得到递归式的最终结果。

数组排序c语言数组排序方法

数组排序c语言数组排序方法

数组排序c语言数组排序方法在C语言中,可以使用多种排序算法对数组进行排序。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。

下面将详细介绍这些排序算法的原理、实现以及时间复杂度。

1. 冒泡排序(Bubble Sort):冒泡排序是一种简单的排序算法,其基本思想是重复地在相邻的元素之间进行比较和交换,将最大的元素逐渐“浮”到数组的尾部。

具体实现过程如下:cvoid bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-1-i; j++) {if (arr[j] > arr[j+1]) {交换相邻元素int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}冒泡排序的时间复杂度为O(n^2),其中n为数组长度。

2. 选择排序(Selection Sort):选择排序也是一种简单的排序算法,其基本思想是每次从未排序的部分中选取最小(或最大)的元素,放到已排序部分的末尾。

具体实现过程如下:cvoid selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}将最小元素交换到已排序部分的末尾int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}选择排序的时间复杂度为O(n^2)。

3. 插入排序(Insertion Sort):插入排序的基本思想是将数组分为已排序和未排序两部分,每次从未排序部分选择一个元素,插入到已排序部分的正确位置。

使用C语言实现12种排序方法

使用C语言实现12种排序方法

使⽤C语⾔实现12种排序⽅法⽬录1.冒泡排序2.插⼊排序3.折半插⼊排序4.希尔排序5.选择排序6.鸡尾酒排序7.堆排序8.快速排序9.归并排序10.计数排序11.桶排序12.基数排序1.冒泡排序思路:⽐较相邻的两个数字,如果前⼀个数字⼤,那么就交换两个数字,直到有序。

时间复杂度O(n^2),稳定性:这是⼀种稳定的算法。

代码实现:void bubble_sort(int arr[],size_t len){size_t i,j;for(i=0;i<len;i++){bool hasSwap = false; //优化,判断数组是否已经有序,如果有序可以提前退出循环for(j=1;j<len-i;j++){ //这⾥j<len-i是因为最后⾯的肯定都是最⼤的,不需要多进⾏⽐较if(arr[j-1]>arr[j]){ //如果前⼀个⽐后⼀个⼤swap(&arr[j-1],&arr[j]); //交换两个数据hasSwap = true;}}if(!hasSwap){break;}}}2.插⼊排序思路:把⼀个数字插⼊⼀个有序的序列中,使之仍然保持有序,如对于需要我们进⾏排序的数组,我们可以使它的前i个数字有序,然后再插⼊i+1个数字,插⼊到合适的位置使之仍然保持有序,直到所有的数字有序。

时间复杂度:O(n^2) 稳定性:稳定的算法代码实现:void insert_sort(int arr[],int len){int i,j;for(i=1;i<len;i++){int key = arr[i]; //记录当前需要插⼊的数据for(j= i-1;i>=0&&arr[j]>key;j--){ //找到插⼊的位置arr[j+1] = arr[j]; //把需要插⼊的元素后⾯的元素往后移}arr[j+1] = key; //插⼊该元素}}3.折半插⼊排序思路:本质上是插⼊排序,但是通过半分查找法找到插⼊的位置,让效率稍微快⼀点。

C语言八大排序算法

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语言中的算法实现算法是计算机科学中非常重要的概念,它是解决问题的一系列步骤或指令集。

在C语言中,我们可以使用不同的方法来实现算法。

本文将介绍一些常见的C语言算法实现方式。

一、排序算法1. 冒泡排序冒泡排序是一种简单但效率较低的排序算法。

它通过不断比较相邻的元素,并按照规则交换它们的位置,直到整个序列排序完成。

2. 选择排序选择排序是一种简单而直观的排序算法。

它每次从未排序的序列中选择最小(或最大)的元素,并将其放置在已排序序列的末尾。

3. 插入排序插入排序是一种简单且高效的排序算法。

它通过构建有序序列,对未排序的元素逐个插入到已排序的序列中,直到所有元素都被插入完成。

二、查找算法1. 顺序查找顺序查找是一种简单的查找算法。

它从列表的开头开始逐个比较元素,直到找到目标元素或查找完整个列表。

2. 二分查找二分查找是一种高效的查找算法,但要求列表必须是有序的。

它通过将待查找区域分成两部分,判断目标元素落在哪一部分,从而缩小查找范围,直到找到目标元素或确定不存在。

三、递归算法递归是一种常用的算法设计技巧。

它通过在函数内调用自身来解决相同问题的不同实例。

在C语言中,递归函数需要定义出口条件,以避免无限递归。

四、动态规划算法动态规划是一种用于解决具有重叠子问题和最优子结构性质的问题的方法。

它将问题分解为一系列子问题,并以自底向上的方式求解子问题,最终得到整体问题的解。

在C语言中,可以使用循环、数组和指针等特性来实现动态规划算法,从而有效地解决问题。

五、图算法图是一种用于描述对象之间关系的数据结构,图算法是解决图相关问题的一类算法。

常见的图算法包括深度优先搜索(DFS)和广度优先搜索(BFS)。

六、字符串算法字符串算法用于处理字符串相关的问题,如字符串匹配、编辑距离等。

C语言提供了一系列字符串处理函数,如strlen、strcpy等,可以方便地实现字符串算法。

七、数学算法C语言在数学算法方面提供了丰富的库函数支持,如求平方根、对数、指数等。

C语言常用简单算法

C语言常用简单算法

C语言常用简单算法C语言是一门功能强大的编程语言,其算法也是很多的。

下面是一些常用的简单算法:1.二分查找算法:二分查找是一种在有序数组中查找特定元素的算法。

它的基本思想是首先在数组的中间位置找到待查找的元素,如果该元素等于目标值,则查找成功;如果该元素大于目标值,说明目标值在数组的前半部分,则在前半部分继续进行查找;如果该元素小于目标值,则说明目标值在数组的后半部分,则在后半部分继续进行查找。

重复以上步骤,直到找到目标值或者确定目标值不存在。

2.冒泡排序算法:冒泡排序是一种简单直观的排序算法。

它的基本思想是通过反复交换相邻的两个元素,将较大的元素逐渐往后移动,从而实现排序的目的。

具体实现时,每一轮比较都会使最大的元素移动到最后。

3.插入排序算法:插入排序是一种简单直观的排序算法。

它的基本思想是将数组分成已排序部分和未排序部分,每次从未排序部分取出一个元素,然后将该元素插入到已排序部分的合适位置,从而实现排序的目的。

4.选择排序算法:选择排序是一种简单直观的排序算法。

它的基本思想是每次选择一个最小(或最大)的元素放到已排序部分的末尾,从而实现排序的目的。

具体实现时,每一轮选择都通过比较找出未排序部分的最小(或最大)元素。

5.快速排序算法:快速排序是一种高效的排序算法。

它的基本思想是通过选取一个基准元素,将数组分成两个子数组,一个子数组中的元素都小于基准元素,另一个子数组中的元素都大于基准元素,然后对这两个子数组分别进行快速排序,最终实现排序的目的。

6.斐波那契数列算法:斐波那契数列是一列数字,其中每个数字都是前两个数字之和。

常见的斐波那契数列算法有递归算法和迭代算法。

递归算法通过反复调用自身来计算斐波那契数列的值,而迭代算法则通过循环来计算。

7.求最大公约数算法:求两个数的最大公约数是一种常见的问题。

常见的求最大公约数的算法有欧几里得算法和辗转相除法。

欧几里得算法通过不断用较小数除以较大数的余数,直到余数为0,得到最大公约数。

C语言常见排序算法

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
6.1.5 选择排序
算法实例:
08 0
25 1 i
49 2
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
6.1.5 选择排序
算法实现:
25*
16
21
i=3
08
16
49
25*
25
21
6.1.5 选择排序
算法实例:
08 0
16 1
21 2 21
25*
3 25*
25
4 25 5
最小者 25* 无交换
08
16
最小者 25 49 无交换
08
16
21
25*
25
49
各趟排序后的结果
6.1.5 选择排序
算法实例:
i =2时选择排序的过程
25 1 i k
6.1.5 选择排序

k
k
k
i=1 初始: [ 49 13
38 j k
65
j
97 j
76
j
13 49 j
27 ]
j
排序实例:
k
97 j 97 [97 76 j 76 76 49 38 27 ] j 49 49 j 38 ] 65 ]
i=2 一趟: 13
[38 27 65 j
二趟: 13 三趟: 13

c语言排序方法

c语言排序方法

c语言排序方法C语言是一种高效的编程语言,其基础算法和数据结构内容是必备的知识。

排序算法是其中一种重要的基础算法,是C语言程序开发中常用的一种技能,可以帮助我们对数据进行有序处理,更好地解决问题。

在C语言中,排序算法分为内部排序和外部排序。

内部排序是指将需要排序的数据都放在内存中进行排序,主要适用于数据量较小的情况。

而外部排序则是指需要对大数据集进行排序,需要借助外部存储器进行排序。

在此我们主要讨论内部排序算法。

内部排序可以分为以下几类:1. 插入排序插入排序包括直接插入排序、希尔排序等。

直接插入排序是将一个记录插入到有序表中形成一个新的有序表;而希尔排序是通过缩小元素间的间隔,并对每个子序列分别进行插入排序来完成整个排序过程。

插入排序方法简单,适用于小数组或部分有序的数组,是稳定排序方法。

2. 选择排序选择排序包括简单选择排序、堆排序等。

简单选择排序是通过不断的在剩余元素中找到最小元素,并将其放在已排好序的数组末尾进行排序,是不稳定排序方法;而堆排序则是通过将待排序数组看作一个完全二叉树,不断将根节点放到其正确位置上进行排序,是不稳定排序方法。

3. 交换排序交换排序包括冒泡排序、快速排序等。

冒泡排序是通过不断比较相邻的两个数,将较小(或较大)数向前(或向后)交换,在每一次外循环中确定一个元素的位置的排序方法,是稳定排序方法;而快速排序则是通过不断地将待排序数组分成两部分,分别进行递归排序,再将两部分合并成一个有序的数组,是不稳定排序方法。

4. 合并排序合并排序是将待排序数组分成若干个子数组,将每个子数组排好序,再将排好序的子数组合并成最终有序的数组。

合并排序是稳定排序方法,主要优化点在于合并有序数组的过程中需要有额外的空间存放有序的数据。

在实际开发中,我们需要选择适合当前情况的排序方法,优化算法的实现,提高算法的效率。

另外,在使用排序算法的过程中,我们还需要注意以下几点:1. 数据量的大小决定了排序算法的选择。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环,每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。

for(j=0;j<n-1;j++) {//外循环一次,就排好一个数,并放在后面,//所以比较前面n-j-1个元素即可for(i=0;i<n-j-1;i++) {if(data[i]>data[i+1]) {temp = data[i];data[i] = data[i+1];data[i+1] = temp;}}}}/*--------------------快速排序---------------------*/intfindPos(int data[], int low, int high) {//将大于t的元素赶到t的左边,大于t的元素赶到t的右边int t = data[low];while(low < high) {while(low < high && data[high] >= t) {high--;}data[low] = data[high];while(low < high && data[low] <=t) {low++;}data[high] = data[low];}data[low] = t;//返回此时t在数组中的位置return low;}//在数组中找一个元素,对大于该元素和小于该元素的两个数组进行再排序//再对两个数组分为4个数组,再排序,直到最后每组只剩下一个元素为止voidquickSort(int data[], int low, int high) {if(low > high) {return;}intpos = findPos(data, low, high);quickSort(data, low, pos-1);quickSort(data, pos+1, high);}/*--------------------插入排序---------------------*/ voidbInsertSort(int data[], int n) {intlow,high,mid;inttemp,i,j;for(i=1;i<n;i++) {low = 0;//把data[i]元素插入到它的前面data[0-(i-1)]中temp =data[i];high = i-1;//该while是折半,缩小data[i]的范围(优化手段)while(low <= high) {mid = (low+high)/2;if(data[mid] > temp) {high = mid-1;}else {low = mid+1;}}int j = i;//让data与已经排序好的数组的各个元素比较,小的放前面while((j > low) && data[j-1] > temp) {data[j] = data[j-1];--j;}data[low] = temp;}}/*--------------------希尔排序---------------------*/ voidshellSort(int * data, int n) {intstep,i,j,key;//将数组按照step分组,不断二分到每组只剩下一个元素for(step=n/2;step>0;step/=2) {//将每组中的元素排序,小的在前for(i=step;i<n;i++) {key = data[i];for(j=i-step;j>=0 && key<data[j];j-=step) {data[j+step] = data[j];}//和上面的for循环一起,将组中小的元素换到数组的前面data[j+step] = key;}}}/*--------------------选择排序---------------------*/ voidselectSort(int data[], int n) {inti,j,mix,temp;//每次循环数组,找出最小的元素,放在前面,前面的即为排序好的for(i=0;i<n-1;i++) {//假设最小元素的下标int mix = i;//将上面假设的最小元素与数组比较,交换出最小的元素的下标for(j=i+1;j<n;j++) {if(data[j] < data[mix]) {mix = j;}}//若数组中真的有比假设的元素还小,就交换if(i != mix) {temp = data[i];data[i] = data[mix];data[mix] = temp;}}}/*--------------------堆排序---------------------*///堆排序将数组先组成二叉树,默认从数组的data[1]开始排,data[0]是//无效数据voidheapSort(int data[], int n) {inti;//先将数组组成一棵完全二叉树//从2/n开始,就是从倒数第二排结点往前开始for(i=n/2;i>0;i--) {heapAdjust(data, i, n);}//循环每个结点,将大的结点交换到堆顶for(i=n;i>1;i--) {swap(data, 1, i);//每次交换完都要调整二叉树,将剩下的最大的结点交换到堆顶heapAdjust(data, 1, i-1);}}//交换函数void swap(int data[], inti, int j) {int temp;temp = data[i];data[i] = data[j];data[j] = temp;}voidheapAdjust(int data[], inti, int n) {int j, temp;//假设第一个结点的元素是最大的temp = data[i];//i结点:2*i是i结点的左结点,2*i+1是i结点的右结点 //把结点元素大的交换到前面for(j=2*i;j<=n;j*=2) {if(j < n && data[j] < data[j+1]) {j++;}if(temp >= data[j]) {break;}data[i] = data[j];i = j;}data[i] = temp;}/*--------------------归并排序---------------------*/ voidmergeSort(int data[], int first, int last) {int mid = 0;//将数组不停的二分分组再组合,直到每组只剩一个元素if(first < last) {mid = (first+last)/2;mergeSort(data, first, mid);mergeSort(data, mid+1, last);merge(data, first, mid, last);}return;}void merge(int data[], int low, int mid, int high) { inti, k;//定义一个临时数组存放传进来的无序数组排好序之后的数组int *temp = (int *)malloc((high-low+1)*sizeof(int));//将无序数组分成两个序列intleft_low = low;intleft_high = mid;intright_low = mid+1;intright_high = high;//将两个序列比较排序,小的排前for(k=0;left_low<=left_high&&right_low<=right_high;k++) {if(data[left_low]<=data[right_low]) {temp[k] = data[left_low++];}else{temp[k] = data[right_low++];}}//左序列如果有剩下元素未排序,加到临时数组的末尾if(left_low<= left_high) {for(i=left_low;i<=left_high;i++) {temp[k++] = data[i];}}//右序列如果有剩下元素未排序,加到临时数组的末尾if(right_low<= right_high) {for(i=right_low;i<=right_high;i++) {temp[k++] = data[i];}}//将排好序的小分组转移到原数组中for(i=0;i<high-low+1;i++) {data[low+i] = temp[i];}free(temp);return;}/*--------------------基数排序---------------------*///该函数的作用是找出num的pos位数的数字(比如:23的个位数数字是3) intgetNumPos(intnum, intpos) {inti;int temp = 1;for(i=0;i<pos-1;i++) {temp *= 10;}return (num / temp) % 10;}voidradixSort(int data[], int n) {inti,j,k,pos,num,index;//这几句话是创建一个从0-9(行)× (n+1)(列)的网格,第一列从上往下是0-9,//第二列是该行包含的元素个数,默认为0个int *radixArrays[10];for(i=0;i<10;i++) {radixArrays[i] = (int *)malloc(sizeof(int) * (n+1));radixArrays[i][0] = 0;}//pos最大为31为数,计算机能承受的最大范围了for(pos=1;pos<=31;pos++) {//该for循环是将数组的元素按照位数(pos)的值放进网格内for(i=0;i<n;i++) {num = getNumPos(data[i], pos);index = ++radixArrays[num][0];radixArrays[num][index] = data[i];}//该for循环是将上面的for循环已经按照某个位数(pos)排列好的元素存入数组for(i=0,j=0;i<10;i++) {for(k=1;k<=radixArrays[i][0];k++) {data[j++] = radixArrays[i][k];}//清空网格,以便给下个位数排列radixArrays[i][0] = 0;}}}以上排序算法的优劣(时间复杂度和空间复杂度对比):。

相关文档
最新文档