选择、插入、希尔排序性能比较

代码

使用swift实现了一下三种排序，如下：

protocol Sortable { }

extension Sortable {
    
    ///选择排序
    func selectionSort<T: Comparable>(_ a: inout [T]) {
        let n = a.count
        for i in 0 ..< n {
            var min = i
            for j in (i + 1) ..< n {
                if a[min] > a[j] {
                    min = j
                }
            }
            exchage(&a, i: i, j: min)
        }
    }
    
    ///插入排序
    func insertSort<T: Comparable>(_ a: inout [T]) {
        let n = a.count
        for i in 0 ..< n {
            var min = i
            for j in (0 ..< i).reversed() {
                if a[min] < a[j] {
                    exchage(&a, i: min, j: j)
                    min = j
                } else {
                    break
                }
            }
        }
    }
    
    ///希尔排序
    func shellSort<T: Comparable>(_ a: inout [T]) {
        let n = a.count
        var h = 1
        
        while h < n / 3 {
            h = 3 * h + 1
        }
        
        while h >= 1 {
            for i in h ..< n {
                var min = i
                for j in stride(from: h, through: i, by: h) {
                    if a[min] < a[i - j] {
                        exchage(&a, i: min, j: i - j)
                        min = i - j
                    } else {
                        break
                    }
                }
            }
            
            h = h / 3
        }
    }
    
}

func exchage<T: Comparable>(_ a: inout [T], i: Int, j: Int) {
    let t = a[i]
    a[i] = a[j]
    a[j] = t
}

耗时比较

使用包含10000个整型元素的数组测试，选择排序平均耗时30秒，插入排序15秒，希尔排序不到1秒。

笔记

长度为N的数组: 选择排序大约需要N²/2次比较，N次交换，数据移动最少。 插入排序大约需要N²/4比较，N²/4次交换，对有序数组十分高效。希尔排序思想就是使数组中任意间隔为h的元素都是有序的。通过交换不相邻的元素对数组局部进行排序，最终用插入排序对局部有序数组进行排序。