交换排序--冒泡排序&快排

利用交换元素的位置进行排序的方法称作交换排序。常用的交换排序的方法有冒泡排序和快速排序。快速排序是一种分区交换排序方法。

一、冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
算法步骤：
冒泡排序算法的运作如下：（从后往前）
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
（3）针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
代码实现：

void BubbleSort(int *array, int size)
{
    int flag = false;
    for (int i = 0; i < size-1; i++)
    {
        for (int j = 0; j < size - i - 1; j++)
        {
            if (array[j]>array[j+1])
            {
                flag = true;
                swap(array[i], array[j]);
            }
        }
        if (flag == false)
            return;
    }
}

算法性能分析：
（1）时间复杂度：最好情况–O（N）， 最坏情况–O（N^2），平均–O（N^2）
（2）空间复杂度：O（1）
（3）稳定性：稳定

二、快速排序

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

这里有三种方法找基准值：
第一种：以数列最右边元素为基准值，比该元素小的放在左边，大的放在右边

int  Pation1(int *array, int left, int right)
{
    int begin = left;
    int end = right- 1;
    int key = array[end];
    while (begin < end)
    {
        while (begin < end&&array[begin] <= key)
            begin++;
        while (begin < end&&array[end] >= key)
            end--;
        if (begin < end)
            swap(array[begin], array[end]);
    }
    if (begin != right)
        swap(array[begin], array[right-1]);
    return begin;
}

第二种：挖坑法

//挖坑法
int Pation2(int *array, int left, int right)
{
    int begin = left;
    int end = right - 1;
    int key = array[end];
    while (begin < end)
    {
        while (begin < end&&array[begin] <= key)
            begin++;
        if (begin < end)
            array[end] = array[begin];
        while (begin < end&&array[end] >= key)
            end--;
        if (begin < end)
            array[begin] = array[end];
    }
    array[begin] = key;
    return begin;
}

第三种：前后指针法找基准值

int Pation3(int *array, int left, int right)
{
    int pCur = left;
    int prev = pCur - 1;
    int end = right - 1;
    int key = array[end];
    while (pCur < end)
    {
        if (array[pCur] <= key&&prev++ != pCur)
            swap(array[prev], array[pCur]);
            pCur++;
    }
    if (++prev != right)
        swap(array[prev], array[right - 1]);
    return prev;
}

具体代码实现：

//快速排序--递归写法
void QuickSort(int *array, int left,int right)
{
    if (left < right)
    {
        int div = Pation1(array, left, right);
        QuickSort(array, left, div);
        QuickSort(array, div + 1, right);
    }   
}
//快排的非递归写法
void QuickSort_O(int *array, int size)
{
    int left = 0;
    int right = size;
    stack<int> s;
    s.push(right);
    s.push(left);
    while (!s.empty())
    {
        left = s.top();
        s.pop();
        right = s.top();
        s.pop();
        if (left < right)
        {
            int div = Pation3(array, left, right);
            //保存右半部分区间
            s.push(right);
            s.push(div+1);
            //保存左半部分区间
            s.push(div);
            s.push(left);
        }
    }
}

算法性能分析：
（1）时间复杂度：O（logN）
（2）空间复杂度：O(logN)
（3）稳定性：稳定