从零开始学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)

}
}

输出结果是



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