初等排序算法

1. 插入排序

思想： 其思路与打扑克时排列手牌的方法类似，即需要将牌一张张抽出来，分别插入到前面已排序好的手牌中的适当位置。

算法伪代码：

InsertSort(A, N)　　　　//包含N个元素的0起点数组A
    for i = 1 ... N-1
        v = A[i]
        j = i - 1
        while j >= 0 && A[j] > v
            A[j+1] = A[j]
            j--
        A[j+1] = v

　　

2. 冒泡排序

思想：让数组元素逐个地像水中气泡一样上浮。

伪代码1：

BubbleSort(A, N)　　　　// 包含N个元素的0起点数组A
　　flag = true　　　　　// 表示存在顺序相反的相邻元素
　　while flag
　　　　flag = 0
　　　　for i = N-1 ... 1
　　　　　　if A[i] < A[i-1]
　　　　　　　　　　A[i]与A[i-1]交换
　　　　　　　　　　flag = 1　　

 

伪代码2：

BubbleSort(A, N)
    for i = 1 ... N-1
        for j = N-1 ... i
            if A[j] < A[j-1]
            　　交换A[j] 和A[j-1]

　　　　

 

3. 选择排序

思想：在每个计算步骤中选出一个最小值，进而完成排序。

伪代码：

 

SelectSort(A, N)
    for i = 0 ... N-1
        min = i
        for j = i ... N-1
            if A[j] < A[min]
                min = j
        A[i] 和A[min]交换

 

　　

 

4. 稳定排序

思想：要求排序后的结果具有稳定的输出，所谓的稳定输出是指当输入数组中有多个同样大小元素时，应保证这些元素的相对顺序在输入与输出中保持不变。

判断稳定性的伪代码：

 

IsStable(in, out)    //in为排序之前的数组，out为排序之后的数组
    for i = 0 ... N-1
        for j = i+1 ... N-1
            for m = 0 ... N-1
                for n = m+1 ... N-1
                    if in[i]和in[j]的数字相等 && in[i] == out[n] && in[j] == out[m]
                        return false
return true

 

冒泡排序法属于稳定排序算法。而选择排序算法是一种不稳定的排序算法，需要检查输出结果，可将选择排序与冒泡排序的结果相比较来检查，可显著提高计算复杂度。

 

 

5.希尔排序

思想：因插入排序法可高速处理顺序较整齐的数据，希尔排序法就利用了这一特长。在希尔排序中，程序会重复进行以间隔为g的元素为对象的插入排序。比如，间隔为2就表示元素位置为奇数的作为一组来进行插入排序，且位置为偶数的作为另一组进行插入排序。算法的复杂度基本维持在O(N^1.25)。

算法伪代码：

 

InsertSort(A, n, g)
    for i = g to n-1
        v = A[i]
        j = i -g
        while j >= 0 && A[j] > v
            A[j+g] = A[j]
            j = j -g
            count++
        A[j+g] = v

ShellSort(A, n)
    count = 0
    G[] = {1, 4, 13, 40, 121...} //可尝试选择其他的间隔g序列，但一般即采用：G[n+1] = 3*G[n] + 1.
    for i = 0 ... G.length() -1
        InsertSort(A, n, G[i])