Binary Search on 跟著 Desolve 學程式

從LeetCode學演算法 - 112 Binary Search (6) / Newton’s Method

Mon, 01 Feb 2021 00:00:00 +0800

0367. Valid Perfect Square (Easy)

寫在前面

目前0元挑戰賽 的活動已經開始囉！
只要修課後三個月內完課且成功錄取新工作並撰寫心得，
課程就會全額退費喲！請使用下面連結看更詳細的規則說明：

同時，還有限時更便宜的套組3490 (再便宜500呦！限額10名！)
新年限量組合🎁 零元求職挑戰賽 Python 組｜從 LeetCode 學演算法https://hiskio.com/packages/ZXwe2p9yv

零元求職挑戰賽 Python 組｜從 LeetCode 學演算法 + 面試成功指南 http://bit.ly/zeroclg

抽獎活動還在繼續累積人數(現在好像沒有人想抽XD)
在Python Taiwan的連結第100篇的文章 底下，
公開分享到你的臉書、按讚該篇文章、並留言告訴我說，
「你最喜歡這一整個系列的哪一篇？為什麼？」或
「除了從LeetCode學演算法系列以外，
你還想要看到關於什麼方向的文章？」
超過20則留言的話 (有完成以上步驟的才算)，我們就抽一組
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」
課程的免費兌換券進行贈送！

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

容筆者工商一下，
「從Leetcode學演算法｜進階篇」 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/leetcodeadv

Question

Given a positive integer num, write a function which returns True if num is a perfect square else False.

Follow up: ** Do not** use any built-in library function such as sqrt.

Example 1

1
2


Input: num = 16
Output: true

Example 2

1
2


Input: num = 14
Output: false

Constraints

1 <= num <= 2^31 - 1

分析/解題

給定一個正整數num，試檢驗num是否為完全平方數(也就是可以分解成兩個完全相等的數相乘)。
請不要使用內建的sqrt或類似的函式。

雖然被封印了平方根函數，但已經看到標題的讀者應該不難猜想到，
我們可以運用一般的二分逼近法，
去將目標(我們先稱之為x)的範圍縮小。
當找到 x² 和num相等時，就表示num是完全平方數(回傳True)，
否則一路找到兩個邊界交叉時，表示num不存在整數平方根，
我們就可以回傳False。

那麼，有沒有再更厲害一點的方法呢？
這邊來介紹一下一個著名的方法，名為牛頓法(Newton’s Method)。
我們在求x² = num當中的x，(下面方便起見，將num寫成n)
其實相當於求 y = f(x) = x² - n在y = 0時的正根。
假定r是這個根，我們先取一個任意一個比較大的值x0，
那麼它對應到的座標應該是(x0, f(x0))。
對於這個點做曲線的切線的話，應該可以得到切線方程式：
y = f(x0) + f’(x0) (x-x0)
也就是y = ax +b嘛! a就是在x0上的切線斜率，
而x代入x0的話可以驗證y = f(x0)，
所以這個方程式可以表達該切線沒錯。

我們將這個切線叫做L，
那麼L和x軸的交點的x座標，應該就和r更近囉！
(想像一下拋物線的斜度會越來越平，所以切線和x軸的交點，
比起拋物線和x軸的交點來說應該會大一點)
我們將後面和x軸的交點位置叫做x1 ，
那麼就可以計算其斜率為 f(x0) / (x0-x1) = (x0²-n)/(x0-x1) ，
同時也等於f(x)的導數(就是對其微分)f’(x) = 2x 。
因此，2x0 = (x0²-n)/(x0-x1) -> 2x0(x0-x1) = x0²-n
繼續化簡：
-> 2x0²-2x0x1=x0²-n
-> x0²+n = 2x0x1
-> x1 = (x0 + n/x0) / 2

每次取得一個更接近的x來逼近r的位置

