重新教自己学算法之非递归排序——冒泡-插入-排序（三）

排序可以分为两种：一种是非递归排序，它主要按照非递归的方法对数据进行排序，也就是说主要数据的移位和循环来完成；另外一种就是递归方法，我们在排列当前数据的时候首先把子数据排列有序，然后才会排列当前的数据。这种不断递归调用的方法就是递归排序。
非递归排序的方法有很多，冒泡排序、插入排序、希尔排序；递归的方法有快速排序、归并排序和堆排序。

根据一个小例子来分别讲解每种算法的基本思想：
假定数组为：array[7] = {3,1,8,6,4,2,5};

冒泡：

void buddle_sort(int array[], int length )
{
    //参数合法性检验
    if(NULL == array || 0 == length)
        return ;
    int temp_value = 0;

    //改进，如果在一次遍历中位发生移位，则该数组有序。
    int flag = 1;

    for (int i = length - 1; i >= 1 && flag; --i)
    {
        flag = 0;
        for (int j = 1; j <= i; ++j)
        {
            if(array[j - 1] > array[j])
            {
                temp_value = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp_value;

                if(flag == 0)
                    flag = 1;
            }
        }
    }
}

假定数组为：array[7] = {3,1,8,6,4,2,5};
冒泡通过每一次排序找到最大的数据，移到最后。进行n-1次排序即可完成。
第一趟排序：{1,3,6,4,2,5,8} 第二趟排序：{1,3,4,2,5,6,8 }
进行6次排序后可以得到结果。

插入：

void insert_sort(int array[], int length)
{
    if(NULL == array || 0 == length)
        return;
    int temp_value = 0;
    for (int i = 1; i < length; ++i)
    {
        temp_value = array[i];
        for (int j = i -1; j >= 0; --j)
        {
            if(temp_value < array[j])
            {
                array[j + 1] = array[j];   //插入排序，像向右移位
                if(j == 0)
                    array[j] = temp_value;
            }
            else
            {
                array[j + 1] = temp_value;  //插入数据
                break;
            }
        }
    }
}

假定数组为：array[7] = {3,1,8,6,4,2,5};
插入将数组默认分成已排序和未排序两部分，每一次排序将未排序组的第一个插入到排序好的数组里面，直到未排序组长度为0.
第一趟排序：{3}，{1,8,6,4,2,5}, 1 < 3,3向右移，1插到3的位置。得到：{1,3},{8,6,4,2,5}
第二趟排序：{138}，{6425} 第四趟排序：{1368},{425} …………

希尔排序：一种插入排序的变种

void shell_sort_pro(int array[], int length, int step)
{
    if(NULL == array || 0 == length)
        return ;
    for(; step >= 1; step -= 2)           //根据step进行多少次排序
    {
        for(int loop = 0; loop < step; loop++)       //对每一分组进行排序
        {
            for(int i = step + loop; i < length; i = i + step)    //对每一组进行排序
            {
                int temp_value = array[i];
                for(int j = i - step; j >= 0; j = j - step)
                    if(temp_value < array[j])
                    {
                        array[j + step] = array[j];
                        if(j < step)
                            array[j] = temp_value;
                    }
                    else
                    {
                        array[j + step] = temp_value;
                        break;
                    }
                }
            }
        }
}

假定数组为：array[7] = {3,9,1,8,6,4,7,2,0,5};
先取一个小于n的增量，对数组进行分组插入排序。缩小增量，在分组进行插入排序，当增量为1时，排序即可完成。(增量的选取一般不能整除。)
增量取5,3,1.
增量为5时，分为5组：{3，4}，{9,7}，{1，2}，{8，0}，{6，5}，进行插入排序后：{3,7,1,0,5,4,9,2,8,6}.完成增量为5的排序。
增量为3时：分组：{3，0，9，6}，{7，5，2}，{1，4，8}，进行插入排序后：{0，2，1，3，5，4，6，7，8，9}
增量为1时，对整个数组进行插入排序，完。
希尔排序为改进的插入排序，通过减少数组元素的向右移动次数来达到提高效率的目的。