BST on 跟著 Desolve 學程式

從LeetCode學演算法 - 96 BST (5) / DFS (10)

Tue, 09 Jun 2020 00:00:00 +0800

1008. Construct Binary Search Tree from Preorder Traversal (Medium)

寫在前面

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

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://hiskio.com/packages/MByQ4pw3W

另外，

Question

Return the root node of a binary search tree that matches the given preorder traversal.

(Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value <``node.val, and any descendant of node.right has a value >``node.val. Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.)

It’s guaranteed that for the given test cases there is always possible to find a binary search tree with the given requirements.

Example 1

1
2


Input: [8,5,1,7,10,12]
Output: [8,5,10,1,7,null,12]

Constraints

1 <= preorder.length <= 100
1 <= preorder[i] <= 10^8
The values of preorder are distinct.

分析/解題

從給定的前序走訪 一棵二元搜尋樹的結果，
重建一棵符合的二元搜尋樹，並回傳其根節點。
題目給出的測試資料均保證可以找到一個符合的二元搜尋樹。

我們很早以前已經解說過二元搜尋樹的特性 了，
前序走訪(preorder) 表示順序是根-左-右 ，
不像是中序走訪(inorder) 會剛好是左-根-右，順序會剛好由小到大排列 。
那麼，我們要怎麼樣才能架構一個合理的BST(二元搜尋樹)呢？
由於BST和preorder的特性，當我們一路往左走的時候，
我們會越走碰到的值越小 ，這表示我們是一路看到當下的根節點 ，
接著往左走看到左節點 才會發生這樣的狀況；

如果我們當下碰到了比根節點還要大的狀況呢？
代表這段往左已經走完了，現在看到的是右節點。
那麼怎麼知道是不是當下這個位置的右節點 呢？
我們必須要比較現在所在的位置的前面的根節點值 才行。
如果比根節點值小，代表它是被包含在當下這個子二元樹，
反之，則代表它應該在上一層或更上層 才對。
此外，我們可以設定一個class的變數i，
用來紀錄現在我們建立二元樹的過程走到哪個index。

那麼我們來整理一下流程：
0. 初始化一個class變數 i = 0 。

先檢查當前的陣列/串列是不是沒東西 ，沒東西的話就回傳null/None。
將int的最大值 作為邊界值 bound，
傳入用來建立二元樹的函式(這裡命名為build )
在build函式中，檢查如果i走完全長了 或者preorder[i] > bound，
前者表示整個樹重建完了，後者表示這個子樹底下對於preorder[i]來說不可能放在任何一個地方了，所以回傳null/None回到上一層。4. 在這層建立一個 根節點root，** 其值為preorder[i]，完成後 將i遞增**。
接下來要建立root.left，呼叫build函式，
將preorder及邊界值root.val 傳入。
(因為root的左子樹所有值都要小於root的值)
再來建立root.right，呼叫build函式，
將preorder及邊界值bound傳入。
(因為root的右子樹裡的所有值要介於root的值 和上一層限制的bound 之間)
這層等於建立完畢了，將root回傳 。

我們簡單拿Example 1為範例來嘗試推導看看：

(i, preorder[i], bound) = (0, 8, Integer.MAX_VALUE)
=> root節點建立，其值為8，i遞增，呼叫build(preorder, 8)以建立左節點。
(i, preorder[i], bound) = (1, 5, 8)
=> 建立根節點，其值為5，i遞增，呼叫build(preorder, 5)以建立左節點。
(i, preorder[i], bound) = (2, 1, 5)
=> 建立根節點，其值為1，i遞增，呼叫build(preorder, 1)以建立左節點。
(i, preorder[i], bound) = (3, 7, 1)
=> 7>1，所以表示這層沒辦法放了，回傳null到上一層。
(i, preorder[i], bound) = (3, 7, 5)
=> 走到root.right這行，呼叫build(preorder, 8)以建立右節點。
(i, preorder[i], bound) = (3, 7, 8)
=> 建立根節點，其值為7，i遞增，
呼叫root.left及root.right兩行都會回傳null，
所以回傳該節點到上一層。
(i, preorder[i], bound) = (4, 10, 8)
=> 在5的底下建立完7的右節點了，這邊也完成了，
回傳5的節點回到上一層。
(i, preorder[i], bound) = (4, 10, Integer.MAX_VALUE)
=> 走到root.right這行，呼叫build(preorder, Integer.MAX_VALUE)。
(i, preorder[i], bound) = (4, 10, Integer.MAX_VALUE)
=> 建立根節點，其值為10，i遞增，
root.left這行會回傳null，
root.right傳入build(preorder, Integer.MAX_VALUE)。
(i, preorder[i], bound) = (5, 12, Integer.MAX_VALUE)
=> 建立根節點，其值為12，i遞增。
後面的部分由於i已經到達6，所以會往上層回到8的這層，
最後回傳根節點(值為8)，結束。

