OI小白算法学习–排序篇

主流的排序算法分为4种：冒泡、快排、并归排序、堆排序

一、冒泡、插入等等一系列O(N²)算法

不用多说，最经典的排序算法，思路也很简单。

主要思路：一串数字，第一个与第二个比较，大的放后面小的放前面，第二个与第三个比较，大的放后面小的放前面……比完后，取出最后一个数（整个数列中最大的在后面）（这时最后的取走了所以k要自减），重新开始这个过程，直到k为1（没得比了嘛）。

特点：简单好理解，但是时间复杂度高

//arr数组是待排序的数列，其中有k个数
void sortmr()
{
    while(k>1)
    {
        for (int i = 1; i <= k; ++i)
        {
            if (arr[i]<arr[i+1])
            {
                int tempp;
                tempp=arr[i+1];
                arr[i+1]=arr[i];
                arr[i]=tempp;
                //交换
            }
        }
        sort[j]=arr[k];
        j++;
        k--;
    }
}

二、堆排序

借助于堆的数据结构，速度大大的加快了

主要思路：先把数列(k个数)存储在数组中，然后从最后一个非页子节点（k/2）开始向上比较。当到达顶端后，取出最上面的数（一定最小），然后用最后一位数字替换掉刚刚取出的第一位数字，然后k自减（因为取走一个了嘛）并重新开始排序（从k/2开始）。

特点：速度快，但需要理解二叉树数据结构，我刚开始接触的排序算法就是这个，结果云里雾里花了两天才搞懂。

#include "stdio.h"
int arr[500],k;
void get(int n);
 
int main(int argc, char const *argv[])
{
    scanf("%d",&k);
    for (int i = 1; i <= k; ++i)
    {
        scanf("%d",&arr[i]);
    }
    get(k/2);
    return 0;
}
 
void get(int n)
{
    if (k<1)
    {
        return;
        //整体全部排序完了
    }
    if (n==0)
    {
        printf("%d ",arr[1] );
        arr[1]=arr[k];
        k--;
        get(k/2);
        //该轮完成，开始新一轮
        return;
    }
    //left
    if (arr[n]>arr[2*n])
    {
        int temp=arr[n];
        arr[n]=arr[n*2];
        arr[n*2]=temp;
        //交换
    }
    //right
    if (2*n+1<=k)
    {
        //先判断有没有右节点再判断
        if (arr[n]>arr[2*n+1])
        {
            int temp=arr[n];
            arr[n]=arr[n*2+1];
            arr[n*2+1]=temp;
            //交换
        }
    }
    get(n-1);
}

三、快速排序（QuickSort）

快排，算法中间几乎无人不晓，也是最经典的排序算法。

原理很简单，用到了分治的思想，将平均时间复杂度降到了O(n logn)

实现的方法是，设置一个数（一般是最左边的）为“基准数”

然后从一个数列的最右边找起，一旦发现比基准数大的就停下来，记录位置（j）

然后从最左边开始找比基准数小的，然后停下来，记录位置（i）

然后交换i与j代表的数，一直这么做，直到i与j相等的时候，停下来，以i为界限，一分为二继续执行以上步骤，直到所有数排完

其实一小段文字还是难以帮助理解，快排的资料网上很多，可以去看看

注意，快排有多个版本，虽然都是快排，但是有的速度很快，有的在部分点里面会蜜汁超时。

#include <bits/stdc++.h>
using namespace std;
int a[100001];
void quicksort(int left,int right) {
    int i,j,temp;
    if(left>right)
        return;
    temp=a[(left+right)/2];
    i=left;
    j=right;
    while(i!=j) {
        while(a[j]>=temp && i<j)
            j--;
        while(a[i]<=temp && i<j)
            i++;
        if(i<j) 
            swap(a[i],a[j]);
    }
    a[(left+right)/2]=a[i];
    a[i]=temp;
    quicksort(left,i-1);
    quicksort(i+1,right);
}
 
int main() {
    int n;
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    quicksort(1,n);
    for (int i=1; i<=n; i++)
        printf("%d ",a[i]);
    return 0;
}

四、归并排序(Merge Sort)

很多人说到快排就想到分治，其实真正是利用分治来排序的不是快排，而是这个–归并排序

用这个的人貌似不多，相比起来也没有快排的时间复杂度“稳定”，不过神奇的是，在洛谷的排序模板题那里

我用快排3个点TLE，但是用并归排序就过了。不过他们都是O(n logn)

具体的原理就是不停二分，直到变成两两相比较，然后两个两个的比完后再合并

一张图就能理解这个算法：

得益于O(n)的复杂度即可将两个有序数列合并为一个有序数列，时间复杂度仅仅为O(n logn)

#include <bits/stdc++.h>
#define MAXN 1000
using namespace std;
int a[MAXN];
void sortmerge(int left,int right) {
    if(left==right)
        return;
    int mid=(left+right)/2;
    sortmerge(left,mid);
    sortmerge(mid+1,right);
    int i=left,j=mid+1;
    int temp[MAXN],k=0;
    while (i<=mid&&j<=right)
        if (a[i]<a[j])
            temp[k++]=a[i++];
        else 
            temp[k++]=a[j++];
    while (i<=mid)
        temp[k++]=a[i++];
    while (j<=right)
        temp[k++]=a[j++];
    for (int x=0;x<k;x++) a[left+x]=temp[x]; } 
int main() {
        int n; 
        //ios::sync_with_stdio(false); 
        cin >> n;
    for (int i=1; i<=n; i++) 
                cin >> a[i];
    sortmerge(1,n);
    for (int i=1; i<=n; i++)
        cout << a[i] << " ";
    return 0;
}

5、万能的STL

既然我们用的是C++了，为何放着简单好用的STL不去用，而来折腾这手动的算法呢？

其实，STL并不是万能的，只有在我们理解了传统的算法后，才能更好的利用STL来解题。

相信没拿到题目会这么考吧：输入N个数，请进行排序，然后依次输出。

不过，在熟悉了算法后，能省一秒是一秒嘛。STL还是有很大的用滴。

直接入正题：

已知：a数组，n个数，从第k个数开始，一直对后面的m个数排序，我们直接这样写即可：

sort(a+k-1,a+k-1+m);

接下来就排好了。STL就是这么优雅。

全文完。

转载于:https://www.cnblogs.com/mrcn/p/sort.html