关于排序

编译器版本：vs2013

排序的目的

：：如果输入一系列数字a1,a2,a3,a4,a5,a6,a7
经过排序有
：：输出a1< a2< a3< a4< a5< a6< a7或者
：：输出a1>a2>a3>a4>a5>a6 >a7
即让一系列无序数字从大到小或者从小到大有序即为排序。

学习中的几种排序算法

1：插入排序
基本思想：
升序：给一个数组，并不知道是否有序，从第二个数开始依次往后直到数组最后一个元素，挨个和前面那个数比大小，大的放这个数后面，小的接着和前面数比，如果比前面每一个数都小，就放在最前面，依次循环比完每一个数。
降序和升序思想一致，只是要把大的放在前面，小的放在后面。

具体代码

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;
    }
}

给一个整型数组a，数组元素n个，首先assert数组不能为空，空数组不需要排序，

i是下标，从0开始，上图中每一个b都是在所画圆圈区域内即将要插入得数，思想在上面已经讲过，就是每一个即将要插入的数和前面的数相比，比前面一个数大就差到那个数后面，找不到要插入的位置就需要一直找，找完已经排序完成的所有数为止，当然，既然是插入，在插入一个新的数以后，排在这个数后面的那些书当然要往后挪一下位置了。

2：希尔排序
希尔排序就是升级版的插入排序，在中间加了一个间距gap，只是为了更快的将前面的大数据和后面的小数据换回来，达到的效果是预排序，

假如gap=3,那么就是在这个数组中隔三个数做排序，这样可以尽快把后面的小数据和前面的大数据交换，思想和前面的插入排序一样

void shellsort(int* a, size_t n)
{
    assert(a);
    int gap = 3;
    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;
    }
}

 end=i;
 tmp=a[end+gap];
 要插入的新元素是tmp，tmp先和前面的a[end]比较，若a[end]大，将a[end]往后挪，end-=gap;再比，知道不满足while或者if条件，a[end + gap] = tmp;完成插入；

3：选择排序
具体思想：升序–给一个无序数组，min和max分别表示数组中最小和最大数的下标，两个都是从0下标开始，找到两个数以后，最小值换到0下标位置，最大值换到n-1下标位置，

void Selectsort(int* a, size_t n)//选下标
{
    assert(a);
    size_t left = 0; 
    size_t right = n - 1;
    while (left < right)
    {
        size_t min = left, max = left;
        for (size_t i = left; i < right; ++i)
        {
            if (a[i]< a[min])
            {
                min = i;
            }
            if (a[i] > a[max])
            {
                max = i;
            }
            swap(a[min], a[left]);
            //9 0 1 2 4 5 7
            //下面这个if条件判断的就是类似上面这类情况，此时min是
            //数组元素0的下标，left是9的下标同时也是数组最大元素9
            //的下标，把0和9交换以后，9的下标即刚才交换之前0的下标
            //而把最小值换到最左边以后需要做的就是把最大值换到最右边
            //最大值现在是9，即a[min],所以需要把max赋值为min和最
            //右边交换，然后--left,--right,在剩下的数里面找最大最
            //小接着上面的操作
            if (max == left)
            {
                max = min;
            }
            swap(a[max], a[right]);
            ++left;
            --right;
        }
    }
}

4：快速排序
具体思想：就是把数组通过多次划分成小区间，甚至这个小区间里面就一个数，把小区间划分排序成有序区间再组合起来就是一个大的有序数组。

int Partsort1(int *a, int left, int right)   //挖坑
{
    int key = a[right];
    int begin = left;
    int end = right;
    while (begin < end)
    {
        while (a[begin] <= key)
        {
            ++begin;
        }
        if (begin < end)
        {
            swap(a[end], a[begin]);
        }
        while (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;
        }
        a[right] = a[left];
        while (left < right&&a[left] >= key)
        {
            --right;
        }
        a[left] = a[right];
    }
    a[left] = key;
}
int Partsort3(int *a, int left, int right)   //前后指针
{
    int cur = left;
    int key = a[right];
    int prev = left - 1;
    while (cur < right)
    {
        if (a[cur] < a[key] && ++prev != cur)
        {
            swap(a[prev], a[cur]);
        }
        ++cur;
    }
    swap(a[++prev], a[right]);
    return prev;
}
void Quicksort(int *a, int left, int right)
{
    assert(a);
    if (left >= right)
    {
        return;
    }
    else
    {
        int div = Partsort1(a, left, right);
        int div = Partsort2(a, left, right);
        int div = Partsort3(a, left, right);
        Quicksort(a, left, div - 1);
        Quicksort(a, div + 1, right);
    }
}