請讀者嘗試在紙上畫出來推過一遍，有助於更了解整個程式運行。
由於我們是先一路往左深入並建立節點，碰到無法建立時，
才回到上一層並嘗試往右走，
所以這樣子的方式是DFS(深度優先搜尋) 的模式。

依此，寫成程式碼如下：

Java

Java的部分，
使用int時可以用Integer.MAX_VALUE作為初始邊界(即int能表示的最大值)。

Python

Python的部分，我們可以設定bound在未傳入值時預設值當作float(‘inf’) ，
即可使用同一個函式進行遞迴。
此外，還是不要忘記Python並沒有++或–，請自己換成用**”self.i += 1"** 。

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

「時間/空間複雜度？」
(O(length of array)/O(1), 如果計算call stack的話則是O(BST的深度))

相似及延伸

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

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

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

從LeetCode學演算法 - 51 BST (4)

Tue, 17 Sep 2019 00:00:00 +0800

0235. Lowest Common Ancestor of a Binary Search Tree (Easy)

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

Question

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself ).”

Given binary search tree: root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1

1
2
3


Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2

1
2
3


Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Note:

All of the nodes’ values will be unique.
p and q are different and both values will exist in the BST.

分析/解題

給定一個二元搜尋樹及其中兩個不同的節點，
試找出它們的最近共同祖先(LCA)。

題目有標註說一個節點可以視作自己的後裔(descendant)，
這點會有影響，還請留意。

那麼，我們如何尋找這個最近共同祖先呢？
首先要知道，這是一棵二元搜尋樹，假設這個LCA的節點叫作L好了，
兩個節點分別叫p跟q，那麼我們可以考慮以下幾個狀況：

如果L是p或q其中之一的話，先遇到誰，就代表誰是那個LCA 。
(因為先遇到的節點會是後面的那個節點的祖先)
如果L不是p或q其中之一 的話，L的値的範圍必在p.val和q.val之間 ，
也就是說兩者會位在L的不同側的子樹。
(即p.val < L.val < q.val或p.val > L.val > q.val)

如果從root開始判斷的話，就可以分成幾種情況：

root的値和p或q的值相等 => ** 直接回傳root** (p或q就是L)
root的値在p和q的值的範圍之內 => ** 直接回傳root**
(即p.val < L.val < q.val 或p.val > L.val > q.val )
p和q的値都小於 root的值 => 往下找root.left 的狀況遞迴
p和q的値都大於 root的值 => 往下找root.right 的狀況遞迴

也就是說，最終總會找到L是p或q之一 ，或者L能將兩個節點拆成兩邊 。
於是我們可以輕鬆解出這個題目，在Python的部分，
除了要留意a < b < c這種形式是Python才能用的，Java不接受以外，
這邊在Java的解答中要提供一個較簡潔的解法。

仔細思考的話，我們可以發現1, 2其實可以看作一件事情：
root.val - p.val和root.val - q.val的關係。
當符合1. 的時候，上面的兩個式子會有一個等於0 ；
當符合2. 的時候，上面的兩個式子會一正一負 。
所以兩者相乘 時，符合1.跟2.的條件的狀況下，
結果會<=0 (或<1，因為值是int)。

同時，當不符1.且不符2.時，由於p, q已經確定是同邊 了，
只需要拿p來比較即可，不用再去比較q。

根據上面的推導我們可以寫成Java的答案版本。
同時，由於每次遞迴都只有動到root所指向的節點，
所以我們也可以很簡單地將其改動成迭代的解法，
由於不需call stack，總體速度有可能會有些許的加快。

