iOS 算法总结

1. 不用中间变量,用两种方法交换A 和 B的值

func arithmetic1 () {
        var a = 10
        var b = 15
        swap11(&a, &b)
        swap22(&a, &b)
        print("a:\(a)------b:\(b)")
    }

    func swap11(_ a: inout Int,_ b: inout Int) {
        a = a + b
        b = a - b
        a = a - b
    }
    
    func swap22(_ a: inout Int,_ b: inout Int) {
        a = a^b
        b = a^b
        a = a^b
    }

    func swap33(_ a: inout Int,_ b: inout Int) {//Swift 里的元组
        (a,b) = (b,a)
    }

2. 求两个数的最大公约数

func arithmetic2 () {
        var a = 80
        var b = 30
        var c = a
        if a > b {
            c = b
        }
        
        var maxNum = 1
        while a%b > 0 {
            maxNum = a%b
            a = b
            b = maxNum
        }
        print("\(a)和\(b)的最大公约数是:\(maxNum)")
    }

3. 冒泡排序

//冒泡排序1
    func arithmetic3 () {
        var arr = [1,232,32,434,42,45,65,657,64,32]
        var i = 0
        var j = 1
        while j<(arr.count) {
            i = 0
            while i<(arr.count - j) {
                if arr[i] <= arr[i + 1] {
                    arr[i] = arr[i] + arr[i + 1]
                    arr[i + 1] = arr[i] - arr[i + 1]
                    arr[i] = arr[i] - arr[i + 1]
                }
                i += 1
            }
            j += 1
            
        }
        print(arr)
    }
    
    //冒泡排序2
    func arithmetic4 () {
        var arr = [1,232,32,434,42,45,65,657,64,32]
        var i = 0
        var j = 0
        var maxIndex = 0
        var temp = 0
        while j<arr.count {
            temp = arr[j]
            i = j
            while i<arr.count {
                if temp <= arr[i] {
                    temp = arr[i]
                    maxIndex = i
                }
                i += 1
            }
            arr[maxIndex] = arr[j]
            arr[j] = temp
            j += 1
            
        }
        print(arr)
    }

4. 插入排序

func arithmetic5 () {
        var arr = [1,232,32,434,42,45,65,657,64,32]
        var i = 0
        var j = 0
        var newArr:[Int] = []
        while j<arr.count {
            if newArr.count == 0 {
                newArr.append(arr[j])
            } else {
                i = 0
                while i<newArr.count {
                    if arr[j] >= newArr[i] {
                        newArr.insert(arr[j], at: i)
                        break
                    }
                    i += 1
                }
            }
            j += 1
        }
        print(newArr)
    }

5. 斐波那契数 递归法

func fibna(n:Int) -> Int {
        if(n == 0) {
            return 0
        }
        if n == 1 || n == 2 {
            return 1
        }
        return fibna(n: n-1) + fibna(n: n-2)
    }

6. 递归排序

    let dataArr = [1,8,9,4,3,4,3,2,1]
    study2(head_i: 0, end_j: dataArr.count - 1, dataArrGet: dataArr)
    func study2(head_i:Int,end_j:Int,dataArrGet: [Int]){//{1,8,9,4,3,4,3,2,1}
        var dataArr = dataArrGet
        var i = head_i,j = end_j;
        while i <= j {
            var num = 0
            if dataArr[i] > dataArr[dataArr.count/2] {
                num += 1
            }else{
                i += 1;
            }
            
            if dataArr[j] < dataArr[dataArr.count/2] {
                num += 1
            }else{
                j -= 1;
            }
            if num == 2 {
                let temp = dataArr[i]
                dataArr[i] = dataArr[j]
                dataArr[j] = temp;
                i += 1
                j -= 1
            }
        }
        print(dataArr)
    }

7 快速排序

