排序算法小结（3）交换排序

1.交换排序–冒泡排序
比较简单，直接上程序：

void BubbleSort(int* a,int n)
{   
    if(a == NULL || n == 0)
        return;
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<n-i-1;++j)
        {
            if(a[j] > a[j+1])
            {
                int tmp=a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
    }
}

算法思想：每次找出最大（小）的值放置于正确的位置，并缩小比较范围。
从上面的过程可以看出：
1.算法是稳定的，依次比较不会造成元素相对位置的变化。
2.时间复杂度为O（n），当元素基本有序时最优的时间复杂度为O（n），进入第二层循环不需要交换元素。
3.空间复杂度O（1）。

2.交换排序–快排
先看看代码：

void swap(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
void QuickSort(int*a,int low,int high)
{
    if(a == NULL || low >= high)
        return;
    int key = a[low];
    int i = low;
    int j = high+1;//两个哨兵，当寻找到a[i]>=key和a[j]<=key时，交换a[i]和a[j];
    while(i < j)
    {
        ++i,--j;//每次交换完，先将哨兵移动一位（考虑a[i] == a[j] == key的情况）
        while(a[i] < key) ++i;
        while(a[j] > key) --j;
        if(i<j)
            swap(a[i],a[j]);    

    }
    swap(a[low],a[j]);
    QuickSort(a,low,j-1);//前半部分递归
    QuickSort(a,i,high);//后半部分递归
}

快排的基本思路：
1.每次选出一个key值，将不小于**key的元素放到一边，将不大于**key的元素小的放到另一边；
2.分别对左右两边再做上诉步骤。
使用两个哨兵能够提高算法的效率，减少交换次数。还有很多中快排的变形算法，以后可以仔细研究一下。
从上诉过程可以看出：
1.算法是不稳定的，因为交换时会改变相同值元素的相对位置。
2.算法的时间复杂度为O(nlog2n),当序列基本有序时，算法退化为冒泡排序，时间复杂度为O(n^2)。
3.算法的空间复杂度为O（1）。