交换排序

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

交换排序有冒泡排序和快速排序

冒泡排序

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void BubbleSort(int* a, int n)
{

    for (int end = n; end > 0; --end)
    {
        int exchange = 0;
        for (int i = 1; i < end; ++i)
        {
            if (a[i - 1] > a[i])
            {
                Swap(&a[i - 1], &a[i]);
                exchange = 1;
            }
        }

        if (exchange == 0)
        {
            break;
        }
    }
}

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

三数取中优化代码

int GetMidIndex(int* a, int left, int right)
{
    int mid = (left + right) >> 1;
    // left  mid  right
    if (a[left] < a[mid])
    {
        if (a[mid] < a[right])
        {
            return mid;
        }
        else if (a[left] > a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
    else // a[left] > a[mid]
    {
        if (a[mid] > a[right])
        {
            return mid;
        }
        else if (a[left] < a[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
}

1. hoare版本

int PartSort(int* a, int left, int right)
{
    // 三数取中
    int midIndex = GetMidIndex(a, left, right);
    Swap(&a[left], &a[midIndex]);

    int keyi = left;
    while (left < right)
    {
        // 找小
        while (left < right && a[right] >= a[keyi])
            --right;

        // 找大
        while (left < right && a[left] <= a[keyi])
            ++left;

        Swap(&a[left], &a[right]);
    }
    Swap(&a[keyi], &a[left]);

    return left;
}

2. 挖坑法

int PartSort(int* a, int left, int right)
{
    int midIndex = GetMidIndex(a, left, right);
    Swap(&a[left], &a[midIndex]);

    int key = a[left];
    while (left < right)
    {
        // 找小
        while (left < right && a[right] >= key)
        {
            --right;
        }

        // 放到左边的坑位中,右边就形成新的坑
        a[left] = a[right];

        // 找大
        while (left < right && a[left] <= key)
        {
            ++left;
        }

        // 放到右边的坑位中，左边就形成新的坑
        a[right] = a[left];
    }

    a[left] = key;

    return left;
}

3. 前后指针版本

int PartSort(int* a, int left, int right)
{
    int midIndex = GetMidIndex(a, left, right);
    Swap(&a[left], &a[midIndex]);

    int keyi = left;
    int prev = left, cur = left + 1;
    while (cur <= right)
    {
        if (a[cur] < a[keyi] && ++prev != cur)
        {
            Swap(&a[cur], &a[prev]);
        }

        ++cur;
    }

    Swap(&a[keyi], &a[prev]);

    return prev;
}

快排（小区间优化）

void QuickSort(int* a, int begin, int end)
{
    if (begin >= end)
        return;

    // 1、如果这个子区间是数据较多，继续选key单趟，分割子区间分治递归
    // 2、如果这个子区间是数据较小，再去分治递归不太划算
    if (end - begin > 20)
    {
        int keyi = PartSort(a, begin, end);

        // [begin, keyi-1] keyi [keyi+1, end]
        QuickSort(a, begin, keyi - 1);
        QuickSort(a, keyi + 1, end);
    }
    else
    {
        //HeapSort(a + begin, end - begin + 1);
        InsertSort(a + begin, end - begin + 1);
    }
}