手寫三大排序（快排，歸並，堆排序）
歸並排序(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
- 所以他可算作是：一種非常抽象化的樹形結構。