编程中的排序算法多的真是不能再多了。
也是今天突发奇想，忽然打算整理出一些常用的，较为简单的几种排序算法。（以下程序都是从小到大排序）
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]);
}
}
}
从冒泡中可以发现其实其中总会有些多余的交换，因为当交换的数并不是剩余数中最小的时候，还需要继续往下找到那个最小的数，并且继续交换，因此也就产生了选择排序，先遍历一遍数组，找到剩余数据中的最小值并记录下标，然后再进行交换，避免了不必要的交换，但是复杂度并没有降低，还是没什么实质性的改变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]);
}
}
插入排序也是通过遍历数组，同时将当前数插入到当前位置之前的合适位置。如现在已经排成了（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;
}
}
}
相比上述几种方法，鸽巢排序的方法是另一种思路。不难理解，就是开一个足够大的数组，去记录数据次数，然后遍历开的数组。但是当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用的容器
}
}
堆排序是选择排序的升级版，选择排序是对每个数据都向后遍历，比对数据大小，然后选出最大的，然后两数交换。
堆排序中的难点就是如何看待堆，如何将数组看成二叉树。以及不断调整。
最容易的是理解调整。既是将父亲与自己的左右孩子中较大的那个比较（新手难点：父节点下标*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);
}
}
快速排序也是相对独特的一种排序方式。先确定一个基数，以它为基准线（为了代码方便一般都是取第一个数据），然后将数组中比它大的放在右边，比它小的放在右边（看上去很像插入排序，但有点区别）。先将基准线保存，然后从右向左找到第一个小于它的数，覆盖到基准位置，然后从左向右找到第一个大于它的数，然后覆盖在原先找到的比它小的数，然后不断覆盖，最终的一个位置就是基准线（也就是一开始拿来比较的数）的位置。然后再分左右边进行操作，对其左边的数据操作，右边的数据操作。然后直到最终数据长度为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;
}
5531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
