Scala 是一種有趣的語言。它一方面吸收繼承了多種語言中的優(yōu)秀特性，一方面又沒有拋棄 Java 這個(gè)強(qiáng)大的平臺(tái)，它運(yùn)行在 Java 虛擬機(jī)（Java Virtual Machine）之上，輕松實(shí)現(xiàn)和豐富的 Java 類庫互聯(lián)互通。它既支持面向?qū)ο蟮木幊谭绞?，又支持函?shù)式編程。它寫出的程序像動(dòng)態(tài)語言一樣簡(jiǎn)潔，但事實(shí)上它確是嚴(yán)格意義上的靜態(tài)語言。Scala 就像一位武林中的集大成者，將過去幾十年計(jì)算機(jī)語言發(fā)展歷史中的精萃集于一身，化繁為簡(jiǎn)，為程序員們提供了一種新的選擇。作者希望通過這個(gè)系列，可以為大家介紹 Scala 語言的特性，和 Scala 語言給我們帶來的關(guān)于編程思想的新的思考。

為什么遞歸會(huì)受到忽視
為了回答這一問題，必須先說到編程范式。在所有的編程范式中，面向?qū)ο缶幊蹋∣bject-Oriented Programming）無疑是最大的贏家?？纯淳W(wǎng)上的招聘啟事，無一例外，會(huì)要求應(yīng)聘者熟練掌握面向?qū)ο缶幊?。但其?shí)面向?qū)ο缶幊滩⒉皇且环N嚴(yán)格意義上的編程范式，嚴(yán)格意義上的編程范式分為：命令式編程（Imperative Programming）、函數(shù)式編程（Functional Programming）和邏輯式編程（Logic Programming）。面向?qū)ο缶幊讨皇巧鲜鰩追N范式的一個(gè)交叉產(chǎn)物，更多的還是繼承了命令式編程的基因。遺憾的是，在長(zhǎng)期的教學(xué)過程中，只有命令式編程得到了強(qiáng)調(diào)，那就是程序員要告訴計(jì)算機(jī)應(yīng)該怎么做，而不是告訴計(jì)算機(jī)做什么。而遞歸則通過靈巧的函數(shù)定義，告訴計(jì)算機(jī)做什么。因此在使用命令式編程思維的程序中，不得不說，這是現(xiàn)在多數(shù)程序采用的編程方式，遞歸出鏡的幾率很少，而在函數(shù)式編程中，大家可以隨處見到遞歸的方式。下面，我們就通過實(shí)例，為大家展示遞歸如何作為一種普遍方式，來解決編程問題

一組簡(jiǎn)單的例子
如何為一組整數(shù)數(shù)列求和？按照通常命令式編程的思維，我們會(huì)采用循環(huán)，依次遍歷列表中的每個(gè)元素進(jìn)行累加，最終給出求和結(jié)果。這樣的程序不難寫，稍微具備一點(diǎn)編程經(jīng)驗(yàn)的人在一分鐘之內(nèi)就能寫出來。這次我們換個(gè)思維，如何用遞歸的方式求和？為此，我們不妨把問題簡(jiǎn)化一點(diǎn)，假設(shè)數(shù)列包含 N 個(gè)數(shù)，如果我們已經(jīng)知道了后續(xù) N – 1 個(gè)數(shù)的和，那么整個(gè)數(shù)列的和即為第一個(gè)數(shù)加上后續(xù) N – 1 個(gè)數(shù)的和，依此類推，我們可以以同樣的方式為 N – 1 個(gè)數(shù)繼續(xù)求和，直到數(shù)列為空，顯然，空數(shù)列的和為零。聽起來復(fù)雜，事實(shí)上我們可以用一句話來總結(jié)：一個(gè)數(shù)列的和即為數(shù)列中的第一個(gè)數(shù)加上由后續(xù)數(shù)字組成的數(shù)列的和。現(xiàn)在，讓我們用 Scala 語言把這個(gè)想法表達(dá)出來。
清單 1. 數(shù)列求和
//xs.head 返回列表里的頭元素，即第一個(gè)元素
//xs.tail 返回除頭元素外的剩余元素組成的列表
def sum(xs: List[Int]): Int =
if (xs.isEmpty) 0 else xs.head + sum(xs.tail)

