八種排序算法總結之C++版本
五種簡單排序算法
一、 冒泡排序 【穩定的】
void BubbleSort( int* a,int Count ) //實現從小到大的最終結果
{
int temp;
for(int i=1;i<Count; i++) //外層每循環一次，將最小的一個移動到最前面
for(int j=Count-1;j>=i; j--)
if( a[j] < a[j-1] )
{
temp =a[j];
a[j] =a[j-1];
a[j-1] =temp;
}
}
現在注意，我們給出O方法的定義：
若存在一常量K和起點n0，使當n>=n0時，有f(n)<=K*g(n),則f(n) = O(g(n))。（呵呵，不要說沒學好數學呀，對於編程數學是非常重要的！！！）
現在我們來看1/2*(n-1)*n，當K=1/2，n0=1，g(n)=n*n時，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n) =O(g(n))=O(n*n)。所以我們程序循環的複雜度爲O(n*n)。
二、 交換排序 【穩定的】
void ExchangeSort( int *a,int Count)
{
int temp;
for(int i=0;i<Count-1; i++)
for(int j=i+1;j<Count; j++)
if( a[j] < a[i] )
{
temp =a[j];
a[j] =a[i];
a[i] =temp;
}
}
時間複雜度爲O(n*n)。
三、 選擇法 【不穩定的】
void SelectSort( int *a,int Count)
{
int temp; //一個存儲值
int pos; //一個存儲下標
for(int i=0;i<Count; i++)
{
temp = a[i];
pos = i;
for(int j=i+1;j<Count; j++)
if( a[j] < temp ) //選擇排序法就是用第一個元素與最小的元素交換
{
temp =a[j];
pos = j; //下標的交換賦值，記錄當前最小元素的下標位置
}
a[pos] = a[i];
a[i] = temp;
}
}
遺憾的是算法需要的循環次數依然是1/2*(n-1)*n。所以算法複雜度爲O(n*n)。
我們來看他的交換。由於每次外層循環只產生一次交換（只有一個最小值）。所以f(n)<=n
所以我們有f(n)=O(n)。所以，在數據較亂的時候，可以減少一定的交換次數。
四、 插入法 【穩定的】
void InsertSort( int *a,int Count)
{
int temp; //一個存儲值
int pos; //一個存儲下標
for(int i=1;i<Count; i++) //最多做n-1趟插入
{
temp = a[i]; //當前要插入的元素
pos = i-1;
while( pos>=0 && temp<a[pos] )
{
a[pos+1] =a[pos]; //將前一個元素後移一位
pos--;
}
a[pos+1] = temp;
}
}
其複雜度仍爲O(n*n)。
最終，我個人認爲，在簡單排序算法中，直接插入排序是最好的。
五、 希爾排序法 【不穩定的】
* 希爾排序，n爲數組的個數
*/
void ShellSort( int arr[], int n )
{
int temp,pos;
int d = n; //增量初值
do{
d = d/3 + 1 ;
for(int i= d;i<n; i++ )
{
temp =arr[i];
pos = i-d;
while(pos>=0 && temp < arr[pos] ) { //實現增量爲d的插入排序
arr[ pos+ d ] = arr[pos];
pos -=d;
}
arr[ pos + d] = temp;
}
} while( d > 1 );
}
三種高級排序算法
一、 快速排序 輔助空間複雜度爲O（1） 【不穩定的】
void QuickSort( int *a,int left, int right)
{
int i,j,middle,temp;
i = left;
j = right;
middle = a[(left+right)/2 ];
do
{
while( a[i]<middle && i<right ) //從左掃描大於中值的數
i++;
while( a[j]>middle && j>left ) //從右掃描小於中值的數
j--;
if( i<=j ) //找到了一對值
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
j--;
}
} while ( i<j ); //如果兩邊的下標交錯，就停止(完成一次)
//當左半邊有值（left<j）,遞歸左半邊
if( left < j )
QuickSort( a,left, j);
//當右半邊有值（right>i）,遞歸右半邊
if( i < right )
QuickSort( a, i,right);
}
它的工作看起來象一個二叉樹。首先我們選擇一箇中間值middle，程序中我們使用數組中間值，然後把比它小的放在左邊，大的放在右邊（具體的實現是從兩邊找，找到一對後交換）。然後對兩邊分別使用這個過程（最容易的方法——遞歸）。注意，由於數據的隨機性，對middle的選擇並不會影響該算法的效率。
注意，在掃描過程中，對於給定參考值，對於向右(左)掃描，如果掃描值大(小)於或等於參考值，就需要進行交換。最終得到的結果是，j左邊的值都小於參考值，而i右邊的值都大於參考值，j和i之間的值都等於參考值。對j左邊和i右邊的分別使用遞歸，就可以完成最終的排序。
這裏我沒有給出行爲的分析，因爲這個很簡單，我們直接來分析算法：首先我們考慮最理想的情況
1.數組的大小是2的冪，這樣分下去始終可以被2整除。假設爲2的k次方，即k=log2(n)。
2.每次我們選擇的值剛好是中間值，這樣，數組纔可以被等分。
第一層遞歸，循環n次，第二層循環2*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n)= n+n+n+...+n=k*n=log2(n)*n
所以算法複雜度爲O(log2(n)*n)
其他的情況只會比這種情況差，最差的情況是每次選擇到的middle都是最小值或最大值，那麼他將變
成交換法（由於使用了遞歸，情況更糟），但是糟糕的情況只會持續一個流程，到下一個流程的時候就很可能已經避開了該中間的最大和最小值，因爲數組下標變化了，於是中間值不在是那個最大或者最小值。但是你認爲這種情況發生的機率有多大？？呵呵，你完全不必擔心這個問題。實踐證明，大多數的情況，快速排序總是最好的。
如果你擔心這個問題，你可以使用堆排序，這是一種穩定的O(log2(n)*n)算法，但是通常情況下速度要慢
於快速排序（因爲要重組堆）。
二、 歸併排序（兩種實現方法均要掌握） 【穩定的】
歸併排序是一種極好的外部排序方法，即針對數據保存在磁盤上而不是高速內存中的問題。
//以下程序參考數據結構課本P286頁的模板,爲使用指針鏈表實現的
#include <iostream>
using namespace std;
struct node{ //鏈表的節點數據
int value;
node *next;
};
node * divide_from( node * head )
{
node * position, *midpoint, * second_half;
if( (midpoint=head) == NULL ) //List is empty
return NULL;
position =midpoint->next;
while( position != NULL ) //Moveposition twice for midpoint's one move
{
position =position->next;
if( position != NULL )
{
midpoint =midpoint->next;
position =position->next;
}
}
second_half = midpoint->next;
midpoint->next =NULL; //在這裏將原鏈拆斷，分爲兩段
return second_half;
}
node * merge( node * first, node * second)
{
node * last_sorted; //當前已經鏈接好的有序鏈中的最後一個節點
node combined; //啞節點
last_sorted =&combined;
while( first!=NULL && second!=NULL )
{
if( first->value < second->value ) {
last_sorted->next= first;
last_sorted= first;
first =first->next;
}else {
last_sorted->next= second;
last_sorted= second;
second =second->next;
}
}
if( first==NULL )
last_sorted->next= second;
else
last_sorted->next= first;
return combined.next; //返回啞節點的後繼指針，即爲合併後的鏈表的頭指針
}
//這裏的參數必須是引用調用，需要這個指引去允許函數修改調用自變量
void MergeSort( node * &head)
{
if( head != NULL && head->next != NULL ) //如果只有一個元素，則不需排序
{
node *second_half = divide_from( head );
MergeSort( head);
MergeSort( second_half);
head = merge(head, second_half );
}
}
int main()
{
node a,b,c,d;
node *p1, *p2, *p3,*p4,*head;
p1 = &a;
p2 = &b;
p3 = &c;
p4 = &d;
a.value = 2;
b.value = 4;
c.value = 3;
d.value = 1;
a.next = p2;
b.next = p3;
c.next = p4;
d.next = NULL;
//調用歸併排序前的結果
head = p1;
while( head != NULL )
{
cout<<head->value<<" ";
head =head->next;
}
cout<<endl;
MergeSort( p1 );
//調用歸併排序後的結果
head = p1;
while( head != NULL )
{
cout<<head->value<<" ";
head =head->next;
}
cout<<endl;
}
//以下程序爲使用數組實現的歸併排序,輔助空間複雜度爲O（n）
#include <iostream>
using namespace std;
void Merge( int data[], int left, int mid, int right )
{
int n1,n2,k,i,j;
n1 = mid - left + 1;
n2 = right - mid;
int *L = new int[n1]; //兩個指針指向兩個動態數組的首地址
int *R = new int[n2];
for( i=0,k=left; i<n1; i++,k++)
L[i] = data[k];
for( i=0,k=mid+1; i<n2; i++,k++)
R[i] = data[k];
for( k=left,i=0,j=0; i<n1 && j<n2; k++){
if( L[i] < R[j] ) { //取小者放前面
data[k] =L[i];
i++;
} else {
data[k] =R[j];
j++;
}
}
if( i<n1 ) //左邊的數組尚未取盡
for( j=i; j < n1; j++,k++)
data[k] =L[j];
else
//if( j<n2 ) //右邊的數組尚未取盡 ,這句話可要可不要
for( i=j; i<n2; i++,k++)
data[k] =R[i];
delete []L; //回收內存
delete []R;
}
/*
* left:數組的開始下標，一般爲0；right：數組的結束下標，一般爲 （n-1）
*/
void MergeSort( int data[], int left, int right )
{
if( left < right )
{
int mid = left + ( right-left ) / 2; //mid=(right+left)/2，防止溢出
MergeSort( data,left, mid );
MergeSort( data, mid+1, right );
Merge( data ,left, mid , right );
}
}
int main()
{
int data[] = {9,8,7,2,5,6,3,55,1};
//排序前的輸出
for(int i=0; i<9;i++)
cout<<data[i]<<" ";
cout<<endl;
MergeSort( data, 0,8);
//排序後的輸出
for(int i=0; i<9;i++)
cout<<data[i]<<" ";
cout<<endl;
}
三、 堆排序 【不穩定的】
/*
* 向堆中插入current元素的函數
*/
void insert_heap( int data[], const int ¤t, intlow, int high )
{
int large; //元素data[low]左右兒子中，大者的位置
large = 2*low + 1;
while( large <= high ) {
if( large < high && data[large] < data[large+1] )
large++;
if( current > data[ large ] ) //待插入元素的值比它的兩個兒子都大
break;
else {
data[ low ]= data[ large ]; //將其左右兒子的大者上移
low = large;
large = 2 *large + 1;
}
}
data[ low ] =current;
}
/*
* 建立堆函數，num爲數組data的元素個數
* 只有一個結點的<2-樹>自動滿足堆的屬性，因此不必擔心樹中的任何樹葉，即
* 不必擔心表的後一半中的元素。如果從表的中間點開始並從後向前工作，就
* 能夠使用函數insert_heap去將每個元素插入到包含了所有後面元素的部分堆
* 中，從而創建完整的堆。
*/
void build_heap( int data[], int num )
{
int current;
for( int low = num/2- 1; low>=0; low-- ) {
current = data[low ];
insert_heap(data, current, low, num-1 );
}
}
/*
* 堆排序主函數,num爲數組data的元素個數
*/
void heap_sort( int data[], int num )
{
int current, last_sorted;
build_heap( data,num ); //建立堆
for( last_sorted = num-1; last_sorted>0;last_sorted-- ) { //逐個元素處理
current = data[last_sorted ];
//data[0]在整個數組排序結束前，存儲的是待排序元素中最大的元素
data[last_sorted]= data[0];
insert_heap(data, current, 0, last_sorted-1 );
}
}
int main()
{
//用於排序算法的輸入輸出
int a[8] = {5,7,1,2,9,4,6,3,};
for(int i=0; i< sizeof(a)/sizeof(int); i++)
cout<<a[i]<<"";
cout<<endl;
heap_sort( a, 8 ); //調用堆排序
for(int i=0; i< sizeof(a)/sizeof(int); i++)
cout<<a[i]<<"";
cout<<endl;
return 0;
}