手写三大排序（快排，归并，堆排序）
归并排序(Merge_Sort)
首当其冲的是归并排序，我认为这个算法是除了O(n^2)那些垃圾的排序算法（冒泡，插入，选择）之外同样好理解的，学习成本最低，而且复杂度明显降低的。
个人认为归并排序就两个步骤：递归分治（recrusive）+子段合并（merge）
背景：
6个月前就学习了这种算法，今天再来写一遍，第一次学都会有些困惑，不过多看几遍就OK了！不加任何注释，我认为我写的代码已经勉强可以规范了，不需要注释，多看几遍代码肯定懂，看不懂就再看亿遍！
语言规范：
类C语言：cpp最好在外部定义，java写到类中即可，其他语言个人认为不适合写算法（NOIP和ACM你看哪个不是用的C+STL/C++）
先看代码：
int a[100001]={0},t[100001]={0};void _merge(int l,int mid,int r){
int l1=l,r1=mid,l2=mid+1,r2=r;
int t_l=l,t_r=l;
while(l1<=r1&&l2<=r2){
if(a[l1]<a[l2]){
t[t_l++]=a[l1++];
}else{
t[t_l++]=a[l2++];
}
}
while(l1<=r1){
t[t_l++]=a[l1++];
}
while(l2<=r2){
t[t_l++]=a[l2++];
}
while(l<=r){
a[l++]=t[t_r++];
}
}void _div(int l,int r){
if(l>=r) return;
int mid=(r-l)/2+l;
_div(l,mid);
_div(mid+1,r);
_merge(l,mid,r);
}
关于复杂度
归并的复杂度比较确定，无论数据规模，无论元素大小，时间和空间都是唯一确定的
空间复杂度O(n),时间O(n*logn)
对于这种排序，在合并的时候要利用一个新表来存取被合并的两段到一段中去，然后在复制到原表，要不然你可以用一个数组试一试，肯定会错位的，对于这种浅比较排序，每个元素e的永久位置并不极大的依赖于比较，而是暂时依赖的（不像那些深比较排序：冒泡，选择，这些深比较排序可以用swap(a,b)），等到这个元素所在的段被另外的大段合并时，这个元素e非常不可能在原来的位置，所以这是一种不稳定的排序
快速排序(Quick_Sort）
我的看法和做法：
这种排序我也没看出他快在哪？反正人家就是快，追求运气二字，不过，这种算法最坏的复杂度是O（n^2），平均也是O（n*logn）的，空间人家是 O(1)，比归并省空间。不过还要说说他这个运气是怎么回事？他这个哨兵模式的排序方法看的就是基准数字的选择，你这个基准数字选择的好，排序就快，但是对于这个基准数字的选择问题？是个玄学问题，我一般用C的种子随机数解决，播下随着time不同的种子，每次的数字不同，只要下标index在[1,n]中，数据中任取一个随机数a[index]就可；您要嫌麻烦，直接取最中间的数字a[(1+n)/2]也没事
srand(time(NULL));
int index=rand()%(n-1+1)+1;
上代码：
这个代码是某谷上某位dalao写的，因为自己写的太过于难懂晦涩（垃圾），所以...,可以看到这位dalao写的非常的短，极度清晰...对于这样的代码，我愿称之为：艺术；对于他原称为：诗人。曾有大犇说过：好的代码像一首诗，而不是演算纸.
void _swap(int *a,int *b){ int t=*a;*a=*b,*b=t; }void quick_sort(int l,int r){
int i=l,j=r,pivot=a[(l+j)/2];
do{
while(a[i]<pivot) i++;
while(a[j]>pivot) j--;
if(i<=j) _swap(a+i,a+j),i++,j--;
}while(i<=j);
if(l<j) quick_sort(l,j);
if(i<r) quick_sort(i,r);
}
堆排序(Heap_Sort）
- 在时间和空间上，这是一种优秀的算法，时间：O（n*logn），没有最坏情况，空间 O(1)
- 然而这其实已经不是一种专门的算法了，是一种持久化可维护的数据结构
- 堆呢，分大根堆和小根堆；其实STL 的优先级队列（priority_queue）就是这种结构并且可以用这种比较器来定义堆的创建方法
greater<int>();
所以，我自己手写个小根堆，将所有的数据以此填入堆中，全部填充完后，在一个一个地出队输出即可。不得不说这个堆的手写还是蛮有难度的，要考虑数组下标越界和浮动情况
代码：
/// @2084teamOS Juminiy #include#include #include #include #define MAX_N 200100 #define MAX_P 10010 #define loop(a,b) for ( int i=a;i<=b;i++ ) using namespace std ; typedef unsigned long long ull ; int qr(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
return x*f;
}void swp ( int *p ,int *q ) {
int t = p ; p=q ,q = t;
}
int n = 0 , l = 0 ;
int a [MAX_N] ={ 0 } ;
void adjusts( ) {
int cur=l ,prt = l/2 ;
while ( prt >= 1 && a[cur]>a[prt] ) {
swp (a+cur , a+prt) ;
cur /= 2 , prt /= 2 ;
}
}
void deletes( ) {
swp( a+1 , a+l ) ;
l -- ;
int cur = 1 , son = cur * 2 ;
while ( cur <= l/2 ) {
if ( son+1 <=l && a[son+1] > a[son] ) {
son += 1 ;
}
if ( a[son] > a[cur] ) {
swp (a+son , a+cur ) ;
} else break ;
cur = son , son *= 2 ;
}
}
void outputs( ) {
loop(1,n) {
cout << a[i] << " " ;
}
puts("") ;
}
int main ( void ) {n = qr(); loop(1, n) { a[++l] = qr(); adjusts(); /// outputs( ) ; } loop(1, n) { deletes( ) ; /// outputs( ) ; } outputs(); return 0;
}
/// 9 -15 21 19 -7 0 8 1 13 15
说明：
- 这个堆排序，还算比较好理解，但是实现起来比较复杂，你要注意下标越界和上浮溢出关系的错位问题，而且每个人的实现方式略有不同，（请原谅我这惊奇的码风），谢谢！！！
- _add()方法没有实现，你可以自己试着实现，因为在初始化堆的时候已经建好了结构，所以添加不会很难
- 如果实在不理解上浮过程，你可以把我注释过的代码写上，然后debug跟踪元素e的上浮过程
DESC:
- 可以看到这种数据结构的底层只是一个一维数组，但需要随数据量变长，然而对于确定的数据量来讲，也不需要变长了；
- 对于数据结构上来说，他没有任何的空间上的浪费：堆以每个元素的下标index来组织数据，时间呢？也没有：他以树形化的层次关系向上浮动数据
- 堆又叫优先级队列，顾名思义，是在排队的时候有优先级，那么根据我的经验来讲：他的任何元素在任何元素出队之后整个的树形结构和数据位置都会发生很大的改变
- 形象的比喻是这样：我们在食堂买饭，这个打饭的大妈有个亲戚，这个亲戚在长长的队伍后面，这个亲戚不愿插队还想快点吃饭，于是只要他一到食堂，食堂大妈就叫他的名字，他就走出去（出队）打饭
- 这种自己写的堆，最好数组下标index从零开始，不然会出很多麻烦
- 树形结构初始化时从index=（n-1）/2开始，因为从这个元素开始有儿子，左儿子index* 2+1,右儿子index* 2+2
- 所以他可算作是：一种非常抽象化的树形结构。