Swift 选择排序/冒泡排序

var arr = [9,19,1,3,2,7,5,10,11,13]

选择排序

     // 从for循环可以看出，每次循环，都是拿i+1的数据，在跟i作对比
     // 一轮循环下来，已经把最小的值放在了数组的第一位
     // 第二轮循环，已经从下表 i + 1开始了，不再对比 i 的数据了，因为在第一轮的时候，最小值已经放在了第一位了
     // 所以第二轮的时候，是从i + 1开始的
     // 通俗点讲，就是数组的第一个数据和数组后面的每一个数据进行对比，遇到大的，就换位置，直到数组最后一个数据对比完毕，然后进行第二轮，从数组的第二个开始，和后面的每一个数据做比较，以此循环
     // 复杂度可以理解为 O(n) * O(n -1)
     for i in 0..<(arr.count - 1) {
         for j in (i+1)..<(arr.count) {
             if arr[i] > arr[j] {
                 let temp = arr[i]
                 arr[i] = arr[j]
                 arr[j] = temp
             }
         }
     }

冒泡排序

    for i in 0..<(arr.count - 1) {
            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
                }
            }
        }

     [9,19,1,3,2,7,5,10,11,13]
     当 i=0时 i层 arr.count - 1 = 9
     当 i=0时 j层 arr.count - 1 - 0 = 9
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3,2,7,5,10,11] (0..<9)
    
     当 i=1时 i层 arr.count - 1 = 9
     当 i=1时 j层 arr.count - 1 - 1 = 8
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3,2,7,5,10] (0..<8)
        
     当 i=2时 i层 arr.count - 1 = 9
     当 i=2时 j层 arr.count - 1 - 2 = 7
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3,2,7,5] (0..<7)
    
     当 i=3时 i层 arr.count - 1 = 9
     当 i=3时 j层 arr.count - 1 - 3 = 6
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3,2,7] (0..<6)
    
     当 i=4时 i层 arr.count - 1 = 9
     当 i=4时 j层 arr.count - 1 - 4 = 5
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3,2] (0..<5)
    
     当 i=5时 i层 arr.count - 1 = 9
     当 i=5时 j层 arr.count - 1 - 5 = 4
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1,3] (0..<4)
    
     当 i=6时 i层 arr.count - 1 = 9
     当 i=6时 j层 arr.count - 1 - 6 = 3
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19,1] (0..<3)
    
     当 i=7时 i层 arr.count - 1 = 9
     当 i=7时 j层 arr.count - 1 - 7 = 2
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9,19] (0..<2)

     当 i=8时 i层 arr.count - 1 = 9
     当 i=8时 j层 arr.count - 1 - 8 = 1
     i层 [9,19,1,3,2,7,5,10,11] (0..<9)
     j层 [9] (0..<1)

可以发现j层的数据范围在越来越小，而j层每次一次的两两对比，都会把最大的值放到最后
因为最大的值已经在数组的尾部了，那么下次对比的时候，就可以缩小范围
不需要遍历到最后一个
j层每一轮的遍历完毕，下一轮的遍历范围都会缩小1，所以j层数组数量每
都少一个，从上面观察的来看便是如此
我再把j层每次变化的数据放在一起，方便大家做比较
[9,19,1,3,2,7,5,10,11]
[9,19,1,3,2,7,5,10]
[9,19,1,3,2,7,5]
[9,19,1,3,2,7]
[9,19,1,3,2]
[9,19,1,3]
[9,19,1]
[9,19]
[9]

注意，以上只是展示数组数量上的变化，并未做排序，排序可以在for循环里每次打印j层的数组