1、氣泡排序演算法思想及實現

這是最原始，也是眾所周知的最慢的演算法了。

             按待排序序列的先後順序，依次比較相鄰的兩個數，將小數放在前面，大數放在後面（若二者是升序，則不作任何操作，否則交換兩個數即可）。即在第一趟：首先比較第1個數和第2個數，將小數放前面，大數放後面。然後比較第2個數和第3個數，將小數放前面，大數放後面，如此繼續，直至比較最後兩個數，將小數放前面，大數放後面。至此第一趟排序結束，最大的數在最後的位置。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前面，大數放後面，一直比較到倒數第二個數（倒數第一的位置上已經是最大的）， 第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重複以上過程，直至最終完成排序。由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，因此稱作氣泡排序。

#include <iostream>
using namespace std;

void bubble_sort(int *pData,int count)
{
	int iTemp;
	for (int i = count - 1; i >0; i--)
	{
		for ( int j = 0; j < i; j++)
		{
			if (pData[j] > pData[j+1])
			{
				iTemp = pData[j];
				pData[j] = pData[j+1];
				pData[j+1] = iTemp;
			}
		}
	}
}

void main()
{
	int data[] = {10,9,8,7,6,5,4};
	bubble_sort(data,7);
	for (int i=0;i <7; i++)
		 cout << data << " ";
	cout << "\n";
}
 

=O(g(n))=O(n*n)。所以我們程式迴圈的複雜度為O(n*n)。

[演算法思想]：將被排序的記錄陣列R[1..n]垂直排列，每個記錄R[i]看作是重量為 R[i].key的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描陣列R：凡掃描到違反本原則的輕氣泡，就使其向上"飄浮"。如此反覆進行，直到 最後任何兩個氣泡都是輕者在上，重者在下為止。

    [演算法]：

 void BubbleSort(SeqList R) {
     //R（l..n)是待排序的檔案，採用自下向上掃描，對R做氣泡排序
         int i，j；
         Boolean exchange； //交換標誌
         for(i=1;i<n;i++){ //最多做n-1趟排序
             exchange=FALSE； //本趟排序開始前，交換標誌應為假
             for(j=n-1;j>=i；j--) //對當前無序區R[i..n]自下向上掃描
                 if(R[j+1].key<R[j].key){//交換記錄
                     R[0]=R[j+1]； //R[0]不是哨兵，僅做暫存單元
                     R[j+1]=R[j]；
                     R[j]=R[0]；
                     exchange=TRUE； //發生了交換，故將交換標誌置為真
                 }
             if(!exchange) return；//本趟排序未發生交換，提前終止演算法
         } //endfor(外迴圈)
     } //BubbleSort

    [分析]：起泡排序的結束條件為：最後一趟沒有進行“交換”。從起泡排序的過程可 見，起泡排序是一個增加有序序列長度的過程，也是一個縮小無序序列長度的過程，每經過一趟起泡，無序序列的長度只縮小1。 

2、快速排序演算法思想及實現

快速排序的基本思路是：首先我們選擇一箇中間值middle（程式中我們可使用陣列中間值），把比中間值小的放在其左邊，比中間值大的放在其右邊。由於這個排序演算法較複雜，我們先給出其進行一次排序的程式框架（從各類資料結構教材中可得）：

void QuickSort(int *pData, int left, int right)
{
　int i, j;
　int middle, iTemp;
　i = left;
　j = right;
　middle = pData[(left + right) / 2]; //求中間值
　do
　{
　　while ((pData[i] < middle) && (i < right)) //從左掃描大於中值的數
　　　i++;
　　while ((pData[j] > middle) && (j > left)) //從右掃描小於中值的數
　　　j--;
　　if (i <= j) //找到了一對值
　　{
　　　//交換
　　　iTemp = pData[i];
　　　pData[i] = pData[j];
　　　pData[j] = iTemp;
　　　i++;
　　　j--;
　　}
　} while (i <= j) ; //如果兩邊掃描的下標交錯，就停止（完成一次）
　//當左邊部分有值(left<j)，遞迴左半邊
　if(left<j)
　　QuickSort (pData,left,j);
　　//當右邊部分有值(right>i)，遞迴右半邊
　if(right>i)
　　QuickSort (pData,i,right);
}

【演算法思想】
    快速排序是C.R.A.Hoare於1962年提出的一種劃分交換排序。它採用了一種分治的策略，通常稱其為分治法(Divide-and-ConquerMethod)。

分治法的基本思想：
    分治法的基本思想是：將原問題分解為若干個規模更小但結構與原問題相似的子問題。遞迴地解這些子問題，然後將這些子問題的解組合為原問題的解。
快速排序的基本思想：
    設當前待排序的無序區為R[low..high]，利用分治法可將快速排序的基本思想描述為：
分解：在R[low..high]中任選一個記錄作為基準(Pivot)，以此基準將當前無序區劃分為左、右兩個較小的子區間R[low..pivotpos-1)和R[pivotpos+1..high]，並使左邊子區間中所有記錄的關鍵字均小於等於基準記錄(不妨記為pivot)的關鍵字pivot.key，右邊的子區間中所有記錄的關鍵字均大於等於pivot.key，而基準記錄pivot則位於正確的位置(pivotpos)上，它無須參加後續的排序。
注意：
        劃分的關鍵是要求出基準記錄所在的位置pivotpos。劃分的結果可以簡單地表示為(注意pivot=R[pivotpos])：
            R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys    其中low≤pivotpos≤high。
求解：通過遞迴呼叫快速排序對左、右子區間R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
組合：因為當"求解"步驟中的兩個遞迴呼叫結束時，其左、右兩個子區間已有序。對快速排序而言，"組合"步驟無須做什麼，可看作是空操作。

【快速排序演算法QuickSort】

void QuickSort(SeqList R，int low，int high)
{
    //對R[low..high]快速排序
    int pivotpos； //劃分後的基準記錄的位置
    if(low<high)
    {
        //僅當區間長度大於1時才須排序
        pivotpos=Partition(R，low，high)； //對R[low..high]做劃分
        QuickSort(R，low，pivotpos-1)； //對左區間遞迴排序
        QuickSort(R，pivotpos+1，high)； //對右區間遞迴排序
        }
} //QuickSort

注意：

int Partition(SeqList R，int i，int j)
{
    //呼叫Partition(R，low，high)時，對R[low..high]做劃分，
    //並返回基準記錄的位置
    ReceType pivot=R[i]； //用區間的第1個記錄作為基準
    while(i<j)
    {
        //從區間兩端交替向中間掃描，直至i=j為止
        while(i<j&&R[j].key>=pivot.key) //pivot相當於在位置i上
            j--； //從右向左掃描，查詢第1個關鍵字小於pivot.key的記錄R[j]
        if(i<j) //表示找到的R[j]的關鍵字<pivot.key
            R[i++]=R[j]； //相當於交換R[i]和R[j]，交換後i指標加1
        while(i<j&&R[i].key<=pivot.key) //pivot相當於在位置j上
            i++； //從左向右掃描，查詢第1個關鍵字大於pivot.key的記錄R[i]
        if(i<j) //表示找到了R[i]，使R[i].key>pivot.key
            R[j--]=R[i]; //相當於交換R[i]和R[j]，交換後j指標減1
    } //endwhile
    R[i]=pivot； //基準記錄已被最後定位
    return i；
} //partition