iOS 算法-冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素日后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。因此，若是两个元素相等，我想你是不会再无聊地把他们俩交换一下的；

若是两个相等的元素没有相邻，那么即便经过前面的两两交换把两个相邻起来，这时候也不会交换，因此相同元素的先后顺序并无改变，因此冒泡排序是一种稳定排序算法 图解

func sort() {
    var arr = [3,6,4,2,11,10,5]
    for i in 0..<arr.count {
        for j in 0..<arr.count-1-i {
            if arr[j] > arr[j+1] {
                arr.swapAt(j, j+1)
            }
        }
        print(arr)
    }
    print(arr)
}

复制代码

优化点--当队列提早变得有序时，提早结束循环

• Q:那么如何肯定已经提早有序了呢？
• A:只须要内部循环下来一次交换都没有发生过，就说明此序列已经有序，就能够提早结束了。即在交换中有一个标识便可。

func sort() {
    var arr = [3,6,4,2,11,10,5]
    for i in 0..<arr.count {
        var isSort = true
        for j in 0..<arr.count-1-i {
            if arr[j] > arr[j+1] {
                arr.swapAt(j, j+1)
                isSort = false
            }
        }
        if isSort {
            break
        }
        print(arr)
    }
    print(arr)
}
复制代码

优化点--当队列部分有序时，记录部分有序的位置，也就是偶尔迈大步子。

既然总体数列会提早有序，那么当数列部分有序时，冒泡排序还傻傻的以步长1，不断的进行循环。

• Q:那么如何肯定下次迈多大步呢呢？
• A:只须要记录最后一次交换的位置，那么此处下标减1即为下次迈步到的位置。

func sort() {
    var arr = [3,6,4,2,11,10,5]
    
    var len = arr.count - 1
    var endIndex = 0
    for _ in 0..<arr.count {
        var isSort = true
        for j in 0..<len {
            if arr[j] > arr[j+1] {
                arr.swapAt(j, j+1)
                isSort = false
                endIndex = j
            }
        }
        if isSort {
            break
        }
        len = endIndex
        print(arr)
    }
    print(arr)
}
复制代码