经典排序（一）

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；

1.2 算法分析

最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

1.3 代码实现
用一个布尔值减少不必要的循环：var isSort = true

//swift代码
 func bubbleSort( list: [Int]) -> [Int] {
        var myList = list
        for i in 0 ..< myList.count {
            var isSort = true
            for k in 0 ..< myList.count - i - 1 {
                if myList[k] > myList[k + 1] {
                    let swap = myList[k]
                    myList[k] = myList[k + 1]
                    myList [k + 1] = swap
                    isSort = false
                }
            }
            if isSort {
                break
            }
        }
        return myList
    }

2、选择排序（Selection Sort）

选择排序是最稳定的排序之一，因为无论什么数据时间复杂度都是O(n2)
唯一的好处就是不占用额外的内存空间。

2.1 算法描述
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.2 代码实现

//Swift
public func selectionSort(aList: [Int]) -> [Int] {
    var list = aList
    for i in 0 ..< list.count - 1 {
        var minIndex = i
        for j in i + 1 ..< list.count {
            if list[j] < list[minIndex] {
                minIndex = j
            }
        }
        let temp = list[minIndex]
        list[minIndex] = list[i]
        list[i] = temp
    }
    return list
}

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

3.1 算法描述

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。
   3.2 代码实现

//Swift
public func insertionSort(aList: [Int]) -> [Int] {
    var list = aList
    //第一层循环基础
    for i in 0 ..< list.count - 1 {
//        var nowIndexValue = list[i]
        var j = i + 1
        var isNeedSort = false
        while j > 0 {
            if list[j] < list[j - 1] {
                let temp = list[j]
                list[j] = list[j - 1]
                list[j - 1] = temp
                isNeedSort = true
            }
            j = j - 1
            if !isNeedSort {
                break
            }
        }
    }
    return list
} 

4、快速排序

快速排序 - （类似于选择排序的定位思想）选一基准元素，依次将剩余元素中小于该基准元素的值放置其左侧，大于等于该基准元素的值放置其右侧；然后，取基准元素的前半部分和后半部分分别进行同样的处理；以此类推，直至各子序列剩余一个元素时，即排序完成（类比二叉树的思想，from up to down）
时间复杂度：O(NlogN)

func quickSort(a: inout [Int], low: Int, high: Int) {
    if low >= high { // 递归结束条件
        return
    }
    var i = low
    var j = high
    let key = a[i]
    while i < j {
        // 从右边开始比较，比key大的数位置不变
        while i < j && a[j] >= key {
            j -= 1
        }
        // 只要出现一个比key小的数，将这个数放入左边i的位置
        a[i] = a[j]
        // 从左边开始比较，比key小的数位置不变
        while i < j && a[i] <= key {
            i += 1
        }
        // 只要出现一个比key大的数，将这个数放入右边j的位置
        a[j] = a[i]
    }
    a[i] = key // 将key放入i的位置，则左侧数都比key小，右侧数都比key大
    quickSort(a: &a, low: low, high: i - 1) // 左递归
    quickSort(a: &a, low: i + 1, high: high) // 右递归
}