Java

Python

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

「時間/空間複雜度？」
(Worst case: O(N)/O(N) (如果節點都在同一邊)
平衡樹的話最大會走到整個深度的節點，是O(logN))
(用迭代解的話，因為不用call stack，空間複雜度為O(1))

「用相乘的方法會有什麼副作用？」
(在有限定變數是int的狀況下，相乘有機會導致溢位 ，所以如果這題的測試資料刁鑽一點的話，請不要用相乘的，一組一組判斷就好。)

相似及延伸

1.0236. Lowest Common Ancestor of a Binary Tree (如果這棵樹只是二元樹 而非二元搜尋樹呢？)

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

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

從LeetCode學演算法 - 35 BST (3)

Tue, 20 Aug 2019 00:00:00 +0800

0108. Convert Sorted Array to Binary Search Tree (Easy)

Question

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differs by more than 1.

Example:

1

Given the sorted array: [-10,-3,0,5,9],

1

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

分析/解題

給定一個陣列，其元素以升冪排序 (也就是後面的一定比前面大)，
試將其轉成一個高度平衡的二元搜尋樹。

高度平衡的樹由於已在先前的題目中講過了(0110. Balanced Binary Tree)，
這邊就不再贅述，簡言之就是對每個節點，
其兩邊的子樹深度相差均<=1就對了！

我們知道要達到這個條件，最基本的就是一個root的左右兩邊要公平，
所以最簡單的作法就是取中位數作為根，其左邊就是左子樹的所有節點，
右邊就是右子樹的所有節點；再分別讓各自的左右子樹再次拆分，直到分到沒有節點為止。

這樣作可以讓每一層都均分節點，從而讓每個分支的深度基本接近一致。
故整體流程如下：

檢查陣列是否是空的或者null，是的話直接回傳
呼叫一個用來遞迴建立BST的函式，這邊命名成getNode()
getNode會輸入陣列以及當下的左右邊界(nums, l, r)
(一開始l = 0, r = N-1, N是nums的總數)
每次先檢查左右邊界是否黃金交叉(表示已經完成了，可以回傳null)
讓mid = l加r的一半，直接建立一個root節點
root節點的左節點 就應該是呼叫getNode(nums, l, mid-1) 得到的結果
root節點的右節點 則會是getNode(nums, mid+1, r) 得到的結果
回傳root

我們可以看到每次會抓中間值產生一個節點，再利用已排序的特性，
繼續進入遞迴往下將左邊和右邊的節點處理完畢。
思考它的執行流程，應該會發現總體而言我們會先一路來到最左邊的節點，
再回頭建立每個遞迴函式的右邊節點；
也就是說，程式執行的優先順序是先往深處的方向走 而非先將這一層的狀況處理完，這種模式我們稱之為深度優先搜尋(Depth-First Search, DFS) ；
如果換作是優先順序是先廣泛地處理完這一層，再往下一層走 ，這種模式就稱之為廣度優先搜尋(Breadth-First Search, BFS) 。

程式碼的部分，僅需留意Java因為想避免overflow的狀況，
計算的方式為 start + (end - start) / 2 ，而非(start + end) / 2。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(N)
每個節點都會掃過一遍，且基本和其他節點沒有太多連帶關係。)

「那麼如果要將一個BST轉成排序陣列 呢？」
(原則上可用Inorder Traversal ，
但留意不加NIL的狀況其實中間樹的架構資訊可能會就此流失掉)

相似及延伸

0109. Convert Sorted List to Binary Search Tree (起始給的從陣列/串列改成排序好的LinkedList)

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

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

從LeetCode學演算法 - 32 BST (2)

Fri, 16 Aug 2019 00:00:00 +0800

0700. Search in a Binary Search Tree (Easy)

Question

Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node’s value equals the given value. Return the subtree rooted with that node. If such node doesn’t exist, you should return NULL.

For example,

1
2
3
4
5
6


Given the tree:
 4
 / \
 2 7
 / \
 1 3

1

And the value to search: 2

You should return this subtree:

In the example above, if we want to search the value 5, since there is no node with value 5, we should return NULL.

