1.冒泡排序：

冒泡排序的基本思想是，一趟冒泡可以交换出序列中的一个最值，并且放在它的正确位置；

所以一共有 n 个元素，一共需要找出 n - 1 个最值，也就是要循环 n - 1 次。

即外层循环为 1 ~ n 。

而内层循环，是要从 0 循环到第 n - i 个，然后分别和后一个元素来比较，进行交换操作（C++里面可以直接用 swap( a , b ) 来交换，但是 C 语言不行哦）

具体代码函数如下哦：

int a[100];
void bubblesort(int a[], int n) //从0 ~ n 的元素从小到大排序
{
    for(int i = 1; i < n; i++)
    {
        for(int j = 0; j < n - i; j++)
        {
            if(a[j] > a[j+1])
                swap(a[j], a[j+1]);
        }
    }
}

2.选择排序：

选择排序的基本思想是，每一趟循环，找到一个最值，然后跟它需要放在的位置上面的元素来交换位置。

因为一共 n 个元素，也是一共需要循环 n - 1 次。

int a[100];
void selectsort(int a[],int n) //从0 ~ n 的元素从小到大排序
{
    for(int i = 1; i < n; i++)
    {
        int k = 0;
        for(int j = 0; j <= n - i; j++)
        {
            if(a[j] > a[k])
                k = j;
        }
        swap(a[k],a[n-i]);
    }
}

3.sort排序：

我之前博客里面有，所以就不细致讲了。超链接：sort 排序

直接在 main 函数里面调用即可，简要代码：

#include <algorithm>
int a[100];
int main()
{
    sort(a,a+n);
}

4.快速排序：

快速排序思想是，从一个序列中寻找到一个tmp值（一般为第一个）作为基准值，然后将整个序列中比它小的，放在它前面，比它大的，放在后面，然后通过递归，一次次二分下去，一直到排序完成。

struct type
{
    int key;
}R[1000];

int partition(type R[], int s, int t)
{
    int i = s, j = t;
    type tmp = R[i];
    while(i < j)
    {
        while(j > i && R[j].key >= tmp.key)
            j--;
        R[i] = R[j];
        while(i < j && R[i].key <= tmp.key)
            i++;
        R[j] = R[i];
    }
    R[i] = tmp;
    return i;
}

void Quicksort(type R[], int s, int t)
{
    int i;
    if(s < t)
    {
        i = partition(R,s,t);
        Quicksort(R, s, i-1);
        Quicksort(R, i+1, t);

    }
}

int main()
{
    Quicksort(R, 0, n);//从 0 ~ n 从小到大排序
}

一般 sort 排序用的比较多，也比较方便，所以别的仅供参考哦！

OVER！