总结排序算法

1. 冒泡排序： 一个泡泡从前面升过来， 如果比他小， 那他就超过他， 如果比他大， 说明这个泡泡一定是在大泡的后边 我就换成大泡泡升

void bubblesort(int p[], int l, int r)
{
    for(int i = l; i <= r; i++)
    {
        for(int j = l; j < r; j++)
        {
            if(a[j+1] < a[j]) swap(a[j+1], a[j]);
        }
    }

2.选择排序： 每次选择一个最大的或者最小的放最后 然后再从剩下的重复此步骤

void selectsort(int p[], int l, int r)
{
    for(int i = l; i < r; i++)
    {
        for(int j = i+1; j <= r; j++)
        {
            if(a[j] < a[i]) swap(a[i], a[j]);
        }
    }
}

3.归并排序

void Merge_sort(int p[], int l, int r)
{
    if(l >= r) return;
    int i = l, mid = (l + r) >> 1; /*相当于 /2 */
    int j = mid+1, k = l;
    Merge_sort(a, l, mid);
    Merge_sort(a, mid+1, r);// 一定要先于后边的步骤
    // 后边的步骤是 对左右两个有序数列排队 如果先后边再这个 就乱套了
    while(i <= mid && j <= r)
    {
        if(p[i] < p[j]) b[k++] = p[i++];
        else b[k++] = p[j++];
    }
    while(i <= mid)
    {
        b[k++] = p[i++];
    }
    while(j <= r)
    {
        b[k++] = p[j++];
    }

    for(int i = l; i <= r; i++)
    {
        p[i] = b[i];
    }
    return ;
}

4.插入排序 ：从数列中第2-n项依次取 然后 将这个数 与他前面的 i - 1 项进行伴随比较找到他在这算上自己 共 i 个人中的位置

void Insertsort(int p[], int l,int r)
{
    for(int i = l; i < r; i++)
    {
        int  ans = i;
        int cnt = a[ans+1]; // 这里一定是从 i + 1 开始 不然就会全部变成a[1]
        while(ans)
        {
            if(p[ans] > cnt)
            {
                p[ans+1] = p[ans];
                ans--;
            }
            else
            {
                break;// 如果cnt 开始的位置错了 就会一直break 然后进行下边的赋值
            }
        }
        p[ans+1] = cnt;

    }
}

5.快速排序：二分 + 取一个基数（标杆） 把比他小的放左边 比他大的放右边 然后 再以他为界限继续重复（快速排序似乎有三个版本）

void quicksort(int *p, int l, int r)
{
    if(l >= r) return; // 异常条件判断不能少
    int temp = p[l];
    int i = l, j = r;
    while(j > i)
    {
        while(j > i && p[j] >= temp)
        {
            j--;
        }
        while(j > i && p[i] <= temp)
        {
            i++;
        }
        if(j > i) swap(p[i], p[j]);
    }
    //swap(p[i], p[l]);// 当i == j 时 就是 这个标杆应该在的位置。
    quicksort(p, l, i-1);
    quicksort(p, i+1, r);
    return;
}

另外一种快速排序

void quick_sort(int p[], int l, int r)
{
    int mid = a[(l + r)/2];
    int i = l, j = r;
    do{
        while(p[i] < mid)
        {
            i++;
        }
        while(p[j] > mid)
        {
            j--;
        }
        if(i <= j)
        {
            swap(p[i], p[j]);
            i++;
            j--;
        }
    }while(i <= j);
    if(l < j) quick_sort(p,l, j);
    if(i < r) quick_sort(p,i, r);
    return;
}

6.桶排序（简单版） ： 一个桶里边装好多个元素的我不会呢。

for(int i = 1; i <= n; i++)
    {
        int x;
        scanf("%d",&x);
        a[x]++;
         // 这种简单版就是 一个萝卜一个坑  而且还是萝卜序号和坑号相同 因此比较简单 但是空间复杂度高
         // 现在把萝卜都放坑里了 看看你要干啥了 比如你要把萝卜从小到大排列
    }
    for(int i = 1; i <= 1000; i++)
    {
        while(a[i]--)
        {
            printf("%d ",i);
        }
    }

7.计数排序：

桶排序： b[I] --> 等于i 的数的个数   计数排序   b[i] ---->  <=i 的数的个数

for(int i = 1; i <= n; i++)
    {
        int x;
        scanf("%d", &x);
        a[x]++;
        b[x] = b[x-1] + a[x];
    }
    for(int i = 1; i <= n; i ++)
    {
        printf("%d ", b[i]); // 小于等于1 --- n 的数分别有多少个 
    }
    for(int i = 1; i <= n; i++)
    {
        printf("%d ", b[i] - b[i-1]);// 等于i 的数有多少个
    }