Acwing 算法基础课——排序

一、快速排序

1.快速排序算法思想:

1.1主要思想

        主要基于分治思想。确定分界点，调整区间使得左边区间的数都小于等于分界点，右边区间的数都大于等于分界点；再分别对左边和右边的区间进行相同处理，直到最后区间内仅剩1个数或者没有数结束；此时左边和右边都已经排好序了，整体就排好序了。

1.2快速排序算法时间复杂度：

        最差：O(n^2)；平均：O ( n l o g  n ) 。

1.3.快速排序步骤：

        a.确定分界点x：  q[(l+r)/2]  //q[l+r>>1]

        b.调整区间，使小于等于x的在左边 l，大于等于x 的在右边 r；

        c. 递归处理x的左右段；

1.4.模板 ：

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return; //数组中没有元素或只有一个元素递归停止

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);     
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);        
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

1.5.题目链接：

https://www.acwing.com/problem/content/787/

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5+10;

int q[N];

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

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);    //左指针和右指针没有相遇，交换位置
    }

    quick_sort(q, l, j);             //递归处理左边界
    quick_sort(q, j + 1, r);         //递归处理右边界
}

int main()
{
    int n;
    scanf("%d", &n);

    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

    quick_sort(q, 0, n - 1);

    for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);

    return 0;
}

2.快速排序应用：找第k个数

  2.1时间复杂度：O（n）

  2.2题目链接https://www.acwing.com/problem/content/788/

  2.3主要思想：

        在调整区间之后，根据左边的数目决定递归处理左边区间或者右边区间。如果左边数目小于等于k则递归处理左边区间，否则只递归处理右边区间。这里需要注意边界计算，左边区间数目：j-l+1,若递归右边区间则 k=k-(j-l+1)

#include <bits/stdc++.h>

using namespace std; 

const int N=1e5+10;
int q[N];

int quick_sort(int q[], int l, int r, int k)
{
    if (l >= r) return q[l];

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while(i<j)
    {
        do ++i;while(q[i]<x);
        do --j;while(q[j]>x);
        if(i<j) swap(q[i],q[j]);
    }
    if(j-l+1>=k) return quick_sort(q,l,j,k);
    else return quick_sort(q,j+1,r,k-(j-l+1));
}

int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i) scanf("%d",&q[i]);
    printf("%d",quick_sort(q,0,n-1,k));
    return 0;
}

二、归并排序

1.归并排序算法思想

1.1主要思想：

        归并排序也是使用分治的思想，首先将数组一分为二，将数组左半部分排好序，再将数组右半部分排好序，最终将两个数组合并形成一个有序的数组。难点在于将两个数组合并为有序数组，建立一个临时数组temp，首先比较两个数组的第一个数，较小的放入temp数组，再向后移动一位，继续比较直到两个数组中有一个数组全部比较完成。最后将剩余的数组放到temp数组中，完成排序。

1.2.时间复杂度：稳定为O（n log n）

1.3主要步骤:

        a.确定分界点 mid=l+r>>1;

        b.递归排序左右区间

        c.将两个有序区间合并成一个有序区间

1.4.模板

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

1.5题目链接：https://www.acwing.com/problem/content/789/

    

#include<bits/stdc++.h>
using namespace std;

const int N =1e5+10;
int q[N],temp[N];


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 i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]>=q[j]) temp[k++]=q[j++];
        else temp[k++]=q[i++];
    }
    while(i<=mid) temp[k++]=q[i++];
    while(j<=r) temp[k++]=q[j++];
    for(int i=l,j=0;i<=r;i++，j++) q[i]=temp[j]; //注意这里i的值为左边界
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    merge_sort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

2.归并排序算法的应用

2.1题目链接：https://www.acwing.com/problem/content/790/

2.2题解：

        求解逆序对数目，采用分治的思想。逆序对可能出现三种情况，逆序对都在左区间，逆序对都在右区间，逆序对一个在左区间，一个在右区间。首先递归计算都在左边区间的逆序对个数，然后计算都在右边的逆序对个数，最后计算一个在左区间，一个在右区间的逆序对个数。在本题中左区间和右区间任意调换顺序是不影响第三步的计算的，但排好序之后第三步计算时间复杂度会降低，并且容易计算。

        同时int 的最大范围大约是2e9，本题中n的范围为1e5，最大逆序对数（n-1)+(n-2)+....+1约等于5e9超过了int的最大范围，应使用 long long 

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N =1e5+10;
int q[N],temp[N];

ll merge_sort(int q[],int l,int r)
{
    if(l>=r) return 0;
    ll ans=0;
    int mid=l+r>>1;
    ans=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]) temp[k++]=q[i++];
        else
        {
            temp[k++]=q[j++];
            ans+=mid-i+1;
        }
    }
    while(i<=mid) temp[k++]=q[i++];
    while(j<=r) temp[k++]=q[j++];
    for(int i=l,j=0;i<=r;i++,j++) q[i]=temp[j];
    return ans;
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;++i) scanf("%d",&q[i]);
    printf("%lld",merge_sort(q,0,n-1));
    return 0;
}

三、sort排序和桶排序

https://mp.csdn.net/mp_blog/creation/editor/132055541

四、稳定性和不稳定性

相同的数在排序之后是否位置发生了变化，快排不稳定，归并排序稳定