C语言排序算法实现

C语言各种排序

算法复杂度以及稳定性分析

算法名称平均时间辅助空间稳定性冒泡排序O(n2)O(1)是选择排序O(n2)O(1)否插入排序O(n2)O(1)是自底向上归并排序O(nlog2n)O(n)是自顶向下归并排序O(nlog2n)O(n)是快速排序O(nlog2n)O(n)否堆排序O(nlog2n)O(1)否基数排序O(dn)O(rn)是希尔排序\O(1)否

一、冒泡排序

冒泡排序算法的运作如下：（从后往前）
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

void bubble_sort() {       int a[] = {1, 34, 23, 55, 22, 11};        int i,j,k;    for(i=0;i<5;i++)      {for(j=0;j<5-i;j++)if(a[j]>a[j+1])      {k=a[j];           a[j]=a[j+1];           a[j+1]=k;  printf("%d\n", a[j]);//a[j] ^= a[j+1] ^= a[j];}    }

二、插入排序

直接插入排序的算法思路：

（1） 设置监视哨r[0]，将待插入纪录的值赋值给r[0]；

（2） 设置开始查找的位置j；

（3） 在数组中进行搜索，搜索中将第j个纪录后移，直至r[0].key≥r[j].key为止；

（4） 将r[0]插入r[j+1]的位置上。

void insert_sort() {        int i, j, m, tmp;int a[10] = {1, 34, 23, 55, 22, 11, 45, 67, 35, 26};#if 1for(i=0;i<10;i++) {m=a[i];         for(j=i-1;j >= 0;j--) {    if(a[j] < m)break;else a[j+1] = a[j];}a[j+1] = m;}#else for(i = 1; i < 10; i++) {m = 5;if(i != m){j = i;tmp = a[i];while(j > m){a[j] = a[j-1];j--;}a[j] = tmp;}}

三、快速排序

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

quick_sort(int L[],int first,int end) {  int pos;      if(end>first) {  pos=quick(first,end,L);         quick_sort(L,first,pos-1);         quick_sort(L,pos+1,end);      }   }quick(int first,int end,int L[]) { int left=first,right=end,key;   key=L[first];   while(left<right) {  while((left<right)&&(L[right]>=key)) {        right--;       printf("left:%d  right:\n",left);}if(left<right) {L[left++]=L[right];       //printf("left2:%d  right: \n",left);}while((left<right)&&(L[left]<=key))      left++;       if(left<right)L[right--]=L[left];}      L[left]=key;      //printf("left3:%d  right: \n",left);return left;   }    

四、选择排序

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

void select_sort() {       int t,k,i,j, d;int a[10] = {1, 34, 23, 55, 22, 11, 45, 67, 35, 26};    //printf("Please input some number that you want to sort:");    for(i=0;i<9;i++) {d=i;         for(j=i+1;j<10;j++) {if(a[j] < a[d])d = j;if(d != i) {       t=a[d];        a[d]=a[i];        a[i]=t;     }}}

五、希尔排序

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量=1(<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

void shell_sort(int *x, int n){   int h, j, k, t;    for (h=n/2; h>0; h=h/2) /*控制增量*/   {       for (j=h; j<n; j++) /*这个实际上就是上面的直接插入排序*/      {         t = *(x+j);         for (k=j-h; (k>=0 && t<*(x+k)); k-=h)                 *(x+k+h) = *(x+k);                    *(x+k+h) = t;      }    } }

六、归并排序

归并操作的工作原理如下：
第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

void MergeSort(int r[],int r1[],int s,int t){if(s==t);else{int m=(s+t)/2;MergeSort(r,r1,s,m);MergeSort(r,r1,m+1,t);Merge(r,r1,s,m+1,t+1);}}
void Merge(int* array, int *p_array, int bindex, int mindex, int eindex) { int mlen = eindex - bindex; //合并后的序列长度 int i = 0; //记录合并后序列插入数据的偏移 int j = bindex; //记录子序列1插入数据的偏移 int k = mindex; //记录子序列2掺入数据的偏移 while (j < mindex && k < eindex) { if (array[j] <= array[k]) { p_array[i++] = array[j]; j++; } else { p_array[i++] = array[k]; k++; } } if (j == mindex) //说明序列1已经插入完毕 while (k < eindex) p_array[i++] = array[k++]; else p_array[i++] = array[j++]; for (i = 0; i < mlen; i++) //将合并后序列重新放入array array[bindex + i] = p_array[i]; } 
/*    int a[10] = {1, 34, 23, 55, 22, 11, 45, 67, 35, 26};
    int *p = (int *)malloc(sizeof(int )*10);

    MergeSort(a, p, 0, 9);
*/
七、堆排序
n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）：
(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n/2），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶子结点，K(2i）则是左子节点，k(2i+1）是右子节点
若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：
树中任一非叶子结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。
//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度////本函数功能是：根据数组array构建大根堆void heap_mer(int array[],int i,int nlen){int nchild,ntmp;for(; 2*i+1 < nlen; i = nchild){nchild = 2*i+1;if(nchild < nlen-1 && array[nchild+1] > array[nchild])++nchild;if(array[i] < array[nchild]){ntmp = array[i];array[i] = array[nchild];array[nchild] = ntmp;}elsebreak;}}void HeapSort(int array[],int length){int tmp, i;//调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素//length/2-1是最后一个非叶节点，此处"/"为整除for(i=length/2-1;i>=0;i--)heap_mer(array,i,length);//从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素for(i=length-1;i>0;i--){//把第一个元素和当前的最后一个元素交换，//保证当前的最后一个位置的元素都是在现在的这个序列之中最大的//Swap(&array[0],&array[i]);tmp=array[i];array[i]=array[0];array[0]=tmp;//不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值heap_mer(array,0,i);}}



                                             
        0        0           
	
				
	
					   
排序算法(C语言实现)
	  	   
C语言排序算法实现
	  	   
排序算法--C语言实现
	  	   
C语言实现排序算法---希尔排序
	  	   
基本排序算法的C语言实现
	  	   
插入排序算法的C语言实现
	  	   
选择排序算法的C语言实现
	  	   
插入排序算法C语言实现
	  	   
经典排序算法(C语言实现)
	  	   
用C语言实现常用排序算法
	  	   
快速排序C语言算法实现
	  	   
c语言实现快速排序算法
	  	   
冒泡排序算法的c语言实现
	  	   
快速排序算法的c语言实现
	  	   
插入排序算法C语言实现
	  	   
计数排序算法（C语言实现）
	  	   
c语言 实现堆排序算法
	  	   
冒泡排序算法（C语言实现）
	     		  
	  	   
Java 时间转换
	  	   
process.waitFor() 返回值含义
	  	   
.net中跨数据库遇到的问题 分布式
	  	   
正则表达式
	  	   
Android Util工具类的封装
	  	   
C语言排序算法实现
	  	   
中国格地区的DNS地址
	  	   
分布式tensorflow
	  	   
spring学习之@ModelAttribute运用详解
	  	   
使用Beef劫持客户端浏览器并进一步使用Beef+msf拿客户端shell
	  	   
移动硬盘安装CentOS 7+Ubuntu 16.04.2整体过程记录
	  	   
python 360 社区 监控 爬虫 in not in 问题
	  	   
[BZOJ 2216][Poi2011]Lightning Conductor：DP决策单调性
	  	   
maven学习——认识pom文件