[排序算法] 交換排序（2種）

1.冒泡排序

【思想】不停地比較相鄰的記錄，如果不滿足排序要求就交換相鄰數據，直到所有的記錄都已經排好序

【特點】穩定

 空間代價：O(1)

 時間代價：O(n^2)

 -比較次數　　　　　　　 -交換次數　

·最少：O(n)　　　　　　·最少：0

·最多：O(n^2)　　　　　·最多：O(n^2)

void BubbleSort(int Array[], int n)
{
    bool NoSwap;            // 是否發生了交換的標志
    int i, j;
    for(i = 0; i < n-1; i ++)
    {
        NoSwap = true;        // 標志初始為真
        for(j = n - 1; j > i; j --)
            if(Array[j] < Array[j-1])  // 判斷是否逆置
            {
                swap(Array[j], Array[j - 1]);    // 交換逆置對
                NoSwap = false;    // 發生了交換，標志變為假
            }
        if (NoSwap) return;        // 沒發生交換，則排好序
    }
}

2.快速排序

【思想】基於分治法的排序

·選擇軸值（pivot）

·將序列划分為兩個子序列L和R，使得L中的所有記錄都小於或等於軸值，R中的記錄都大於軸值

·對子序列L和R遞歸進行快速排序

【特點】不穩定

 空間代價：O(logn)

 時間代價：O(nlogn)

分治策略的基本思想：

 -分 -- 划分子問題

 -治 -- 求解子問題（子問題不重疊）

 -合 -- 綜合解

軸值選擇：

·盡可能使L,R長度相等

·選擇策略：

　-選擇最左邊記錄（第一個記錄）

  -隨機選擇

  -選擇平均值

分割過程（整個快速排序的關鍵）：

·分割算法1

（1）備份軸值（首記錄）

（2）取兩個指針low和high，初始值就設為第二個元素和最后一個元素的下標，low <= high

（3）移動兩個指針

　　·從high所指位置向左搜索，找到第一個比軸值小的元素

　　·從low所指位置向右搜索，找到第一個比軸值大的元素

（4）交換low和high兩位置的值

（5）重復（3）、（4）兩步驟的過程，直到low > high

（6）把軸放在high所指的位置

int Partition1(int Array[], int first, int last)
{
    int low = first + 1,high = last;
    int pivot = Array[first];
    while(low <= high)
    {
        while(low <= high && Array[low] <= pivot) low++;
        while(low <= high && Array[high] > pivot) high --;
        if(low < high)
            swap(Array[high--] , Array[low++]);
    }
    swap(Array[first],Array[high]);
    return high;
}
void QSort(int Array[], int first, int last)
{
    if(first < last)
    {
        int x = Partition1(Array,first,last);
        QSort(Array,first,x - 1);
        QSort(Array,x + 1,last);
    }
}

·分割算法2

（1）備份軸值（首記錄）

（2）取兩個指針low和high，初始值就是序列兩端的下標，保證low <= high

（3）移動兩個指針

　　·從high所指位置向左搜索，找到第一個比軸值小的元素，將其放在low的位置

　　·從low所指位置向右搜索，找到第一個比軸值大的元素，將其放在high的位置

（4）交換low和high兩位置的值

（5）重復（3）、（4）兩步驟的過程，直到low = high

（6）把軸放在low所指的位置

int Partition2(int Array[], int first, int last)
{
    int low = first, high = last;
    int pivot = Array[first];
    while(low < high)
    {
        while(low <= high && Array[high] >= pivot) high --;
        Array[low] = Array[high];
        while(low < high && Array[low] <= pivot) low ++;
        Array[high] = Array[low];
    }
    Array[low] = pivot;
    return low;
}
void QSort(int Array[], int first, int last)
{
    if(first < last)
    {
        int x = Partition2(Array,first,last);
        QSort(Array,first,x - 1);
        QSort(Array,x + 1,last);
    }
}