常用排序算法非递归篇

      一直以来，对于冒泡、插入、选择这样的简单排序算法都没有弄得特别清楚，总是弄混淆。趁着晚上有空，把相关的排序算法回忆一下并做个记录。接下来讲的排序算法都以对整数的排序为例：

      冒泡排序的实现描述：

      1、将所有待排序的整数放入数组中；
      2、从数组的第一个数字到倒数第二个数字进行逐个检查：若某一位上的整数大于它的下一位，则将它与它的下一位交换；

      3、重复2号步骤，直至再也不能交换。

      根据以上算法实现描述，可以比较简单的实现代码：

void bubble_sort(int *array, int length)
{
    int temp = 0;
    
    if (NULL == array || 0 == length)
    {
        return;
    }
    
    for (int i = length - 1; i >= 1 ; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (array[j] > array[j + 1])
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    
    return;
} 

 

      从上面的算法描述和实现中，不难看出该算法还有优化的余地，即在某一轮比较过程中，若未发生过一次交换，则可以认为冒泡排序已经完成。优化结果如下：

void bubble_sort(int *array, int length)
{
    int temp = 0;
    bool flag = false;
    
    if (NULL == array || 0 == length)
    {
        return;
    }
    
    for (int i = length - 1; i >= 1 ; i--)
    {
        flag = false;
        for (int j = 0; j < i; j++)
        {
            if (array[j] > array[j + 1])
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag = true;
            }
        }
        
        if (!flag)
        {
            break;
        }
    }
    
    return;
} 

      插入排序的实现描述：

      1、首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）；
      2、从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态；
      3、重复2号步骤，直至原数列为空。

      根据以上算法实现描述，具体代码实现如下：

void insert_sort(int *array, int length)
{
    int temp = 0;
    int i, j;
    
    if (NULL == array || 0 == length)
    {
        return;
    }
    
    for (i = 1; i < length; i++)
    {
        temp = array[i]; 
        for (j = i - 1; j >= 0; j--)
        {
            if (temp < array[j])
            {
                array[j + 1] = array[j]; //元素向右移动 
            }
            else
            {
                break;
            }
        }
        array[j + 1] = temp; //插入数据 
    }
    
    return;
}

      从代码实现来看，并没有新建空列表，而是直接在原列表上进行了排序。其实，我们可以把原列表的前面部分（已排序部分）看成是新建的空列表，后面部分（未排序部分）看成是原列表中剩余的未排序部分。那么，插入排序是否还有可以优化的余地呢？我们可以发现每一轮插入排序都是局部排序的结果，没法保证未排序部分的结果，因此没法像冒泡排序一样进一步做优化。

 

      选择排序的实现描述：

      1、数组中放了n个待排序整数，数组下标从0开始，到n - 1结束，i = 1；
      2、从数组的第i个元素开始到第n个元素，寻找最小的元素；
      3、将上一步找到的最小元素和第i位元素进行交换；
      4、如果i = n - 1则结束，否则i++，回到第2步。

      根据以上算法实现描述，具体实现代码如下：

void select_sort(int *array, int length)
{
    int temp = 0;
    int index = 0;
    
    if (NULL == array || 0 == length)
    {
        return;
    }
    
    for (int i = 0; i < length - 1; i++)
    {
        index = i;
        
        for (int j = i + 1; j < length; j++)
        {
            if (array[index] > array[j])
            {
                index = j;
            }
        }
        
        if (index != i)
        {
            temp = array[i];
            array[i] = array[index];
            array[index] = temp;
        }
    }
    
    return;
}

      希尔排序的实现描述：

      先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

根据以上算法实现描述，具体实现代码如下：

void shell_sort(int *array, int length)
{
    int temp = 0;
    int d, i, j;
    
    for (int d = length / 2; d >= 1; d /= 2)
    {
        for (int i = d; i < length; i++)
        {   
            temp = array[i];
            for (j = i - d; j >= 0; j -= d)
            {
                if (temp <array[j])
                {
                    array[j + d] = array[j];
                }
                else
                {
                    break;
                }
            }
            
            array[j + d] = temp;
        }
    }
    
    return;
}

      对于希尔排序，d的取值方法不一定需要根据以上每次都除以2。比如可以在每次除以2后，d为偶数的，则d再加1，但是d最后必须为1。

      希望对于以上排序算法有同样困惑或者容易混淆的朋友有所帮助。