我們可以再用這個x1再取得在f(x)上的點，接下來再畫切線，
重復上面的動作。
當我們每次用前面這個算式迭代，就可以取得一個新的x，
理論上它會更接近於r。(x1, x2, x3, …)
由於要取的是整數，所以我們在計算的時候，
就將所有的算式中的除法都取整數，
這樣算出來的狀況，就會變得有機會更小。
所以在運用到實際的計算時，
我們可以設定一個迴圈，將x直接先定為num，
當x² > num時，就持續迴圈，
那麼在x持續縮小的狀況下，
最終要嘛縮小到剛好得到一個正整數的平方根，
要嘛就是x²已經小於num了，我們就不用繼續往下做啦！

依此，寫成程式碼如下：

Java Java的部分，請留意到大小問題，我們應該要使用long來宣告變數。

Python

Python部分則請不要忘記整數除法是”//”。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(時間複雜度難以界定，最差應該是O(num)，(但二分法也是)
平均應該優於O(log(num))，這可能也取決於初始值的取法；
空間複雜度則為O(1))

相似及延伸：
本題還有其他的解法可以參考以下連結https://leetcode.com/problems/valid-perfect-square/discuss/130010/Python-4-Methods-with-time-testing

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

想看看其他題目嗎？
歡迎從第零篇 找你想要的！

同時追蹤粉專以獲得更多新文章的通知：
跟著Desolve學程式

另外，「從Leetcode學演算法｜基礎篇」 已經回原價囉，
先前的優惠碼會失效，但這邊仍然為讀者保留了300塊的折抵，
雖然整捆一起買總體比較划算 (差290而已就有整組了阿XD)，
如果你還是想先試試基礎課的話，
300元折抵的連結 在這邊：
https://bit.ly/1desolve

從LeetCode學演算法 - 78 Two Pointer (4) / Binary Search (5)

Sat, 28 Dec 2019 00:00:00 +0800

0392. Is Subsequence (Easy)

Question

Given a string s and a string ** t**, check if ** s** is a subsequence of ** t**.

You may assume that there are only lower case English letters in both s and ** t**. ** t** is potentially a very long (length ~= 500,000) string, and ** s** is a short string (<=100).

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).

Example 1

s = "abc", ** t** = "ahbgdc"

Return true.

Example 2

s = "axc", ** t** = "ahbgdc"

Return false.

Follow up:
If there are lots of incoming S, say S1, S2, … , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?

分析/解題

給定一個字串s跟一個字串t，
檢查s是否是t的subsequence(子序列)。可以假設s是一個短字串(長度≤100)且t是一個長字串(長度約500000)。

從原字串t刪除字母(也可以完全不刪)，
並保有原字串的相對位置，所構成的新字串，即為t的子序列。
後面有一個Follow up問的是，
假設這個函式會拿來檢查很多次(k次)不同的S的話(例如會處理1billion次)，
要怎麼實作這個函式比較好？

首先我們先來看看比較直觀的解法。
我們先舉個例子，如果有一個s是”abcde”的話，
s要是t的子序列的條件，就是我們要能在t當中，
依序得到 a~e這五個字母。
那麼第一個我們一定要先找a，假設從t中找到一個a以後，
按照順序的話，這個a以前的bcde就都不能用了 ！
(因為順序就不對啦XD)
同樣的，找到b以後b以前的cde也不能用，以此類推。
因此，我們要保持能確定找到可能性的方式，
就是每一次在t中都取這個順序最前面出現的字母 。

在s當中使用一個記錄index用的i ，
從頭開始找t中的s[i] 在哪，記錄為pre 。
每次找到以後，將i遞增 ，
接下來從t的pre+1處 開始尋找下一個s[i]的位置。
如果找不到的話呢？就表示沒辦法成立，應該回傳false，
否則當全部的s的字母都能找到對應的位置的話，
則代表s可以作為t的子序列。

上面描述這樣的方法，我們使用了兩個索引值，
來記錄s和t當前查找到的位置，
所以這個解法可以視為two pointer手段的一種操作。

同時，我們前面在解的時候，
每次都盡可能 去找最前面出現 的第一個s[i]，
這種概念的想法，僅在特定的題目適用。
當符合在每一個當前狀況都取當前最佳的狀況 ，
全局就會是最佳 的時候，我們就在局部的區段盡可能貪婪。
這樣子的策略被稱為貪婪演算法 (Greedy Algorithm)

