排序算法之直接插入排序

排序算法之直接插入排序

这一系列主要讲的是排序算法，首先会简单介绍各种排序算法的基本思想，然后会给出每种算法的Python实现和C++实现,代码中均有非常详细的注释。最后会给出不同算法的复杂度分析。

文中Python代码是在Python3.4.3或 Python3.2上实现的，C++代码是在Dev-C++5.7.1上实现的。如果有什么不清楚或者不对的地方，欢迎大家随时指正。

直接插入排序的基本思想是：将一个元素插入到已经排好序的有序表中，即得到一个新的、元素个数增1的有序表。我们可以假设最开始的有序表只有一个元素，则重复上述过程，直到所有待排序的元素全部加入到有序表中为止。
Python代码实现：

import numpy as np

def StraightInsertionSort(unSortedArray):
    length = len(unSortedArray)         #获取待排序数组的长度

    for i in range(length-1):
        flag = True  #设置标志变量
        while i >= 0 and flag == True:  #因为插入的是有序序列，所以一旦不需要交换，就退出内层循环
            flag = False
            if unSortedArray[i] > unSortedArray[i+1]:
                temp = unSortedArray[i]
                unSortedArray[i] = unSortedArray[i+1]
                unSortedArray[i+1] = temp
                flag = True
                i -= 1                  #此处的i跟外层循环的i不一样

    return unSortedArray

//算法验证
unSortedArray = np.array([2,7,1,5,9,3,10,18,6])
print("The original data is: ",unSortedArray)
print("The sorted data is: ",StraightInsertionSort(unSortedArray))

运行结果为：

>>> ================================ RESTART ================================
>>>
The original data is:  [ 2  7  1  5  9  3 10 18  6]
The sorted data is:  [ 1  2  3  5  6  7  9 10 18]

C++代码实现：

#include <iostream>
using namespace std;
//交换两个元素，形参为引用形参
void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
//直接插入排序：输入待排序数组和数组长度，返回指向排好序的数组的指针 
int* StrightInsertionSort(int *a, int length)
{
    for(int i = 0; i < length-1; ++i)
    {
        bool flag = true;
        int j = i+1;

        while(j > 0 && flag == true)          //因为每次都是插入到有序数组中，所以当没有交换时直接退出内循环
        {
            flag = false;
            if(a[j] < a[j-1])                 //比较待插入元素和有序数组中的元素
            {
                swap(a[j], a[j-1]);          //交换之后设置标志变量为true，说明还需要与有序数组中其它元素进行比较
                flag = true;
                --j;                         //内层循环变量减1，指向待插入元素
            }
        }
    }
    return a;
}

int main(int argc, char** argv) {

    int originalArray[] = {2,7,1,5,9,3,10,18,6};
    int length = sizeof(originalArray)/sizeof(int);          //计算数组长度

    cout << "The length of the array is " << length << endl;
    cout << "The original array is: ";
    for(int i = 0; i <= length-1; i++)                       //打印待排序数组元素
    {
        cout << originalArray[i] << static_cast<char>(32);   //32是空格的ASCII值，把它转换成空格输出
    }
    cout << endl;

    int *sortedArray = StrightInsertionSort(originalArray,length);     //调用排序算法，返回一个指向int型数组的指针
    cout << "The sorted array is: ";
    for(int i = 0; i <= length-1; i++)                       //打印排序结束之后的数组元素
    {
        cout << sortedArray[i] << static_cast<char>(32);
    }
    return 0;
}

运行结果为：

The length of the array is 9
The original array is: 2 7 1 5 9 3 10 18 6
The sorted array is: 1 2 3 5 6 7 9 10 18

直接插入排序的算法复杂度：
最好的情况是待排序列本身有序，则此时只要比较即可，不需要交换，时间复杂度为O(n)；最坏的情况是待排序列逆序，此时则需要比较(n+2)*(n-1)/2次，移动次数也为最大值(n+4)*(n-1)/2次；如果序列中元素随机，则平均比较和移动次数约为(n^2)/4，所以直接插入排序法的时间复杂度为O(n^2)。

排序算法之简单选择排序