快排，归并排序，堆排序，冒泡排序

快速排序基于分治思想（不稳定）：看稳不稳定取决于两个相同的数在排序后该没改变位置

时间复杂度：平均时间复杂度为o（nlogn），最坏n方

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。

1.确定分界点，这里取中间值。

2.划分区间，使分界点左边的值都小于分界点，右边的值都大于分界点。

3，递归处理左右两边。（对左右两边在进行以1，2）操作，直至排序完成。

这里用到了双指针，一个指针指向数组的最左侧，一个指针指向数组的最右侧，左指针先动，当指针指向的数小于分界点，指针向右移动，若大于或等于分界点则停止，此时右指针向左动，当指针指向的值小于等于分界点则停止，若此时i<j交换两个指针指向的值，然后左右指针分别进一格。

#include <iostream>
using namespace std;
const int N=1e5+10;
int q[N];
void quick(int q[],int l,int r){
    if(l>=r)return ;
    int x=q[(l+r)>>1],i=l-1,j=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(q,l,j);
    quick(q,j+1,r);
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)scanf("%d",&q[i]);
    quick(q,0,n-1);
    for(int i=0;i<n;i++)printf("%d ",q[i]);
    return 0;
}

这是从小到大排序，若要从大到小排序，反过来就行了，划分区间的时候分界点左边存比分节点大的值，右边存小的值。

void quick(int q[],int l,int r){
    if(l>=r)return ;
    int x=q[(l+r)>>1],i=l-1,j=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(q,l,j);
    quick(q,j+1,r);
}

归并排序同样基于分治思想。（稳定）

时间复杂度：一定为o（nlogn）

1.确定分界点：中间值。

2.递归将分界点左边排序，递归将分界点右边排序。

3.将两个排完序的序列归并。

归并，是将两个排完序的序列进行比较，从两个序列的最小值开始，若那个小就存入到一个辅助数组进去，一直到左边或右边有一个排完了，然后就把没排完的全都放到辅助数组里面去。

#include <iostream>
using namespace std;
const int N=1e5+10;
int q[N],tmp[N];

void quick(int q[],int l,int r){
    if(l>=r)return ;
    int mid=(l+r)>>1;
    quick(q,l,mid);
    quick(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(int i=l,j=0;i<=r;j++,i++)q[i]=tmp[j];
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cin>>q[i];
    quick(q,0,n-1);
    for(int i=0;i<n;i++)cout<<q[i]<<" ";
    return 0;
}

冒泡排序，就是外层循环轮数，比如说五个数，就循环5-1轮，内层循环区间，比如说，数组的小标为0到n-1，那么内层循环就是j=0，比如到j<=n-1-i;，前提比较的时候是s[j]与s[j+1]比较。