實現算法排序（冒泡排序，選擇排序，插入排序，快速排序）

一、冒泡排序

 //冒泡
    func BubbleSort(arr:inout [Int]) -> [Int] {
        //inout修飾的參數是不能有默認值的，有范圍的參數集合也不能被修飾；
        //一個參數一旦被inout修飾，就不能再被var 和 let 修飾了。
        for i in 0..<arr.count {
            for j in i+1..<arr.count {
                if arr[i] > arr[j] {
                    let temp = arr[i]
                    arr[i] = arr[j]
                    arr[j] = temp
                }
            }
            print(arr)
        }
        return arr
    }


var arr = [3,6,5,1,9,2,4,15,12]
print(BubbleSort(arr: &arr))

　　這里需要直接對傳遞進來的數組進行修改，所以函數在參數上要設置添加inout標識符表示這個數組可以在函數內保持同一份，因為數組是值類型。

　　冒泡排序，每次都是將數組中剩下數字的最小值找出來，最終得到排好序的有序數組。當然也可以改變代碼的實現邏輯，每次循環將數組剩下的最大值找出來放到數組的后面。冒泡排序的時間復雜度O(n²)。

2、選擇排序

　　選擇排序與冒泡排序有些類似，但比冒泡要更好一些，代碼如下。

func selectSort(arr : inout [Int]) -> [Int] {
        for i in 0..<arr.count {
            var minIndex = i
            for j in i+1..<arr.count {
                if arr[minIndex] > arr[j] {
                    minIndex = j
                }
            }
            
            if minIndex != i {
                let temp = arr[minIndex]
                arr[minIndex] = arr[i]
                arr[i] = temp
            }
            print(arr)
        }
        return arr
    }

        var arr = [3,6,5,1,9,2,4,15,12]
        print(selectSort(arr: &arr))

　　通過打印結果看出，選擇排序也是在外層循環每次結束將數組剩下數字的最小值找出來，放在已排好序的末尾，結果是一樣的，但是在實現邏輯上選擇排序會更好一些，因為在選擇排序中，都是通過記錄最小值的index來獲取最小值的位置，最后才進行交換，少做了無用功。時間復雜度是O(n²)。

3、插入排序

　　插入排序是比較直觀的排序算法，將數組從頭至尾依次通過交換向前排至正確的位置。

func insertSort(arr: inout [Int]) -> [Int] {
        for i in 0..<arr.count {
            let temp = arr[i]
            var j = i
            while j > 0,temp < arr[j - 1] {
                arr[j] = arr[j - 1]
                j -= 1
            }
            arr[j] = temp
            print(arr)
        }
        return arr
    }

        var arr = [3,6,5,1,9,2,4,15,12]

        print(insertSort(arr: &arr)) 

　　插入排序相當於冒泡排序和選擇排序來說，是一種值移動的方法，而冒泡排序和選擇排序是產生中間變量用於交換，所以在數組個數不大的情況下插入排序是要優於冒泡排序和選擇排序的。由於仍然是需要兩輪循環，所有插入排序的時間復雜度是O(n²)。

4、快速排序

　　快速排序又叫二分排序，二分插入排序，相比於前三種排序，是一種真正體現出算法優越性的排序。快速排序有些是在插入排序的基礎上，使用二分查找的方式，將一個list划分為兩個list來執行，所有時間復雜度上有明顯的優勢。

//快速排序
    func partition(arr: inout [Int],left:Int,right:Int) -> Int {
        var left = left
        var right = right
        let pivot = arr[left]
        while left < right {
            while left < right,arr[right] >= pivot {
                right -= 1
            }
            arr[left] = arr[right]
            while left < right,arr[left] <= pivot {
                left += 1
            }
            arr[right] = arr[left]
        }
        arr[left] = pivot
        return left
    }
    func quickSort(arr: inout [Int],left:Int,right:Int) {
        guard left <= right else {
            return
        }
        let pivotIndex = partition(arr: &arr, left: left, right: right)
        quickSort(arr: &arr, left: left, right: pivotIndex - 1)
        quickSort(arr: &arr, left: pivotIndex + 1, right: right)
    }


        var arr = [3,6,5,1,9,2,4,15,12]
        quickSort(arr: &arr, left: 0, right: arr.count - 1)
        print(arr) 

　　時間復雜度為O(nlogn)。