冒泡排序

交换函数
    func swap(_ array: inout [Int], _ i : Int, _ j : Int){
        if (i == j){
            return
        }
        array[i] = array[i] ^ array[j]
        array[j] = array[i] ^ array[j]
        array[i] = array[i] ^ array[j]
    }

说到冒泡排序我们大多数人第一眼就会想到如下的算法，他是不停的将i与i后面的数字比较的算法，这只能算作一种伪冒泡排序，因为已排序的i，对后面的排序并没有任何帮助

 //冒泡排序（伪）
    func BurbleSort(_ array:inout [Int]){
        for i in 0..<array.count {
            for j in i..<array.count {
                if array[i] > array[j] {
                   swap(&array, i, j)
                }
            }
        }
    }

下面才是真正的冒泡排序的算法

    //冒泡排序
    func BurbleSortImp(_ array: inout [Int]) -> Void {
        for i in 0..<array.count {
            var flag = true
            for j in 0..<array.count-i-1 {
                if array[j] > array[j + 1] {
                    swap(&array, j, j+1)
                    flag = false
                    print("发生了交换",array)
                }
            }
            print("第\(i)次遍历:", array)
            if flag {
                break
            }
        }
    }

从这个算法我们可以看到，每次比较的都是array[j]与array[j+1]这样的算法然后将较大的值上浮，每次循环中每次比较都会将较大值上浮，这样会对下一次循环比较产生一定的帮助，这才是真正的冒泡算法。
然后我们进一步优化了比较，也就是flag的设立，某一次没有发生交换，我们可以确定已经排序好了，无需下一次排序