5：快排非递归实现
具体思想:利用stack先入后出，实现数组划分成小区间，小区间依次排序实现有序并合并以后实现大数组有序。

int Partsort1(int *a, int left, int right)   //挖坑
{
    int key = a[right];
    int begin = left;
    int end = right;
    while (begin < end)
    {
        while (a[begin] <= key)
        {
            ++begin;
        }
        if (begin < end)
        {
            swap(a[end], a[begin]);
        }
        while (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;
        }
        a[right] = a[left];
        while (left < right&&a[left] >= key)
        {
            --right;
        }
        a[left] = a[right];
    }
    a[left] = key;
}
int Partsort3(int *a, int left, int right)   //前后指针
{
    int cur = left;
    int key = a[right];
    int prev = left - 1;
    while (cur < right)
    {
        if (a[cur] < a[key] && ++prev != cur)
        {
            swap(a[prev], a[cur]);
        }
        ++cur;
    }
    swap(a[++prev], a[right]);
    return prev;
}
void Quicksort(int *a, int left, int right)
{
    assert(a);
    if (left >= right)
    {
        return;
    }
    else
    {
        int div = Partsort1(a, left, right);
        int div = Partsort2(a, left, right);
        int div = Partsort3(a, left, right);
        Quicksort(a, left, div - 1);
        Quicksort(a, div + 1, right);
    }
}
void Quicksort(int *a, int left, int right)
{
    stack<int> s;
    if (left < right)
    {
        s.push(right);
        s.push(right);
        while (s.empty())
        {
            int begin = s.top();
            s.pop();
            int end = s.top();
            s.pop();
            int div = part1(a, begin, end);
            int div = part2(a, begin, end);
            int div = part3(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);
            }
        }
    }

}

6：归并排序
基本思想：归并排序有点类似于合并两个有序链表
归并排序是建立在归并操作上的一种有效的排序算法,该算法和快速排序都是采用分治法来设计算法的，区别在于归并排序把数组分为两个基本等长（最多相差一个元素）的子数组，分别排好序之后还要进行归并操作，而快速排序在拆分子数组的时候则有所不同，其取一个基准元素，拆分之后基准元素左边的元素都比基准元素小，右边的元素都不小于基准元素，这样只需要分别对两个子数组排序即可，不再像归并排序一样需要归并操作。归并排序是稳定的算法，其最坏的时间复杂度是O(n^2)，其最好的时间复杂度是O(nlogn).
假设有数组 a，比较 a[i] 和 a[j] 的大小，若 a[i] ≤ a[j]，则将第一个有序表中的元素 a[i] 复制到 r[k] 中，并令 i 和 k 分别加上 1；否则将第二个有序表中的元素 a[j] 复制到 r[k] 中，并令 j 和 k 分别加上 1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到 r 中从下标 k 到下标 t 的单元。归并排序的算法我们通常用递归实现，先把待排序区间 [s,t] 以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间 [s,t].

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

    }
    else if (begin2 >= end2)
    {
        while (begin1<end1)
        {
            tmp[index++] = a[begin1++];
        }
    }
    else
    {
        return;
    }
    memcpy(a + pos, tmp + pos, sizeof(int)*(end2 - pos + 1));
}
void _Mergesort(int*a, int *tmp, int left, int right)
{
    if (left >= right)
    {
        return;
    }
    else
    {
        int mid = left + (left + right) / 2;
        _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);
}

7：冒泡排序
基本思想：即对相邻两个数进行比较，如果反序就交换位置，直到整个序列没有出现反序为止。
代码里面的flag是优化部分，如果第一趟没有发现有交换产生，则直接跳出循环，

void Bubble_sort(int *a, size_t n)
{
    int i, j, temp;
    bool flag = true;
    for (i = n - 1; i >= 0; i--)
    {
        flag = false;
        for (j = 0; j < i; j++)
        {
            if (a[j] >a[j + 1])
            {
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
                flag = true;
            }
            if (flag == false) break;
        }
    }
}