排序sort

排序算法有很多，下面只说明几种：

1. 归并排序：

先使用递归将数组中元素进行划分，直至划分得到单个元素作为一个数组，此时就可以将其看作一个有序数组（只有一个元素自然是有序的）进行归并。最终将所有元素归并得到一个有序数组，所以这种排序方法称作为归并排序。归并排序主要涉及两个部分：一个是递归问题，另一个就是有序数组进行归并。模板如下：（vector型）

#include<iostream>
#include<vector>
using namespace std;
vector<int> merge(vector<int> a,vector<int> b)
{
    vector<int> newarr;
    int i=0,j=0;
    while(i<a.size()&&j<b.size())
    { 
        if(a[i]<=b[j])
        {
            newarr.push_back(a[i]);
            i++;
        }else{
            newarr.push_back(b[j]);
            j++;
        }
    }
    for(;i<a.size();i++) newarr.push_back(a[i]);
    for(;j<b.size();j++) newarr.push_back(b[j]);
    return newarr;
}
vector<int> mergesort(vector<int> arr)
{
    if(arr.size()<=1) return arr;
    int n=arr.size();
    vector<int> leftpart,rightpart;
    for(int i=0;i<n/2;i++)    leftpart.push_back(arr[i]);
    for(int i=n/2;i<n;i++)  rightpart.push_back(arr[i]);
    return merge(leftpart,rightpart);
}
int main()
{
    int n,a;
    vector<int> arr;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a;
        arr.push_back(a);
    }
    arr=mergesort(arr);
    for(int i=0;i<n;i++) cout<<arr[i]<<" ";
}

（数组型）

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}

2. 快速排序：

1、选出一个key，一般是最左边或是最右边的。

2、定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。

3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）

4、此时key的左边都是小于key的数，key的右边都是大于key的数

5、将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，此时此部分已有序

（左右指针法）

void QuickSort(int* arr, int begin, int end)
{
    //只有一个数或区间不存在
    if (begin >= end)
        return;
    int left = begin;
    int right = end;
    //选左边为key
    int keyi = begin;
    while (begin < end)
    {
        //右边选小   等号防止和key值相等    防止顺序begin和end越界
        while (arr[end] >= arr[keyi] && begin < end)
        {
            --end;
        }
        //左边选大
        while (arr[begin] <= arr[keyi] && begin < end)
        {
            ++begin;
        }
        //小的换到右边，大的换到左边
        swap(&arr[begin], &arr[end]);
    }
    swap(&arr[keyi], &arr[end]);
    keyi = end;
    //[left,keyi-1]keyi[keyi+1,right]
    QuickSort(arr, left, keyi - 1);
    QuickSort(arr,keyi + 1,right);
}

（挖坑递归法）

void QuickSort1(int* arr, int begin, int end)
{
    if (begin >= end)
        return;
    int left = begin,right = end;
    int key = arr[begin];
    while (begin < end)
    {
        //找小
        while (arr[end] >= key && begin < end)
        {
            --end;
        }
        //小的放到左边的坑里
        arr[begin] = arr[end];
        //找大
        while (arr[begin] <= key && begin < end)
        {
            ++begin;
        }
        //大的放到右边的坑里
        arr[end] = arr[begin];
    }
    arr[begin] = key;
    int keyi = begin;
    //[left,keyi-1]keyi[keyi+1,right]
    QuickSort1(arr, left, keyi - 1);
    QuickSort1(arr, keyi + 1, right);
}