实现算法排序（冒泡排序，选择排序，插入排序，快速排序）

一、冒泡排序

 //冒泡
    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)。