聲明：算法和數(shù)據(jù)結(jié)構(gòu)的文章均是作者從github上翻譯過來，為方便大家閱讀。如果英語閱讀能力強(qiáng)的朋友，可以直接到swift算法俱樂部查看所有原文，以便快速學(xué)習(xí)。作者同時(shí)也在學(xué)習(xí)中，歡迎交流
目的：快速找到數(shù)組中的某一元素。
假如你有一個(gè)數(shù)組，包含數(shù)百個(gè)數(shù)字，然后你需要從中找出某一個(gè)數(shù)字所在的位置，在大多數(shù)情況下，Swift自帶的indexOf()函數(shù)可以快速幫你解決這種問題。過程如下：
let numbers = [11, 59, 3, 2, 53, 17, 31, 7, 19, 67, 47, 13, 37, 61, 29, 43, 5, 41, 23]
numbers.indexOf(43) // returns 15
Swift自帶的 indexOf函數(shù)是屬于線性搜索，其代碼為：
func linearSearch<T: Equatable>(_ a: [T], _ key: T) -> Int? {
for i in 0 ..< a.count {
if a[i] == key {
return i
}
}
return nil
}
我們可以用以下方法運(yùn)行代碼：
linearSearch(numbers, 43) // returns 15
雖然很簡便，但是由于是線性搜索，意味著我們需要從數(shù)組的第一位開始搜索整個(gè)數(shù)組，在最糟糕的情況下，可能你需要搜尋完整個(gè)數(shù)組才發(fā)現(xiàn)數(shù)組里面沒有你需要尋找的數(shù)字。所以說，線性搜索算法跟數(shù)組的大小相關(guān)性很大，數(shù)組越大，意味著消耗的時(shí)間越久。
分治法
對于數(shù)組大的情況下，最經(jīng)典的算法當(dāng)屬二分搜索算法。它的核心就是不斷的將數(shù)組一分為二，直到找到我們尋找的數(shù)字。
比如說，一個(gè)大小為n的數(shù)組，使用線性搜索算法的效率為O(n)，而二分搜索算法的效率為O(log n)。更詳細(xì)一點(diǎn)來說，當(dāng)數(shù)組大小為1000000的時(shí)候，二分搜索算法只花了20步就能找到結(jié)果。因?yàn)?code>log_2(1000000) = 19.9。而當(dāng)數(shù)組大小上升到十億級別的時(shí)候，二分搜索卻只需要30步就能找到答案。
不過，使用二分搜索必須有個(gè)前提：這個(gè)必須數(shù)組是按照一定順序排列的。
二分搜索的工作原理：
1.將數(shù)組一分為二，并決定你需要尋找的元素是在數(shù)組的左邊還是右邊。
2.由于我們的數(shù)組是已經(jīng)排序好的數(shù)組，所以你只需要將尋找的元素和得到中間數(shù)字進(jìn)行大小比較。
3.確定好尋找的元素在哪邊后，在新的數(shù)組里面繼續(xù)一分為二，然后比較大小。
4.不斷重復(fù)上述過程，直到我們找到這個(gè)元素在數(shù)組中的位置，或者當(dāng)數(shù)組無法繼續(xù)一分為二的時(shí)候，判斷數(shù)組中不存在需要尋找的元素。
代碼
以下為遞歸版的二分搜索算法：
func binarySearch<T: Comparable>(_ a: [T], key: T, range: Range<Int>) -> Int? {
if range.lowerBound >= range.upperBound {
// 如果我們進(jìn)入這個(gè)函數(shù)，則說明要尋找的元素不在數(shù)組里
return nil
} else {
// 計(jì)算數(shù)組一分為二的位置
let midIndex = range.lowerBound + (range.upperBound - range.lowerBound) / 2
// 判斷尋找的元素是否在數(shù)組左側(cè)
if a[midIndex] > key {
return binarySearch(a, key: key, range: range.lowerBound ..< midIndex)
// 判斷尋找的元素是否在數(shù)組右側(cè)
} else if a[midIndex] < key {
return binarySearch(a, key: key, range: midIndex + 1 ..< range.upperBound)
// 如果進(jìn)入這個(gè)函數(shù)內(nèi)部，則說明我們已經(jīng)在數(shù)組里找到這個(gè)元素！
} else {
return midIndex
}
}
}
我們可以在playground里進(jìn)行測試：
let numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
binarySearch(numbers, key: 43, range: 0 ..< numbers.count) // 得到 13
必須注意這里的numbers是已經(jīng)排序好的！
雖然說二分算法是不斷的進(jìn)行數(shù)組拆分，但是這里我們并不是真的去創(chuàng)建兩個(gè)新的數(shù)組，而是使用Swfit中的Range對象。最初的時(shí)候，range包含數(shù)組的所有元素的位置，0..<numbers.count，隨著拆分不斷進(jìn)行，range越變越小。
示例解析
我們有一組已經(jīng)排序好的數(shù)組：
[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67 ]
在這個(gè)數(shù)組中，我們需要尋找的元素為43。首先我們需要確定數(shù)組中間值來將數(shù)組一分為二：
let midIndex = range.lowerBound + (range.upperBound - range.lowerBound)/2
最初的時(shí)候，這里的范圍是lowerBound = 0和upperBound = 19。這里我們可以得到midIndex = 0 + (19 - 0)/2 = 9.5 = 9（向下取整）。如圖，我們的中間數(shù)組為29，其左右兩個(gè)數(shù)組位數(shù)大小相等。
[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67 ]
*
接下來，二分算法將會(huì)決定我們接下去會(huì)使用哪一邊的數(shù)組。相關(guān)代碼為：
if a[midIndex] > key {
// 使用左邊部分
} else if a[midIndex] < key {
// 使用右邊部分
} else {
return midIndex
}
由于29比43小，所以我們可以確定左側(cè)的數(shù)組不存在43。我們繼續(xù)在右側(cè)數(shù)組中尋找43。此時(shí)新的范圍為midIndex + 1 到range.upperBound。
[ x, x, x, x, x, x, x, x, x, x | 31, 37, 41, 43, 47, 53, 59, 61, 67 ]
此時(shí)新的中間值為midIndex = 10 + (19 - 10)/2 = 14。
[ x, x, x, x, x, x, x, x, x, x | 31, 37, 41, 43, 47, 53, 59, 61, 67 ]
*
新的中間值對應(yīng)的數(shù)字為47<43，所以我們繼續(xù)在左側(cè)數(shù)組進(jìn)行拆分。
[ x, x, x, x, x, x, x, x, x, x | 31, 37, 41, 43 | x, x, x, x, x ]
此時(shí)新的中間值為：
[ x, x, x, x, x, x, x, x, x, x | 31, 37, 41, 43 | x, x, x, x, x ]
*
37<43。在右側(cè)數(shù)組繼續(xù)拆分：
[ x, x, x, x, x, x, x, x, x, x | x, x | 41, 43 | x, x, x, x, x ]
*
再一次，41<43，繼續(xù)拆分：
[ x, x, x, x, x, x, x, x, x, x | x, x | x | 43 | x, x, x, x, x ]
*
終于，我們找到了43，此時(shí)的中間值為13，即43在數(shù)組的位置為13。整個(gè)過程看起來好像很冗長，但其實(shí)我們只花了4個(gè)步驟就得到了答案。與log_2(19) = 4.23相近。而如果是線性搜索，我們需要花14個(gè)步驟才能找到43！
迭代vs遞歸
通常情況下二分搜索屬于遞歸過程，因?yàn)椴粩噙\(yùn)用了同樣的邏輯去縮小數(shù)組。但是這不意味著我們不能使用迭代的方法去實(shí)現(xiàn)二分搜索。同時(shí)，遞歸算法轉(zhuǎn)化成迭代算法實(shí)現(xiàn)通常會(huì)提高運(yùn)行效率，因?yàn)樗挥昧艘粋€(gè)循環(huán)而不是多個(gè)嵌套循環(huán)。
以下為迭代版本的二分搜索算法：
func binarySearch<T: Comparable>(_ a: [T], key: T) -> Int? {
var lowerBound = 0
var upperBound = a.count
while lowerBound < upperBound {
let midIndex = lowerBound + (upperBound - lowerBound) / 2
if a[midIndex] == key {
return midIndex
} else if a[midIndex] < key {
lowerBound = midIndex + 1
} else {
upperBound = midIndex
}
}
return nil
}
代碼本身會(huì)比遞歸版本的更簡單，其主要的不同就是對while循環(huán)的使用。我們同樣可以在playground對代碼進(jìn)行測試:
let numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
binarySearch(numbers, key: 43) // 得到13
結(jié)語
看到這里，是否會(huì)感覺需要將數(shù)組先進(jìn)行排序會(huì)很復(fù)雜？其實(shí)不然，雖然排序也需要花時(shí)間，但是，排序加上二分搜索的過程往往會(huì)比直接進(jìn)行線性查找來得更快速。 特別是當(dāng)你不是單單只想尋找一個(gè)元素的情況下。
