Tree on 跟著 Desolve 學程式

從LeetCode學演算法 - 116 Tree (21) / DFS (19)

Tue, 21 Sep 2021 00:00:00 +0800

0814. Binary Tree Pruning (Medium)

寫在前面

(基礎+進階+面試篇) 從 LeetCode 學演算法 + 面試成功指南**http://bit.ly/zeroclg

新書(第一本，不曉得會不會是最後一本XD)開始預購啦！
初學 Python 的第一本書 : 從基本語法到模組應用（iT邦幫忙鐵人賽系列書） https://www.tenlong.com.tw/products/9789864348503
這本書主要是針對初學Python的入門讀者，希望能夠提供一個得以從零開始上手，又不會太過冗長的入門學習書。有興趣的話請多多支持！

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

Question

Given the root of a binary tree, return the same tree where every subtree (of the given tree) not containing a 1 has been removed.

A subtree of a node node is node plus every node that is a descendant of node.

Example 1

1
2
3
4
5


Input: root = [1,null,0,0,1]
Output: [1,null,0,null,1]
Explanation:
Only the red nodes satisfy the property "every subtree not containing a 1".
The diagram on the right represents the answer.

Example 2

1
2


Input: root = [1,0,1,0,0,0,1]
Output: [1,null,1,null,1]

Example 3

1
2


Input: root = [1,1,0,1,1,0,1,0]
Output: [1,1,0,1,1,null,1]

Constraints

The number of nodes in the tree is in the range [1, 200].
Node.val is either 0 or 1.

分析/解題

給定一個二元樹的root，將同一棵樹中未含任何1的子樹均去除掉並回傳。
(限制條件：樹的節點數目在1~200之間，且Node的值只會是0或1)

如果我們看到範例的話，大致上可以理解要被去掉的部分就是包括自己以及其底下的所有節點值均為0的子樹，這樣才能保證剩下的符合題目要求的條件。

因此，我們總體要做的就是檢查一棵樹的左子樹及右子樹狀況，
然後分別決定左子樹/右子樹是否要被去掉，最後將當棵樹的總體狀況往上回傳，因此，設計一個子函數helper如下：

傳入要檢查的節點n
如果n是空節點，則直接回傳0(因為這代表往下左右沒有其它節點了，也不用繼續檢查)
遞迴檢查左子樹(將n.left代入helper)，取得左子樹含1的節點數量為l
遞迴檢查右子樹(將n.right代入helper)，取得右子樹含1的節點數量為r
若l為0，表示無左子樹或左子樹均無節點值為1的節點，將n.left設為NIL
同理，若r為0，將n.right設為NIL
回傳l+r+n.val

在將root代入helper遞迴結束後，所有root的子樹應該都被清乾淨了，
除了root自己以外，所以我們要檢查helper得到的最後的值，
若為0的話，則最終我們應回傳NIL，否則應回傳root。

依此，寫成程式碼如下：

Java

Java的部分使用三元運算子來處理最後的c，
其實我們也可以將整個helper的函式使用True/False來處理，
這樣中間的計算就要改成or來檢查是否至少存在一個節點值為1的節點。

Python

Python的部分使用子函數來簡單處理，其它的部分邏輯一樣。

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

「時間/空間複雜度？」
(O(N)/O(N)，N為節點總數，總體的遞迴深度則和樹的高度一致。)

相似及延伸

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

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

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

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

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

從LeetCode學演算法 - 108 Tree (20) / DFS (17)

Sun, 03 Jan 2021 00:00:00 +0800

1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree (Medium)

寫在前面

好久不見！筆者最近剛換了工作，
所以比較忙一點XD 之後1月中會有HiSKIO 技術年貨節的活動，
歡迎大家拿著折價券來修從LeetCode學演算法的課程喲！
如果預算不夠，相信這108篇也還是很夠讀者練習的啦XDD

在更之後還有規劃0元挑戰賽的部分，
只要修課後一定時間內成功錄取新工作 ，
課程就會全額退費喲！ 這部分再請留意官方那邊的公告，
如果有開始的話，文章中也會再提醒各位。

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

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

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

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

Question

Given two binary trees original and cloned and given a reference to a node target in the original tree.

The cloned tree is a copy of the original tree.

Return a reference to the same node in the cloned tree.

Note that you are ** not allowed** to change any of the two trees or the target node and the answer ** must be** a reference to a node in the cloned tree.

Follow up: Solve the problem if repeated values on the tree are allowed.

Example 1

1
2
3


Input: tree = [7,4,3,null,null,6,19], target = 3
Output: 3
Explanation: In all examples the original and cloned trees are shown. The target node is a green node from the original tree. The answer is the yellow node from the cloned tree.

Example 2

1
2


Input: tree = [7], target = 7
Output: 7

Example 3

1
2


Input: tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
Output: 4

Example 4

1
2


Input: tree = [1,2,3,4,5,6,7,8,9,10], target = 5
Output: 5

Example 5

1
2


Input: tree = [1,2,null,3], target = 2
Output: 2

Constraints

The number of nodes in the tree is in the range [1, 10^4].
The values of the nodes of the tree are unique.
target node is a node from the original tree and is not null.

分析/解題

給定兩個二元樹 original 跟 cloned ，
並給定一個 originl 樹上的參考節點 target，
當中，cloned是original的完全複製，
請找到 cloned 上和 target 相對應的相同節點回傳。
留意兩棵樹上的節點都不允許被改變，
且答案必須要是cloned這棵樹上的對應節點。
(而不是original上的或新作出來的節點)

條件限制：

樹上的總節點數量範圍在1到10⁴之間。
樹上的各節點值均為獨一無二 的。
target是original這棵樹上的節點，且不為null。

後續：如果重複值可被允許，嘗試在這個條件下解決問題。

這題雖然標為Medium，但說實在的不難XD
看完題目以後，已經經歷過前面各種難題的讀者，
應該會直覺想到使用DFS來解決。

那麼，由於題目一開始已經給定說值是全部獨一無二。
如果先不計較Follow up的部分，
其實我們可以直接比較值就可以了！
我們可以直接將target的值當作目標，
並且對於cloned這棵樹進行dfs，只要比較到相同的值，
就可以進行回傳啦！
由於1的關係，我們不用擔心使用遞迴會超過call stack限制，
使用一個helper函式，當遇到null/None時，
回傳null/None，接著檢查所在節點值是否和target的值相同 ；
接著分別dfs往左邊和往右邊的樹進行尋找 。

當左邊已經找到時，我們可以不用再檢查右邊的部分 ，
直接回傳得到的節點；否則當右邊有找到時，回傳右邊得到的節點 ；
當右邊也沒有找到時，則回傳null/None 。

那麼，如果節點值不一定獨一無二呢？
那麼我們就要同時也將original一起進行遞迴，
這時候檢查的就是original上歷經的節點是否是target節點，
在檢查到的時候同時去回傳cloned的對應節點。

這時候我們用來檢查相等的就是記憶體位址，而非節點值 。
因為唯有記憶體位址相同時，能保證這個節點是對應位置的那個節點。
(而非只有裡面的值相同)

依此，我們寫成程式碼如下：

Java

Java的部分我們額外提供了LeetCode上Follow Up的解法在註解，
使用相同的做法，應該也可以寫出Python的方法，
讀者可以自行嘗試看看。

Python

Python的部分，請讀者留意，
對Python而言，我們寫n: TreeNode, v: int這樣的格式，
是寫給人看的 XD，讀者也可以完全都不寫，一樣可以執行。
而且對於使用者來說，就算你將v代成不是int的東西，
也不會直接被Python視為錯誤，
並不像Java或其他程式語言那樣對這邊有型別檢查，
這點請務必留意喲！

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

「時間/空間複雜度？」
(O(N)/O(1)，基本上最差的狀況要遍歷整棵樹，
而空間上要計較Call Stack的話，則會跟樹的深度成正比，
除此以外沒有其他額外和N相關的部分)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 106 Tree (19) / DFS (16)

Mon, 09 Nov 2020 00:00:00 +0800

0563. Binary Tree Tilt (Easy)

寫在前面

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

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

Question

Given the root of a binary tree, return the sum of every tree node’s *tilt *.

The tilt of a tree node is the ** absolute difference** between the sum of all left subtree node ** values** and all right subtree node ** values**. If a node does not have a left child, then the sum of the left subtree node ** values** is treated as 0. The rule is similar if there the node does not have a right child.

Example 1

1
2
3
4
5
6
7


Input: root = [1,2,3]
Output: 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tile of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1

Example 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Input: root = [4,2,9,3,5,null,7]
Output: 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15

Example 3

1
2


Input: root = [21,7,14,1,1,2,2,3,3]
Output: 9

Constraints

The number of nodes in the tree is in the range [0, 104].
-1000 <= Node.val <= 1000

分析/解題

給定一個二元樹，試計算二元樹的每個節點的tilt(坡度)和。

什麼是tilt呢?
題目告訴我們，對於一個節點，
其左子樹的和以及右子樹的和相減的絕對值，
就稱為它的坡度(tilt)，當子樹不存在時，和則視為0。

另外由於整個樹的總節點數已經被限定在0~104之間了，
表示我們可以放心的用遞迴！

那麼，我們該怎麼對每個節點算坡度呢？
對於一個節點n，如果它不存在的話(NIL)，
其坡度自然為0，且總和同樣為0 ；
存在的話，我們必須先算出左子樹(n.left為根節點的子樹)和，
以及右子樹(n.right為根節點的子樹)和，將兩者相減取絕對值，
就是n的坡度。

因此，我們可以使用一個dfs的函式來同時處理算子樹和，
以及坡度的部分，整個dfs的概念應該會如下：

