排序

首先我们看一下排序的种类，排序有比较排序和非比较排序，今天我们主要探讨一下常用的几个排序。

插入排序
插入排序是一种简单直观的排序。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
步骤：
1。从第一个元素开始，该元素可以认为已经被排序
2。取出下一个元素，在已经排序的元素序列中从后向前扫描
3。如果该元素（已排序）大于新元素，将该元素移到下一位置
4。重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5。将新元素插入到该位置中
6。重复步骤2

void PrintArray(int* a, size_t n)
{
    for (size_t i = 0; i < n; ++i)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

void InsertSort(int* a, size_t n)
{
    assert(a);

    for (size_t i = 0; i < n-1;++i)
    {
        int end = i;
        int tmp = a[end+1];
        while (end >= 0)
        {
            if (a[end] > tmp)
            {
                a[end+1]=a[end];
                --end;
            }
            else
            {
                break;
            }
        }
        a[end+1] = tmp;
    }
}

void TestInsertSort()
{
    int a[] = {2,5,4,9,3,6,8,7,1,0};
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    InsertSort(a, sizeof(a)/sizeof(a[0]));
    PrintArray(a,sizeof(a)/sizeof(a[0]));
}

希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
1、插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
2、但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位

void ShellSort(int*a,size_t n)
{
    assert(a);
    int gap = n;

    while (gap > 1)
    {
        gap = gap/3+1;
        for(size_t i = 0; i < n-gap; ++i)
        {
            int end = i;
            int tmp = a[end+gap];
            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end+gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end+gap] = tmp;
        }
    }
}

void TestShellSort()
{
    int a[] = {2,5,4,9,3,6,8,7,1,0};
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    ShellSort(a, sizeof(a)/sizeof(a[0]));
    PrintArray(a,sizeof(a)/sizeof(a[0]));
}

选择排序
选择排序是一种简单直观的排序算法。
首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。

void SelectSort1(int *a,size_t n)
{
    int begin = 0;
    int end = n-1;
    int min= 0;
    while(begin < end)//o(n)
    {
        min = begin;
        for(size_t i = begin; i<=end; i++)
        {
            if(a[min] > a[i])
            {
                min = i;// 选择出最小数
            }
        }
        swap(a[begin],a[min]);
        ++begin;
    }
}
//优化
void SelectSort2(int* a, size_t n)
{
    int begin = 0;
    int end = n-1;
    int min = 0;
    int max = 0;
    while(begin < end)//o(1/n)
    {
        min = begin;
        max = begin;
        for(size_t i =  begin; i <= end; i++ )
        {
            if(a[min]>a[i])
            {
                min = i;
            }
            if(a[max]<a[i])
            {
                max = i;
            }
        }
        swap(a[max],a[end]);
        if(end == min)//防止min max互换
        {
            a[min] = a[max];
        }
        swap(a[min],a[begin]);
        ++begin;
        --end;
    }
}

void TestSelectSort()
{
    int a[] = {9,5,4,9,3,6,8,7,1,0};
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    //SelectSort1(a, sizeof(a)/sizeof(a[0]));
    SelectSort1(a, sizeof(a)/sizeof(a[0]));
    PrintArray(a,sizeof(a)/sizeof(a[0]));
}

堆排序
堆积排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

void AdjustDwon(int* a, size_t root, size_t n)
{
    size_t parent = root;
    size_t child = parent*2+1;
    while (child < n)
    {
        if (child+1 < n && a[child+1] > a[child])
        {
            ++child;
        }

        if (a[child] > a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = 2*parent+1;
        }
        else
        {
            break;
        }
    }
}

void HeapSort(int* a, size_t n)
{
    assert(a);
    for (int i = (n-2)/2; i >=0; --i)
    {
        AdjustDwon(a, i, n);
    }

    size_t end = n-1;
    while (end > 0)
    {
        swap(a[0], a[end]);
        AdjustDwon(a, 0, end);
    }
}

冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
步骤：
1。比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3。针对所有的元素重复以上的步骤，除了最后一个。
4。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

