C/C++的八种排序算法及实现
来源:互联网 发布:优化站和竞价站的区别 编辑:程序博客网 时间:2024/05/29 06:43
最近看排序算法的书籍,记录下自己的心得和总结。关于几种常见排序的原理和实现。(快速排序借了别人的步骤描述,可以很清晰的理解每一趟怎么跑的)
首先说下稳定排序和非稳定排序,简单地说就是所有相等的数经过某种排序方法后,
仍能保持它们在排序之前的相对次序,我们就说这种排序方法是稳定的。反之,就是非稳定的。
几个基本常见的排序,插入排序(包括直接插入,希尔插入,折半插入等),交换排序(包括冒泡排序,快速排序),选择排序(简单选择,堆排序,树形排序等),归并排序,基数排序(多关键字,链式基数)。
1. 直接插入排序(稳定排序)
简单的说就是将序列分为有序序列和无序序列。每一趟排序都是将无序序列的第一个元素插入有序序列中。R[1… i-1] <- R[i…n] , 每次取R[i]插入到R[1… i-1]中。
步骤如下:
1> 在R[1 … i-1]中找到R[i]的插入位置k (0<k<i)
2> 将R[k … i-1]均后移一位,K位置上插入R[i]
改进版:
1> 在R[1 … i-1]中将R[i]从右向左一一比较,R[j] >R[i],则R[j]后移一位(j = i-1开始)
2> 如果R[j] <=R[i],则j+1 为R[i]的插入位置
实现如下(包括测试):
<span style="font-size:14px;">#include<iostream>using namespace std;void insert_sort(int a[],int len){int i=0,j=0,temp=0;for(i=1;i<len;i++){temp =a[i];for(j=i-1;j>=0&&temp<a[j];j--){ a[j+1]=a[j];} a[j+1]=temp;}}void print_array(int a[].int len){for(int i=0;i<len;i++){ cout<<a[i]<<””;} cout<<endl;} int main(){ inta[]={1,3,5,9,8,6,4,2,7} ; cout<<”before sort:”; print_array(a,9); insert_sort(a,9); cout<<”after sort:”; print_array(a,9); return 0;}</span>
2. 希尔排序(不稳定排序)
希尔排序算法是先将要排序的一组数按照某个增量d分成若干组,对每组中的元素进行排序,然后在用更小的增量来进行再次分组,并给每个分组重新排序,直到增量为1时,整个要排序的数被分成一组,排序结束。
形象点说,例如[R1 ,R2 , R3, R4,R5,R6,R7,R8],先增量d =len/2 =4 ,则先分成[R1 R5] ,[R2 R6] ,[R3 R7] ,[R4 R8]四组,进行组内排序;再d=d/2 =2,分成[R1 R3 R5R7] 和 [R2 R4 R6 R8]两组,组内排序;再d=d/2=1,整个数组只剩一个大的分组[R1 , R2 , R3, R4,R5,R6,R7,R8],组内排序。全部结束。
实现如下(包括测试):
<span style="font-size:14px;">#include<iostream>using namespace std;void shell_sort(int a[],int len){int d,i,j,temp;for(d=len/2;d>0;d=d/2){for(i=d;i<len;i++){ temp= a[i]; for(j=i-d;j>=0&&temp<a[j];j-=d) { a[j+d]=a[j];} a[j+d]=temp;}}} void print_array(int a[],int len){for(int i=0;i<len;i++){ cout<<a[i]<<" ";} cout<<endl;} int main(){ inta[]={2,3,5,9,8,6,4,1,7} ; cout<<"before sort:"; print_array(a,9); shell_sort(a,9); cout<<"after sort:"; print_array(a,9); return 0;}</span>
3. 冒泡排序(稳定排序)
冒泡排序也叫起泡排序,顾名思义,就是每一趟,从左到右,两两比较,大的(小的)后移,最后最轻的气泡到最后的位置R[i],为最大或最小值,然后下一趟,选出次大的到R[i-1],以此,到最后R[1],至此全部有序。(按照递增递减都可以)
实现如下:
/*a[0]..从a[0]最小开始 */
<span style="font-size:14px;">void bubble_sort(int a[],int len){ int i,j,temp; for(i=0;i<len-1;i++){ for(j=len-2;j>=i;j--){ if(a[j+1]<a[j]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;}}}} /* ...a[n] ,从a[n]最大开始,*/void bubble_sort1(int a[],int len){ inti,j,temp; for(i=0;i<len-1;i++){ for(j=0;j<len-i-1;j++){ if(a[j+1]<a[j]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;}}}}//考虑如果中间的某一趟扫描之前,数组已经全部有序,后面的扫描则没有必要。此时可以加一个标记,来判断是否提前结束循环。改进:void bubble_sort(int a[],int len){ int i,j,temp; int exchange=0; for(i=0;i<len-1;i++){ exchange = 0; for(j=len-2;j>=i;j--){ if(a[j+1]<a[j]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; exchange=1; //如果发生过交换,exchange置为1}}if(exchange!=1) //如果exchange为0,说明已经有序,这一趟没发生交换,直接结束循环 return;}} </span>
4. 快速排序(不稳定排序)
快速排序是一种划分交换排序,采用的是分治法的策略。该方法的基本思想是:
1.先从数列中取出一个数作为基准数。
2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
3.再对左右区间重复第二步,直到各区间只有一个数。
下面借助这篇文章的步骤描述,就会很好理解快速排序每一趟到底怎么走的:
来源:http://blog.csdn.net/liuchen1206/article/details/6954074
以一个数组作为示例,取区间第一个数为基准数(pivot)。
0
1
2
3
4
5
6
7
8
9
72
6
57
88
60
42
83
73
48
85
初始时,i = 0; j =9; X = a[i] = 72
由于已经将a[0]中的数保存到X中,可以理解成在数组a[0]上挖了个坑,可以将其它数据填充到这来。
从j开始向前找一个比X小或等于X的数。当j=8,符合条件,将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8];i++; 这样一个坑a[0]就被搞定了,但又形成了一个新坑a[8],这怎么办了?简单,再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数,当i=3,符合条件,将a[3]挖出再填到上一个坑中a[8]=a[3];j--;
数组变为:
0
1
2
3
4
5
6
7
8
9
48
6
57
88
60
42
83
73
88
85
i = 3; j =7; X=72
再重复上面的步骤,先从后向前找,再从前向后找。
从j开始向前找,当j=5,符合条件,将a[5]挖出填到上一个坑中,a[3] = a[5]; i++;
从i开始向后找,当i=5时,由于i==j退出。
此时,i = j = 5,而a[5]刚好又是上次挖的坑,因此将X填入a[5]。
数组变为:
0
1
2
3
4
5
6
7
8
9
48
6
57
42
60
72
83
73
88
85
可以看出a[5]前面的数字都小于它,a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。a[5]已经确定好位置。后面每一趟也是。
对挖坑填数进行总结
1.i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。
3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。
4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。
具体实现如下(测试不重复,在前面的代码上加个函数,都测试过):<span style="font-size:14px;">/*这里的low和high是数组的头和尾的下标*/void quick_sort(int a[],int low,int high){ int i,j,pivot; if(low<high){ pivot =a[low]; //pivot的初始值为a[low] i=low; j=high; while(i<j){ while(i<j&&a[j]>=pivot) j--; if(i<j) a[i++]=a[j]; //比pivot小的元素移动到低端while(i<j&&a[i]<=pivot) i++;if(i<j) a[j--]=a[i]; //比pivot大的元素移动到高端}a[i]=pivot;quick_sort(a,low,i-1); //对左右两个子区间进行递归quick_sort(a,i+1,high);}}</span>
5. 直接选择排序(不稳定排序)
选择排序的基本思想:每一次从待排序的记录中选出关键字最小的记录,顺序的放在有序的序列的最后,直至全部记录排序完毕。
而直接选择排序就是n条记录经过n-1次后,直接得到有序记录。
实现如下:
void select_sort(int a[],int len){ int i,j,min,k; //min保存最小数,k记录最小数的位置 for(i=0;i<len;i++) { min= a[i]; k =i; for(j=i+1;j<len;j++) { if(a[j]<min) { min = a[j]; k = j; } } a[k]=a[i]; //a[k]为最小值,已由min保存 a[i]=min; }}或者简化:void select_sort(int a[],int len) { int i,j,temp; for(i=0;i<len;i++) { for(j=i+1;j<len;j++) { if(a[i]>a[j]) { temp=a[i]; a[i]=a[j]; a[j]=temp; } } } }
6. 堆排序(不稳定排序)
堆排序是一种树形选择排序方法,它的特点是:在排序过程中,将A[n]看成是一棵完全二叉树的顺序存储结构,利用完全二叉树中双亲节点和孩子节点之间的内在关系,在当前无序区中选择关键字最大(或最小)的元素。
堆的定义如下:n个关键字序列A[n]成为堆,当且仅当该序列满足:
①L(i) <= L(2i)且L(i) <= L(2i+1) 或者 ②L(i) >=L(2i)且L(i) >= L(2i+1) 其中i属于[1, n/2]。
满足第①种情况的堆称为小根堆(小顶堆),满足第②种情况的堆称为大根堆(大顶堆)。
如上的小根堆或大根堆,输出堆顶的最小(大)值之后,使得剩下的n-1个元素的序列重新建成一个新的堆,则又得到n个数中的次小(大)值,如此反复,最后得到的有序序列,这个过程就是堆排序。
代码实现:
<span style="font-size:14px;">void swap(int *a ,int *b) { int temp = *a; *a = *b; *b = temp; } void HeapAdjust(int a[],int i) { int left = 2*i+1;//左孩子节点 int right = 2*i + 2;//右孩子节点 int max = 0;//暂存最大元素下标 if(left <=heapsize && a[left] >a[i]) max = left; else max = i; if(right <= heapsize&& a[right] > a[max]) max = right; if(max != i)//表明当前的父节点并不是最大的 { swap(&a[i],&a[max]); HeapAdjust(a,max);//有交换就要递归把子树也整成最大堆 } } void BuildHeap(int a[],int len) { int i = 0; heapsize = len; for( i = len/ 2;i >=0;i--)//非叶节点最大下标为/2 { HeapAdjust(a,i); } } //堆排序对要排序的序列有个要求就是下标是从1开始到size的,而并非常用的0~size-1 void heap_sort(int a[],int len) { int i; BuildHeap(a,len-1);//先建立初始的最大堆 for( i = len-1;i >=1;i--) { swap(&a[0],&a[i]);//把最大的元素放到最后面 heapsize--;//不再包括最大的元素 HeapAdjust(a,0); } //至此数组就已经从小到大排好序了, //如果要从大到小输出,则倒着输出就行了; //而如果要将序列从大到小排序,则应建立最小堆。 } </span>
7. 归并排序(稳定排序)
归并是指将若干个已排序的子文件合并成一个有序的文件。常见的归并排序有两路归并排序。
归并操作的基本步骤如下:
1.申请两个与已经排序序列相同大小的空间,并将两个序列拷贝其中;
2.设定最初位置分别为两个已经拷贝排序序列的起始位置,比较两个序列元素的大小,依次选择相对小的元素放到原始序列;
3.重复2直到某一拷贝序列全部放入原始序列,将另一个序列剩下的所有元素直接复制到原始序列尾。
设归并排序的当前区间是R[low..high],三个步骤分别是:
1.分解:将当前区间一分为二,即求分裂点
2.求解:递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序;
3.组合:将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。
递归的终结条件:子区间长度为1(一个记录自然有序)。
代码实现:
<span style="font-size:14px;">void Merge(int *a, int p, int q, int r) { int n1 = q-p+1; int n2 = r-q; int *L = new int[n1+1]; int *R = new int[n2+1]; int i, j, k; for (i=0; i<n1; i++){ L[i] = a[p+i]; } for (j=0; j<n2; j++) { R[j] = a[q+j+1]; } L[n1] = 10000000; R[n2] = 10000000; for (i=0, j=0, k=p; k<=r; k++) { if (L[i]<=R[j]) { a[k] = L[i]; i++; } else { a[k] = R[j]; j++; } } delete []L; delete []R; } void merge_sort(int *a, int p, int r) //测试时候,参为a,0,len-1{ if (p<r) { int q = (p+r)/2; merge_sort(a, p, q); merge_sort(a, q+1, r); merge_sort(a, p, q, r); } } </span>
8. 基数排序(稳定排序)
http://blog.csdn.net/u012580566/article/details/47702955
实现如下:
<span style="font-size:14px;">int maxbit(int data[], int n) { int d = 1; //保存最大的位数 int p = 10; for(int i = 0; i < n; ++i) { while(data[i] >= p) { p *= 10; ++d; } } return d; } void radixsort(int data[], int n) //基数排序 { int d = maxbit(data, n); int tmp[n]; int count[10]; //计数器 int i, j, k; int radix = 1; for(i = 1; i <= d; i++) //进行d次排序 { for(j = 0; j < 10; j++) count[j] = 0; //每次分配前清空计数器 for(j = 0; j < n; j++) { k = (data[j] / radix) % 10; //统计每个桶中的记录数 count[k]++; } for(j = 1; j < 10; j++) count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶 for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中 { k = (data[j] / radix) % 10; tmp[count[k] - 1] = data[j]; count[k]--; } for(j = 0; j < n; j++) //将临时数组的内容复制到data中 data[j] = tmp[j]; radix = radix * 10; } } </span>
总结:选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法,
冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
- C/C++的八种排序算法及实现
- 常见的排序算法对比及实现C语言版本
- Shell排序算法及C语言实现
- 堆排序算法及C语言实现
- 算法导论-----排序的9种实现(C/C++)
- 排序算法实现(C/C++)
- 排序算法c实现
- 排序算法 (C实现)
- 常用排序算法之冒泡排序c及lua实现
- 常用排序算法之插入排序c及lua实现
- 常用排序算法之选择排序c及lua实现
- 常用排序算法之快速排序c及lua实现
- 八种排序算法(C语言简易版)
- 基本排序算法的C语言实现
- 插入排序算法的C语言实现
- 选择排序算法的C语言实现
- 各种排序算法的C实现
- 内部排序算法的C/C++实现
- 第一个SpringMVC
- Hibernate4自学入门(三)——生成策略标识符
- MySQL之——GTIDs Replication模式下切换Master服务器或中继服务器方法
- java中访问数据库的封装
- java---泛型和反射机制
- C/C++的八种排序算法及实现
- Qt通过QRegExp类来实现输入的有效性判断与正则表达式的学习
- 编译问题_part1
- hpu-【1012: QAQ的区间统计】
- 欢迎使用CSDN-markdown编辑器
- 耳机左右声道接反的问题
- 剑指Offer面试题35(java版):第一个只出现一次的字符
- CFgym 100851B-Binary vs Decimal
- CSS知识归纳—1