若n為NIL，回傳0
將n.left代入dfs中，取得n.left的子樹和l
將n.right代入dfs中，取得n.right子樹和r
將|l-r|加到物件變數的答案res中
回傳l+r+n.val

留意到我們使用dfs的回傳一直都是回傳以n為根節點的子樹和，
這個和我們要計算的坡度不同，所以必須要用一個res變數來儲存。

在寫出dfs函式後，我們只需要初始化res，
並且在主函式中呼叫dfs後，回傳res即可。

依此，寫成程式碼如下：

Java 對於Java而言abs在java.lang.Math函式庫中，

如果不是在LeetCode的編輯器的話，不要忘記自行import。

Python

Python的部分和Java大同小異，
這邊採用將dfs寫成一個子函式，別忘記要宣告以後才能夠使用呦！
此外，__init__並非一定要這樣使用，在class Solution中直接定義也沒問題。

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

「時間/空間複雜度？」
(O(N)/O(樹的深度)，最差則為O(N))

相似及延伸

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

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

從LeetCode學演算法 - 105 Tree (18) / DFS (15) / Backtracking (7)

Mon, 14 Sep 2020 00:00:00 +0800

0437. Path Sum III (Medium)

寫在前面

容筆者工商一下， 「從Leetcode學演算法｜進階篇」及 加贈的**「從Leetcode學演算法｜面試篇」已經全數上傳完囉！**

目前只剩下給讀者的進階篇+面試篇(3150) 和全套同捆優惠(3990) 了QQ
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」：
https://bit.ly/leetcodeadv
「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

內容介紹：
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！

Question

You are given a binary tree in which each node contains an integer value.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

Example:

1

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

1

Return 3. The paths that sum to 8 are:

1
2
3


1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11

分析/解題

給定一個二元樹，當中每個節點均含一個整數，
找出所有可以加總等於目標總和的路徑數量。
一個路徑不需要從根節點開始，也不必一定要到葉節點結束，
但是路徑只能往下走(也就是說只能從父節點往子節點走)；
另外，這棵樹最多只會有1000個節點，
且其值均在-1000000~1000000之間。

這一題是一整組Path Sum系列題的第三題。
由於題目提示節點數不會超過1000個，
所以基本是無法超過各程式的Call Stack限制，可以放心使用遞迴。

那麼，我們看看另一個重點：
路徑只能往下走，會有什麼特點呢？
舉例來說，以上面的二元樹，當我們走到某個節點2時，
所有終點是2的路徑有以下三種：
10 -> 5 -> 2
5 -> 2
2
再往下走到1的時候，路徑有以下四種：
10 -> 5 -> 2 -> 1
5 -> 2 -> 1
2 -> 1
1

我們可以發現，走到1的路徑和到底有沒有符合target的解這件事情，
可以透過兩點知道：

從root起算走到現在這個節點的總和是否和target相等
從root起算走到現在這個節點的總和-target是否在過往出現過

第2點比較抽象，我們稍微舉一下簡單的例子：
假設我們要找的目標是8的話，
那麼直接看我們當然知道是5->2->1，
但如果不能回頭重算的話，要怎麼辦呢？
我們可以得到5->2->1的路徑，
其實相當於從根節點10走到1的路徑和，減去節點10。

換句話說，如果我們每走到一個節點，都將路徑和記錄下來，
那麼我們就可以用前面過往的路徑和，
來表達出所有達到現在這個節點的路徑和。

例如：
1其實等於10 -> 5 -> 2 -> 1 去掉** 10 -> 5 -> 2
2** -> 1等於** 10 -> 5 -> 2** -> 1去掉** 10 -> 5
5 -> 2** -> 1等於** 10 -> 5 -> 2** -> 1去掉** 10**

這樣足夠清楚了嗎XD？
因此，我們要做的事情有：
0. 建一個dictionary或hashmap，
當中key/value分別代表路徑和/路徑和出現的次數。
同時，將(0, 1)置入字典當中。(這裡稱之為preSum)
(方便我們在剛好等於根節點到當前節點總長時計算)

呼叫遞迴DFS函式並回傳其結果。
在DFS函式中，遍歷整棵二元樹：
2.0. 檢查節點是否存在，不存在則回傳0
2.1. 將當前的節點值加上根節點的値，做為現在的總和(currSum)
2.2. 初始化res，其值為currSum-target在preSum中出現的次數
2.3. 分別向左右節點遞迴呼叫DFS函式，將得到的結果加到res
2.4. 由於這條路徑只能一路向下，
所以要回到上一層前，
需將剛剛加過的1次記錄從preSum中扣掉(backtracking)。
2.5. 回傳res

依此，寫成程式碼如下：

Java

Java的部分preSum使用HashMap，留意先進行一次put，
再放入helper函式中做DFS；
helper函式中的部分，由於HashMap本身找不存在的值會出錯，
別忘了使用getOrDefault來給定預設值(當然，你要用containsKey也行)。
在遞迴取得左右兩邊節點的符合路徑數加總後，
別忘記回傳前要將加上去的刪掉，才符合回溯法的要件。

Python

Python的部分大同小異，
不同的是我們可以用defaultdict來將預設值當作0，
從Python的寫法中應該可以更清晰看見回溯法的樣貌。
(先加1後減1)
這邊的helper直接寫成子函式，
所以我們就不需使用self.xxx的形式來呼叫了。

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

「時間/空間複雜度？」
(O(N)/O(N*樹深)，每個節點均需要經過一次，
每個節點最多可以成立d個preSum值，
d為樹的深度，以平衡樹來說則是log(N))

相似及延伸

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

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

從LeetCode學演算法 - 104 Tree (17) / DFS (14) / Backtracking (6)

Tue, 18 Aug 2020 00:00:00 +0800

0113. Path Sum II (Medium)

寫在前面

容筆者工商一下， 「從Leetcode學演算法｜進階篇」及 加贈的**「從Leetcode學演算法｜面試篇」已經全數上傳完囉！**

Question

Given a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

Return:

1
2
3
4


[
 [5,4,11,2],
 [5,8,4,5]
]

分析/解題
給定一個二元樹以及目標的和(sum)，找出所有根節點到葉的路徑，這些路徑各自的和要等於給定的和。

這一題是一整組Path Sum系列題的第二題。
由於要找出路徑，所以我們需要一組記錄當前路徑current的位置的list。
同時，要能夠判定是否要確認這條路徑OK的狀態，
只取決於現在是否走到葉節點(因為題目要求)；
並且走到葉節點時，左右也都沒有節點了，就無法往下走。

我們可以用一個result的list記錄最終處理完的結果，
接著使用DFS 的方式往下找。

那麼自然我們每走過一個節點，
就要將sum減去現在root的値，同時記錄到current上。

接下來要往下走還是檢查呢？
當然就是看左右節點是否為NIL且sum和root的値是否相等啦！
如果是的話，可以將result加上走到現在的路徑；
如果不是的話，則以DFS往左和往右走(不要忘記去檢查NIL的狀況)。
這整段走完要回到上一層的時候，表示已經處理完了，
不要忘記我們先前將這層root的値放進了current裡面，
所以我們應該要將其移除。(** Backtracking**的部分)

依此，寫成程式碼如下：

Java

Java的部分我們可以使用同名但不同參數長度的函式，
直接利用開頭檢查root，
來順便處理後續帶入root.left/root.right所需要的檢查。
Backtracking的部分，
currentResult先加上root.val後，後續再進行remove即可；
而留意由於我們不斷地在變換currentResult，
不要忘記要將其複製一份以加到result裡面，而非直接用加的。
(使用new LinkedList(currentResult) )

Python

同理，Python的部分一樣需要複製，
我們可以寫成curr[:]以複製一份用來讓res進行附加。

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

「時間/空間複雜度？」
(O(N)/O(logN)，因為整棵樹要遍歷過一遍，
然後平均而言，樹的深度會到O(logN)，
所以空間複雜度所以空間複雜度，這個部分不包含result的占用空間)

相似及延伸

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

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

從LeetCode學演算法 - 103 Tree (16) / DFS (13) / BFS (3) / Queue (4)

Sat, 08 Aug 2020 00:00:00 +0800

0112. Path Sum (Easy)

寫在前面

容筆者工商一下， 「從Leetcode學演算法｜進階篇」及 加贈的**「從Leetcode學演算法｜面試篇」已經全數上傳完囉！**

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

Question

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

return true, as there exists a root-to-leaf path 5->4->11->2 which sum is 22.

分析/解題

給定一棵二元樹，試決定該二元樹是否有一個從根到葉的路徑，
使得路徑上的節點總和恰等於給定的目標和。

這一題是一整組Path Sum系列題的第一題，
除了接下來幾篇會陸續談到系列題外，這篇也想著重給讀者一個提醒：
很多時候能用DFS解的題目，通常也能用BFS解 (反之亦然)

所以當下遇到一個題目的時候，除非有限定要求，
否則只要能想到的解法就是好解法 ，
不要硬逼自己一定要用DFS或一定要用BFS。
(練習的時候，當然還是可以自我挑戰兩種都想出解來就是了XD)

首先我們要留意到一件事情：
由於是從根到葉，
所以我們只需要在走到左右均無節點時再檢查總和是否相符即可，
千萬不要沿途檢查呀XD！

再者，由於路途經過的都會算做計入的總和，
所以我們可以沿路將往下走所需的總和減去當前經過的節點。

依照這個概念，我們可以蠻直觀地寫出一個DFS的解：

先檢查root如果是NIL -> 直接回傳False
檢查root.left/root.right 是不是都為NIL -> 若均為NIL，
若root.val等於所需和 則回傳True ，否則回傳False
將往下走的剩下的和next定為sum — root.val(剩下需要湊的和)
回傳hasPathSum(root.left, next) || hasPathSum(root.right, next) (因為只要存在一條路徑即為True，所以兩者用或來連接)

