C语言8大经典排序方法
c语言中排序的各种方法解析

c语言中排序的各种方法解析一、引言在计算机编程中,排序是一个重要的操作,它按照一定的顺序排列数据元素,使得数据元素按照从小到大的顺序排列。
在C语言中,有多种方法可以实现排序,包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
这些排序算法都有各自的优缺点,适合不同的应用场景。
二、冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
算法步骤:1. 比较相邻的元素。
如果第一个比第二个大(升序),就交换它们两个。
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。
这步做完后,最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤,除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
三、选择排序选择排序是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。
算法步骤:1. 在未排序序列中找到最小元素,存放到排序序列的起始位置。
2. 再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。
3. 以此类推,直到所有元素均排序完毕。
四、插入排序插入排序的工作方式是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序在实现上通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
五、快速排序快速排序使用了分治的原则,它在每一层划分都比前面方法有所改进和精进,当切分到两边的子序列长度都大于某个值时,或者一个大于一个小于这个值时再进行交换的操作来结束此层的递归过程。
这层的结果又成为下一层的两个子数组来处理,最后就得到递归式的最终结果。
数组排序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语言中的排序算法

c语言中的排序算法排序算法是计算机科学中非常重要的一个概念,它可以将一组无序的数据按照特定的规则进行排列,使得数据具有一定的有序性。
在C语言中,有多种排序算法可以实现这一功能。
本文将介绍一些常见的排序算法,并对它们的原理和实现进行详细的讲解。
一、冒泡排序冒泡排序是一种简单而常见的排序算法。
其基本思想是从待排序的数据序列的起始位置开始,依次比较相邻两个元素的大小,若发现逆序则交换它们的位置,直到整个序列有序。
冒泡排序的时间复杂度为O(n^2)。
二、选择排序选择排序是一种简单的排序算法,其基本思想是每次从待排序的数据序列中选择最小(或最大)的元素,将其放置在已排序序列的末尾,直到整个序列有序。
选择排序的时间复杂度为O(n^2)。
三、插入排序插入排序是一种简单而常用的排序算法,其基本思想是将待排序的数据序列分为已排序和未排序两部分,每次从未排序的部分中选择一个元素,并插入到已排序部分的适当位置,直到整个序列有序。
插入排序的时间复杂度为O(n^2)。
四、快速排序快速排序是一种高效的排序算法,其基本思想是选择一个基准元素,通过一趟排序将待排序的数据序列分割成独立的两部分,其中一部分的所有元素均小于(或大于)基准元素,然后再递归地对这两部分进行排序,直到整个序列有序。
快速排序的时间复杂度为O(nlogn)。
五、归并排序归并排序是一种高效的排序算法,其基本思想是将待排序的数据序列分成两个子序列,分别对这两个子序列进行排序,然后再将排好序的子序列合并成一个有序序列,直到整个序列有序。
归并排序的时间复杂度为O(nlogn)。
六、堆排序堆排序是一种高效的排序算法,其基本思想是将待排序的数据序列看成是完全二叉树的顺序存储结构,利用堆的性质进行排序。
堆排序的时间复杂度为O(nlogn)。
七、希尔排序希尔排序是一种高效的排序算法,其基本思想是将待排序的数据序列分成若干个子序列,对每个子序列进行直接插入排序,然后逐步缩小子序列的长度,最终使整个序列有序。
使用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语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式,那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码,不通过不断的锤炼,是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分,系统地学习⼀下是很有必要的。
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语言入门必学—10个经典C语言算法

