排序算法 7 兄弟

swift青铜
133 阅读8分钟

排序算法可以说是数据结构与算法当中最为基础的部分，针对的是数组这一数据结构。将数组中的无序数据元素通过算法整理为有序的数据元素即为排序

时间复杂度

时间复杂度是一个函数，它描述了该算法的运行时间，考察的是当输入值大小趋近无穷时的情况。数学和计算机科学中使用这个大 O 符号用来标记不同”阶“的无穷大。这里的无穷被认为是一个超越边界而增加的概念，而不是一个数。

想了解时间复杂度，我想讲讲常见的 O(1)，O(log n)，O(n)，O(n log n)，O(n^2) ，计算时间复杂度的过程，常常需要分析一个算法运行过程中需要的基本操作，计量所有操作的数量。

O（1）常数阶

O（1）中的 1 并不是指时间为 1，也不是操作数量为 1，而是表示操作次数为一个常数，不因为输入 n 的大小而改变，比如哈希表里存放 1000 个数据或者 10000 个数据，通过哈希码查找数据时所需要的操作次数都是一样的，而操作次数和时间是成线性关系的，所以时间复杂度为 O（1）的算法所消耗的时间为常数时间。

O（log n）对数阶

O（log n）中的 log n 是一种简写，loga n 称作为以 a 为底 n 的对数，log n 省略掉了 a，所以 log n 可能是 log2 n，也可能是 log10 n。但不论对数的底是多少，O（log n）是对数时间算法的标准记法，对数时间是非常有效率的，例如有序数组中的二分查找，假设 1000 个数据查找需要 1 单位的时间， 1000,000 个数据查找则只需要 2 个单位的时间，数据量平方了但时间只不过是翻倍了。如果一个算法他实际的得操作数是 log2 n + 1000， 那它的时间复杂度依旧是 log n， 而不是 log n + 1000，时间复杂度可被称为是渐近时间复杂度，在 n 极大的情况，1000 相对 与 log2 n 是极小的，所以 log2 n + 1000 与 log2 n 渐进等价。

O（n）线性阶

如果一个算法的时间复杂度为 O(n)，则称这个算法具有线性时间，或 O(n) 时间。这意味着对于足够大的输入，运行时间增加的大小与输入成线性关系。例如，一个计算列表所有元素的和的程序，需要的时间与列表的长度成正比。遍历无序数组寻最大数，所需要的时间也与列表的长度成正比。

O（n log n）线性对数阶

排序算法中的快速排序的时间复杂度即 O（n log n），它通过递归 log2n 次，每次遍历所有元素，所以总的时间复杂度则为二者之积， 复杂度既 O（n log n）。

O（n^2）平方阶

冒泡排序的时间复杂度既为 O（n^2），它通过平均时间复杂度为 O（n）的算法找到数组中最小的数放置在争取的位置，而它需要寻找 n 次，不难理解它的时间复杂度为 O（n^2）。时间复杂度为 O（n^2）的算法在处理大数据时，是非常耗时的算法，例如处理 1000 个数据的时间为 1 个单位的时间，那么 1000,000 数据的处理时间既大约 1000,000 个单位的时间。

算法一：插入排序

784630-2705f4eca05d768c.gif 插入排序是一种简单直观的算法。它的工作原理是构建一个有序序列，对于未排序数据，在有序序列中从后往前遍历，找到位置插入。

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

//MARK:- 插入排序
func insertSort(inout arr: [Int]) -> [Int] {
    
    for i in 1 ..< arr.count {
        let key = arr[i]
        var j = i - 1
        while j >= 0 && arr[j] > key {
            arr[j + 1] = arr[j]
            j -= 1
        }
        arr[j + 1] = key
    }
    return arr

}

算法二：希尔排序

784630-804ae9c932b047d0.gif

希尔排序(Shell Sort)是插入排序的一种，它是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。

希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

步骤如下：
* 希尔排序是对数组按照一定的步长gap分组，对每组使用直接插入排序算法排序；
* 随着步长gap逐渐减少，每组包含的关键词越来越多，当步长gap减至1时，整个文件恰被分成一组，算法便终止。

static func shellSort(arr:inout [Int]) -> [Int] {
        var gap = arr.count / 2  // 步长

        //步长循环, 步长不断缩小，最后成为一，也就是分组个数越来越小，每组成员数越来越大
        while gap > 0 {

            //按照步长,分组循环
            for gapIndex in 0 ..< gap {
                
                //取当前组第二个元素index开始做插入排序
                var insertIndex = gapIndex + gap
                while insertIndex < arr.count { //遍历组中所有元素
                    let insertItem = arr[insertIndex]
                    var j = insertIndex - gap
                    if insertItem < arr[j] {
                        while j >= 0 && arr[j] > insertItem {
                            arr[j + gap] = arr[j]
                            j -= gap
                        }
                        arr[j + gap] = insertItem
                    }
                    
                    insertIndex += gap
                }
            }

            gap /= 2
        }
    return arr
}

算法三：选择排序

784630-a46d04db0862fe2f.gif

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

步骤如下：
* 遍历数组，找到最小的元素，将其置于数组起始位置。
* 从上次最小元素存放的后一个元素开始遍历至数组尾，将最小的元素置于开始处。
* 重复上述过程，直到元素排序完毕。