由上可知，用來判定這個位置能不能成為我們要的路徑和，
只取決於兩點：

現在這個位置是否已經是葉(leaf)
現在這個位置的値是否是剩下需要的和

所以我們也可以用BFS的方式，搭配前面講過的Queue來處理：

同樣先檢查root及處理回傳
將**[(root, sum - root.val)]** 放入Queue當中
進行迴圈，每次從Queue中取出一組**(curr, val)** 並檢查：
3–1. 若curr.left/curr.right均為NIL -> ** 若val為0，回傳True**
3–2. 檢查curr.left，若存在 -> 將**(curr.left, val - curr.left.val)放入Queue** 中
3–3. 對curr.right做相同處理
若迴圈結束仍未回傳，則回傳Fals e(找不到適合的路徑)

依上面的方式，我們分別在Java/Python演示不同的方法：
(讀者也可以自行嘗試完整練完單一語言的DFS/BFS的方法)

Java

Java的部分，使用了DFS，所以整體而言看起來很簡單，
不過原則上有用遞迴的題目，就盡量要留意call stack的深度會不會超過。

Python

Python的部分則使用了BFS，搭配deque做為queue使用，
留意當val != 0的時候記得要繼續操作，因為你可能會有其他節點符和XD，
這點和DFS時不一樣，請特別留意不要直接在那邊回傳False呦！

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

「時間/空間複雜度？」
(O(N)/O(log N)或O(N)(平均)，
因為DFS的話記憶體計算call stack深度，
BFS的話則是要用最底部的橫向長度來看；
如果極端的狀況的話DFS也有可能到O(N)，因為樹可能不平衡)

相似及延伸

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

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

從LeetCode學演算法 - 102 Tree (15) / DFS (12)

Fri, 31 Jul 2020 00:00:00 +0800

1530. Number of Good Leaf Nodes Pairs (Medium)

寫在前面

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

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

Question

Given the root of a binary tree and an integer distance. A pair of two different leaf nodes of a binary tree is said to be good if the length of ** the shortest path** between them is less than or equal to distance.

Return the number of good leaf node pairs in the tree.

Example 1

1
2
3


Input: root = [1,2,3,null,4], distance = 3
Output: 1
Explanation: The leaf nodes of the tree are 3 and 4 and the length of the shortest path between them is 3. This is the only good pair.

Example 2

1
2
3


Input: root = [1,2,3,4,5,6,7], distance = 3
Output: 2
Explanation: The good pairs are [4,5] and [6,7] with shortest path = 2. The pair [4,6] is not good because the length of ther shortest path between them is 4.

Example 3

1
2
3


Input: root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
Output: 1
Explanation: The only good pair is [2,5].

Example 4

1
2


Input: root = [100], distance = 1
Output: 0

Example 5

1
2


Input: root = [1,1,1], distance = 2
Output: 1

Constraints

The number of nodes in the tree is in the range [1, 2^10].
Each node’s value is between [1, 100].
1 <= distance <= 10

分析/解題

這題是2020/07/26舉辦的199th LeetCode Weekly Contest的第3題。
給定一個二元樹的根節點root和一個整數距離distance，
如果兩個不同的葉節點配對，其最小距離小於等於distance，
我們就將其稱之為好(good)。
試回傳這棵樹好的葉節點配對的總數。

我們先前應該已經提到過葉節點就是指左右都沒有連接節點的節點 ，
那麼，這題要怎麼思考呢？

我們不妨先留意一下題目給定的條件：
節點數量是1~2¹⁰，由於2¹⁰=1024 ，所以最壞的狀況，
遞迴的數量也就1024而已，所以應該可以不會超過call stack的上限。
接著，1≤distance≤10決定了我們在遞迴時，
可以適度修剪我們要處理的節點。

那這題該怎麼思考呢？
由於我們在求的是最短距離，假定我們要看兩個節點x, y，
那麼最短路徑肯定是從x往上走到x, y的最低共同祖先，
再往下走到y的位置。

如果我們知道x, y的LCA(最低共同祖先)n，
又知道n的左子樹的所有葉節點各自的深度，
及右子樹的所有葉節點各自的深度，
那麼我們就可以知道以n為LCA時，正確的節點對有哪些。
怎麼知道？就迴圈加起來就好了嘛！

那我們又怎麼知道某個節點n的左右子樹的葉節點深度呢？
我們可以先用dfs往深處走，走到出現葉節點的時候，
將其記錄為距離1並往上傳(因為這時候左右也都沒得走了)；

那在某個非葉節點的n 時，我們應該可以從dfs的結果，
分別獲得左右子樹的各個葉節點離n的距離 。
我們將兩個距離的列表分別叫作llt跟rlt (left list, right list)，
從llt跟rlt分別成對取出來相加，
每發現一組葉節點距離相加小於等於10，全局的解就加1 。

做完檢查以後該做什麼呢？
裡面所有的葉節點應該可以往上通用，對吧？
可是我們左子樹和右子樹往上都導到當前的節點再往上，
再往上的深度應該都要加1 才對！
所以我們應該將llt和rlt裡面的所有值都分別+1以後，
放入一個新的list，這裡命名為merge，再將其往上傳。

因此，整個流程會大致如下：

定一個class變數cnt，用來記錄成功配對的葉節點對的總數
在主函式裡，先檢查root是否為NIL，是的話直接回傳0
將root和distance帶入遞迴函式dfs中
回傳cnt

而在dfs函式中，我們要做的事情是：

若n為NIL，回傳空的串列
若n的左右節點均為NIL ，則回傳一個裡面只含一個1的串列
呼叫dfs(n.left, distance) 及dfs(n.right, distance) 進行遞迴，
取得回傳的llt 跟rlt (記錄兩邊葉節點深度的串列)
初始化一個空的串列merge
雙重迴圈，每當遇到llt和rlt的値**，
兩兩相加會小於等於distance的狀況，就將 cnt遞增1**
分別將llt和rlt的値全數+1後，加到merge 裡
(這邊可以檢查值必須小於distance ，超過的話因為總路徑肯定超過， 所以不符的不用放到merge內)
回傳merge

依此，寫成程式碼如下：

Java

由於需要一個一個取出，並且重複使用，
所以我們使用ArrayList 並使用get 來取得當中的值。
在雙重迴圈的時候，我們可以順便將外層的値處理一下放到merge內 ，
這樣後面就不用再重複一個新的迴圈處理。
(但內層的不能這麼做，因為會被重複執行)

Python

Python的部分，cnt的累計可以使用list comprehension，
處理符合的配對再來取len() ，這樣寫起來會比雙重迴圈方便許多。
llt和rlt則可以用類似的方式，最後將串列用加號組起來回傳。

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

「時間/空間複雜度？」
(O((log N)³)/O(log N)，因為只有葉節點需要被記錄，
空間應該跟最底層的節點數有關，而除了雙重迴圈外，
dfs的深度也跟這棵樹的深度有關，但這個部分會受到distance的制約，
所以實際應該比這個複雜度快不少)

相似及延伸

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

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

從LeetCode學演算法 - 99 Tree (14) / DFS (11)

Mon, 13 Jul 2020 00:00:00 +0800

0404. Sum of Left Leaves (Easy)

寫在前面

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

Question

Find the sum of all left leaves in a given binary tree.

Example:

1

There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.

分析/解題

給定一個二元樹，試求所有左葉子的總和。

我們很久以前有提過二元樹的定義，
忘記的話，請再複習一下XD
而葉子的定義，就是它左右都沒有連接節點(NIL)！

這時候，你可能會說：
我知道，那我只要一直往左邊看就好啦！

呃……同學，你忘記了你的右子樹也可能產生左葉子 嗎XD？
範例中的15，不就是先從3的右節點20，
再往左節點來到15所得到的嗎？

那怎麼辦呢？
所以我們在檢查所在節點是不是葉子的時候，
還需要看看這個節點是不是從它的根節點往左邊走下來 的。
因此，我們可以每次分支往左右走，給出一個參數from，
分別給往左子樹走的函式1，給右子樹走的函式-1 ，
用來代表下一層的時候拿來判定是不是左葉子的前置依據。

當我們看到from == 1且左右節點均為NIL時，
就可以將當前的節點值回傳，
否則的話，就繼續遞迴往下找底下子樹當中左葉的和。

依此，寫成程式碼如下：

Java

Java的部分，每次先檢查root是否為null，
接著我們的答案就用
sumOfLeftLeaves(root.left, 1) + sumOfLeftLeaves(root.right, -1)
來取得。
其他的寫法概念如前所述。

Python

Python的部分寫一個子函式，因為這邊沒有用self，
所以可以不用self.getSum來算。
(也可以把add設定預設値-1，
使用單個sumOfLeftLeaves來解此題，
這個化簡方式很簡單，就留給讀者來練習看看XD)

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

「時間/空間複雜度？」
(O(N)/O(1)，因為要經過每個節點，
而如果考慮call stack的話，
空間複雜度會是O(depth of Tree))

相似及延伸

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

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

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

從LeetCode學演算法 - 98 Tree (13) / DFS (10)

Sat, 27 Jun 2020 00:00:00 +0800

0129. Sum Root to Leaf Numbers (Medium)

寫在前面

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

Question

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

Note: A leaf is a node with no children.

Example:

1
2
3
4
5
6
7
8
9


Input: [1,2,3]
 1
 / \
 2 3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2

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


Input: [4,9,0,5,1]
 4
 / \
 9 0
 / \
5 1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

分析/解題

給定一個二元樹，當中只有數字0~9，
每個根到葉子的路徑可以表達一個數。
舉例來說，1->2->3可以表達123。
找出所有的根到葉的數字的總和。
(葉的定義是沒有子節點的節點)

