常见的排序算法

排序算法

冒泡算法

//冒泡排序 时间复杂度O(n2)

//优化方案:设置flag 是否交换
func bubbleSort(list: inout Array<Int>) {
    var isSwap = false//优化
    for i in 0..<list.count {
        isSwap = false
        for k in 0..<(list.count - i - 1) {
            if list[k] > list[k + 1] {
                let swap = list[k + 1]
                list[k + 1] = list[k]
                list[k] = swap
                isSwap = true
            }
        }
        if !isSwap {
            break
        }
    }
}

快速排序

快速排序:排序效率在同为O(N*logN)的几种排序方法中效率较高,
快速排序称为分治法,但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明:挖坑填数+分治法:

基本思想
先从数列中取出一个数为基数
分区过程,把比它打的放在右边,小于等于的放在左边
对左右区间进行递归重复操作

//快速排序
func quickSort(list: inout Array<Int>, l: Int, r: Int) {
    if l >= r {
        return
    }
    var i = l
    var j = r
    let key = list[l] //选择第一个数为key
    while i < j {
        while(i < j && list[j] >= key) {
            j -= 1
        }//从右向左找第一个小于key的值
        if(i<j){
            list[i] = list[j];
            i += 1
        }
        while(i < j && list[i] < key) {
            i += 1
        }//从左向右找第一个大于key的值
        if(i<j){
            list[j] = list[i];
            j -= 1
        }
    }
    list[i] = key;
    quickSort(list: &list, l: l, r: i-1);//递归调用
    quickSort(list: &list, l: i + 1, r: r);//递归调用
}

选择排序(SelectionSort)

基本思想: 每次选择出剩余最小的一次交换即可
时间复杂度: O(n2)

//选择排序
func selectionSort(list: inout Array<Int>) {
    for i in 0..<(list.count - 1) {
        var index = i
        var isChange = false
        var min = list[i]
        for j in (i + 1)..<list.count {
            if min > list[j] {
                index = j
                min = list[j]
                isChange = true
            }
        }
        if isChange {
            list[index] = list[i]
            list[i] = min
        }
        
    }
}

插入排序(SelectionSort)

思想: 在排序的一组数中,假定n-1个数已经排好,现在将第n个数插到前面的有序数列中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。
时间复杂度: 平均时间复杂度:O(n2)

//插入排序时间复杂度O(n2)
func insertSort(list: inout Array<Int>) {
    for i in 0..<(list.count - 1) {
        var j = i + 1
        while j > 0 {
            if list[j] < list[j - 1] {
                let swap = list[j]
                list[j] = list[j - 1]
                list[j - 1] = swap
            }else {
                break
            }
            j -= 1
        }
    }
}

希尔排序(Shell Sort)

基本思想: 在要排序的一组数中,根据某一增量分为若干子序列,并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序
时间复杂度:O(n1.5)

//希尔排序(Shell Sort)
func shellSort(list: inout Array<Int>) {
    var incre: Int = list.count //缩小增量法
    while true {
        incre = incre / 2
        for k in 0..<incre {
            var i = k + incre
            while i < list.count {
                var j = i
                while j > k {
                    if(list[j]<list[j-incre]){
                        let temp = list[j-incre]
                        list[j-incre] = list[j]
                        list[j] = temp
                    }else{
                        break
                    }
                    j -= incre
                }
                i += incre
            }
        }
        if(incre == 1){
            break
        }
    }
}

归并排序(Merge Sort)

基本思想: 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。
首先考虑下如何将2个有序数列合并。这个非常简单,只要从比较2个数列的第一个数,谁小就先取谁,取了后就在对应数列中删除这个数。然后再进行比较,如果有数列为空,那直接将另一个数列的数据依次取出即可。
时间复杂度: O(NlogN)
归并排序的效率是比较高的,设数列长为N,将数列分开成小数列一共要logN步,每步都是一个合并有序数列的过程,时间复杂度可以记为O(N),故一共为O(N
logN)。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 精致技术 设计师:CSDN官方博客 返回首页