内部排序的几种方法，升序排列

直接插入排序

1.将整个待排序序列的第一个元素视为已排序序列，其起始位置为0，长度为1。
2.从第二个元素开始，依次将每个元素视为待插入的元素，与已排序序列中的元素从后往前进行比较。
3.将待插入元素放到找到大小中间的位置上插入。

//直接插入排序
void insert_sort(int32_t arr[], uint32_t num)
{
    int32_t j = 0, sentry = 0;
    for(uint32_t i = 1; i < num; i++)
    {
        sentry = arr[i]; //哨兵即要插入的值，此值和前面已排序好的序列值做比较，在合适位置插入
        j = i - 1;
        while( j >= 0 && sentry < arr[j] )
        {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = sentry;
    }
}

冒泡排序

1. 比较相邻两个数据，如果第一个比第二个大，就交换两个数
2. 对每一个相邻的两个数做同样的工作，这样从开始到结尾，在最后的数就是最大的数。
3. 重复上述步骤，直到顺序完成。

//冒泡排序
void bubble_sort(int32_t arr[], uint32_t num)
{	
    for(uint32_t i = 0; i < num - 1; i++)
    {
        for(uint32_t j = 0; j < num - i - 1; j++)
        {
            if(arr[j] > arr[j+1]) //通过两两交换，将最大值冒到最后
            {
                int32_t temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

快速排序

1. 从数列中挑出第一个元素作为基准值。
2. 重新排列数列，把所有的比基准值小的放在基准前面，反之放在后面(一样大可任意一边）完成后基准值处于分区的中间位置。
3. 通过递归调用把小于基准元素和大于基准元素的子序列再进行排序。

//快速排序
int32_t partition(int32_t arr[], int32_t low, int32_t high)
{
    int32_t pivotkey = arr[low]; //把第一个值记录为枢轴值
    while(low < high) //从数组的两端向中间扫描
    {
        while(low < high && arr[high] >= pivotkey)
        {
            high--;
        }
        arr[low] = arr[high]; //比轴枢值小的移到低端
        while(low < high && arr[low] <= pivotkey)
        {
            low++;
        }
        arr[high] = arr[low]; //比轴枢值大的移到高端
    }
    arr[low] = pivotkey;
    return low;
}

void q_sort(int32_t arr[], int32_t low, int32_t high)
{
    if(low < high)
    {
        int32_t pivotpos = partition(arr, low, high); //先一分为二， pivotpos为轴枢位置
        q_sort(arr, low, pivotpos - 1); //对低子数组进行递归排序
        q_sort(arr, pivotpos + 1, high); //对高子数组进行递归排序
    } 
}

void quick_sort(int32_t arr[], uint32_t num)
{
    q_sort(arr, 0, num - 1);
}

选择排序

1. 在一个长度为 N 的无序数组中，第一次遍历整个数组找到最小的值和第一个数做交换。
2. 第二次从下一个数开始遍历 N-1个数，找到最小的数和第二个数交换。
3. 重复以上操作直到第 N-1 次遍历最小的数和第 N-1 个数交换，排序完成。

//选择排序
void select_sort(int32_t arr[], uint32_t num)
{
    for(int32_t i = 0; i < num; i++)
    {
        int32_t min_key = arr[i];
        for(int32_t j = i; j < num; j++)
        {
            if(arr[j] < min_key)
            {
                int32_t temp = arr[j];
                arr[j] = min_key;
                min_key = temp;
            }
        }
        arr[i] = min_key;
    }
} 

测试代码

//测试代码，排序均为从小到大排序
static int32_t arr_sort[] = {5, 6, 7, 1, -1, 10, 7, 8, 21};
select_sort(arr_sort, sizeof(arr_sort)/sizeof(int32_t));
for(uint32_t i = 0; i < sizeof(arr_sort)/sizeof(int32_t); i++)
{
    printf("%d\n", arr_sort[i]);
}