Note that an empty tree is represented by NULL, therefore you would see the expected output (serialized tree format) as [], not null.

分析/解題

給定一個二元搜尋樹及一個值，試找到這個樹上含有該值的節點；
如果找不到任何節點的值和此值相等的話，回傳NULL。

一個Binary Search Tree在進行搜尋特定值上最大的好處就是，
**碰到相等是目標，比完較小往左走，
比完較大往右走，走到盡頭就沒有。(XDDDD)**類似binary search，只是我們的每次切半/改動上下界的操作，
更改為往左走或往右走。

所以我們只要進行遞迴，直到走到NULL(NIL)或走到剛好對的值即可，
下面的程式碼中，由於判斷root是否為NIL 及root的值等於目標值 的狀況，
均為回傳root (雖然一種情況是NIL，另一種情況不是)，
所以我們可以將之合併。

而當val < root.val 的時候，
選擇往左走 去找比當下的root更小的值來比較，反之則往右走。

在實測上以筆者目前的觀察，是否全數使用if/elif連貫的判斷式，
或者前面root的回傳是否合併成一個情況，
均對執行的速度沒有特別明顯的影響 ，
故讀者可依自己的喜好選擇撰寫的方式，只需邏輯正確即可。

此外，之前可能有提到過的三元運算子 ( ? : )也僅是方便縮短行數，
同樣對結果沒有影響。

Java

Python

如果讀者習慣於使用LeetCode解二元樹或二元搜尋樹的題目，
應該會發現其實二元搜尋樹是可以使用陣列/串列的方式進行輸入 的。
這麼做的好處是只要管理好index，就可以用index的操作 來達到走訪某個節點的目的，而不用真的去把每個節點都進行連結到left/right。
缺點的部分則是有些地方必須輸入null進去(因為有可能會是null節點)。

讀者可以找一些題目來思考一下，
(像是前面的0094. Binary Tree Inorder Traversal)
如果從index i想要走到其left/right節點，這兩個的節點index會是多少呢？
讀者可以開啟Testcase中的Tree Visualizer，
來觀看輸入的陣列會長成的樹的形狀。
(註：這種表示法未必是通用的，但可以做為參考。)

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

「時間/空間複雜度？」
(Worst case O(N)/Average Case O(logN) , O(1)，
最糟的狀況是所有節點集中在同一側，一路搜尋到最底下；
平均來說，如果節點較接近平衡的分布的話，
每次搜尋往下走能去掉一半的可能性，所以會是O(logN)。
由於不需要額外的紀錄，所以空間複雜度為O(1))

相似及延伸

1.0701. Insert into a Binary Search Tree

Special Thanks suggestions/corrections from viewers: 感謝Tony Kuo 的建議，這邊附上之前講的BST定義及validation的文章。
從LeetCode學演算法 — 16 BST (1) (0098. Validate Binary Search Tree)

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

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

從LeetCode學演算法 - 16 BST (1)

Sun, 21 Jul 2019 00:00:00 +0800

0098. Validate Binary Search Tree (Medium)

Question

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
Both the left and right subtrees must also be binary search trees.

Example 1

1
2


Input: [2,1,3]
Output: true

Example 2

1
2
3


Input: [5,1,4,null,null,3,6]
Output: false
Explanation: The root node's value is 5 but its right child's value is 4.

分析/解題

題目給定一個二元樹，檢查它是否是二元搜尋樹(Binary Search Tree)。
終於我們來到二元樹的進階版了！
二元搜尋樹如同題目說明，要符合以下三個特性：

任一個節點的左子樹的所有節點值 均小於該節點自身的值
任一個節點的右子樹的所有節點值 均大於該節點自身的值
二元搜尋樹的左子樹 和右子樹 也都是二元搜尋樹

直觀來說，當我們從某個節點開始往左邊走的時候，一定要比自己小；
反之往右邊走的時候，要比自己大。也因為這個特性，當這棵樹足夠平衡時(節點分布的很均勻時)，會相當有利於搜尋值，因為每次都幾乎可以排除掉一半的可能性 。

Binary Serach Tree (Balanced, Complete, Perfect)

