Swift 经典算法之快速排序

原理：

快速排序：给基准数据找其正确索引位置的过程. 快排的时间复杂度是O(nlogn)，空间复杂度是O(logn)

1、给一个基准数据，一般是数组第0个，即target = array[0]

2、从后半部分开始，如果扫描到的值大于基准数据就让high减1,如果发现有元素比该基准数据的值小，就将high位置的值赋值给low位置

3、从前往后扫描，如果扫描到的值小于基准数据就让low加1,如果发现有元素大于基准数据的值，就再将low位置的值赋值给high位置的值

4、直到low=high结束循环,此时low或high的下标就是基准数据target在该数组中的正确索引位置

    func quickSort(_ array: inout Array<Int>, _ low: Int, _ hight: Int) -> Void {
        // 需要排序的区间只包含一个数字，则不需要重排数组，直接返回
        if low >= hight {
            return
        }
        // 找寻基准数据的正确索引
        let index = getCurrentIndex(&array, low, hight)
        quickSort(&array, low, index-1)
        quickSort(&array, index+1, hight)
    }
    func getCurrentIndex(_ array: inout Array<Int>, _ low: Int, _ hight: Int) -> Int {
        //基准数据
        let target = array[low]
        var low = low
        var hight = hight
        while low < hight {
            // 当队尾的元素大于等于基准数据时,向前挪动high指针
            while low < hight && array[hight] >= target {
                hight = hight-1
            }
            // 如果队尾元素小于tmp了,需要将其赋值给low
            array[low] = array[hight]
            
            while low < hight && array[low] <= target {
                low = low+1
            }
            // 当队首元素大于tmp时,需要将其赋值给high
            array[hight] = array[low];
        }
        //替换数组原数
        array[low] = target
        return low
    }
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.

        var dataArray = [49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22]
        
        quickSort(&dataArray, 0, dataArray.count-1)
        print("排序后数组：\(dataArray)")
    }

测试结果：

排序后数组：[-1, 0, 1, 2, 5, 8, 22, 22, 23, 38, 49, 65, 76, 97]

使用Swift filter函数实现更简单：

   func quickSort<T: Comparable>(_ data: [T]) -> [T] {
        guard data.count > 1 else {
            return data
        }
        let pivot = data[data.count/2]
        let less = data.filter {
            $0 < pivot
        }
        let equel = data.filter {
            $0 == pivot
        }
        let greater = data.filter { (ff) -> Bool in
            ff > pivot
        }
        
        return quickSort(less) + equel + quickSort(greater)
    }

   //调用测试
   var data = [1,55,3,11,2,77,34,6,32]
        
       print(data.sorted())
       print(quickSort(data))

排序结果：

[1, 2, 3, 6, 11, 32, 34, 55, 77]