static func selectionSort(arr: inout [Int]) -> [Int] {
        for i in 0 ..< arr.count - 1 {
            
            //从第i个开始，遍历后续的，找出最小, 和i元素置换
            var min = i
            for j in i+1 ..< arr.count {
                if arr[min] > arr[j] {
                    min = j
                }
            }
            let temp = arr[min]
            arr[min] = arr[i]
            arr[i] = temp
        }
    return arr
}

算法四：冒泡排序

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

784630-3fe1e03dfba912df.gif

//MARK:- 冒泡排序
func bubbleSort(inout arr: [Int]) -> [Int] {
    for i in 0 ..< arr.count {
        for j in 0 ..< arr.count - 1 - i {
            if arr[j] > arr[j + 1] {
                let temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    } 
    return arr
}

算法五：归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 784630-287c68f5e0e1804a.gif

步骤如下：
1. 申请空间，创建两个数组，长度分别为两个有序数组的长度
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

//MARK:- 归并排序
func mergeSort(inout arr: [Int]) -> [Int] {
    
    func merge (inout arr: [Int], low: Int, mid: Int, high: Int, inout temp: [Int]) {
        var i = low
        var j = mid + 1
        let m = mid
        let n = high
        var k = 0
        
        while (i <= m && j <= n) {
            if (arr[i] <=  arr[j])
            {
                temp[k] = arr[i]
                k += 1
                i += 1
            }
            else
            {
                temp[k] = arr[j]
                k += 1
                j += 1
            }
        }
        
        while i <= m {
            temp[k] = arr[i]
            k += 1
            i += 1
        }
        
        while j <=  n {
            temp[k] = arr[j]
            k += 1
            j += 1
        }
        
        for f in 0 ..< k {
            arr[low + f] = temp[f]
        }
        
    }
    
    func internalMergeSort(inout arr: [Int], low: Int, high: Int, inout temp: [Int]) {
        if high <= low {
            return
        }
        let mid = low + (high - low) / 2
        // 左边有序
        internalMergeSort(&arr, low: low, high: mid, temp: &temp)
        // 右边有序
        internalMergeSort(&arr, low: mid + 1, high: high, temp: &temp)
        // 将两边合起来
        merge(&arr, low: low, mid: mid, high: high, temp: &temp)
    }
    
    var temp: [Int] = arr// 辅助数组
    internalMergeSort(&arr, low: 0, high: arr.count - 1, temp: &temp)
    return arr
}

算法六：快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

步骤：
* 从数列中挑出一个元素，称为 “基准”（pivot），
* 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
* 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

784630-13f5c7b35b1d0ae4-2.gif

static func quickSort(arr: inout [Int]) -> [Int] {
        func partition(_ p: Int, _ r: Int) -> Int {
            var i = p - 1
            let key = arr[r] //基准
            for j in p ..< r { //遍历， 找到所有小于key的，arr放到前面
                if arr[j] < key {
                    i = i + 1
                    let temp = arr[j]
                    arr[j] = arr[i]
                    arr[i] = temp
                }
            }
            //i + 1 放基准
            arr[r] = arr[i + 1]
            arr[i + 1] = key
            return i + 1
        }
        
        func internalQuickSort(_ p: Int, _ r: Int) {
            if p < r {
                let q = partition(p, r)//找到基准，并分区
                internalQuickSort(p, q - 1)//基准前区递归
                internalQuickSort(q + 1, r)//基准后区递归
            }
        }
        
        internalQuickSort(0, arr.count - 1)
        return arr
}

算法七：堆排序

堆排序（Heap Sort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

步骤如下：
* 按堆的定义将数组R[0..n]调整为堆（这个过程称为创建初始堆），交换R[0]和R[n]；
* 将R[0..n-1]调整为堆，交换R[0]和R[n-1]；
* 重复上述过程，直到交换了R[0]和R[1]为止。

13683227-2b419e002e293219.gif

13683227-6de0b85789abf90c.gif

//MARK:- 堆排序
func heapSort(inout arr: [Int]) -> [Int] {
    
    func buildheap(inout arr: [Int]) {
        let length = arr.count
        let heapsize = length
        var nonleaf = length / 2 - 1
        while nonleaf >=  0 {
            heapify(&arr, i: nonleaf, heapsize: heapsize)
            nonleaf -= 1
        }

    }
    
    func heapify(inout arr: [Int], i : Int, heapsize: Int){
        var smallest = i
        let left = 2*i+1
        let right = 2*i+2
        if(left < heapsize){
            if(arr[i]>arr[left]){
                smallest = left
            }
            else {
                smallest = i
            }
        }
        if(right < heapsize){
            if(arr[smallest] > arr[right]){
                smallest = right
            }
        }
        if(smallest != i){
            var temp: Int
            temp = arr[i]
            arr[i] = arr[smallest]
            arr[smallest] = temp
            heapify(&arr,i: smallest,heapsize: heapsize)
        }
        
    }
    
    func internalHeapSort(inout arr: [Int]) {
        var heapsize = arr.count
        buildheap(&arr)
        for _ in 0 ..< arr.count - 1 {
            var temp: Int
            temp = arr[0]
            arr[0] = arr[heapsize - 1]
            arr[heapsize - 1] = temp
            heapsize = heapsize - 1
            heapify(&arr, i: 0, heapsize: heapsize)
            
        }
        
    }
    
    internalHeapSort(&arr)
    return arr
}
avatar
文章
阅读
粉丝