這題雖然標註為Medium，但其實並不那麼難思考，
只是定義要弄清楚而已。

首先，假設我們在某個節點n，它如果左節點和右節點都沒有的話，
意味著它是葉(leaf)，這時數字就要計入總和；
如果有其中一個成立的話，我們應該要往下走，
並記錄之前經過的節點値，這樣子在遇到葉的時候才能夠結算。

那麼自然，由於每棵樹只有0~9，
所以從一層樹到下一層的時候，原先經過的數字的作用會放大10倍。
也就是說，從上一層下來的時候，如果所在是葉的話，
我們應該要把這個數字乘以10以後，加上現在的節點値 。

因此，我們只要遍歷完整棵樹，將葉子加總 起來即可。
寫成流程應該如下：

檢查根節點是否為NIL，如果是，直接回傳0(此路不通)
計算上面下來的值(last)到當前根節點的值(now)的結果，
now = last * 10 + root.val
如果左右節點均為NIL，直接回傳now 即可(當前節點為葉)
將root.left, now及root.right, now 分別傳入做遞迴計算左右子樹的和 ，
最後加總起來並回傳 。
所以我們會先沿著最左邊一路到最底，然後依序將所有節點走過，
這樣子是先往深處走，所以是所謂的深度優先搜尋(DFS)的方法。

另外一方面，留意由於我們最開始已經檢查了root是否為NIL，
所以在傳入左右子節點時，可以讓前面這條檢查來確認NIL的狀況，
也就不用再先檢查節點是否為空了。

依此，寫成程式碼如下：

Java

Java可以使用相同的函式名稱，傳入不同長度的參數 來處理。

Python

Python的部分，我們直接設定預設值 ，這樣就可以通用了XD
當從根節點開始時，由於只傳入root, 自然last會是0。

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

「時間/空間複雜度？」
(O(N)/O(1), 如果算上call stack的部分的話，
平均空間複雜度是O(logN) (DFS的深度))

相似及延伸

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

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

從LeetCode學演算法 - 93 Tree (12) / DFS (9)

Sun, 10 May 2020 00:00:00 +0800

0687. Longest Univalue Path (Easy)

Question

Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.

The length of the path between two nodes is represented by the number of edges between them.

Example 1

Input:

Output: 2

Example 2

Input:

Output: 2

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

分析/解題

給定一個二元樹，尋找其最長的路徑長，
當中的所有節點必須擁有相同的值。
這條路徑通過或沒有通過根節點均可。
(路徑長度的定義為兩個節點之間經過的邊(edge)的數量)

由於很早我們就介紹過樹的基本性質了，
(印象模糊的讀者請回頭參照0100. Same Tree)，
在此就不再贅述。這題嘗試要找相同值的路徑，
但又不限定要通過root，該怎麼思考呢？
我們可以先考慮怎樣可以算一條相同值的路徑 。
一條相同值的路徑有可能有以下兩種狀況：

從一個頂點下來，
每次選擇往左節點走或往右節點走，到一個位置停下。
例如：

當中的5-5-5就是一條相同值的路徑。

從一個頂點進行分岔，左右各自走到一個位置停下。
例如：

當中的粗斜體的4-4-4 就是一條從頂點往左右分岔所得到的路徑，
可以選擇從左下的4 -> 中間的4 -> 再到右邊的4 ，這樣連成一個路徑。
但從這邊來看可以發現，這條路徑就無法把root的4算在內，
因為不管怎麼連，我們都沒辦法一筆不重複將這4個4走完。

因此，我們可以得知：
對於某個節點來說，有經過它所能得到的最長路徑，
有可能是從它的上面連下來(分岔點在它的上面 )，
也可能是以它自己為分岔點 ，左右各自找完和它值相同的節點路徑。
在第一個情況來說，要求它的上一個節點值和它的值相同；
第二個情況來說，則要將左右和它的值相同的路徑長相加 。

所以我們可以定義一個count函式，
回傳以某個節點值來說，其下的最長所能得到的相同值的路徑長，
當中計算的時候一邊留意當下最長的路徑長並進行更新。

我們將整個題目的答案(相同值的最長路徑長)叫做mx(叫result也可以)，
流程順序應為：

一開始應該先檢查root是否為NIL ，
如是，回傳0 (因為沒有路徑)，否則呼叫count函式，
檢查它所能得到的相同值的最長路徑長 。
(傳入root節點，及當下的路徑節點值root.val )
在count當中，
同樣應先檢查傳入的節點值是否為null，
接下來為了要知道左右路徑的相同值的最長路徑長，
應該要分別帶入其left/right節點及當前節點的值 進去檢查，
假設得到的結果分別為l/r 。
依照2的定義，l + r的值代表了一條可能的相同值路徑，
所以要拿它和mx比較，將較長的路徑值更新。
如果當前的節點值 和**傳進來的路徑節點值兩者相同，
代表有機會可以考慮上面提到過的
「從一個頂點下來，每次選擇往左節點走或往右節點走，
到一個位置停下。」的狀況，
這時候要回傳的值會是左右路徑長較長的部分+1。
(因為要包含左節點/右節點到當前節點的這個路徑)
上面的判斷不成立的話，代表路徑從上面下來到這邊斷掉了。
(值不相同)，這時候應該回傳0，代表相同值路徑到這邊沒辦法繼續。**

上面的流程順序，請讀者務必自行畫圖推導，
會比較清楚整個思考過程。

依此，寫成程式碼如下：

Java

Java的部分mx直接宣告一個class變數即可，其它就是使用Math.max，
及檢查null的部分，並不複雜。

Python

Python的話，可以使用self.mx來宣告，
並且在__init__時進行處理，
其它就是一樣注意呼叫時不要忘記用self 即可。

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

「時間/空間複雜度？」
(O(N)/O(1)，如果空間要算上call stack的部分的話，
則是O(TreeNode的高度)。)

相似及延伸

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

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

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

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(最後一波早鳥優惠了，不確定調回原價是什麼時候)： ** https://hiskio.com/courses/319?promo_code=VE9Q5VE**

從LeetCode學演算法 - 84 Tree (11) / DFS (8)

Fri, 24 Jan 2020 00:00:00 +0800

0116. Populating Next Right Pointers in Each Node (Medium)

Question

You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:

1
2
3
4
5
6


struct Node {
 int val;
 Node *left;
 Node *right;
 Node *next;
}

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Follow up:

You may only use constant extra space.
Recursive approach is fine, you may assume implicit stack space does not count as extra space for this problem.

Example 1

1
2
3