void BubbleSort(int* a, size_t n)
{
    assert(a);
    int end = n;
    while(end > 0)
    {
        bool exchange = false;//交换标志
        // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上  
        for(int i = 1;i < end;++i)
        {
            if(a[i-1] > a[i])
            {
                swap(a[i-1],a[i]);
                exchange = true;
            }
        }
        // 如果标志为false，说明本轮遍历没有交换，已经是有序数列，可以结束排序
        if (exchange == false)
        {
            break;
        }

        --end;
    }
}

快速排序
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。
步骤：
1。从数列中挑出一个元素，称为 “基准”（pivot），
2。重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3。递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

// 左右指针法
int PartSort1(int* a, int left, int right)
{
    int mid = GetMidIndex(a, left, right);
    swap(a[mid], a[right]);

    int key = a[right];
    int begin = left;
    int end = right;
    while (begin < end)
    {
        while (begin < end && a[begin] <= key)
        {
            ++begin;
        }

        while (begin < end && a[end] >= key)
        {
            --end;
        }

        if (begin < end)
            swap(a[begin], a[end]);
    }

    swap(a[begin], a[right]);
    return begin;
}

// 挖坑法
int PartSort2(int* a, int left, int right)
{
    int key = a[right];
    while (left < right)
    {
        // 找大
        while (left < right && a[left] <= key)
        {
            ++left;
        }

        // 找到比key大的数据放到右边的坑
        a[right] = a[left];

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

        a[left] = a[right];
    }

    a[left] = key;
    return left;
}

int PartSort3(int* a, int left, int right)
{
    int prev = left-1;
    int cur = left;
    int key = a[right];
    while (cur < right)
    {
        if (a[cur] < key && ++prev != cur)
        {
            swap(a[prev], a[cur]);
        }

        ++cur;
    }

    swap(a[++prev], a[right]);

    return prev;
}

// [left, right]
void QuickSort(int* a, int left, int right)
{
    assert(a);

    if (left >= right)
        return;

    if (right - left < 5)
    {
        InsertSort(a+left, right-left+1);
    }
    else
    {
        int div = PartSort1(a, left, right);
        QuickSort(a, left, div-1);
        QuickSort(a, div+1, right);
    }
}

#include <stack>
void QuickSortNonR(int* a, int left, int right)
{
    assert(a);
    stack<int> s;
    if (left < right)
    {
        s.push(right);
        s.push(left);
    }

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

        int div = PartSort1(a, begin, end);
        if (begin < div-1)
        {
            s.push(div-1);
            s.push(begin);
        }

        if (div+1 < end)
        {
            s.push(end);
            s.push(div+1);
        }
    }
}

归并排序
步骤：
1。申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2。设定两个指针，最初位置分别为两个已经排序序列的起始位置
3。比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4。重复步骤3直到某一指针达到序列尾
5。将另一序列剩下的所有元素直接复制到合并序列尾

void Merge(int* a, int* tmp, int begin1,int end1, int begin2, int end2)
{
    size_t pos = begin1;
    size_t index = begin1;
    while (begin1 <= end1 && begin2 <= end2)
    {
        if (a[begin1] < a[begin2])
            tmp[index++] = a[begin1++];
        else
            tmp[index++] = a[begin2++];
    }

    while (begin1 <= end1)
    {
        tmp[index++] = a[begin1++];
    }

    while (begin2 <= end2)
    {
        tmp[index++] = a[begin2++];
    }

    memcpy(a+pos, tmp+pos, sizeof(int)*(end2-pos+1));
}

void _MergeSort(int* a,int* tmp, int left, int right)
{
    if (left >= right)
        return;

    int mid = left+(right-left)/2;
    // 0 0 1 1
    // [left mid] [mid+1, right]

    _MergeSort(a, tmp, left, mid);
    _MergeSort(a, tmp, mid+1, right);

    Merge(a, tmp, left, mid, mid+1, right);
}

void MergeSort(int* a,size_t n)
{
    assert(a);

    int* tmp = new int[n];
    _MergeSort(a,tmp, 0, n-1);
    delete[] tmp;
}