排序算法 1，冒泡排序 原文鏈接（http://www.cnblogs.com/kkun/archive/2011/11/23/2260280.html）
經典排序算法 - 冒泡排序Bubble sort 原理是臨近的數字兩兩進行比較,按照從小到大或者從大到小的順序進行交換, 這樣一趟過去后,最大或最小的數字被交換到了最后一位, 然后再從頭開始進行兩兩比較交換,直到倒數第二位時結束,其余類似看例子 例子為從小到大排序, 原始待排序數組| 6 | 2 | 4 | 1 | 5 | 9 |
第一趟排序(外循環) 第一次兩兩比較6 > 2交換(內循環) 交換前狀態| 6 | 2 | 4 | 1 | 5 | 9 | 交換后狀態| 2 | 6 | 4 | 1 | 5 | 9 |
第二次兩兩比較,6 > 4交換 交換前狀態| 2 | 6 | 4 | 1 | 5 | 9 | 交換后狀態| 2 | 4 | 6 | 1 | 5 | 9 |
第三次兩兩比較,6 > 1交換 交換前狀態| 2 | 4 | 6 | 1 | 5 | 9 | 交換后狀態| 2 | 4 | 1 | 6 | 5 | 9 |
第四次兩兩比較,6 > 5交換 交換前狀態| 2 | 4 | 1 | 6 | 5 | 9 | 交換后狀態| 2 | 4 | 1 | 5 | 6 | 9 |
第五次兩兩比較,6 < 9不交換 交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 | 交換后狀態| 2 | 4 | 1 | 5 | 6 | 9 |
第二趟排序(外循環) 第一次兩兩比較2 < 4不交換 交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 | 交換后狀態| 2 | 4 | 1 | 5 | 6 | 9 |
第二次兩兩比較,4 > 1交換 交換前狀態| 2 | 4 | 1 | 5 | 6 | 9 | 交換后狀態| 2 | 1 | 4 | 5 | 6 | 9 |
第三次兩兩比較,4 < 5不交換 交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 | 交換后狀態| 2 | 1 | 4 | 5 | 6 | 9 |
第四次兩兩比較,5 < 6不交換 交換前狀態| 2 | 1 | 4 | 5 | 6 | 9 | 交換后狀態| 2 | 1 | 4 | 5 | 6 | 9 |
第三趟排序(外循環) 第一次兩兩比較2 > 1交換 交換后狀態| 2 | 1 | 4 | 5 | 6 | 9 | 交換后狀態| 1 | 2 | 4 | 5 | 6 | 9 |
第二次兩兩比較,2 < 4不交換 交換后狀態| 1 | 2 | 4 | 5 | 6 | 9 | 交換后狀態| 1 | 2 | 4 | 5 | 6 | 9 |
第三次兩兩比較,4 < 5不交換 交換后狀態| 1 | 2 | 4 | 5 | 6 | 9 | 交換后狀態| 1 | 2 | 4 | 5 | 6 | 9 |
第四趟排序(外循環)無交換 第五趟排序(外循環)無交換
排序完畢,輸出最終結果1 2 4 5 6 9
C語言代碼
#include <iostream>using namespace std;// 冒泡排序extern void swap( int *a, int *b);int main(int argc, char* argv[]){ int arr[10] = { 8,5,2,1,3,7,6,9,0,4 }; for( int i = 0; i < 10; i ++ ) { for( int j = i+1; j < 10; j ++ ) { if( arr[i] > arr[j] ) { swap( &arr[i], &arr[j] ); } } } { cout << "冒泡排序結果" << endl; for( int i = 0; i < 10; i ++ ) { cout << arr[i] << " "; } cout << endl; } return 0;}void swap(int *a, int *b) { int c; c = *a; *a = *b; *b = c; }2，選擇排序 原文鏈接（http://www.cnblogs.com/luchen927/archive/2012/02/27/2367108.html） 選擇排序的思想。從所有序列中先找到最小的，然后放到第一個位置。之后再看剩余元素中最小的，放到第二個位置……以此類推，就可以完成整個的排序工作了。可以很清楚的發現，選擇排序是固定位置，找元素。相比于插入排序的固定元素找位置，是兩種思維方式。不過條條大路通羅馬，兩者的目的是一樣的。
C語言代碼
3，快速排序 原文鏈接（百度百科：快速排序） 快速排序（Quicksort）是對冒泡排序的一種改進。 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
1算法介紹 設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用數組的第一個數）作為關鍵數據，然后將所有比它小的數都放到它前面，所有比它大的數都放到它后面，這個過程稱為一趟快速排序。值得注意的是，快速排序不是一種穩定的排序算法，也就是說，多個相同的值的相對位置也許會在算法結束時產生變動。 一趟快速排序的算法是： 1）設置兩個變量i、j，排序開始的時候：i=0，j=N-1； 2）以第一個數組元素作為關鍵數據，賦值給key，即key=A[0]； 3）從j開始向前搜索，即由后開始向前搜索(j–)，找到第一個小于key的值A[j]，將A[j]和A[i]互換； 4）從i開始向后搜索，即由前開始向后搜索(i++)，找到第一個大于key的A[i]，將A[i]和A[j]互換； 5）重復第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小于key,4中A[i]不大于key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指針位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令循環結束）。
2排序演示 假設用戶輸入了如下數組： 下標 0 1 2 3 4 5 數據 6 2 7 3 8 9 創建變量i=0（指向第一個數據）, j=5(指向最后一個數據), k=6(賦值為第一個數據的值)。 我們要把所有比k小的數移動到k的左面，所以我們可以開始尋找比6小的數，從j開始，從右往左找，不斷遞減變量j的值，我們找到第一個下標3的數據比6小，于是把數據3移到下標0的位置，把下標0的數據6移到下標3，完成第一次比較： 下標 0 1 2 3 4 5 數據 3 2 7 6 8 9 i=0 j=3 k=6 接著，開始第二次比較，這次要變成找比k大的了，而且要從前往后找了。遞加變量i，發現下標2的數據是第一個比k大的，于是用下標2的數據7和j指向的下標3的數據的6做交換，數據狀態變成下表： 下標 0 1 2 3 4 5 數據 3 2 6 7 8 9 i=2 j=3 k=6 稱上面兩次比較為一個循環。 接著，再遞減變量j，不斷重復進行上面的循環比較。 在本例中，我們進行一次循環，就發現i和j“碰頭”了：他們都指向了下標2。于是，第一遍比較結束。得到結果如下，凡是k(=6)左邊的數都比它小，凡是k右邊的數都比它大： 下標 0 1 2 3 4 5 數據 3 2 6 7 8 9 如果i和j沒有碰頭的話，就遞加i找大的，還沒有，就再遞減j找小的，如此反復，不斷循環。注意判斷和尋找是同時進行的。 然后，對k兩邊的數據，再分組分別進行上述的過程，直到不能再分組為止。 注意：第一遍快速排序不會直接得到最終結果，只會把比k大和比k小的數分到k的兩邊。為了得到最后結果，需要再次對下標2兩邊的數組分別執行此步驟，然后再分解數組，直到數組不能再分解為止（只有一個數據），才能得到正確結果。 C語言代碼 // 快速排序
// 快速排序#include "stdafx.h"#include <stdio.h>#include <stdlib.h> const int MAX_ELEMENTS = 10;extern void PRintlist(int list[],int n);extern void swap(int *x,int *y);extern int choose_pivot(int i,int j );extern void quicksort(int list[],int m,int n);void main(){ int list[10] = { 8,5,2,1,3,7,6,9,0,4 }; printf("快速排序前:/n"); printlist(list,MAX_ELEMENTS); // sort the list using quicksort quicksort(list,0,MAX_ELEMENTS-1); // print the result printf("快速排序后:/n"); printlist(list,MAX_ELEMENTS);}void printlist(int list[],int n){ int i; for(i=0;i<n;i++) printf("%d/t",list[i]);}void swap(int *x,int *y){ int temp; temp = *x; *x = *y; *y = temp;}int choose_pivot(int i,int j ){ return((i+j) /2);}void quicksort(int list[],int m,int n){ printlist(list,MAX_ELEMENTS); int key,i,j,k; if( m < n) { k = choose_pivot(m,n); swap(&list[m],&list[k]); key = list[m]; i = m+1; j = n; while(i <= j) { while((i <= n) && (list[i] <= key)) i++; while((j >= m) && (list[j] > key)) j--; if( i < j) swap(&list[i],&list[j]); } swap(&list[m],&list[j]); quicksort(list,m,j-1); quicksort(list,j+1,n); }}4，歸并排序 原文鏈接（百度百科：歸并排序） 歸并排序（MERGE-SORT）是建立在歸并操作上的一種有效的排序算法,該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為二路歸并。 歸并過程為：比較a[i]和a[j]的大小，若a[i]≤a[j]，則將第一個有序表中的元素a[i]復制到r[k]中，并令i和k分別加上1；否則將第二個有序表中的元素a[j]復制到r[k]中，并令j和k分別加上1，如此循環下去，直到其中一個有序表取完，然后再將另一個有序表中剩余的元素復制到r中從下標k到下標t的單元。歸并排序的算法我們通常用遞歸實現，先把待排序區間[s,t]以中點二分，接著把左邊子區間排序，再把右邊子區間排序，最后把左區間和右區間用一次歸并操作合并成有序的區間[s,t]。
C語言代碼
//// 歸并排序#include "stdafx.h"#include<iostream> using namespace std; #include "stdio.h"#include "stdlib.h"const int MAX_ELEMENTS = 10;//第一個參數為需要排序的數組，第2個參數為分割的第一個數組開始元素的下標 //第3個參數為分割的第一個數組的最后1個元素的下標 //第4個參數為數組最后1個元素的下標 extern void Merge(int *A,int p,int q,int r); extern void MergeSort(int *A,int p,int r);extern void printlist(int list[],int n);void main() { int list[MAX_ELEMENTS] = { 8,5,2,1,3,7,6,9,0,4 }; cout << "歸并排序前" << endl; printlist(list,MAX_ELEMENTS); MergeSort( list, 0, MAX_ELEMENTS-1 ); cout << "歸并排序后" << endl; printlist(list,MAX_ELEMENTS); system("pause"); } void Merge(int *A,int p,int q,int r) { int n1,n2,i,j,k,g; n1=q-p+1; n2=r-q; int *L,*R; L=(int *)malloc(sizeof(int)*(n1+1)); R=(int *)malloc(sizeof(int)*(n2+1)); L[n1]=0x7fff; //開辟的左右2個數組最后1個數設置為最大值 R[n2]=0x7fff; g=0; for(i=p;i<=q;i++) { L[g]=A[i]; g++; } g=0; for(i=q+1;i<=r;i++) { R[g]=A[i]; g++; } //逐個比較左右兩組數組，把較小的值寫入原來的數組 j=k=0; for(i=p;i<=r;i++) { if(L[j]<R[k]) { A[i]=L[j]; j++; } else { A[i]=R[k]; k++; } } } void MergeSort(int *A,int p,int r) { int q; if(p<r) //當第一個元素比最后1個元素還小時，繼續執行遞歸，直到只剩下一個元素（形參p=r） { q=(p+r)/2; MergeSort(A,p,q); MergeSort(A,q+1,r); Merge(A,p,q,r); } } void printlist(int list[],int n){ int i; for(i=0;i<n;i++) printf("%d/t",list[i]);}新聞熱點
疑難解答