大家可以看到，我們只使用一行程序，就將上面求和的方法表達(dá)出來了，而且這一行程序看上去簡(jiǎn)單易懂。盡量少寫代碼，這也是 Scala 語言的設(shè)計(jì)哲學(xué)之一，較少的代碼量意味著寫起來更加容易，讀起來更加易懂，同時(shí)代碼出錯(cuò)的概率也會(huì)降低。同樣的程序，使用 Scala 語言寫出的代碼量通常會(huì)比 Java 少一半甚至更多。
上述這個(gè)數(shù)列求和的例子并不是特別的，它代表了遞歸對(duì)于列表的一種普遍的處理方式，即對(duì)一個(gè)列表的操作，可轉(zhuǎn)化為對(duì)第一個(gè)元素，及剩余列表的相同操作。比如我們可以用同樣的方式求一個(gè)數(shù)列中的最大值。我們假設(shè)已經(jīng)知道了除第一個(gè)元素外剩余數(shù)列的最大值，那么整個(gè)數(shù)列的最大值即為第一個(gè)元素和剩余數(shù)列最大值中的大者。這里需要注意的是對(duì)于一個(gè)空數(shù)列求最大值是沒有意義的，所以我們需要向外拋出一個(gè)異常。當(dāng)數(shù)列只包含一個(gè)元素時(shí)，最大值就為這個(gè)元素本身，這種情況是我們這個(gè)遞歸的邊界條件。一個(gè)遞歸算法，必須要有這樣一個(gè)邊界條件，否則會(huì)一直遞歸下去，形成死循環(huán)。
清單 2. 求最大值
def max(xs: List[Int]): Int = {
if (xs.isEmpty)
throw new java.util.NoSuchElementException
if (xs.size == 1)
xs.head
else
if (xs.head > max(xs.tail)) xs.head else max(xs.tail)
}
同樣的方式，我們也可以求一個(gè)數(shù)列中的最小值，作為一個(gè)練習(xí)，讀者可下去自行實(shí)現(xiàn)。
讓我們?cè)倏匆粋€(gè)例子：如何反轉(zhuǎn)一個(gè)字符串？比如給定一個(gè)字符串"abcd"
，經(jīng)過反轉(zhuǎn)之后變?yōu)?dcba"
。同樣的，我們可以做一個(gè)大膽的假設(shè)，假設(shè)后續(xù)字符串已經(jīng)反轉(zhuǎn)過來，那么接上第一個(gè)字符，整個(gè)字符串就反轉(zhuǎn)過來了。對(duì)于一個(gè)只有一個(gè)字符的字符串，不需要反轉(zhuǎn)，這是我們這個(gè)遞歸算法的邊界條件。程序?qū)崿F(xiàn)如下：
清單 3. 反轉(zhuǎn)字符串
def reverse(xs: String): String =
if (xs.length == 1) xs else reverse(xs.tail) + xs.head

最后一個(gè)例子是經(jīng)典的快速排序，讀者可能會(huì)覺得這個(gè)例子算不上簡(jiǎn)單，但是我們會(huì)看到，使用遞歸的方式，再加上 Scala 簡(jiǎn)潔的語言特性，我們只需要短短幾行程序，就可以實(shí)現(xiàn)快速排序算法。快速排序算法的核心思想是：在一個(gè)無序列表中選擇一個(gè)值，根據(jù)該值將列表分為兩部分，比該值小的那一部分排在前面，比該值大的部分排在后面。對(duì)于這兩部分各自使用同樣的方式進(jìn)行排序，直到他們?yōu)榭?，顯然，我們認(rèn)為一個(gè)空的列表即為一個(gè)排好序的列表，這就是這個(gè)算法中的邊界條件。為了方便起見，我們選擇第一個(gè)元素作為將列表分為兩部分的值。程序?qū)崿F(xiàn)如下：
清單 4. 快速排序
def quickSort(xs: List[Int]): List[Int] = {
if (xs.isEmpty) xs
else
quickSort(xs.filter(x=>x<xs.head)):::xs.head::quickSort(xs.filter(x=>x>xs.head))
}
當(dāng)然，為了使程序更加簡(jiǎn)潔，作者在這里使用了列表中的一些方法：給列表增加一個(gè)元素，連接兩個(gè)列表以及過濾一個(gè)列表，并在其中使用了 lambda 表達(dá)式。但這一切都使程序變得更符合算法的核心思想，更加易讀。