C语言入门必学—10个经典C语言算法C语言是一种广泛使用的编程语言,具有高效、灵活和易学的特点。
它不仅在软件开发中被广泛应用,也是计算机科学专业的必修课。
在学习C语言的过程中,掌握一些经典的算法是非常重要的。
本文将介绍10个经典C语言算法,帮助读者更好地了解和掌握C语言。
一、冒泡排序算法(Bubble Sort)冒泡排序算法是最简单、也是最经典的排序算法之一。
它通过不断比较相邻的元素并交换位置,将最大(或最小)的元素逐渐“冒泡”到数组的最后(或最前)位置。
二、选择排序算法(Selection Sort)选择排序算法是一种简单但低效的排序算法。
它通过不断选择最小(或最大)的元素,并与未排序部分的第一个元素进行交换,将最小(或最大)的元素逐渐交换到数组的前面(或后面)。
三、插入排序算法(Insertion Sort)插入排序算法是一种简单且高效的排序算法。
它通过将数组分为已排序和未排序两个部分,依次将未排序部分的元素插入到已排序部分的合适位置。
四、快速排序算法(Quick Sort)快速排序算法是一种高效的排序算法。
它采用了分治的思想,通过将数组分为较小和较大两部分,并递归地对两部分进行排序,最终达到整个数组有序的目的。
五、归并排序算法(Merge Sort)归并排序算法是一种高效的排序算法。
它采用了分治的思想,将数组一分为二,递归地对两个子数组进行排序,并将结果合并,最终得到有序的数组。
六、二分查找算法(Binary Search)二分查找算法是一种高效的查找算法。
它通过不断将查找范围折半,根据中间元素与目标值的大小关系,缩小查找范围,最终找到目标值所在的位置。
七、递归算法(Recursive Algorithm)递归算法是一种通过自我调用的方式解决问题的算法。
在C语言中,递归算法常用于解决树的遍历、问题分解等情况。
八、斐波那契数列算法(Fibonacci Sequence)斐波那契数列是一列数字,其中每个数字都是前两个数字的和。
c语言不同排序方式
c语言不同排序方式
C语言中常见的排序方式有以下几种:
1.冒泡排序:这是一种简单的排序算法,通过不断地比较相邻的两个元素并
交换它们(如果需要),使得较大的元素逐渐地移动到数组的末尾。
2.选择排序:这种排序算法首先找到数组中的最小元素,将其放到数组的开
头,然后找到次小的元素,将其放到数组的第二个位置,以此类推,直到整个数组排序完成。
3.插入排序:这种排序算法通过将一个元素插入到已经排好序的数组中的适
当位置,使得该数组仍然保持有序。
4.快速排序:这是一种分而治之的排序算法,首先选择一个元素作为"pivot",
然后将所有比pivot小的元素移到它的左边,所有比pivot大的元素移到它的右边,然后再对左右两部分进行同样的操作。
5.归并排序:这也是一种分而治之的排序算法,它将一个大列表分成两个较
小的子列表,然后递归地对子列表进行排序,最后将排序好的子列表合并成一个有序的列表。
以上是C语言中常见的几种排序算法的概述,其中具体代码实现会有一定的复杂性,需要在掌握一定的C语言知识的基础上才能完成。
每种排序方式都有其特定的应用场景和优缺点,在实际使用时需要根据具体需求进行选择。
c语言实现简单排序(8种方法)
#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循环,每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
C语言9种常用排序法
C语⾔9种常⽤排序法C语⾔9种常⽤排序法1.冒泡排序2.选择排序3.插⼊排序4.快速排序5.希尔排序6.归并排序7.堆排序8.带哨兵的直接插⼊排序9.基数排序例⼦:乱序输⼊n个数,输出从⼩到⼤排序后的结果1.冒泡排序#includeint main(){int i, j, n, a[100], temp;while(scanf("%d",&n)!=EOF){for(i=0;iscanf("%d",&a[i]);for(i=0;i{for(j=0;j{if(a[j]>a[j+1]) //⽐较a[j]与a[j+1],使a[j+1]⼤于a[j] {temp = a[j+1];a[j+1] = a[j];a[j] = temp;}}}for(i=0;iprintf("%d ",a[i]);return 0;}2.选择排序#includeint main(){int i, j, n, a[100], t, temp;while(scanf("%d",&n)!=EOF){for(i=0;iscanf("%d",&a[i]);for(i=0;i{t = i;for(j=i+1;jif(a[t]>a[j])t = j;}temp = a[i];a[i] = a[t];a[t] = temp;}for(i=0;iprintf("%d ",a[i]);printf("\n");}return 0;}3.快速排序/*1.假设数组为a[n];2.第⼀次排序过程如下:取x = 0 ( a[0]为中轴 );i=0 (第⼀个元素下标), j=n-1(最后⼀个元素下标);从a[j]起,向前找⼩于a[x]的元素,同时j--,找到后,a[j]与a[x]交换,x=j;从a[i]起,向后找⼤于a[x]的元素,同时i++,找到后,a[i]与a[x]交换,x=i; }3.注意快排函数是迭代函数,必须要有结束条件 (因为忽略结束条件,调试了很久......)4.再对a[low]~a[x-1]、a[x+1]~a[high]分别调⽤快排函数*/#includevoid quicksort(int a[],int low,int high);int main(){int i, n, a[100];while(scanf("%d",&n)!=EOF){for(i=0;iscanf("%d",&a[i]);quicksort(a,0,n-1);for(i=0;iprintf("%d ",a[i]);printf("\n");}return 0;}void quicksort(int a[],int low,int high){if(low>=high) return; //坑爹的结束条件,return后⾯不能跟数值 int i=low, j= high, x=i, temp; while(i{for(;a[j]>=a[x]&&iif(i{temp = a[j];a[j] = a[i];a[i] = temp;x = j;break; //i>=j即可跳出本次while循环for(;a[i]<=a[x]&&iif(i{temp = a[i];a[j] = temp;x = i;j--;}elsebreak; //跳出本次while循环 } quicksort(a,low,x-1);quicksort(a,x+1,high);}4.插⼊排序法#includevoid show(int a[],int n) //输出数组{int i;for(i=0;iprintf("%d ",a[i]);printf("\n");}void insertsort(int a[],int n);int main(){while(scanf("%d",&n)!=EOF){for(i=0;iscanf("%d",&a[i]);insertsort(a,n);show(a,n);void insertsort(int a[],int n){int i ,j ,k ,temp;for(i=1;i{j=i-1;for(;a[i]=0;j--); //寻找插⼊点j++;if(j==i) //该数有序,不需要前插continue;else{temp=a[i];for(k=i-1;k>=j;k--) //将插⼊点后⾯的数依次后移⼀位 { a[k+1]=a[k];}}}}5.shell排序法#includevoid show(int a[],int n) //输出数组{int i;for(i=0;iprintf("%d ",a[i]);printf("\n");}void shellsort(int a[],int n);int main(){int i, n, a[100];while(scanf("%d",&n)!=EOF)scanf("%d",&a[i]);shellsort(a,n);show(a,n);}return 0;}void shellsort(int a[],int n){int k ,i ,j ,l ,temp;k = n/2;while(k>=1){for(i=k;i{if(a[i]>=a[i-k]) //已经有序,不需要移动continue;else{for(j=i-k;a[j]>=a[i]&&j>=0;j=j-k); j+=k; //寻找插⼊点a[j] temp = a[i]; // 保存a[i]for(l=i-k;l>=j;l-=k) //依次向后移动k个位置{a[l+k] = a[l];}a[j]=temp; //插⼊}}k = k/2;}}6.归并排序归并排序是⼀种很容易进⾏并⾏化的算法,因为归并的各个数据区间都是独⽴的,没有依赖关系。
C语言程序设计的常用算法
C语言程序设计的常用算法1.排序算法-冒泡排序:通过多次比较和交换来将最大(小)的数移到最后(前),时间复杂度为O(n^2)。
适用于数据较少、数据基本有序的情况。
- 快速排序:通过一趟排序将待排序序列分隔成独立的两部分,其中一部分的所有元素都比另一部分的所有元素小。
然后递归地对两部分进行排序,时间复杂度为O(nlogn)。
适用于大规模数据的排序。
-插入排序:将待排序序列分为已排序和未排序两部分,每次从未排序部分取一个元素插入到已排序部分的适当位置,时间复杂度为O(n^2)。
适用于数据量较小的排序场景。
- 归并排序:将待排序序列分为若干个子序列,分别进行排序,然后再将排好序的子序列合并成整体有序的序列,时间复杂度为O(nlogn)。
适用于需要稳定排序且对内存空间要求不高的情况。
2.查找算法-顺序查找:从头到尾依次对每个元素进行比较,直到找到目标元素或者遍历完整个序列。
时间复杂度为O(n)。
- 二分查找:对于有序序列,将序列的中间元素与目标元素进行比较,根据比较结果缩小查找范围,直到找到目标元素或者查找范围为空。
时间复杂度为O(logn)。
3.图算法-广度优先(BFS):从给定的起始顶点开始,按照“先访问当前顶点的所有邻接顶点,再依次访问这些邻接顶点的所有未访问过的邻接顶点”的顺序逐层访问图中的所有顶点。
适用于寻找最短路径、连通性等问题。
-深度优先(DFS):从给定的起始顶点开始,按照“先递归访问当前顶点的一个邻接顶点,再递归访问这个邻接顶点的一个邻接顶点,直到无法再继续递归”的方式遍历图中的所有顶点。
适用于寻找路径、判断连通性等问题。
4.动态规划算法-背包问题:给定一个背包容量和一组物品的重量和价值,选择一些物品装入背包,使得装入的物品总重量不超过背包容量,且总价值最大。
利用动态规划的思想可以通过构建二维数组来解决该问题。
-最长公共子序列(LCS):给定两个序列,找出一个最长的子序列,且该子序列在两个原序列中的顺序保持一致。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
C语言8大经典排序方法冒泡排序main(){int i,j,temp;int a[10];for(i=0;i<10;i++)scanf ("%d,",&a[i]);for(j=0;j<=9;j++){ for (i=0;i<10-j;i++)if (a[i]>a[i+1]){ temp=a[i];a[i]=a[i+1];a[i+1]=temp;}}for(i=1;i<11;i++)printf("%5d,",a[i] ); printf("\n");}选择排序void sa(int array[],int n) {int i,j,k,temp;for(i=0;i<10;i++){k=i;for(j=i+1;j<n;j++)if(array[j]<array[k])k=j;temp=array[k];array[k]=array[i];array[i]=temp;}}直接插入排序#include"stdio.h"#define MAXSIZE 20int Insertsort(int r[],int n) {int i,j;for(i=2;i<=n;i++){ r[0]=r[i];j=i-1;while(r[0]<r[j]){ r[j+1]=r[j]; j--;}r[j+1]=r[0];for(j=1;j<=n;j++){printf("%d ",r[j]);}printf("\n");}}int main(){int n,i;int r[MAXSIZE];scanf("%d",&n);for(i=1;i<=n;i++)scanf("%d",&r[i]);Insertsort(r,n);}希尔排序#include <stdio.h>void shell_sort(int arr[],int size) {int i,j,k,temp;for(i=size/2;i>0;i/=2){for(j=i;j<size;j++){temp=arr[j];for(k=j-i;k>=0&&temp<arr[k];k-=i) {arr[k+i]=arr[k];}arr[k+i]=temp;}}for(i=0;i<size;i++){printf("%d ",arr[i]);}}void main(){int arr[]={12,34,64,23,87,54,89,45,56,1,3,7,5,4,2}; shell_sort(arr,15);}堆排序#include<time.h>#include<stdio.h>#include<stdlib.h>void sift(int *a,int k,int m){int t;t=a[k];int i;i=k;int j;j=2*i;bool finished=false;while(j<=m&&!finished){if(j<m&&a[j]<a[j+1])j=j+1;if(t>a[j])finished=true;else{a[i]=a[j];i=j;j=2*i;}}a[i]=t;}void createheap(int *a,int length){int n=length;for(int i=n/2;i>=1;--i){sift(a,i,n);}}void heapsort(int *a,int n){createheap(a,n);for(int i=n;i>=2;--i){int x=a[1];a[1]=a[i];a[i]=x;sift(a,1,i-1);}}int main(){int *a;a=new int[10];srand(time(NULL));int i;printf("%s","随机数:");for(i=1;i<=10;i++){a[i]=rand();printf("%d ",a[i]);}printf("\n");heapsort(a,10);printf("%s","排序后:");for(i=1;i<=10;i++) printf("%d ",a[i]);printf("\n");}归并排序#include <stdio.h>#include <stdlib.h>#include <time.h>void Merge(int *R,int low,int m,int high) {int i=low,j=m+1,p=0;int *R1;R1=(int *)malloc((high-low+1)*sizeof(int)); if(!R1)return;while(i<=m&&j<=high)R1[p++]=(R[i]<=R[j])?R[i++]:R[j++]; while(i<=m)R1[p++]=R[i++];while(j<=high)R1[p++]=R[j++];for(p=0,i=low;i<=high;p++,i++) R[i]=R1[p];}void MergeSort(int R[],int low,int high){int mid;if(low<high){mid=(low+high)/2;MergeSort(R,low,mid);MergeSort(R,mid+1,high);Merge(R,low,mid,high);}}int main(void){int i;int a[10]=;int low=0,high=9;srand( (unsigned int)time(NULL) );for (i = 0; i < 10; i++){a[i] = rand() % 100;}MergeSort(a,low,high);for(i=low;i<=high;i++)printf("%d ",a[i]);return 0;}基数排序#include <stdio.h>typedef struct node {int data;int next;} node;int head;int fr[10];int re[10];void Distribute(node *a, int w){int i;for (i=0; i<10; i++) {fr[i] = -1;}for (i=head; i!=-1; i=a[i].next) { int x = a[i].data / w % 10;10=9(十位)if (fr[x] == -1) {fr[x] = re[x] = i;}else {a[re[x]].next = i;re[x] = i;}}for (i=0; i<10; i++) {if (fr[i] != -1) {a[re[i]].next = -1;}}}void Collect(node *a){int i, last;last = -1;for (i=0; i<10; i++) {if (fr[i] != -1) {if (last == -1) {head = fr[i];last = re[i];}else {a[last].next = fr[i];last = re[i];}}}a[last].next = -1;}void Out(node *a, int w){int i, p, k;printf("weight == %d\n", w); for (i=0; i<10; i++) {printf("fr[%d] ", i);p = fr[i];k = 0;while (p != -1) {printf("->%4d ", a[p].data);p = a[p].next;k++;}while (k<3) printf("-------"),k++;printf("-> re[%d]\n", i);}}void Output(node *a, int head){while (head != -1) {printf("%4d", a[head].data);head = a[head].next;}printf("\n");}void main(){node a[10];int i, n = 10, max;max = 0x80000000;printf("max == %d\n", max);printf("Please intput %d numbers~\n", n); for (i=0; i<n; i++) {scanf("%d", &a[i].data);a[i].next = i + 1;if (a[i].data > max) max=a[i].data;}head = 0;a[n - 1].next = -1;Output(a, head);for (i=1; i<=max; i*=10) {Distribute(a, i);Out(a, i);Collect(a);Output(a, head);}}比较排序#include<iostream>int main(){int a,b,c,*p1,*p2,*p3,*p;printf("Please integer three numbers:\n"); scanf("%d%d%d",&a,&b,&c);p1=&a;p2=&b;p3=&c;if(a<b){p=p1;p1=p2;p2=p;}if(a<c){p=p1;p1=p3;p3=p;}if(b<c){p=p2;p2=p3;p3=p;}printf("由大到小排列是:\n");printf("%d,%d,%d\n", *p1, *p2, *p3);}。