請留意到，這種方式往往在很多情況下會失效，
所以在使用前請詳閱公開說明書(X)。
(開玩笑的XD，應該是使用前請確認局部最佳能推導至全局最佳 。)

這麼做基本上要掃過s跟t的字串，所以時間會是O(len(s)+len(t))，
或者說當t遠大於s的時候可以視為O(len(t))。

那麼如果搭配Follow up的條件呢？
如果有k次不同的s的檢查，
就上面的解法而言，每次仍然要各掃過一遍s跟t，
時間複雜度是O(k*(len(s)+len(t))) ，顯然當t很大的時候，
掃過k次是很不理想的，我們會希望能夠化簡一點這個部分。

那要怎麼作呢？這邊引用shuoshankou 在leetcode上的解，
我們可以先針對t建立一個HashMap ，當中的key是t上的字母 ，
而value是這個字母出現在t上面的indices (使用ArrayList來儲存)。
這個儲存過程會是O(len(t)) 。

接著要查找的過程就會變成針對s[i]來搜尋HashMap上的index，
且限定這個index要剛好是在i之後的第一個出現的位置。有沒有覺得很眼熟？沒錯， 這不就是Binary Search嗎？
我們在處理的，就跟對於某個陣列，
搜尋一個值在哪裡(或應插入在哪裡)的問題一樣！

所以就一般來說，搜尋需求是log(N)，
如果前後拆成常數的單位可以忽略不記，
所以對於k個s搜尋所需會是O(k*len(s) * log(len(t))) ，
當k大到一定程度的時候，顯然只作一次O(len(t))先建立對應表，
讓後面的搜尋相關的t的複雜度都變成對數量級 是相當划算的。

注意，以這題的測試資料而言，Binary Search速度並不會跑起來比較漂亮，
原因是測試資料的總數可能相對有限，並不像Follow up假想那樣，
所以前面吃下一整個建立HashMap的時間就會顯得拖累。

Java

Java的部分可以先檢查s和t的長度來避免一些根本不需要跑的狀況，
同時使用indexOf 來搜尋每次的si第一個出現的位置。
(搜尋不到的話indexOf會回傳-1 )

Binary Search的寫法則如註解處，
先建立起HashMap並掃過整個t並依序塞入，
後面再使用getNextIndex來寫Binary Search。
其實如果要能像Follow up那樣反覆利用的話，
應該要能將t的輸入抽離開來，題目的要求和預設寫法並沒有考慮這點，
會導致每次都需要對t建立一個HashMap。

如果要重複利用的話，應該要給定成class Solution的變數，
且建立時能先給入t才對。

Python

Python的部分則使用index 來進行查找，
請留意查找不到的話會產生exception，
所以這邊是使用try/except 來處理的。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(請見上面詳述。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(接下來快要漲成下個價格啦XD)： https://hiskio.com/courses/319?promo_code=VEQZV7E

從LeetCode學演算法 - 57 Binary Search (4)

Sun, 29 Sep 2019 00:00:00 +0800

0074. Search a 2D Matrix (Medium)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.

Example 1

1
2
3
4
5
6
7
8


Input:
matrix = [
 [1, 3, 5, 7],
 [10, 11, 16, 20],
 [23, 30, 34, 50]
]
target = 3
Output: true

Example 2

1
2
3
4
5
6
7
8


Input:
matrix = [
 [1, 3, 5, 7],
 [10, 11, 16, 20],
 [23, 30, 34, 50]
]
target = 13
Output: false

分析/解題

給定一個m x n的矩陣，此矩陣每列(row)都是從左到右升冪排序；
同時此矩陣每列的第一個值都比前一個列的最後一個值還要大。
試找出一個有效率的演算法，
來處理在這個矩陣搜尋一個值是否在這裡面。

有沒有覺得很熟悉？
其實這題的延伸題目就是上一題，作為同樣Medium難度的題目，
這題就要來得簡單許多。
為什麼呢？
因為按照題目的定義的話，
我們假設從每一列的尾巴接到下一列的頭，
最終就會得到一個完整的已排序陣列。
那麼，已排序陣列的搜尋方式，
我們以前已提到過了，就使用基本的二元搜尋法(Binary Search) 即可。
(還沒弄清楚或還不知道二元搜尋法的讀者，可以參見前面這篇 。)

那麼我們所要做的，就只剩下將matrix上的index，
轉為如果攤平以後對應到的陣列index即可。
對於matrix[i][j]來說，
由於有m列n行，i代表從0到i(總共i+1個列) ，
所以前面會經過i列，共 (i * n) 個數字；
接著要往右邊移動，
j代表從0到j有j+1個數字 ，再相加起來，
所以matrix[i][j]是整個攤平以後的第(i * n + j + 1)個數字，
從0開始起算的話就是(i * n + j)。

因此，如果我們找到某一個中間index mid ，
要轉換成i, j 的型式的話，
就只需要分別取除以n得到的商和餘數 即可。

依此進行二元搜尋的時候，其方式就和一般的二元搜尋一模一樣，
若跳出迴圈則代表該目標值不存在於matrix中，則回傳false 。

Java

Python的部分請不要忘記取整數除法要用雙斜線"//"。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(log(mn))/O(1))