尾遞歸
從上面的例子中我們可以看到，使用遞歸方式寫出的程序通常通俗易懂，這其實(shí)代表這兩種編程范式的不同，命令式編程范式傾向于使用循環(huán)，告訴計(jì)算機(jī)怎么做，而函數(shù)式編程范式則使用遞歸，告訴計(jì)算機(jī)做什么。習(xí)慣于命令式編程范式的程序員還有一個(gè)擔(dān)憂：相比循環(huán)，遞歸不是存在效率問題嗎？每一次遞歸調(diào)用，都會(huì)分配一個(gè)新的函數(shù)棧，如果遞歸嵌套很深，容易出現(xiàn)棧溢出的問題。比如下面計(jì)算階乘的遞歸程序：
清單 5. 遞歸求階乘
def factorial(n: Int): Int =
if (n == 0) 1 else n * factorial(n - 1)

當(dāng)遞歸調(diào)用 n – 1
的階乘時(shí)，由于需要保存前面的 n
，必須分配一個(gè)新的函數(shù)棧，這樣當(dāng) n
很大時(shí)，函數(shù)棧將很快被耗盡。然而尾遞歸能幫我們解決這個(gè)問題，所謂尾遞歸是指在函數(shù)調(diào)用的最后一步，只調(diào)用該遞歸函數(shù)本身，此時(shí)，由于無需記住其他變量，當(dāng)前的函數(shù)?？梢员恢貜?fù)使用。上面的程序只需稍微改造一下，既可以變成尾遞歸式的程序，在效率上，和循環(huán)是等價(jià)的。
清單 6. 尾遞歸求階乘
def factorial(n: Int): Int = {
@tailrec
def loop(acc: Int, n: Int): Int =
if (n == 0) acc else loop(n * acc, n - 1)

loop(1, n) 

}

在上面的程序中，我們?cè)陔A乘函數(shù)內(nèi)部定義了一個(gè)新的遞歸函數(shù)，該函數(shù)最后一步要么返回結(jié)果，要么調(diào)用該遞歸函數(shù)本身，所以這是一個(gè)尾遞歸函數(shù)。該函數(shù)多出一個(gè)變量 acc
，每次遞歸調(diào)用都會(huì)更新該變量，直到遞歸邊界條件滿足時(shí)返回該值，即為最后的計(jì)算結(jié)果。這是一種通用的將非尾遞歸函數(shù)轉(zhuǎn)化為尾遞歸函數(shù)的方法，大家可多加練習(xí)，掌握這一方法。對(duì)于尾遞歸，Scala 語言特別增加了一個(gè)注釋 @tailrec
，該注釋可以確保程序員寫出的程序是正確的尾遞歸程序，如果由于疏忽大意，寫出的不是一個(gè)尾遞歸程序，則編譯器會(huì)報(bào)告一個(gè)編譯錯(cuò)誤，提醒程序員修改自己的代碼。

一道面試題
也許有的讀者看了上面的例子后，還是感到不能信服：雖然使用遞歸會(huì)讓程序變得簡(jiǎn)潔易懂，但我用循環(huán)也一樣可以實(shí)現(xiàn)，大不了多幾行代碼而已，而且我還不用知道什么尾遞歸，寫出的程序就是效率最高的。那我們一起來看看下面這個(gè)問題：有趣的零錢兌換問題。題目大致如下：假設(shè)某國的貨幣有若干面值，現(xiàn)給一張大面值的貨幣要兌換成零錢，問有多少種兌換方式。這個(gè)問題經(jīng)常被各大公司作為一道面試題，不知難倒了多少同學(xué)，下面我給出該問題的遞歸解法，讀者們可以試試該問題的非遞歸解法，看看從程序的易讀性，及代碼數(shù)量上，兩者會(huì)有多大差別。該問題的遞歸解法思路很簡(jiǎn)單：首先確定邊界條件，如果要兌換的錢數(shù)為 0，那么返回 1，即只有一種兌換方法：沒法兌換。這里要注意的是該問題計(jì)算所有的兌換方法，無法兌換也算一種方法。如果零錢種類為 0 或錢數(shù)小于 0，沒有任何方式進(jìn)行兌換，返回 0。我們可以把找零的方法分為兩類：使用不包含第一枚硬幣（零錢）所有的零錢進(jìn)行找零，使用包含第一枚硬幣（零錢）的所有零錢進(jìn)行找零，兩者之和即為所有的找零方式。第一種找零方式總共有countChange(money, coins.tail)
種，第二種找零方式等價(jià)為對(duì)于 money – conins.head
進(jìn)行同樣的兌換，則這種兌換方式有 countChange(money - coins.head, coins)
種，兩者之和即為所有的零錢兌換方式。
清單 7. 零錢兌換問題的遞歸解法
def countChange(money: Int, coins: List[Int]): Int = {
if (money == 0)
1
else if (coins.size == 0 || money < 0)
0
else
countChange(money, coins.tail) + countChange(money - coins.head, coins)
}