从零开始学swift(三)－算法之斐波那契数列

怎么这么快就到斐波那契数列啦，因为这个正好是我昨天写出来哒

众所周知斐波那契数列递推公式 F(n)=F(n-1)+F(n-2)，那么我们如何用swift实现求其任意一项的值捏，在此，分享一种解法

哇哦 我们要用swift写矩阵了诶 不会怎么办，不用担心。

https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/还记得这个网站吗，里面有现成的Matrix Structure

struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(count: rows * columns, repeatedValue: 0.0)
    }
    func indexIsValidForRow(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

我们稍加改动 变成下面这样

struct Matrix {
    var rows: Int, columns: Int
    var grid: [Int]
    init() {
        self.rows = 2
        self.columns = 2
        grid = Array(count: rows * columns, repeatedValue: 0)
    }
    func indexIsValidForRow(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Int {
        get {
            assert(indexIsValidForRow(row, column: column), "Index out of range")//警告数组是否越界
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

然后就可以开始我们的解题之路啦

首先实现矩阵乘法

func multiply(x:Matrix, y:Matrix)-> Matrix{
    var mul = Matrix()
    for i in 0...1 {
        for j in 0...1{
            mul[i,j]=0
            for k in 0...1{
                mul[i,j] += x[i,k]*y[k,j]
            }
        }
    }
    return mul
}

然后就是2*2矩阵的乘方

var base = Matrix()/
base[0,0] = 1
base[0,1] = 1
base[1,0] = 1
base[1,1] = 0
var ans = Matrix() //在方法外面声明两个Matrix

func power(e : UInt32)->Matrix{
    if(e == 0)
    {
        ans[0,0] = 1
        ans[0,1] = 0
        ans[1,0] = 0
        ans[1,1] = 1
        return and//查看奇偶
        
    }
    if (e == 1)
    {return base}
    
    ans = power(e>>1);//借助二进制实现二分
    ans = multiply(ans, ans);
    if(Int(e) % 2 == 1)//查看奇偶
    {ans = multiply(ans,base)}
    return ans
}

然后就是最后

var mat = Matrix()
for n in 1...61{
    if(n == 1) {println(1)}//输出所有61个斐波那契 ，太大了输出不了 毕竟int
    else {
        mat = power(UInt32(n-1))
        println(mat[0,0])
    }
}

让我们来测测每一次算出答案的时间

var mat = Matrix()
var time_1 = clock()
var time_2 = clock()
for n in 1...61{
    if(n == 1) {println(1)}
    else {
        time_1 = clock()
        mat = power(UInt32(n-1))
        time_2 = clock()
        //println(mat[0,0])
        println(time_2 - time_1)

    }
}

输出结果是

用时真的超少啊， 可见优化算法还是有很大用处的～，大家可以试试用用别的方法实现 看看用时会不会比这个少。