我们先来看一段代码
let numbers1 = [0, 1, 3, 7, 5, 11, 25]
var maxNumber1 = Int.min
for number in numbers1 {
if number > maxNumber1 {
maxNumber1 = number
}
}
print(maxNumber1)
//求 numbers1 数组中最大的数
let numbers2 = [2, 4, 8, 5, 7, 13, 9]
var maxNumber2 = Int.min
for number in numbers2 {
if number > maxNumber2 {
maxNumber2 = number
}
}
print(maxNumber2)
//求 numbers2 数组中最大的数
let numbers3 = [12, 4, 6, 15, 27, 13, 8]
var maxNumber3 = Int.min
for number in numbers3 {
if number > maxNumber3 {
maxNumber3 = number
}
}
print(maxNumber3)
//求 numbers3 数组中最大的数
上述三小段代码实际上是一样的功能，都是求一个整数数组中的最大值，而我们却重复写了三遍，如果某一个功能比较复杂，需要几百几千行代码来完成，显然是不能每次使用都敲几百行几千行代码，我们可以把这种特点功能的代码抽离出来，写成一个函数
// func 关键字表示定义一个函数
// func 后面跟着的是函数的名字，我们一般用大致能表示函数功能的英文
// 函数名称后面跟着的小括号里面就是函数的参数列表
// 函数最后面用 -> 加返回值类型
func maxNumberIn(numbers: [Int]) -> Int {
var maxNumber = Int.min
for number in numbers {
if number > maxNumber {
maxNumber = number
}
}
return maxNumber //函数计算结束，并返回计算结果
}
let numbers1 = [0, 1, 3, 7, 5, 11, 25]
let maxNumber1 = maxNumberIn(numbers: numbers1)
print(maxNumber1)
//求 numbers1 数组中最大的数
let numbers2 = [2, 4, 8, 5, 7, 13, 9]
let maxNumber2 = maxNumberIn(numbers: numbers2)
print(maxNumber2)
//求 numbers2 数组中最大的数
let numbers3 = [12, 4, 6, 15, 27, 13, 8]
let maxNumber3 = maxNumberIn(numbers: numbers3)
print(maxNumber3)
//求 numbers3 数组中最大的数
要从小白到入门，心里一定要装着这样的思想：不写重复的代码，第一步就是要学会封装函数，然后要学会封装类型，如果最后学会了封装整套开发框架，那就是高手中的高手了，我们先从最简单的函数学起
无参数无返回值的函数
还记得我们学的第一个程序 Hello World 吗，我们把它封装成函数
func helloWorld() {
print("Hello World!")
}
helloWorld()
封装成函数后，我们就不用每次需要打印 Hello World！时敲这一串英文字母了，在我们调用函数时，Xcode会自动为我们带出完整的函数，当我们在代码中敲 he 的时候（或者多敲几个字母），helloWorld函数就自动出现了，不需要完完整整的靠手敲
实际上我们把函数的定义写完整应该像下面这样，只不过当函数没有返回值的时候可以省略返回类型
// Void 代表没有返回值
func helloWorld() -> Void {
print("Hello World!")
}
有参数的函数
下面我们来定义一个函数，传入一个人的名字，然后打印一句欢迎他的话
func greet(someone: String) {
print("Hello \(someone), nice to meet you!")
}
greet(someone: "ZhangQi")
//Hello ZhangQi, nice to meet you!
观察一下这个函数的参数列表的定义，这里只有一个参数，那就是 someone ，我们把 someone 叫做参数名称，在参数名称后面需要指明参数的类型，这里我们指明的是一个字符串类型，用来表示某个人的名字。在函数体里面（也就是大括号里的代码片段）参数名就代表我们调用函数时传入的值，函数参数默认是一个常量，不允许修改
再来观察一下函数的调用 greet(someone: "ZhangQi") ，这里的 someone 跟函数体中的不是一个意思，这里表示为指定参数传值，这里叫做参数标签，因此调用函数时使用参数标签，函数体里则使用函数名称
把函数改成多参数的函数
func greet(someone: String, from: String) {
print("Welcome \(someone) from \(from)!")
}
greet(someone: "ZhangQi", from: "YiChang")
//Welcome ZhangQi from YiChang!
这个函数的作用是，欢迎来自哪里的谁，在调用函数的地方我们一眼就能明白，但是在函数体中，用 from 来表示家乡会显得不是那么合理，将函数定义修改成下面这样
func greet(_ someone: String, from hometown: String) {
print("Welcome \(someone) from \(hometown)!")
}
greet("ZhangQi", from: "YiChang")
这样的表达就更加简练，在定义函数参数时，通常我们会偷懒只写参数名和参数类型，而实际上函数参数完整的定义有参数标签，参数名称，参数类型，参数标签是调用者使用的，参数名是函数体使用的，在只写参数名的情况下，参数标签与参数名一致，参数标签可以用下划线 _ 省略
如果我们十分讲究函数的命名，追求意图清晰，可以使用参数标签来美化函数，让函数看起来更接近人类的语言，但是很多时候程序员不需要追求这些，只要函数的名称符合其功能，参数设计合理，能让别人和自己看懂就行了
函数返回值
函数可以有任意返回类型，并且如果函数有返回类型，就必须有且仅有一次返回值，开篇我们写了一个计算数组中最大值的函数，那就是一个标准的有参数有返回值的函数，我们再来写一个计算数组中最小值的函数
func minNumberIn(_ numbers: [Int]) -> Int? {
if numbers.isEmpty {
return nil
}
var minNumber = Int.max
for number in numbers {
if number < minNumber {
minNumber = number
}
}
return minNumber
}
let numbers = [2, 5, 8, 4, 9, 0, 7]
if let minNumber = minNumberIn(numbers) {
print("The minimum value of \(numbers) is \(minNumber)")
} else {
print("Can't find the minimum value because the array is empty")
}
这个函数跟开篇计算最大值的函数稍微有些不同，随着学习的深入，我们需要对代码越来越严谨，一个数组不一定有最大值或者最小值，因为有可能传入一个空的数组，因此我们需要把返回值类型设计为可选类型，同时在函数体中判断数组是否是空数组，如果是空数组就直接返回 nil
为什么这里我没有在 if 后面加 else ，因为函数只会 return 一次，return nil 后，函数就结束了，之后的代码就不会执行了
我们还可以利用元组来返回多个结果，注意不是多次返回，是一次性返回多个结果，例如同时计算数组的最小值和最大值
func minAndMaxIn(_ numbers: [Int]) -> (min: Int, max: Int)? {
if numbers.isEmpty {
return nil
}
var minNumber = Int.max
for number in numbers {
if number < minNumber {
minNumber = number
}
}
var maxNumber = Int.min
for number in numbers {
if number > maxNumber {
maxNumber = number
}
}
return (minNumber, maxNumber)
}
print(minAndMaxIn([]))
print(minAndMaxIn([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
我们可以在函数中调用其他函数来帮助自己计算，之前说过，不写重复的代码，而我们之前已经写了计算最大值和最小值的函数，我们就不用再实现一次，可以直接用
func minNumberIn(_ numbers: [Int]) -> Int? {
if numbers.isEmpty {
return nil
}
var minNumber = Int.max
for number in numbers {
if number < minNumber {
minNumber = number
}
}
return minNumber
}
func maxNumberIn(numbers: [Int]) -> Int? {
if numbers.isEmpty {
return nil
}
var maxNumber = Int.min
for number in numbers {
if number > maxNumber {
maxNumber = number
}
}
return maxNumber
}
func minAndMaxIn(_ numbers: [Int]) -> (min: Int, max: Int)? {
if numbers.isEmpty {
return nil
}
//对计算结果直接强制解析是因为我们已经判断了数组不为空，一定有最小值和最大值
return (minNumberIn(numbers)!, maxNumberIn(numbers: numbers)!)
}
print(minAndMaxIn([]))
print(minAndMaxIn([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
默认参数值
函数的参数可以指定默认值，在调用函数的时候，如果参数有默认值，可以不传参数，不传参数则表示使用默认值，传参数表示使用传入的参数
假如我们有一个函数，其功能是对一个数加1
func increase(_ aNumber: Int) -> Int {
return aNumber + 1
}
print(increase(1)) // 1 + 1 = 2
print(increase(10)) // 10 + 1 = 11
这个函数可能我们在很多地方都用到了，现在我们有了新的需求，要把函数改成可以指定增加多少量，如果这样改
func increase(_ aNumber: Int, with addition: Int) -> Int {
return aNumber + addition
}
print(increase(1, with: 1)) // 1 + 1 = 2
print(increase(10, with: 1)) // 10 + 1 = 11
print(increase(10, with: 2)) // 10 + 2 = 12
我们就需要把以前调用过这个函数的地方全部改一遍，那么如果我们给新增的参数设置一个默认值 1 ，原来的代码就可以原封不动了
func increase(_ aNumber: Int, with addition: Int = 1) -> Int {
return aNumber + addition
}
print(increase(1)) // 1 + 1 = 2
print(increase(10)) // 10 + 1 = 11
print(increase(10, with: 2)) // 10 + 2 = 12
因为有了默认参数值， increase 函数使用起来就有不同的形式了，还记得我们之前写过一个很长很长的 print 吗，实际上 print 也是一个有默认参数值的函数
//下面两行代码是一个结果，因为 print 函数的有默认值，平常我们可以省略很多参数
print("Hello World!")
print("Hello World!", separator: "", terminator: "\n")
//在编程语言中 \n 是一种转义字符，表示换行
输入输出参数
接下来我用输入输出参数来引出参数传递的一个重要知识点，来看下面的代码
func increase(_ aNumber: Int, with addition: Int = 1) -> Int {
return aNumber + addition
}
var a = 1
increase(a)
我们创建了一个整数 a ，并赋值为 1 ，然后调用 increase 函数计算 a 的值加 1 ，虽然我们得到了计算结果 2 ，但是 a 的值并不会改变，除非将计算结果赋值给 a ，这样的参数传递我们称之为值拷贝，好比电脑上有一个 txt 文本，我把它拷贝到另一个地方去编辑，原有的文本并不会改变，如果我们希望函数能够直接修改参数的值呢，那么就需要把参数定义为输入输出参数
func increase(_ aNumber: inout Int, with addition: Int = 1) {
aNumber = aNumber + addition
}
var a = 0
increase(&a) //现在a的值是1
increase(&a, with: 2) //现在a的值是3
在参数类型前面使用 inout 声明为输入输出参数，之前我们的参数在函数体中都是以常量的形式存在，不能对其进行赋值，而 inout 参数则以变量的形式存在，可以对其赋值，同时在调用函数时需要在参数前面加上 &
输入输出参数只做了解内容，在实际开发中几乎不会这么做，也没有必要这么做，这里提到是因为下一节课我们要学习很重要的概念，值类型 和 引用类型
嵌套函数
我们可以在函数里定义函数，而函数里的函数只有由这个函数来调用，其他地方是无法访问的
func countingToZero(_ number: Int) {
func countForward(_ number: Int) {
//外层的函数也用了 number 作为参数，还记得域的概念吗，这里的 number 指的是内层函数自己的 number 参数
var countNumber = number
while countNumber <= 0 {
print(countNumber)
countNumber += 1
}
}
func countBackward(_ number: Int) {
var countNumber = number
while countNumber >= 0 {
print(countNumber)
countNumber -= 1
}
}
if number > 0 {
countBackward(number)
} else {
countForward(number)
}
}
countingToZero(5) //5 4 3 2 1 0
countingToZero(-5) //-5 -4 -3 -2 -1 0
这个函数的功能就是从传入的数开始计数，数到0为止，传入的数是正数和负数的情况下计数的方式是不同的，因此我们在函数里定义了两个子函数分别来处理这两种情况
函数递归
函数调用自己就叫递归调用，拿斐波那契数举例，我们把1，1，2，3，5，8，13...这样的数称为斐波那契数，第一个数和第二个数是1，之后的第n个等于第n-1个数与n-2个数之和，那么第n个数是多少呢，我们用递归来实现
func fibonacci(_ n: Int) -> Int {
if n <= 1 {
return 1
}
return fibonacci(n - 1) + fibonacci(n - 2)
}
print(fibonacci(1)) //1
print(fibonacci(10)) //89
递归的唯一优点就是容易理解，代码量少，但是递归绝不会是最好的计算方式，借用一张图片来看看递归的计算过程
递归展开后是一棵二叉树的结构，我们粗略的认为需要计算2的n次方次，从这点上来说，这就不是一个好的算法，我们可以尝试计算 25 位的拿斐波那契数，已经需要等待一会儿才出结果了，不要再尝试更大的数了，程序可能会卡死，下面我们来着手优化一下
通过上面的图片我们可以看到有许许多多的重复计算，那么首先想到的就是将重复计算消除掉，那么我们可以把计算出来的中间结构保存在字典中，首先在字典中去寻找计算结果，没有找到再去计算
//创建一个用于保存中间结果的字典
var fibCaches = [Int : Int]()
func fibonacci(_ n: Int) -> Int {
if n <= 1 {
return 1
}
if let result = fibCaches[n] {
//优先在字典中寻找已经计算过的结果
return result
}
let result = fibonacci(n - 1) + fibonacci(n - 2)
//将中间结果保存起来避免重复计算
fibCaches[n] = result
return result
}
print(fibonacci(1)) //1
print(fibonacci(50)) //20365011074
现在，不管多少位的拿斐波那契数都能瞬间得出结果，只要最终结果不超出 Int 的最大范围，我们已经初步接触了 算法 这个概念并且完成了一次效果非常显著的算法优化
避免重复计算是我们学会的第一种优化算法的方式，对于这道题，这还不是最好的优化方式，因为我们最终还是需要有一个字典来存放中间结果，如果计算量庞大，中间结果非常多，字典就会随着计算的进行越来越大，这是典型的以空间换时间的优化方案
同时函数的调用也会进行多次递归，调用函数本身就需要消耗性能，占用内存，从上面的二叉树图就能看到，每调用函数一次，计算机就需要为函数分配内存，并且当递归完全结束时内存才会被释放，如果是在运行内存比较小的手机上，还没等计算结束，程序就已经因为内存占用过多被系统杀死了
我们能不能一次性计算到位，答案是可以的，观察拿斐波那契数的规律，我们可以从头开始计算，依次叠加，只关注前两个值就行了，这样就可以用循环来完成计算
func fibonacci(_ n: Int) -> Int {
if n <= 1 {
return 1
}
//a表示前一个数，b表示后一个数，在循环中将两个数依次往后推算
var a = 1
var b = 1
for i in 0..<n-1 {
let tempB = b //先把b的值取出来
b += a //让b等于两个值之和
a = tempB //再让a等于之前的b，这样两个数就合作往后推了一位
}
return b
}
print(fibonacci(1))
print(fibonacci(50))
在函数中计算的结果可能比我们自己动手计算的结果要多一位，因为计算机以 0 为开始，所以多了一位，这个没有关系，稍微修改一下位数就行了
这样优化后同样能在瞬间得出结果，并且比第一种优化方式更快，消耗内存更低
最后
至此，基础知识就已经介绍完了，同时也初步了解了算法优化的过程，下一课开始就要开始学习 类和结构体 ，准备开启面向对象编程之旅
