总结:
O(n^2) 冒泡/插入/选择
O(nlogn) 快速/归并/堆
O(n^1.3) Shell排序
O(n) 桶/基数(位数差别不大,先低位排序后高位排序)/箱子
数据为正序时,插入和冒泡最佳。
稳定排序: 冒泡/插入/基数/归并。
不稳定排序:选择/快速/shell/堆。
邻近交换的排序基本上是稳定的,存在远距离交换的是不稳定排序。
具体代码如下:
#include<algorithm>
/* 冒泡排序:相邻元素比较;n为数据长度*/
template<typename T>
void BubbleSort(T* r, int n)
{ T temp; bool empty;
for(int i=0;i<n-1;i++)
{ empty=false;
for(int j=0;j<n-1-i;j++)
if(r[j]>r[j+1])
{temp=r[j];r[j]=r[j+1];r[j+1]=temp; empty=true;}
if(!empty)
return ;
}
}
/*快速排序:左边比他小,右边比他大,递归实现;
定义的一个关键数据,可以省去数据交换操作
low=0,high=数据长度-1*/
template<typename T>
void QuickSort(T a[],int low,int high)
{ if(low >=high)
return ;
T elem = a[low]; int l = low, r = high;
while(l < r)
{ while(l < r && a[r] >= elem) r--;
if (l < r){ a[l++] = a[r]; }
while(l< r && a[l] <= elem) l++;
if (l < r) { a[r--] = a[l]; }
}
a[r] = elem;
QuickSort(a,low,r-1);
QuickSort(a,r+1,high);
}
/*插入排序:数据向右移动,a[j+1]=a[j]
n为数据长度*/
template<typename T>
void InsertSort(T a[],int n)
{ int i,j; T elem;
for (i=1;i<n ;++i)
{ j = i- 1; elem = a[i];
while(j>=0 && elem < a[j] ) { a[j+1] = a[j]; j--; }
a[j+1] = elem;
}
}
/*希尔(shell)排序:分组进行插入排序(把插入排序1的改成d即可)
n为数据长度*/
template<typename T>
void ShellInsert(T arra[],int d,int n)
{ int i,j; T elem;
for ( i = d;i < n;i++) //首个下标从d开始
{ j = i - d; elem = arra[i];
while (j >= 0 && elem < arra[j])
{ arra[j+d] = arra[j]; j = j - d; }
arra[j+d] = elem;
}
}
template<typename T>
void ShellSort(T arra[],int n)
{ int inc = n;
do { inc = inc/2;
ShellInsert(arra,inc,n);
} while (inc > 1);
}
/*选择排序:在未排序中找出最小的放在前面*/
template <typename T>
void SelectSort(T a[],int n)
{ T elem;
for (int i=0;i<n-1;i++)
{ int elemNum = i;
for (int j= i+1;j<n;j++)
if (a[j] < a[elemNum])
elemNum = j;
if (elemNum != i)
{ elem = a[i]; a[i] = a[elemNum]; a[elemNum] = elem;}
}
}
/*归并排序:左边小取左边,左边++;右边小取右边,右边++*/
template<typename T>
void Merge(T arra[], int low, int mid, int high)
{ int k; T *temp = new T[high-low+1];
int begin1 = low, end1 = mid, begin2 = mid + 1, end2 = high;
for (k = 0; begin1 <= end1 && begin2 <= end2; ++k)
{ if(arra[begin1]<=arra[begin2]) temp[k] = arra[begin1++];
else temp[k] = arra[begin2++];
}
if(begin1 <= end1)
for(int p=begin1;p<=end1;p++) temp[k++]=arra[p];
if(begin2 <= end2)
for(int p=begin2;p<=end2;p++) temp[k++]=arra[p];
for(int s=left;s<=right;s++) arra[s]=temp[s-left];
delete []temp;
}
template<typename T>
void MergeSort(T arra[], unsigned int first, unsigned int last)
{ int mid = 0;
if(first>=last) return;
mid = (first+last)/2;
MergeSort(arra, first, mid);
MergeSort(arra, mid+1,last);
Merge(arra,first,mid,last);
}
//*堆排序*/
template <typename E>
void HeapDown( E a[],int pos,int len)
{ E temp=a[pos]; int k=pos;//插入排序的思想
for(int i=2*k+1;i<len;i=2*i+1)//下标从0开始
{ if(i<len-1 && a[i]<a[i+1]) i++;
if(a[i]>temp) {a[k]=a[i];k=i;}
else break;
}
a[k]=temp;
}
template <typename E>
void HeapSort( E a[],int n)
{ for(int i=n/2;i>=0;i--) HeapDown(a,i,n);//建堆
for(int j=n-1;j>=1;j--)
{ swap(a[j],a[0]);
HeapDown(a,0,j);
}
}
add here 2016-07-28,程序猿闲来无事,重写了一份,比上面稍微简洁点
/******************
各种排序算法的源代码
*******************/
#include<iostream>
#include<algorithm>
using namespace std;
void swap( int & a, int & b){
int temp=a;
a=b;
b=temp;
}
/*冒泡排序*/
void bubbleSort(int * a ,int n){
for(int i=0;i<n-1;i++){
bool f=false;
for(int j=0;j<n-1-i;j++){
if(a[j]>a[j+1]){
swap(a[j],a[j+1]);
f=true;
}
}
if(f == false){
return ;
}
}
}
/*快速排序, 模版类实现*/
template <class T>
void quickSort( T * a, int left ,int right){
if(left>= right){ return ; }
int l=left,r=right;
T temp=a[left];
while(l < r){
while( l<r && a[r]> temp){ r--;}
if(l< r){ a[l++]=a[r];}
while(l<r && a[l]<temp){l++;}
if(l<r){ a[r--]=a[l];}
}
a[r]=temp;
quickSort(a,left,r-1);
quickSort(a,r+1,right);
}
/*数组排序, 模版类实现。*/
template <class T>
void merge(T * a ,int left,int middle ,int right){
if(left>middle || middle> right) return;
T * pTemp=new T[right-left+1];
int l=left,r=middle+1;
int i=0;
while(l<=middle && r<= right){
if(a[l]<a[r]){
pTemp[i++]=a[l++];
}else{
pTemp[i++]=a[r++];
}
}
while(l<=middle){
pTemp[i++]=a[l++];
}
while(r<=right){
pTemp[i++]=a[r++];
}
for(int i=0;i<(right-left+1);i++){
a[left+i]=pTemp[i];
}
delete pTemp;
return ;
}
/*归并排序, 模版类实现*/
template <class T>
void mergeSort( T * a ,int l,int r){
if(l>=r) return ;
int m=((r-l)>>1)+l;
mergeSort(a,l,m);
mergeSort(a,m+1,r);
merge(a,l,m,r);
}
/*选择排序,模版类实现*/
template <class T>
void selectSort(T * a,int n){
for(int i=0;i<n-1;i++){
int k=i;
for(int j=i;j<n;j++){
if(a[k]>a[j]){
k=j;
}
}
if(k != i){
swap(a[k],a[i]);
}
}
}
/*插入排序,模版类实现*/
template <class T>
void insertSort(T * a, int n){
for(int i=1;i<n;i++){
T temp=a[i];
int j=i-1;
while(j>=0 && a[j]>temp){ a[j+1]=a[j]; j--;}
a[j+1]=temp;
}
}
/*shell希尔排序,模版类实现,相当于从0开始步距为d的sort排序*/
template < class T>
void shellSort(T * a ,int n ,int d){
for(int i=d;i<n;i+=d){
T temp=a[i];
int j=i-d;
while(j>=0 && a[j]>temp){a[j+d]=a[j];j-=d;}
a[j+d]=temp;
}
}
template < class T>
void shell(T * a ,int n){
if(n<=1) return ;
int d=n>>1;
while(d>=1){
shellSort(a,n,d);
d=d>>1;
}
}
/*堆排序,模板类实现
asc排序,用到最大堆*/
template <class T>
void heapDown(T * a , int n ,int nodePos){
int p=nodePos;
T temp=a[p];
for(int k=2*nodePos+1;k<n;k=2*k+1){
if(k+1<n && a[k+1]>a[k]){
k++;
}
if(a[k]> temp){
a[p]=a[k];p=k;
}else{
break;
}
}
a[p]=temp;
}
template <class T>
void heapSort(T a[] ,int n){
for(int i=n/2;i>=0;i--){
heapDown(a,n,i);
}
for(int i=n-1;i>=1;i--){
swap(a[i],a[0]);
heapDown(a,i,0);
}
}
int main(){
cout<<"start"<<endl;
int a[10]={5,4,2,1,3,9,8,6,0,7};
//bubbleSort(a,10);
//quickSort(a,0,9);
//mergeSort(a,0,9);
//selectSort(a,10);
//insertSort(a,10);
//shell(a,10);
heapSort(a,10);
for(int j=0;j<10;j++){
cout<<a[j]<<"\t";
}
cout<<endl<<"end"<<endl;
return 0;
}