var m = [2,3,5,7,1,4,6,15,5,2,7,9,10,15,9,17,12]
quickSort(a: &m, low: 0, high: m.count - 1)
func quickSort(a: inout [Int], low: Int, high: Int) {
        if low >= high { // 递归结束条件
            return
        }
        var i = low
        var j = high
        let key = a[i]
        while i < j {
            // 从右边开始比较，比key大的数位置不变
            while i < j && a[j] >= key {
                j -= 1
            }
            // 只要出现一个比key小的数，将这个数放入左边i的位置
            a[i] = a[j]
            // 从左边开始比较，比key小的数位置不变
            while i < j && a[i] <= key {
                i += 1
            }
            // 只要出现一个比key大的数，将这个数放入右边j的位置
            a[j] = a[i]
        }
        a[i] = key // 将key放入i的位置，则左侧数都比key小，右侧数都比key大
        quickSort(a: &a, low: low, high: i - 1) // 左递归
        quickSort(a: &a, low: i + 1, high: high) // 右递归
    }

8 经典汉诺塔

func study1(){
        /*
         经典汉诺塔 问题描述：假设有3个分别命名为X，Y，Z的塔座，在塔座X上插有n个直径大小各不相同、依小到大编号为1，2，……n个圆盘。现要求将X轴上的n个圆盘移至塔座Z上并仍按同样顺序叠排，圆盘移动时必须遵守下列规则：
         （1）每次只能移动一个圆盘；
         （2）圆盘可以插在X，Y和Z中的任一塔座上；
         （3）任何时刻都不能将一个较大的圆盘压在较小的圆盘之上。
         求n个盘至少需移动的次数。
         
         1 共1次  第1个 1次
         2 共3次  第2个 1次  第1个 2次
         3 共7次  第3个 1次  第2个 2次  第1个 4次
         4 共15次 第4个 1次  第3个 2次  第2个 4次  第1个 8次
         5 共31次 第5个 1次  第4个 2次  第3个 4次  第2个 8次  第1个 16次
 */
        let n = 10
        var result = 0
        for i in 1...n {
            result = result + 1<<(i-1)
        }
        
        print(result)
        print(1<<n - 1)
    }

9 

 /*如果输入3，打印
     1 2  3
     8 9 4
     7 6 5
     如果输入4，打印
     1     2    3  4
     12  13  14  5
     11   16  15  6
     10  9   8   7*/
    func study() {
        let n = 8;// 定义输入的数字
        var arr = Array(repeating:0, count:n*n) //构造一个数组
        
        var k = 0 //圈数 如上图, 最外围算第 0 圈 红色部分为第1圈
        var kx = (n - 1 - 2*k)*4 // 记录第 k 圈的元素总数
        var r = 0 //  表示第n层的第几个元素
        for index in 1...(n*n) {
            if index <= kx {
                //print("value:\(index)第\(k)层-- 第\(r)个数")
            }else{//如果走else 那么 index 就是 29 49 等,圆圈的左上角第一个数
                r = 0 // 需要置0
                k += 1 //  圈数＋1
                kx += (n - 1 - 2*k)*4 //之前累计的圈的元素数
                //print("value:\(index)第\(k)层-- 第\(r)个数")
            }
            var thisIndex = 0// 定义元素的index位置
            if (r < (n - 2*k)) {//上横   (n - 2*k) 表示的是 index 7 14 21 的位置.参照图求
                thisIndex = n*k + k + r //记录着 上横 数值 1-8 应该所在的 位置 以下类推(根据四个角的元素数值去类推)
            }else if (r < (2*(n-2*k) - 1)) {//右竖
                thisIndex = (n-1)*(k+1) + (r - (n - 2*k))*n + n
            }else if(r < (3*(n-2*k) - 2)){// 下横
                thisIndex = n*n - (n+1)*k - 3 - (r - (n-2*k)*2)
            }else{
                thisIndex = n*(n - 1) - k*(n - 1)  - ( r - (3*(n-2*k) - 2) + 1)*n
            }
            arr[thisIndex] = index// 替换相应位置的元素
            r = r + 1//元素位置+1
        }
        
        //打印输出
        for (index, value) in arr.enumerated() {
            if (index + 1)%n == 0 {
                print("\(value) ")
            }else{
                print("\(value) ", terminator: "")
                if value < 10 {
                    print("  ", terminator: "")
                } else if value < 100 {
                    print(" ", terminator: "")
                }
            }
        }
    }