编程中的排序算法多的真是不能再多了。
也是今天突发奇想,忽然打算整理出一些常用的,较为简单的几种排序算法。(以下程序都是从小到大排序)
1.冒泡排序(Bubblesort)
这是最为简单也是初学者接触最多的一种排序方法。不断的比较,交换。复杂度O(n^2)
void BubbleSort(int a[],int Asize)
{
int i,j,temp;
for(i=0;i<Asize;i++){
for(j=i;j<Asize;j++){
if(a[j]<a[i])
swap(a[j],a[i]);
}
}
}
2.选择排序(Selectionsort)
从冒泡中可以发现其实其中总会有些多余的交换,因为当交换的数并不是剩余数中最小的时候,还需要继续往下找到那个最小的数,并且继续交换,因此也就产生了选择排序,先遍历一遍数组,找到剩余数据中的最小值并记录下标,然后再进行交换,避免了不必要的交换,但是复杂度并没有降低,还是没什么实质性的改变O(n^2)
void SelectionSort(int a[],int Asize)
{
int i,j,minindex,temp;
for(i=0; i<Asize-1; i++)
{
minindex=i;
for(j=i+1; j<Asize; j++)
{
if(a[minindex]>a[j])
minindex=j;
}
if(i!=minindex)
swap(a[minindex],a[i]);
}
}
3.插入排序(Insertsort)
插入排序也是通过遍历数组,同时将当前数插入到当前位置之前的合适位置。如现在已经排成了(1,3,5)接下来是4,则将当前数保存下来,并且将先前的比当前数大的数向后移动一位,然后将当前数赋值给最后位置。移动插入完成后既是(1,3,4,5),相比先前的排序方式,没有点对点的的交换,但是多了很多移位赋值的工作,效率也不高。复杂度是O(n^2)
void InsertSort(int a[],int Asize)
{
int i,j,temp;
for(i=1;i<Asize;i++){
if(a[i]<a[i-1]){
temp=a[i];
for(j=i-1;j>=0&&a[j]>temp;j--)
a[j+1]=a[j];
a[j+1]=temp;
}
}
}
4.鸽巢排序
相比上述几种方法,鸽巢排序的方法是另一种思路。不难理解,就是开一个足够大的数组,去记录数据次数,然后遍历开的数组。但是当n比较大的时候,开不出这么大的数组。复杂度是O(n),对于数据量较小的排序相对来说已经是非常快的了。(以下例子程序数据最大为255)
void PigeonholeSort(int a[], int Asize)
{
int b[256] = {0};
int i,k,j = 0;
for(i=0; i<Asize; i++)
b[a[i]]++;
for(i=0; i<256; i++)
for(k=0; k<b[i]; k++)
a[j++] = i;
}
5.希尔排序
希尔排序其实是插入排序的升级版。首先,插入排序是对每个待排序的数,向后遍历对比判断是否往前插入。因此复杂度较高,然而希尔排序先将数据分组,然后不断的二分步长。直到步长为1。
void ShellSort(int a[],int n)
{
int i,j,gap;
for(gap=n/2; gap>=1; gap/=2)//希尔排序步长暂定从n/2开始,不一定是最快的
{
for(i=gap; i<n; i++)//直接从一个步长之后的元素开始比较
{
for(j=i; j>=0&&a[j]<a[j-gap]; j-=gap)//跨度是一个步长,是指是不断交换将小的放在前面,本质就是小型的一个插入排序
{
int temp=a[j];
a[j]=a[j-gap];
a[j-gap]=temp;
}
}
}
}
6.归并排序
归并排序之前先要理解什么是归并。把两个排好序的数组,合并成一个数组是相对容易的。只需要开一个容器,不断比较两个合并数组的头,然后谁小,谁进容器,当两个数组元素都用过了之后,就得到了归并好的数组。那么要归并总要先二分把。
归并排序就是这样比较独特的一种排序,思想也是二分。先是将所有的数据二分,其中不断调用递归二分,一直到子数组长度为1,,然后不断合并。
void Merge(int a[],int left,int mid,int right,int c[])//归并函数,末端将容器内的数据重新移回排序数组中
{
int n,m,i,j,k;
k=0;
i=left;
n=mid;//左半边
j=mid+1;
m=right;//右半边
while(i<=n&&j<=m)
{
if(a[i]<a[j])
c[k++]=a[i++];
else
c[k++]=a[j++];
}
while(i<=n)
c[k++]=a[i++];
while(j<=m)
c[k++]=a[j++];//到此是merge完成,所有元素装在c中
for(i=0; i<k; i++)//因为是对a排序,因此重新赋值回去
a[left+i]=c[i];
}
void MergeSort(int a[],int left,int right)//将数据不断二分,直到都分成一个数然后归并
{
if(right>left)
{
int mid=(left+right)/2;
MergeSort(a,left,mid);//左半边分
MergeSort(a,mid+1,right);//右半边分
Merge(a,left,mid,right,temp);//外部定义temp作为merge用的容器
}
}
7.堆排序
堆排序是选择排序的升级版,选择排序是对每个数据都向后遍历,比对数据大小,然后选出最大的,然后两数交换。
堆排序中的难点就是如何看待堆,如何将数组看成二叉树。以及不断调整。
最容易的是理解调整。既是将父亲与自己的左右孩子中较大的那个比较(新手难点:父节点下标*2是左孩子的下标,再+1就是右孩子),然后交换调整数据,然后不断递归往上继续构造。(升序排序,需要构造最大堆;降序排序,需要构造最小堆)
然后是先处理非叶子节点(新手难点:n/2大致就是非叶子节点的位置),向下搜索(每次比较父亲下的两个孩子,对应下标是*2与*2+1)确保叶子中不存在最大值,越大的数越靠近上边,左边。然后再从右下角开始,将树顶的最大值放到右下角,然后再从0-当前位置,重新调整树,同理找最大值,然后重复交换。
void adjust(int a[],int st,int ed)
{
int temp,left,right,MaxNumindex;
MaxNumindex=st;
left=st*2;
right=left+1;
if(left<ed&&a[left]>a[st])
MaxNumindex=left;
if(right<ed&&a[right]>a[MaxNumindex])
MaxNumindex=right;
if(MaxNumindex!=st)
{
temp=a[st];
a[st]=a[MaxNumindex];
a[MaxNumindex]=temp;
adjust(a,MaxNumindex,ed);//先前的操作只是完成了一次上换,递归调用不断往上换
}
}
void HeapSort(int a[],int n)
{
int temp;
for(int i=n/2-1; i>=0; i--) //从非叶子节点开始调整,创建最大堆(或者最小堆),本质就是不断的把叶子上的大值往上换
adjust(a,i,n);
for(int i=n-1; i>=0; i--)//从叶子开始不断将小值向上放,同时再调整,保证每次都是最大堆
{
temp=a[0];
a[0]=a[i];
a[i]=temp;
adjust(a,0,i);
}
}
8.快速排序
快速排序也是相对独特的一种排序方式。先确定一个基数,以它为基准线(为了代码方便一般都是取第一个数据),然后将数组中比它大的放在右边,比它小的放在右边(看上去很像插入排序,但有点区别)。先将基准线保存,然后从右向左找到第一个小于它的数,覆盖到基准位置,然后从左向右找到第一个大于它的数,然后覆盖在原先找到的比它小的数,然后不断覆盖,最终的一个位置就是基准线(也就是一开始拿来比较的数)的位置。然后再分左右边进行操作,对其左边的数据操作,右边的数据操作。然后直到最终数据长度为1。
void QuickSort(int s[], int l, int r)
{
if (l<r)
{
int i=l, j=r, key=s[l];
while(i<j)
{
while(i<j&&s[j]>=key)// 从右向左找第一个小于x的数
j--;
if(i<j)//是否越界
s[i]=s[j];
while(i<j&&s[i]<=key)// 从左向右找第一个大于等于x的数
i++;
if(i<j)//是否越界
s[j]=s[i];
}
s[i]=key;
QuickSort(s,l,i-1); // 递归调用
QuickSort(s,i+1, r);
}
}
这篇博客第一版仅仅总结总结了4种方法(到鸽巢排序为止),出于个人学习需要,再次完善,补充了4种复杂度为nlog(n)的几种常用的排序方法。个人总结,希望能对大家有帮助作用。
-------------------------------------------------第三版学习-------------------------------
重新复习,又加深了一些排序算法的理解
#include<bits/stdc++.h>
using namespace std;
/*using for print array*/
void printarr(int a[],int n)
{
for(int i=1; i<=n; i++)
cout<<a[i]<<" ";
cout<<endl;
}
/*shell sort*/
void shellsort(int a[],int n)
{
cout<<"Shell Sort:"<<endl;
for(int gap=n/2; gap>=1; gap/=2) //set gap
{
for(int i=gap+1; i<=n; i++) //modify start from gap+1
{
for(int j=i; j>=gap; j-=gap) //change the adjust element until get the proper position
{
if(a[j]<a[j-gap])
swap(a[j],a[j-gap]);
}
}
cout<<"after gap:"<<gap<<" change:";
printarr(a,n);
}
}
/*merge sort*/
/*include two parts:1.separate two parts 2.merge*/
int temp[10];
void merge_arr(int a[],int l,int mid,int r,int b[])
{
int n,m,i,j,cnt;
cnt=0;
i=l;
n=mid;
j=mid+1;
m=r;
while(i<=n&&j<=m)
{
if(a[i]>a[j])
b[cnt++]=a[j++];
else b[cnt++]=a[i++];
}
while(i<=n)b[cnt++]=a[i++];
while(j<=m)b[cnt++]=a[j++];
for(int i=0; i<cnt; i++)a[l+i]=b[i];
}
void mergesort(int a[],int l,int r)
{
if(r>l)
{
int mid = (l+r)/2;
mergesort(a,l,mid);
mergesort(a,mid+1,r);
merge_arr(a,l,mid,r,temp);
}
}
/*quick sort*/
void quicksort(int a[],int l,int r)
{
if(l<r)
{
int i=l,j=r,key=a[l];
while(i<j)
{
while(i<j&&a[j]>=key)j--;//from right to left find a number smaller than key
if(j>i)a[i]=a[j];
while(i<j&&a[i]<=key)i++;//from left to right find a number greater than key
if(j>i)a[j]=a[i];
}
a[i]=key;
quicksort(a,l,i-1);
quicksort(a,i+1,r);
}
}
void adjust(int a[],int st,int n){
int lchild = st*2;
int rchild = st*2+1;
int maxnum_index=st;
if(st<=n/2){
if(lchild<=n&&a[lchild]>a[maxnum_index])
maxnum_index=lchild;
if(rchild<=n&&a[rchild]>a[maxnum_index])
maxnum_index=rchild;
if(maxnum_index!=st){
swap(a[st],a[maxnum_index]);
adjust(a,maxnum_index,n);
}
}
}
void build_heap(int a[],int n){
for(int i=n/2;i>=1;i--)
adjust(a,i,n);
}
/*heap sort*/
/*include two parts: build heap and adjust*/
void heapsort(int a[],int n)
{
build_heap(a,n);
for(int i=n;i>=1;i--){
swap(a[i],a[1]);
adjust(a,1,i-1);
}
}
int main()
{
std::ios::sync_with_stdio(false);
int n=10,a[11]= {0,10,9,8,7,6,5,4,3,2,1};
//shellsort(a,n);
//mergesort(a,1,n);
//quicksort(a,1,n);
heapsort(a,n);
printarr(a,n);
return 0;
}