一.排序

1.简化版的桶排序

1.1：方法：

根据数据的范围定义多个桶，例如数据的范围是1-1000，那么我们需要1001个桶，来表示0-1000之间每一个数出现的次数，另外，每一个桶的作用就是"标记"每个数出现的次数。

1.2：题目:对范围在1-1000内的整数进行排序

代码如下:

#include<stdio.h>
int main()
{
    int book[1001],i,j,t,n;
    for(i = 0;i <= 1000;i++)
    {
        book[i] = 0;
    }
    scanf("%d",&n);
    for(i = 1;i <= n;i++)
    {
        scanf("%d",&t);
        book[t]++;
    }
    for(i = 1000;i >= 0;i++)
    {
        for(j = 1;j <= book[i];j++)
        {
            printf("%d ",i);
        }
    }
}

2. 冒泡排序

1.1：方法

每次比较两个**相邻**的元素，如果他们的顺序错误就把他们交换.

2.2: 题目：对10个数进行从大到小排序

代码如下:

#include<stdio.h>
int main()
{
    int a[100],i,j,t,n;
    scanf("%d",&n);            //输入n，表示从键盘输入n个数
    for(i = 1;i <= n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i = 1;i <= n-1;i++)
    {
        for(j = 1;j <= n-i;j++)
        {
            if(a[j] < a[j+1])
            {
                t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    }
    for(i = 1;i <= n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

2.3:总结

冒泡排序的核心是双重嵌套循环，且它的时间复杂度为O(N²)，下面的快速排序可以更好的对数据进行排序。

3.快速排序

3.1：方法:

每次排序的时候先设置一个**基准点**，将小于等于基准点的数全部放到基准点的左边，大于等于基准点的数全部放到基准点的右边，这样相比于冒泡排序来说总的交换次数就变少了，速度就提高了。

3.2： 题目:对十个数进行从小到大排序

代码如下:

#include<stdio.h>
void quicksort(int left,int right)
{
    int i,j,t,temp;
    if(left > right)
    {
        return;
    }
    temp = a[left];
    i = left;
    j = right;
    while(i != j)
    {
        while(a[j] > temp && i < j)
        {
            j--;
        }
        while(a[i] < temp && i < j)
        {
            i++;
        }
        if(i < j)
        {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    a[left] = a[i];
    a[i] = temp;
    quicksort(left,i-1);
    quicksort(i+1,right);
    return;
}
int main()
{
    int a[101],n,i,j;
    scanf("%d",&n);
    for(i = 1;i <= n;i++)
    {
        scanf("%d",&a[i]);
    }
    quicksort(1,n);
    for(i = 1;i <= n;i++)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

3.3 ：图示

4.总结:

桶排序是最快的，同时占用更多的内存空间，冒泡排序的时间复杂度为O（N²），快速排序是最优的，它的时间复杂度为O(NlogN).