Input: root = [1,2,3,4,5,6,7]
Output: [1,#,2,3,#,4,5,6,7,#]
Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.

分析/解題

給定一個完美二元樹(perfect binary tree)，
也就是所有葉子都在相同level且所有父節點均有兩個子節點。
在Node的定義中增加一個next的定義，
如圖所示，每個節點的next為其右邊的節點，
如右邊已無節點，則為NULL。
(最開始的時候預設所有節點的next均為NULL)
請把整個next的定義完成。

由於這個題目已經有提到說只能用常數的額外記憶體空間了，
但同時將遞迴導致的stack(也就是call stack)當作不算，
所以使用簡單的遞迴可以簡單達到目的。

最直觀的方式，就是先檢查root是否是null，
接下來呼叫一個helper function，代入左節點和右節點來處理，
只要左節點不是NULL，則將左節點的next設為右節點；
接下來則要分別處理這三個連接：
1. 左節點的left -> 左節點的right
2. 左節點的right -> 右節點的left
3. 右節點的left -> 右節點的right

當然，也可以從root為中心出發，
這時候每次要關注的應該是root.left -> root.right，
及root.right -> root.next.left。

如果想要用迭代的方式呢？
我們留意到每次開始進行連接的都是當個階層的最左邊的節點，
從Figure B 上來看的話，即為1, 2, 4…等節點。
所以我們最開始應該要從一個階層的最左邊的節點
(這邊叫做level_first)開始進行迭代，將當前的節點稱為curr
分別將curr.left -> curr.right 及curr.right -> curr.next.left。
接著讓curr遞移到curr.next。
所以每次連接兩組next的關係，直到curr走到NULL為止。
這時候這層走完以後，進行到下一層，
level_first應該遞移到level_first.left。

依此，寫成如下的程式碼。

Java

在Java中，上述三種方法均有列出，
順序剛好跟上面提到的相反，
請務必留意在接續前必須要留意要確定節點是否為null的狀況。
如果計入call stack的話，只有迭代的方式是O(1)才對。

Python

Python的部分大同小異，不要忘記使用self來呼叫，
這邊僅列出第二種和第三種。

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

「時間/空間複雜度？」
(O(N)/O(1)，如果不考慮Call Stack的話。
如果考慮的話上面只有直接使用迴圈迭代的是O(1))

相似及延伸

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

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

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

從LeetCode學演算法 - 62 Tree (10)

Wed, 16 Oct 2019 00:00:00 +0800

0102. Binary Tree Level Order Traversal (Medium)

Question

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

return its level order traversal as:

1
2
3
4
5


[
 [3],
 [9,20],
 [15,7]
]

分析/解題

給定一個二元樹，回傳其節點値的層序遍歷結果。

我們在先前的文章中，
已經提到過層序走訪(level-order traversal)的概念了，
按照題目範例，這邊要將level分層開來。

對於遞迴解來說，如果使用一般的DFS的話，
我們將不知道哪一個節點位在哪一個level上，
故我們將必須加入變數level ，
讓level的值來幫助我們辨別要加到List的哪個level區塊中。

所以對於遞迴解而言，在主函式 中：

檢查根節點
將root的值加入第0層的list 中，再將該list加到答案res 中
呼叫幫助用的函式，將level遞増代入 (表下一層)

在幫助用函式 中：

先檢查代入進來的節點，
若遇到NIL則表示到此為止 ，進行回傳即可。
檢查目前res的size 和level 的關係，
若相等則表示要開一個新的list(因為level從0起算 )；
否則，找到對應level的list，將該節點的值加入。
分別檢查左節點和右節點進行遞迴 。

觀察這樣子的遍歷方式，讀者應該可以發現一點：
幫助用的函式本質上就是在做pre-order traversal。 之所以會達成我們想要的效果，是因為我們額外記錄了level這個資訊。

如果使用迭代法 來解呢？
我們可以建立一個Queue ，在每一層先行取得Queue的大小(長度) ，
每次迴圈只要剛好執行這個次數，
就可以不斷利用相同的Queue來堆出不同的層數 ，
再分頭將對應的左節點和右節點推入Queue中 。
(記得要先檢查，非NIL才需要推入)
最終所有節點都遍歷過一遍時，
剛好Queue裡面也不會留存任何節點。

依照上述說明，請參考對應的程式碼。

Java的部分，記得用來檢查的isEmpty() ，以及可以用LinkedList 來實作Queue 的部分。

Java

Python用deque (記得我們提到過的，list在移除左端的部分效率較差 )
另外，若幫助函式沒有要再被其他函式使用，
是可以考慮如底下34行以後這樣子寫成子函式的方式再呼叫的，
可以省去要加一堆self的狀況。
(但要記得：Python函式要先宣告才能呼叫 )

Python

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

「時間/空間複雜度？」
(O(N)/O(N)，因為要遍歷全部節點並記錄)

相似及延伸

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

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

從LeetCode學演算法 - 50 Tree (9)

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

0226. Invert Binary Tree (Easy)

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

Question

Invert a binary tree.

Example:

Input:

Output:

Trivia:
This problem was inspired by this original tweet by Max Howell:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.

分析/解題

題目要求反轉一個二元樹。

我們今天來看一題經典的題目，
這題經典的原因也許不是在於它有多困難，
而是在於這問題背後的故事XD

或許另一方面也可以看看他本人在Quora上的回應。
所以演算法很重要有沒有XDD
(據稱有一種說法是說當時的題目是要求min-max的反轉，這邊暫不討論，
我們以左右反轉為準)

相信大家經過前面的一堆二元樹相關題目以後，
應該已經對二元樹駕輕就熟了，應該可以輕鬆地寫出遞迴方式的版本。

跟之前的Symmetric Tree相似，
只是這次我們直接將一棵樹的左右節點交換，
除了交換以外，它們的左右子樹的部分也要再度進行交換。

所以我們會拆成：

檢查root是不是null (是的話代表這條路到底了，直接回傳null)
將root.left和root.right進行交換
將root.left和root.right分別做為參數，呼叫函式進行遞迴

Java

Python寫得再簡單一點，不過意思是一樣的XD

Python

你以為這樣就結束了嗎？
我們將繼續來探討一下如果是迭代解的話該怎麼處理。

如果思考一下前面的遞迴解，
會發現一件事情：
對於一個我們造訪的節點而言，
我們所影響到的只有其左節點和右節點，
當下這個節點的値並不會受任何影響。
所以我們只需要保證當走到這個節點的時候，
關於這個節點以上的操作已經做完 即可，
那麼要保證這點的話，只要使用level order 的方式，
我們按順序操作即可做完所有反轉的動作。

由於是先將同一層的做完才會進到下一層，
也可以視作是BFS的方式。
按順序作的話，
可以使用Queue來處理這樣子的問題，步驟大致上是：
0. 檢查root是否為NIL，是的話直接回傳NIL

建立一個queue(python請用deque )
將root放入queue中
每次從queue中取出一個節點，將其左右位置互換 ，
並分別將左右節點中非NIL的節點放入queue中
重複3直到queue中沒有節點
回傳root

Java:

Python:

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

「時間/空間複雜度？」
(因每個節點均要和另一個位置進行對調，所以時間複雜度為O(N)。
空間複雜度會受到樹的平衡程度影響。
平衡狀態 的話空間複雜度對遞迴解來說是O(logN)(call stack) ，
而對迭代解來說是O(N) (因為最大是最底部那層)
(這時候反而越不平衡每層的節點會越不容易太多))

「這兩種解哪種是DFS？哪種是BFS？」
(遞迴解是DFS(一路走到最深才回頭)，迭代解是BFS(當層走完才往下層走))

相似及延伸

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

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

從LeetCode學演算法 - 42 Backtracking (1) / Tree (8)

Thu, 29 Aug 2019 00:00:00 +0800

0257. Binary Tree Paths (Easy)

Question

Given a binary tree, return all root-to-leaf paths.

Note: A leaf is a node with no children.

Example:

1

Input:

1

Output: ["1->2->5", "1->3"]

1

Explanation: All root-to-leaf paths are: 1->2->5, 1->3

分析/解題

給定一個二元樹，回傳其所有根到葉的路徑。
這題是Easy難度的題目，剛好藉由它來講一下回溯法(Backtracking) 。
這個題目看起來挺簡單的，如果沒有特別要求的話，寫起來也不難，
依照遞回的模式就可以順利解決，
思路大致上是每走一步就將root的值串上path字串 ，
直到左右均無節點，表示已走到葉節點了，即可將其放到結果res中。

所以一般可能會寫成這樣：

可以通過但不盡理想的遞回解

這麼做其實不盡理想，
因為我們會發現裡面的每一個tmp其實都是使用一個新的變數 ，
顯然這件事情會讓我們花費更多的空間(因為產生新的變數)。
怎麼辦呢？這時候就到了回溯法上場的時候了。

我們之前有介紹過DFS/BFS ，
分別代表著深度優先搜尋 和廣度優先搜尋 ，
如這題前面的解法其實也可以當作DFS來看待，

而回溯法的概念又更廣泛一些 ：
在每個階段將所有可能性列出 ，
經過檢查排除掉不可能的解後，往下一個階段 進行搜尋；
如果這個階段的所有分支均不成立 ，
則回復到上一個階段 的搜尋，並取消掉這個階段所造成的影響。
(過程中視要求，可在找到所有答案後才回傳，或者找到第一個答案就回傳)

簡單來說，就是一個一個試，
走錯了就回頭，而且記得先前** 試的痕跡要處理掉**就對了XD
聽起來可能還是有點抽象，我們講這題的實作方式好了。

要進行回溯法，首先要確立要處理的對象 。

例如這題裡面最重要的是節點經過的路徑 ，
那麼我們應該可以將當前的路徑當作主要處理的對象：
每次在遞迴函式中應該要做的事情有：

將當前的根節點 加到路徑的ArrayList中
如果左節點 存在，遞迴進行左子樹 的部分
如果右節點 存在，遞迴進行右子樹 的部分
如果左右節點均不存在 ，表示該路徑是答案要求的其中一條 ，
將整個路徑內的節點值按照要求的格式輸出到結果res中
走完前4步，這個階段的可能性均搜索完畢 ，
所以要回到上一個階段，這時在1.的時候加入的根節點應該要被移除 ，
因為上一個階段並沒有它。

可以看到在回溯法中，路徑的部分是所有函式共用 的，
所以只要妥善處理用完後復原，即可使用一個List來處理整個樹的狀況，
這個List最大的占用空間就是這棵樹的深度 。

依此，我們可以寫出其程式碼。

Java的部分，這邊用DFS來命名遞迴的函式名，
也可以叫getPath，可依讀者喜號命名。
使用StringBuilder來進行字串的整理(加上”->”)，
以及使用ArrayList/LinkedList來處理path相關的部分。
(應該是用哪個都可以啦XD 題目只限定List)
最後不要忘記每次該階段做完要將最後一個進行移除(remove)。

Java

Python的部份我們可以直接使用List來處理，
並且利用join 的特性可以很方便地串接所有的path。
最後一樣不要忘記移除當階段的痕跡(pop )。

Python

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

「時間/空間複雜度？」
(時間複雜度為O(N)(因為要掃過整棵樹)；
空間複雜度的部分，使用的path在平衡的狀態下複雜度是O(logN)
而最後的res部分如果用個數來看的話，完美的二元樹深度是O(logN)，
路徑數是O(N)，所以總占用空間是O(N * logN) )

相似及延伸

1.0113. Path Sum II

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

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

從LeetCode學演算法 - 30 Tree (7)

Wed, 14 Aug 2019 00:00:00 +0800

0144. Binary Tree Preorder Traversal (Medium)

Question

Given a binary tree, return the preorder traversal of its nodes’ values.

Example:

1
2
3
4
5
6


Input: [1,null,2,3]
 1
 \
 2
 /
 3

1

Output: [1,2,3]

Follow up: Recursive solution is trivial, could you do it iteratively?

分析/解題

題目給定一個二元樹，試求其Preorder Traversal(前序走訪)。

先前我們介紹過Inorder Traversal，對於Preorder，大家應該也會有一個心理準備，就是使用遞迴會很簡單，迭代則會不容易思考XD。
再複習一下，所謂的Preorder指的是走訪的順序依序為根->左->右 ，走訪的時候遇到根的時後先輸出，接著優先往左邊走，當左邊的全走完時，
才檢查右邊的節點，依此順序將所有節點輸出。

作為遞迴的方式，我們每次將根節點的值放進res(result)中，接著再呼叫遞迴依序進行左邊節點和右邊節點的走訪即可。
Java中使用add，Python中則用append，在前面不要忘記檢查當走到NIL(null/None)的時候要退回到上一層(直接return)。

那麼，迭代的方式呢？
由於之前我們已經提到過在Python裡面，List的append/pop可以拿來當作stack的push跟pop來使用，要用Queue的話則必須用Deque。
所以我們這邊依舊使用stack的思路來解題。

我們已經知道對於stack來說有LIFO(後進先出) 的特性，
利用這點，我們可以讓進入stack的順序設定為右->左->根，
如此pop出來的時候順序即會符合根->左->右的狀態。

思路如下：(前面應先檢查root是否為NIL)

設置一個stack名為st，將root放入，再設一個記錄結果的串列res。
當st裡面有節點時，pop出一個節點n 。
將n的右節點 push至st(如該節點不為NIL)
將n的左節點 push至st(如該節點不為NIL)
將n的值 放到res中
重複2~5直到st中沒有任何節點

這樣一來，我們可以使用一個迴圈，令res依preorder的順序拿到節點值。

Java

Python

這題比較困難的部分就在於迭代法的解法，
如果讀者一時無法理解，請嘗試用紙筆列出一些狀況操作，
會較能夠體會該方法是如何利用迴圈來達到目標的。

同時，存入根節點的值的時間點不同 ，
基本就決定了它是哪一種Traversal。

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

「時間/空間複雜度？」
(O(N), O(N)，因為最終都需要儲存整份樹攤平的結果)

「樹的形狀會影響其時間空間複雜度嗎？」
(只會影響中間空間暫存需要的大小(因為有stack或call stack)，
但複雜度不變 )

「給定一棵二元樹，
請依序寫出preorder/inorder/postorder/levelorder的結果」
(簡單卻重要，請讀者務必自己畫一棵並嘗試寫一下順序，
看看是否有搞混的地方，尤其是每次印出根節點的時機很重要。)

「如果該樹是BST，且改為inorder的話，
能否找到任二節點相差的絕對值當中的最小值？」
(利用inorder的狀態排出來的順序會是遞增排列，每次檢查相鄰的數即可。)

相似及延伸

0145. Binary Tree Postorder Traversal

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

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

從LeetCode學演算法 - 20 Tree (6)

Sat, 27 Jul 2019 00:00:00 +0800

0110. Balanced Binary Tree (Easy)

Question

Given a binary tree, determine if it is height-balanced.

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 differ by more than 1.

Example 1

Given the following tree [3,9,20,null,null,15,7]:

Return true.

Example 2

Given the following tree [1,2,2,3,3,null,null,4,4]:

Return false.

分析/解題

題目給定一個二元樹，試檢查其是否為高度平衡的狀態。
前面已經提到過很多次，若是一棵樹長得不夠平均(例如都長在同一邊)，那麼在進行一些操作的時候會相當耗時間，
這也是為什麼我們會在意一棵樹高度是否平衡的原因。

而題目給的條件其實以更常見的定義來說，會定義成如下所述。
假如底下3點成立，一棵非空的二元樹就被稱作是平衡的：

二元樹的左子樹是平衡的
二元樹的右子樹是平衡的
二元樹的左右子樹高的差不大於1 對於一個樹的高度(或稱作深度)，
是指從樹的根節點走到葉節點的最大長度，所以基於這點，我們的流程應該是從根節點往下，檢查以每個節點為基準的左右子樹高的差均不大於1，該二元樹即為平衡的，反之則為不平衡。

依此，我們會需要知道除了根以外，每個節點的深度，
故可以簡單利用遞迴來操作：

先試寫看看maxdp這個函式的虛擬碼(假設你要求root這個node的深度)：

1
2
3
4
5
6


maxdp(root) {
 if root == NIL return 0
 l = maxdp(root.left)
 r = maxdp(root.right)
 return max(l, r) + 1
}

當我們要求某個節點的深度時，
就相當於求其左右兩邊子樹深度的較大值+1 。
(+1是因為經過了自己這個節點)

回到我們原本的問題，我們想要求左右子樹的深度差不能大於1的話，只需要在maxdp函式中增加去判斷左右深度差即可。
我們同時可以使用一個變數res來記錄是否已經發生不平衡的情況，
一旦發生，其實可以不用繼續往下做。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


let res = true
maxdp(root) {
 if (root == NIL or !res) return 0
 l = maxdp(root.left)
 r = maxdp(root.right)
 if (abs(l-r) > 1) {
 res = false
 return 0
 }
 return max(l, r) + 1
}

在一開始的解答的isBalanced函式中呼叫maxdp，
最後將res回傳即可得到答案。

Java

Python這邊展示了一個再進一步的思路：
如果我們已經發現不平衡的狀況，可以使用-1做為代表，因為深度只可能大於或等於0，那麼，只要每次檢查是否出現-1，就不用使用額外的res變數來儲存結果，我們只需要檢查回傳是否為-1就可以判定二元樹是不是平衡了！

Python

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

「時間/空間複雜度？」
(最差狀況是樹很平衡，每一層都要檢查，時間複雜度是O(N)
自行宣告的額外空間是O(1)，但遞迴中需有Call Stack，
最糟的狀況也是O(N)(全擠在同一邊))

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

從LeetCode學演算法 - 19 Tree (5)

Thu, 25 Jul 2019 00:00:00 +0800

0111. Minimum Depth of Binary Tree (Easy)

Question

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

return its minimum depth = 2.

分析/解題

題目給定一個二元樹，要求找到最小的深度，也就是從根節點到最近的葉節點的路徑長。(葉節點是指它底下沒有其他小孩 了)
上一題我們講解了一題Hard的題目，讓我們稍微喘口氣，
來看個這個比較基本的題目吧！

這題概念並不複雜，只要稍微弄明白要被遞迴的主體即可。
對一個節點來說，我們已經知道所謂的深度就是從根走到這個節點的長度 。
既然我們要求最小的路徑長度，可以選擇的方式就是分別看兩邊有多深，
最後選擇較小的那邊 ，加上1即可。(因為從根走到根的左/右節點要計算到)
那麼，左右各自有多深同樣也要取最小的路徑，
故一樣使用相同的方法再往下遞迴。

依此嘗試寫成遞迴的虛擬碼：

1
2
3
4
5
6
7
8
9


minDepth(root) {
 if root == NIL return 0
 l = minDepth(root.left)
 r = minDepth(root.right)
 if l == 0 or r == 0
 return l + r + 1 // 等同於取非NIL那條的路徑或取1(當左右都是NIL)
 else
 return min(l, r) + 1 // 左右都有時取較小的路徑
}

再化成程式碼如下：

Java

Python的部分使用判斷是否是None來處理，
本質上是一樣的，讀者可依個人喜好來選用寫法。

Python

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

「時間/空間複雜度？」
(由於必須遍歷所有節點，時間複雜度為O(N)，空間複雜度則依照stack深度而定，最糟的狀況也是O(N)，最好的狀況則是O(logN))

「可以用迭代解嗎？」
可以，但比較難想，有興趣的讀者可以嘗試使用我們還沒有仔細講過的level-order traversal 來解此題，大致的思路是使用Queue來保存相同深度的所有節點 ，並且用另一個Queue和level進行記錄，一旦在某次出現了node.left和node.right均為NIL 的狀況，代表在這層就遇到葉子，那麼就可以回傳level即為解答 。
這麼做的時間複雜度和空間複雜度均和最小深度 有關，若最小深度為D，
時間空間複雜度均為O(2^D)，雖然看起來比較可怕，
但其實最糟的狀況是這棵二元樹是平衡的，這時2^D-1 = N；
而其他狀況下複雜度肯定小於O(N)。

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

從LeetCode學演算法 - 18 Tree (4)

Tue, 23 Jul 2019 00:00:00 +0800

0124. Binary Tree Maximum Path Sum (Hard)

Question

Given a non-empty binary tree, find the maximum path sum.

For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along with the parent-child connections. The path must contain at least one node and does not need to go through the root.

Example 1

1

Input: [1,2,3]

1

Output: 6

Example 2

1

Input: [-10,9,20,null,null,15,7]

1

Output: 42

分析/解題

題目給定一個二元樹，試求其上最大的路徑和的值。
所謂路徑，就是在二元樹上任意挑兩個節點，從一個節點走到另一個節點，包含它們自己，所經過的所有節點值的和。
最小的條件是兩個節點相同，這時候的路徑長等同於這個節點的值。

嫌前面太簡單了嗎？別急，Hard等級的題目這不就來了嗎XD
在講解以前，建議讀者先思考一下有沒有任何頭緒並寫下來，再接著往下面看分析，相信會有比較好的收穫。

開始囉！

如果我們多拿幾組節點來進行觀察，會發現從一個節點要走到另一個節點，要先經過它們最低的共同祖先節點(這邊指從雙方往上走第一個碰頭的位置)，再走下來才行。
以Example 1來說，2和3的最低共同祖先是1，
以Example 2來說，15和7的最低共同祖先是20。

那麼，我們怎麼決定兩個節點的路徑長呢？
假設我們知道AB兩個節點的話，它們一定會有一個最低的共同祖先節點，
當中可能是A或B自身，也可能是其他節點 (如前面的範例就都是其他節點，而如果取的是-10跟15的話那最低的共同祖先節點就是-10)，
所以每個節點都可以有做為節點的最低共同祖先節點的可能 。

我們姑且將最低共同祖先節點叫做中繼點好了，比較方便XD
接著，將不含中繼點的左邊的最大路徑和叫做l，右邊的最大路徑和叫做r，對於某個中繼點(node n)而言：

通過中繼點n的最大路徑和 = max(n.val, n.val + l, n.val + r, n.val + l + r)
(因為l或r都有可能是負的，所以要把這四種都考慮在內)

接著我們要考慮的是，如果中繼點是別的點而不是現在這個點 ，
我們只是經過它但想知道包含這個點往下走最大路徑和 是多少的話，
那我們只能去考慮n.val/n.val+l/n.val+r 這三種狀況。
(因為n.val+l+r代表這個點是做為中繼點才會有分支)

所以我們可以嘗試用遞迴的方式解題，從root開始往下走到每個節點，計算該節點往下走的最大路徑和 ，並且每經過一個節點就考慮看看這個節點是中繼點的狀況，一旦發現最大值比現有記錄的大，就更新成新的最大值 。
由於用來遞迴的函式是一路優先往下一層節點進入(一直到最底下才能回頭依序得到各自的l跟r)，這種優先往深的方向走的方式我們一般稱為深度優先搜尋 (DFS, Depth-First Search)。

寫成虛擬碼如下：

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


define res
maxPathSum(root){
 res = root.val
 dfs(root)
 return res
}
dfs(n){
 l = (n.left != NIL) ? dfs(n.left) : 0
 r = (n.right != NIL) ? dfs(n.right) : 0
 m = n.val
 m = max(m, l + m, r + m) // 單做為經過點的最大路徑和
 res = max(res, m, l + r + n.val) // m已比過3種可能，故只需再考慮中繼點
 return m
}

在這個虛擬碼當中，我們先考慮左右是否還有連接節點 ，有的話就進行dfs往下找出經過點 的最大路徑和，沒有的話則補上0 ；接著先考慮m的部分，再利用已經比過大小的m來和作為中繼點的狀況比較，最後和當前最大路徑和相比並更新結果，完整走完所有流程即可得到回傳的答案。

Java的部分，這邊使用了if來作比較，實測上和一組一組依序使用Math.max來相比並沒有明顯速度上的區別，讀者可依自己喜好使用。

Java

Python的部分，留意呼叫時加上的self.即可，
且max可適用於多個傳入值，比起Java會再方便一點。

Python

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

「時間/空間複雜度？」
(每個節點均會走過一遍，故時間複雜度為O(N)
除了res, l, r, m以外沒有額外的空間了，自行宣告的空間複雜度為O(1)，
但進入遞迴會用到Stack，最大應該是這棵二元樹的高度，
也就是最糟的狀況下可以到O(N)，最好的狀況則是O(logN))

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

從LeetCode學演算法 - 17 Tree (3)

Mon, 22 Jul 2019 00:00:00 +0800

0094. Binary Tree Inorder Traversal (Medium)

Question

Given a binary tree, return the inorder traversal of its nodes’ values.

Example:

1
2
3
4
5
6


Input: [1,null,2,3]
 1
 \
 2
 /
 3

1

Output: [1,3,2]

Follow up: Recursive solution is trivial, could you do it iteratively?

分析/解題

給定一個二元樹，題目要求以inorder(中序)方式回傳其節點值。
由於上一題的關係(讀者可以回頭參照第16篇)，我們已經講解過In-order的方式了，原則上就是經過左邊的部分->中間的部分->右邊的部分 的順序。
請留意這題輸出並不一定會由小到大(因為並沒有限制是二元搜尋樹)。

我們先來嘗試遞迴解法，通常較為簡單，這邊重新列出上一篇提到的：

1
2
3
4
5
6


inorder(root) {
 if root == NIL return
 inorder(root.left)
 print(root.val) // Or add/append to the list
 inorder(root.right)
}

若讀者感到不太能夠掌握這個流程的運作，可回頭參考第16篇的gif動畫。
總體而言，每次我們都會走到當前所能走到的左邊 ，直到左邊再也沒有node(變成NIL )時，會回到上一層 (return)，印出值 (或將其放到list中)，接著再往自身的右邊找 ；每次同樣的模式操作完以後，我們可以保證對於每個子樹，都是先拿到其左邊的節點值(們)，再來是自身，最後才是右邊的節點值(們)，從而保證這個演算法是得以遵照目標的順序完成的。

由於我們會使用一個ArrayList或List來存放inorder得到的值，所以下面是採用先宣告再將其放置到另一個遞迴用函式中處理的方式。當然，如讀者只想使用一個函式來遞迴，也可以宣告一個Solution的class變數，這樣就不需要每次傳遞了。兩者各有好處，讀者可依自己喜好決定。

Java

Python

那麼，如果是要求要迭代解(iterative solution)呢？
我們回顧一下前面的作法，遞迴的時候之所以我們能回到上一層，其實是因為我們的程式有記錄上一層的函式的執行狀態，從而在return時能返回到應該繼續的那一行執行。由於最後一層函式在返回時必須先被呼叫到 ，所以電腦在儲存時是採用Stack 的形式(因為要後進先出)。(這個堆疊又叫做The Stack或Call stack(呼叫堆疊))

因此，我們想要能夠不用遞迴解的話，
顯然我們應該要自己使用一個Stack來處理整個流程。

在In-order的流程中，首先我們是先一路走到最左邊的node，
中途經過的node我們應該要將其放進Stack中，這樣才能回到上一層去，
我們將這個node暫時命名為curr(current)。
curr一路向左最終一定會遇到NIL，表示這排從root一路向左邊走，
沿途的node全數放入到Stack中了。
那麼我們應該要將最後一個node從Stack中拿出來(因為後進先出，最後一個node應該是最左邊的node才對)，將其放到list當中。
接著將curr設為自己右邊的node。
反覆上面的流程，一直到curr和stack都空掉為止。

寫成虛擬碼如下：

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


create a list named res
create a stack named stack
curr = root
while ( curr != NIL or !stack.isEmpty() ) {
 while (curr != NIL) {
 stack.push(curr)
 curr = curr.left
 }
 curr = stack.pop()
 res.add(curr.val)
 curr = curr.right
}
return res

Java

Python

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

「時間/空間複雜度？」
（O(N), O(N)，因為要走訪過整棵樹，且list要儲存整個二元樹攤平的結果）

「如果我將res放在class Solution的level有什麼優缺點？」
(優點：
有機會速度快一點點，且通常不用傳位址給函式，因為直接能存取到。
缺點：
對整個class均為可見，如果這個函式是要被反複使用的話，
要注意初始化的問題，且也有可能被其他函式修改到。)

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

從LeetCode學演算法 - 14 Tree (2) / Queue (1)

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

0101. Symmetric Tree (Easy)

Question

Given a binary tree, check whether it is a mirror of itself
(ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

But the following [1,2,2,null,3,null,3] is not:

Note:
Bonus points if you could solve it both recursively and iteratively.

分析/解題

題目給定一個二元樹，要求檢查是否為左右對稱(Symmetric)。
繼前一篇的樹的基本以後，今天同樣來談談另一個基本題，幫助大家熟悉以外，也介紹一個資料結構Queue，用來說明我們怎麼來解迭代解的。

這邊講的左右對稱是指從根節點將左右切開來看，左邊和右邊恰巧要對稱。
要解決這個問題並不困難，但要留意小細節。

首先，如果給定的根是NIL(null/None) =>
沒有東西仍然是可以達成左右對稱，所以必須回傳真值 (true/True)。

扣掉這個狀況，再來觀察上面的圖可以發現，根節點毫不影響，
接著要比較的應該是左子樹跟右子樹是否對稱。
和前一題不同，以[1,2,2,3,4,4,3]為例，要符合對稱的條件，
應該要符合下面三點：

左子樹根的值=右子樹根的值
左子樹 自己的左子樹 (以本例是最左邊的3)要和右子樹 自己的右子樹 對稱
左子樹 的右子樹 要和右子樹 的左子樹 對稱

請留意1的部分，
如果兩者均為NIL ，表示下面不用比(空了)且兩者相等 ，
這時候應該回傳真值 ；而接下來再判斷其一為NIL 的狀況，表示兩者一定不相等(一個有節點一個是NIL )，這個技巧在上一篇同樣有使用到。
上面都沒成立的話，再判斷兩者值是否相等 。

所以直觀上我們可以寫出這樣的遞迴模式：
(註:留意我們這樣寫只是用來表達整個演算的流程，它通常並不能用來在某個語言執行，這樣的用來表達概念的代碼叫作虛擬碼(pseudocode)，虛擬碼通常不用嚴格按照特定規範，目的只是要先將你的流程想法釐清為主。 )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


isSym(root) {
 if root == NIL return true
 return isSymmetric(root.left, root.right)
}
isSymmetric(l, r) {
 if l == NIL and r == NIL return true
 if l == NIL or r == NIL return false
 if l.val != r.val return false
 return isSymmetric(l.left, r.right) and
 isSymmetric(l.right, r.left)
}

寫成Java如下，注意我們這邊將isSymmetric函式的前2行合併了，
使用者也可以依自己習慣決定要不要這麼寫，速度上並不會有明顯差異。
同時，對Java而言，我們可以定義同名的函式，只要輸入的參數(parameter)型態或數量不同，JVM就可以知道哪一條式子是呼叫哪一個函式才正確。
這個做法稱為函式多載(Method Overloading) 。

Java

Python並不支援函式多載，所以我們可以定義不同的名字來使用。
(註: 對於所有程式語言來說，
代表"且 “的操作，只要第一個條件為假，後面就不會再進行判斷；
代表”或 “的操作，只要第一個條件為真，後面也不會再進行判斷。
這個特性是為了節省時間，因為結果已經確定了 。
讀者可以留意一下這點，
避免將一些希望一定要被執行的函式放在判斷條件的第二個以後，
以免發生預期要做的事情結果沒做的狀況。)

Python

上面是遞迴的部分，接下來我們改成嘗試來使用迭代法解看看。
這邊首先要介紹一個資料結構Queue(隊列/佇列)。
隊列基本上就跟現場排隊名店一樣，扣除掉一些現實中的插隊之類的糟糕狀況外，基本上是先排隊的可以先離開排隊序列而進場，也就是說它的特性是先進先出(FIFO)。 我們將放一個東西到Queue中的操作叫作”Offer “(提供)，會放到隊列尾端；
從Queue裡面拿一個東西出來的操作叫作”Poll “(獲得)，會從隊列頭拿出。

這樣的特性對於解這題有什麼幫助呢？
我們可以如下操作：

首先判斷root的部分，沒有問題的話拿出其左右(l跟r)，放到Queue裡面。
此時Queue裡面有東西，一次拿兩個出來(poll兩次)，判斷l跟r本身
(如同遞迴時一樣)
接下來我們應該要判斷的是l.left, r.right跟l.right, r.left ，
所以我們將這四個節點依序offer至Queue中。
重複2~3的動作直到Queue空掉 或當中判斷為假 的狀況即回傳假。
如果Queue空掉了才離開循環，代表結果為真，回傳真值。

這裡我們利用了Queue的特性，只要依照我們目標的順序將東西放進Queue，我們就可以一直按照正確的方式拿到2個需要被判斷的節點。
這邊要注意一點，如果兩個節點均為NIL，只代表這個部分往下沒有節點了，不能直接回傳真值 (因為其他部分還沒比較完)，只是我們在這個位置不需要再放節點進到Queue中而已。

寫成虛擬碼如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


isSymmetric(root) {
 create a queue named q
 if root == NIL return true
 q.offer(root.left)
 q.offer(root.right)
 while q is not empty {
 l = q.poll()
 r = q.poll()
 if l == NIL and r == NIL continue
 if l == NIL or r == NIL return false
 if l.val != r.val return false
 q.offer(l.left)
 q.offer(r.right)
 q.offer(l.right)
 q.offer(r.left)
 }
 return true
}

注意continue 是用來表示這輪的迴圈不再繼續，直接跳到下一輪。

Java的LinkedList 已經有實作包含Queue的資料結構了，所以我們定義一個Queue時，實際上可以使用LinkedList作為宣告的物件。

Java

Python的部分，由於list的特性和Queue不太一致，
從開頭取出 這點會讓用list模擬Queue的行為消耗大量的時間。
針對這點，Python有提供一個deque 的物件可以使用，取出請用popleft() ，放入請用append() 即可。除了像Java這樣子的寫法以外，我們也可以將其使用list的形式每兩個作為一個單位來操作，請參閱下面的程式碼。

Python

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

「時間/空間複雜度？」
(最糟的狀況均為O(N)，因為要查完所有資料有可能要塞完全部的node
遞迴的狀況如果該樹是平衡的話，空間複雜度可以降到O(logN))

「可以將左右比較的順序調過來嗎？」
(只要對應的節點是正確的，先比左邊還是先比右邊並無差異)

「如果我不想在前面單獨判斷root的話，有可能嗎？」
(去掉第4行，並將第一次offer的(root.left, root.right)改成(root, root)即可。)

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

從LeetCode學演算法 - 13 Tree (1)

Mon, 15 Jul 2019 00:00:00 +0800

0100. Same Tree (Easy)

Question

Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1

1
2
3


Input: 1 1
 / \ / \
 2 3 2 3

1

 [1,2,3], [1,2,3]

1

Output: true

Example 2

1
2
3


Input: 1 1
 / \
 2 2

1

 [1,2], [1,null,2]

1

Output: false

Example 3

1
2
3


Input: 1 1
 / \ / \
 2 1 1 2

1

 [1,2,1], [1,1,2]

1

Output: false

分析/解題

給定兩個二元樹，試寫出一個函式來檢查二者是否相等。
(相等的定義是指樹的結構相同，且其相同位置節點的值也相等)

到了第13篇，終於來到樹的部分了，想當年大學時在演算法的課上被各種資料結構搞得眼花撩亂，當中二元樹/二元搜尋樹真的只能算小兒科XD
(不信？有心更進階的讀者可以試試看了解一下紅黑樹)

扯遠了，我們回頭來談樹。
在程式的領域中，樹是指資料之間以一種長得像樹的方式連結在一起的資料結構(廢話XD)，以外型而言就像樹狀圖 或族譜那樣子，不過它們有一點比較特別，那就是他們的根通常是畫在上方 ，下面才是支幹。
如下圖我們所看到的：

每個圈圈我們稱之為節點(node) 。2.最上面的節點是整棵樹的起始，所以我們就稱之為根(root) 。3. 就如族譜一樣，上面節點是下面直接連接的父母，
所以我們稱如A是B和C的父節點(parent) (不要問我為什麼不叫母節點XD)，而B和C是A的子節點(child)， 同時B和C是兄弟節點(siblings) 。
任何從自身追尋血脈上去可以到達的節點均為你的祖先(ancestor) 。
比如A是所有人的祖先，而B不是G的祖先。

From Wikipedia: Tree

樹本身並沒有規定一個節點要連接多少個節點或總共有多少個節點，
你可以子孫滿堂開枝散葉，也可以孑然一身孤苦伶仃，只要有一個根在，
就可以被稱做一棵樹。

不過這邊要介紹的是二元樹(binary tree) ，就有比較明確的限制了，
每個節點最多只能有2 個分支。且左右分支是視作不同 的，將它們互相交換的話，前後兩個二元樹會被視為不同的二元樹。由於只有2個分支，所以一個節點的兩個子節點又可以分別被叫做左節點和右節點(left/right node)，
單就這兩個節點來看，都可以各自視為一個二元樹，
同樣依照左右被稱作左子樹/右子樹(left/right subtree) 。
後續還有一個規範更嚴格，也更常被用到的二元樹稱為二元搜尋樹(Binary Search Tree, BST) ，這個我們之後會專門再開一篇講解。上面這些均為樹的相當基本的部分，並不困難，還請詳加閱讀後再往下。

如同先前提過的linked list一樣，當一個節點它有一邊沒有連接，或者是已經沒有子節點的時候，嚴謹的資料結構會將其連接至NIL (表示什麼都沒有)，而在Java中用null，Python則用None 表示。

一個Binary Tree, 15的左邊/17, 23, 25的左右其實都是NIL(恩，其實它也是BST)

回到問題，其實問題的輸入是透過array或list的型式，但這邊LeetCode應該已經妥善處理好建造二元樹的過程了，我們暫且不管它。
我們如何判斷兩個二元樹是否相等呢？
由於相等的前提是結構相同且所有對應的節點的值 也相同，我們勢必要一個一個檢查才能知道結果，所以我們必須要走訪整棵樹(Tree Traversal )。
一個標準的走訪分成四種模式：
前序、中序、後序以及層序(Pre-order/In-order/Post-order/Level-order) 我們這次只會先從最直覺的前序遍歷開始。

假設如題目所提，我們有兩棵二元樹，他們的root分別是p跟q，
那麼檢查它們是否相等的話，我們要做的事情是：

檢查p和q是否相等
檢查p的左子樹 和q的左子樹 是否相等
檢查p的右子樹 和q的右子樹 是否相等
唯有這三項均成立，我們才能說p跟q兩棵二元樹相等，否則即為不相等。
接下來，我們先考慮2和3的部分，
其實就等同於反複拿更小的子樹去做1~3的動作，
直到比對的兩邊當中有不同或空掉的狀況。

我們拿下面的圖為例，可以簡單推論出，
當檢查兩個節點是否相等 的狀況有幾個可確定：
a. 一邊有節點，另一邊沒有節點 => 結構已經不一樣了，所以兩棵樹不同 。
b. 兩邊均無節點 => 結構相同 且沒有子節點，所以這個位置的子樹相同 。
c. 兩邊都有結點 => 檢查值是否相同，相同的話，再檢查左右子樹 。
(也就是回到上一段那邊的2~3)

所以，我們可以用連續呼叫自己這個解題函式的方式來解決這個問題，
其演算方式可以大致列成這樣：

1
2
3
4
5


isSameTree(p, q) {
 若p和q均為NIL，回傳真
 若p或q為NIL，回傳假(因為表示恰有一個是NIL)
 回傳 (p.val==q.val) 且 isSameTree(p.left, q.left) 且 isSameTree(p.right, q.right)
}

注意這樣子的比較，我們每次是先比較根節點 ，再比較左節點 的部分，最後才是比較右節點 ，同時，每次呼叫isSameTree時，會一路往左邊先找下去，直到左子樹找完了才會走訪右子樹的部分，所以順序是根-左-右 ，也就是一般所謂的前序遍歷(Pre-order Traversal)。

這種不斷呼叫自己來求解的方式，我們稱之為遞迴(Recursion，或譯遞歸) ，這樣的解法一般稱為遞迴解(Recursive solution) ，一般來說還會有另一種解法，主要是透過額外的資料結構及迴圈 ，來解決問題，這種方式叫做迭代法/迭代解(Iterative method/Iterative solution) 。比較熟練的讀者若有興趣，可以自行嘗試使用Queue或Deque來解本題看看。

Java

Python的部分，由於NIL是用None來表示，
所以檢查可以用if not的方法來處理，且not運算的優先層級高於and/or ，
所以我們不用額外幫它加括號。

Python

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

「時間複雜度/空間複雜度？」
(如果答案為真的話，那麼每個節點均會走訪一次，故為O(N) )
(空間複雜度的話，遞迴同樣會佔用記憶體空間，層數則取決於樹的層數，
如果是平衡樹(balanced tree)的話，因為分布要平衡(填滿)，
每層的節點數量會是1, 2, 4, 8, 16, …, 總和N=2的n次方-1，n為層數。
所以空間複雜度會是O(logN) ，N為節點的總數。
最差的狀況下，節點全部連在同一邊，那空間複雜度可以達到O(N)。)

「可以不用遞迴解嗎？」
(可以，有興趣的讀者可以嘗試看看，具體方式是使用Queue或Deque，先將兩個根節點放入，接著每次取出一組節點對；先比較節點，再將兩樹其左右node成對地放入裡面 ，重複迴圈，直到有不相等 的狀況產生，或直到Queue/Deque內再無節點 。)

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