以下面的圖來說，我們想要從一個有15個節點的二元搜尋樹找到58這個值，
就要從根節點開始，每次比較大小，若58比較大就往右邊走，比較小就往左邊走，直到找到剛好的值，或是碰到NIL(沒有別的節點可以搜尋)為止 。
可以看到圖中由於深度一樣 的關係，不論搜尋什麼值，我們可以預期最多就只需要4次的比對就可以找出任意一個值是否在這棵樹裡面；每次刪去一半的可能性 ，所以如果總節點有N個的話，搜尋的複雜度最高即為O(logN) 。
(記得我們提過二元樹不一定非得要全部都有連接節點，這個結果是建立在這棵二元搜尋樹是平衡(balanced) 的狀況，如果這棵樹全部都改成只有左邊的節點的話，結果可是會變成O(N)的！)

Binary Search for value 58

我們同樣以上面這棵樹為例，
如果我們想知道它從小到大的節點怎麼排序呢？
這裡就需要使用到In-order Traversal了。
In-order的順序為左-中-右，代表每次我們目標要先拿到左邊的值，接著是中間，最後才是右邊的值；我們最後希望拿到的是[18, 20, 22, 33, 36, 37, 38, 43, 52, 54, 58, 61, 63, 66, 68]的話，我們要先一路走到最左邊 的節點，代表左邊沒有更小的值 了，才能將其印出來(18)，接著第二小的值則是最左邊節點的父節點(20)，而對33來說，還有20的右節點22比它還要小，最後以此類推，每次找到下一個最小值。
寫成虛擬碼如下：

1
2
3
4
5
6


inorder(root) {
 if root == NIL return
 inorder(root.left)
 print(root.val)
 inorder(root.right)
}

讀者可以嘗試使用上面的遞迴的方式走過一遍，或者參照下面的示意圖，
相信會較為理解這整個流程。留意上面由於當發現NIL的時候就直接return回到了遞迴的上一層，所以就會造成類似往上走一層 的效果。

In-order Traversal

回到我們的題目，我們已經知道在In-order的狀況下，對於二元搜尋樹可以得到一個由小到大的順序，所以只要記住上一個節點，每次去比較上一個節點和現在走到的節點，當現在的節點跟上一個節點相比較小或相等時，表示這不是二元搜尋樹(因為越後面的節點必須較大才行)；反之，當每個節點都走完沒有錯誤時，這時候就可以確認這個二元樹是二元搜尋樹了。

寫成虛擬碼如下：

1
2
3
4
5
6
7
8


let last = NIL
isValidBST(root) {
 if root == NIL return true
 if !isValidBST(root.left) return false
 if last != NIL and root.val <= last.val return false
 last = root // 更新上一個節點的位置
 return isValidBST(root.right)
}

Java的寫法部分，我們可以宣告一個class的變數last，
用來存放上一個走到的節點(放在函式內部的話會被洗掉)

Java

Python的部分，請留意到記得在呼叫時使用self的關鍵字，
否則可能會無法在isValidBST中取得last。

Python

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

「時間/空間複雜度？」
（O(N), O(1)，因為要走過整個BST，
但除了幾個變數外，不需額外的資料結構）

「可否不用遞迴呢？」
(可以，使用Stack，可以用迴圈讓每次先將root塞入，一路向左邊走將每個左節點放入Stack中，接下來同樣每次取出一個節點，判斷和前一個的大小比較。最後每個左側處理完以後，再將位置移向右節點，迴圈重複即可。)

「可以不用class的變數來解此題嗎？」
(可以，有一種解法是記錄對某個節點的最小值和最大值限制 ，將遞迴函式增加為傳入root, min, max 並隨著每次看到的節點更新其底下的限制條件，這樣就不需要按照in-order的方式移動，也不需要class的變數。Java的解法這邊收錄 ryanswizzle在Leetcode的解法如下。)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Solution {
 public boolean isValidBST(TreeNode root) {
 return isValid(root, null, null);
 }

 public boolean isValid(TreeNode root, Integer min, Integer max) {
 if(root == null) return true;
 if(min != null && root.val <= min) return false;
 if(max != null && root.val >= max) return false;

 return isValid(root.left, min, root.val) && isValid(root.right, root.val, max);
 }
}

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