寫在前面

氣泡排序

氣泡排序其實是非常簡單，他就是把一個數與他的前一個數在比較與交換的過程；

這個簡單，我就直接上程式碼了：
版本一：

//最簡單直接，但是效率不高
void BulleSort(int* array, int size)
{
    for(size_t i = 0; i < size; i++)
    {
        for(size_t j = 0; j < size - i - 1; j++)
        {
            if(array[j] > array[j + 1])
                swap(array
 
[j], array[j + 1]);
        }
    }
}

版本二：

void BulleSort(int* array, int size)
{
    int j, k;
    bool flag;
    flag = true;
    k = size;
    while(flag)
    {
        flag = false;
        for(size_t j = 1; j < size; j++)
        {
            if(array[j] < array[j - 1])
            {               
                swap(array
 
[j], array[j - 1])；
                flag = true;
            }
        }
        k--;
    }
}

快速排序

快排的答題思路就是這個樣子，但是我們需要進一步進行深挖：

快排第一種：

左右指標法：
1. 選好一個基準值以後，左指標從左向右找第一個大於基準值的數，找到後停下；
2. 右指標從右向左找第一個小於基準值的數，找到後停下；
3. 然後進行左右交換；
4. 遞迴式的尋找，直到有序

int PortSort(int* array, int left, int right)
{
    int
 
 mid = GetMidIndex(array, left, right);
    swap(array[mid], array[right]);
    assert(array);
    int key = right;
    while(left < right)
    {
        while(array[left] < array[key])
            left++;
        while(array[right] > array[key])
            right--;
        if(array[left] != array[right])
            swap(array[left], array[right]);
    }
    swap(array[left], array[key]);
    return left;
}

快排2

挖坑法
1. 其實和左右指標差不多，就是把資料拿出來了，新資料直接放裡面就可以了；
2. 從左向右遍歷，找到大於基準值的就放到基準值的位置；
3. 從右向左遍歷，找到小於基準值的就放到上一個空位置；
4. 迴圈遞迴就可以；

int PortSort(int* array, int left, int right)
{
    int mid = GetMidIndex(array, left, right);
    swap(array[mid], array[right]);
    assert(array);
    int hole = array[right];
    while(left < right)
    {
        while(array[left] < hole)
            left++;
        if(left < right)
            array[right--] = array[left];
        while(array[right] > hole)
            right++;
        if(left < right)
            array[left++] = array[right];
    }
    array[left] = hole;
    return left;
}

快排3

前後指標法：
1. 用兩個指標標識2個數；
2. 當第二個指標小於基準值並且++第一個指標後不等於第二個指標，就說明第一個指標已經是大於基準值的了；其實可能折磨描述不太好理解，下面配上程式碼，就一目瞭然了；
3. 然後在自增第二個指標；
4. 依次迴圈遞迴即可；

int PortSort3(int *array, int left, int right)
{
    int mid = GetMidIndex(array, left, right);
    swap(array[mid], array[right]);
    int pCur = left;
    int pPre = pCur - 1;
    int key = array[right];
    while(pCur != right)
    {
        if(array[pCur] < key && array[++pPre] != array[pCur])
            swap(array[pPre], array[pCur]);
        ++pCur;
    }
    swap(array[++pPre], array[pCur]);
}

快排的優化

1. 我們都知道在快排中，我們要選取基準值，如果基準值選的是最中間的值，那麼我們的排序效率將會比較高，但是如果選個最小的值，那麼它快排的效率將完全體現不出來了，所以針對基準值的取法，進行優化是一件很重要的事；

//優化1： 三數取中法,不管什麼情況下，返回去的都是大小適中的值
int GetMidIndex(int* array, int left, int right)
{
    int mid = left + ((right - left) >> 1);
    if (array[left] < array[mid])
    {
        if (array[mid] < array[right])
            return mid;
        else if (array[left] < array[right])
            return right;
        else
            return left;
    }
    else
    {
        if (array[mid] > array[right])
            return mid;
        else if (array[left] > array[right])
            return right;
        else
            return left;
    }
}

1. 當劃分的子序列很小的時候(一般認為小於13個元素左右時)，我們再使用快速排序對這些小序列排序反而不如直接插入排序高效。因為快速排序對陣列進行劃分最後就像一顆二叉樹一樣，當序列小於13個元素時我們再使用快排的話就相當於增加了二叉樹的最後幾層的結點數目，增加了遞迴的次數。所以我們在當子序列小於13個元素的時候就改用直接插入排序來對這些子序列進行排序。

void InsertSort(int *array, int n)
{
    int end = 0;
    for (size_t i = 1; i < n; i++)
    {
        int tmp = array[i];
        end = i - 1;
        while (end >= 0)
        {
            if (array[end] > tmp)
            {
                array[end + 1] = array[end];
                --end;
            }
        }
        array[end + 1] = tmp;
    }
}

1. 資料量太大時可能造成遞迴的深度太大，效率就太低，所以可以利用棧來實現
   ““
   void QuickSortNodeR(int* array, int left, int right)
   {
   stack s;
   s.push(right);
   s.push(left);

   while (!s.empty())
   {
   int start = s.top();
   s.pop();
   int end = s.top();
   s.pop();

   if (end > start)
   {
       int div = PortSort1(array, start, end);
       s.push(div - 1);
       s.push(start);
   
       s.push(right);
       s.push(div + 1);
   }
   

   }
   }
   “`