相似及延伸

0240. Search a 2D Matrix II (Medium)

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 56 Binary Search (3)

Thu, 26 Sep 2019 00:00:00 +0800

0240. Search a 2D Matrix II (Medium)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.

Example:

Consider the following matrix:

1
2
3
4
5
6
7


[
 [1, 4, 7, 11, 15],
 [2, 5, 8, 12, 19],
 [3, 6, 9, 16, 22],
 [10, 13, 14, 17, 24],
 [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Given target = 20, return false.

分析/解題

給定一個m x n的矩陣，此矩陣每列(row)都是從左到右升冪排序；
同時此矩陣每行(column)都是由上到下升冪排序。
試找出一個有效率的演算法，
來處理在這個矩陣搜尋一個值是否在這裡面。

這題乍看之下沒有這麼直觀，如果我們從matrix[0][0]出發的話，
顯然馬上就會碰到問題：
「好現在target比1大，我該往哪邊走？」 看來怎麼走都不對是吧？如果透過暴力的方式來一排一排找，
結果時間複雜度會是O(mn) 。
就算有想到Binary Search 可以處理已排序的陣列，
每次取一行或一列來搜尋值，
時間複雜度也只會降到O(m log n)或O(n log m) ，
似乎還是不那麼理想。

那麼，該怎麼考慮這個題目呢？
翻了翻提示，居然也是寫Binary Search；
而Binary Search的精髓，
其實就在於可以在每次的抉擇中保留需要的那部分的選項 。

那麼，回頭看看上面的矩陣，想要能夠靠選擇每次去掉選項，
我們考慮看看15這個點如何？

當target等於15 的時候，就直接是答案了，回傳true 。
當target不是15 的時候，可以分成比15大，或比15小 。

比15大 的狀況：
代表原先15的一整列(1, 4, 7, 11, 15)已經都不用考慮了 ，
因為15已經是這整列的最大值 ，故我們可以挑到19，
因為19這行還沒看過，
同時(15, 19, 22, 24, 30)這當中也是越來越大，
所以挑選19可以繼續進行比較，
這個操作就相當於扣掉一整列的備選 。
比15小 的狀況：
代表原先15的一整行(15, 19, 22, 24, 30)不用考慮了，
理由跟1.講得相似，只是這次我們就變成往右走挑到11 ，
整個操作相當於扣掉一整行的備選 。

我們每次刪去一行或一列，那麼總共有m列n行的話，
最多就要操作m+n次 才能確認target是否在matrix中。
(因為每次扣掉一行或一列的備選嘛)

所以其實再仔細一看，
如果我們將這個矩陣往逆時針轉45度，
(或將你的頭順時針轉45度)，
你會發現這整個矩陣其實可以當作一個以15為根結點的二元樹 。
(不過由於它的特性，可以想像它還有其它不只二元樹的連結)
(或者更準確的說，它就是有向圖(Oriented Graph) )

所以我們的整個演算法如下：

檢查matrix是否正常，不正常則直接回傳false
將初始點定在**(i, j)=(0, n-1)** 的位置
當i和j都沒有超過邊界 的時候，進行下面的迴圈：
3-a. 若target和當前點的値相等，回傳true
3-b. 否則若target較大，將i遞增
3-c. 否則將j遞減
若迴圈結束尚未回傳，代表這個值不在矩陣內，
回傳false結束。

寫成程式碼如下所附。
(也有人判斷第一步的時候用< 1而非==0，但測試目前沒有明顯差異，
讀者依自己喜好選擇寫法即可。)

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(m+n)/O(1)，因為每次都會刪去一行或一列，最差狀況就是全部刪完。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
Python Taiwan 王彥珽：** 直行橫列**才對(註：中國才是橫行直列XD)
(但我工作就會講row跟column啦)

(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

1
2


如果你／妳覺得這篇文章不錯，請給我5個拍手，並且給我5個Like。
(點開最上面的SHOW EMBED!)

從LeetCode學演算法 - 53 Binary Search (2)

Sat, 21 Sep 2019 00:00:00 +0800

0278. First Bad Version (Easy)

Question

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

Example:

1

Given n = 5, and version = 4 is the first bad version.

1
2
3


call isBadVersion(3) -> false
call isBadVersion(5) -> true
call isBadVersion(4) -> true

1

Then 4 is the first bad version.

分析/解題

一個正在由你主導的團隊所開發的產品在最新的版本沒過品質檢驗。
由於每個版本都是由前面的版本進版，所以當某個版本壞掉了，
其後的版本也都會是壞的。
假定有n個版本，你要找出第一個開始壞掉的版本。

這題其實蠻真實的，
除了一般來說不會有什麼API，
可以看這個版本是不是壞掉這種東西(都嘛要自己測XD)
而實際碰到這種狀況的時候，
通常做的也是先想辦法倒回到某個版本時間點。
這時候Project Owner就會叫大家先不要commit了，
開始從上一個好的版本到這個版本中列出所有commits，
再來切一半 的位置來檢查中間的版本 有沒有問題，
沒有問題 的話就代表這個中間點到尾端 這區間才有問題；
有問題 的話就代表是開頭到中間點 這個區間有問題。

所以每次我們都可以排查掉一半的可能性並縮小範圍，
最終就找到那個元凶的commit，視情況決定要做revert或其他動作。

所以我們可以發現，這種連續性的東西，
也可以用Binary Search的方式來解，只是要處理的條件就不同了。

我們將較小的版本叫lo，較大的版本叫hi，
一開始lo=1, hi=n，取中間的版本mid，
當mid剛好是bad version時，並不代表可以回傳mid ，
應該將hi設定為mid (也就是可能的範圍是1~mid )。
否則的話，代表1~mid都是清白的 ，
我們可以將lo設定為mid+1 ，縮小範圍繼續搜尋。

最終，當lo和hi交會的時候，
代表我們找到出問題的那個版本，所以最後要回傳lo 。

Java的部分考慮到int要盡量避免溢位，
一樣使用lo + (hi - lo) / 2的形式來計算。

Java

Python的部分一樣請記得要整數除法。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(logN)/O(1))

相似及延伸

1.0035. Search Insert Position 2.0034. Find First and Last Position of Element in Sorted Array

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 6 Binary Search

Wed, 03 Jul 2019 00:00:00 +0800

0035. Search Insert Position (Easy)

Question

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Example 1

1
2


Input: [1,3,5,6], 5
Output: 2

Example 2

1
2


Input: [1,3,5,6], 2
Output: 1

Example 3

1
2


Input: [1,3,5,6], 7
Output: 4

Example 4

1
2


Input: [1,3,5,6], 0
Output: 0

分析/解題

給定一個排序的陣列和目標值，假定陣列的數字不會重複。
題目要求找到目標值在這個陣列中的位置；
若無，則回傳如果要將其插入時，應插入的位置。

這題是很典型的二元搜索法(Binary Search) 。
所謂的Binary Search，就是資料已處於被排序的狀態，那麼在這些資料內搜索某個特定值就不用一個一個找，我們可以用比較快的方法來搜尋。
假設我們有一組排序過的陣列，
搜尋的第一步就是取得中間點的那個值，我們先稱之為mid，
那mid左邊的數必然小於mid，反之mid右邊的數必然大於mid 。
(按順序排的嘛XD)
所以我們拿目標值target跟mid比較，
如果target == mid ，那mid所在的位置 就是我們要的答案；
如果target > mid ，表示答案只可能在mid右邊到尾端之間(不含mid) ；
如果target < mid ，表示答案只可能在mid左邊到開頭之間(不含mid) 。
如此一來，每次取得區塊的中間點的值，並和target做比較，
則每次都可以至少刪掉一半的可能的數量 ，
直到找到答案(target == mid) ，
或是區塊上下限交錯(那就表示target不存在於陣列之中) ，
我們同樣可以將下限的index輸出，因為它就代表應該被插入的點。

例1. nums=[1,3,5,6], target=2
首先取下限lo = 0, 上限up = 3(頭跟尾), 中間點mi = (lo + up) / 2 = 1 ->
nums[1]為3, 3 > 2 -> 將up改為mi-1=0 -> mi = (0 + 0) / 2 = 0 ->
nums[0]為1, 1 < 2 -> 將lo改為mi+1=1 ->
lo和up已交叉，故結果應輸出1。

中間的值的變化如下：

1
2
3
4


lo up mi nums[mi]
0 3 1 3
0 0 0 1
1 0 0 1

例2. nums=[1,3,5,6], target=5
首先取下限lo = 0, 上限up = 3(頭跟尾), 中間點mi = (lo + up) / 2 = 1 ->
nums[1]為3, 3 < 5 -> 將lo改為mi+1=2 ->mi = (2+3)/2 = 2 ->
nums[2]為5, 5==5 -> 直接輸出mi的值2即是答案。

中間的值的變化如下：

1
2
3


lo up mi nums[mi]
0 3 1 3
2 3 2 5

下面也列出[1,3,5,6], 7跟[1,3,5,6], 0的值變化的過程，
有興趣或對整個邏輯還沒有弄得很明白的讀者可以嘗試推導一遍。

nums=[1,3,5,6], target=7 -> ans = 4

1
2
3
4
5


lo up mi nums[mi]
0 3 1 3
2 3 2 5
3 3 3 6
4 3 3 6

nums=[1,3,5,6], target=0 -> ans = 0

1
2
3
4


lo up mi nums[mi]
0 3 1 3
0 0 0 1
0 -1 -1 6 #(這個是用python輸出的，所以nums[-1] == 6)

底下的解法看個人喜好命名均可。

Java

Python

在這個解題過程，由於每次我們都會將範圍縮小一半，
所以總共比對的次數就相當於求這個陣列的長度是2的幾次方，
故時間複雜度為O(logN) 。
(電腦科學領域的對數一般不特別提的話通常是以2為底)

事實上，Java中也有提供 Arrays.binarySearch(int[] a, int key) 於utils的函式庫中，但有一點不一樣的是，當找不到target的時候，
如果插入該key所在位置為index，則回傳值為**-index-1** 。
取負號是為了和key存在於陣列的狀況做分隔，
額外減1則是為了將key在0的位置 及key應該要插入在0的位置 做區分。
(因為0取負號還是0)

Binary Search是在排序陣列或一些有序的資料結構中很常用到的演算法，
以後在談到二元搜尋樹(BST, Binary Search Tree) 的時候也會用到它。
所以如何寫一個二元搜尋的簡單方法是很有用的，可以的話務請熟練XD

面試實際可能會遇到的問題

「(Java)如果上限接近Integer.MAX_VALUE的話相加有overflow的可能？」
(將(lo+up)/2改成lo + (up-lo)/2，可以保證不會溢出)

「時間/空間複雜度？」
(O(logN), O(1))

「我想知道到底結果target是否存在array中，但不想額外加回傳的值？」
(如上面提到的，將插入的狀況改為**-index-1** 來表達)

從LeetCode學演算法，我們下次見囉，掰~