BFS on 跟著 Desolve 學程式

從LeetCode學演算法 - 118 DFS (20) /BFS (5) / Queue (6)

Sun, 28 May 2023 00:00:00 +0800

0934. Shortest Bridge (Medium)

寫在前面

(基礎+進階+面試篇)從 LeetCode 學演算法 + 面試成功指南**

(3591元特價中: 2023/06/30 23:59後截止)
https://hiskio.com/bundles/eCP23B397?s=tc

(3990元長期有效) https://bit.ly/lc2022all

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

Question

You are given an n x n binary matrix grid where 1 represents land and 0 represents water.

An island is a 4-directionally connected group of 1’s not connected to any other 1’s. There are ** exactly two islands** in grid.

You may change 0’s to 1’s to connect the two islands to form one island .

Return the smallest number of 0’s you must flip to connect the two islands.

Example 1

1
2


Input: grid = [[0,1],[1,0]]
Output: 1

Example 2

1
2


Input: grid = [[0,1,0],[0,0,0],[0,0,1]]
Output: 2

Example 3

1
2


Input: grid = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
Output: 1

Constraints

n == grid.length == grid[i].length
2 <= n <= 100
grid[i][j] is either 0 or 1.
There are exactly two islands in grid.

分析/解題

給定一個 n x n 的 binary 矩陣 grid，當中 1 代表陸地，0 代表水。
一個 island (島嶼) 的定義是指一組在四個方向和其他的1相連的群組，
且沒有再和其他1相連(也就是中間經過1的都算是同一塊島嶼)。
在 grid 中恰好兩塊島嶼。
你可以將0變成1用來連接兩塊島嶼，以形成一塊島嶼，
試回傳要翻轉0到1使得兩塊島嶼連接的最少所需的數目。

好久不見了！

這題算是比較特別的題目，因為比較好的解法會是DFS和BFS都用上，
一個用來找到第一整塊島嶼，另一個用來連接。

就題目而言，從0翻到1，其實就是一個搭橋的概念，
單就grid上考慮，那麼我們肯定是從兩個島距離最近的點來搭會最好，
但怎麼知道哪兩個點距離最近呢？

如果兩塊島嶼都是完整矩形的話，
或許我們還可以從邊與邊的垂直距離來做文章，
也還有一些比較簡單的計算方法(比如下圖取兩點的垂直+水平距離)
(如果水平或垂直方向有重合的話則只計di或dj)

取最近的兩點垂直距離+水平距離(也有可能其中一個方向不用計)

但.…..它們並不一定是矩形XD"
所以有可能出現像這樣子的狀況，然後旁邊可能全是不規則形狀，
無法用矩形算完：

看圖會知道算哪個點，但究竟要娶幾個點才能算呢？

所以既然無法知道兩塊島嶼長什麼樣子，也不知道規不規則，
那只能回到笨方法了：
先找到其中一塊島嶼，再從這塊島嶼的邊界往外找(搭橋)。

我們嘗試來列出解題步驟：

取得grid的長寬r, c (沒錯，這題其實就算不是正方形的grid應該也可以做)
先遍歷找到grid上任意一個值為1的點(i, j)，
這個點肯定是其中一塊島上的陸地
從(i, j)開始進行DFS往四方探索陸地，同時將所有途經的陸地標為2
(標成2的意義是為了可以和另一塊島嶼的陸地區分開來)；
在步驟3的探索中，如果碰到0時，
把和0相接的陸地座標記到一個queue 裡面
(代表這是第一塊陸地的臨水的邊界)
完成3, 4後，我們會得到一個queue，當中全是第一個島嶼的臨水的邊界 ，
作為我們搭橋的出發點，這裡設定我們要求的答案step為0
當queue中有值的時候，持續操作以下步驟：
取得當前queue的長度L，進行一個L次的迴圈：
從queue中取出一組座標(i, j)
從(i, j)往四個方向看，如果沒有超出grid的話，檢查以下可能：
9-1. 如果值是1，則代表成功接通，這時候直接回傳step作為答案即可
9-2. 如果值是0，則代表繼續搭橋，將新座標放到queue當中，
並且將這個位置的值標為-1(代表已經走過了)
步驟7的迴圈結束後，將step遞增1，接下來回到6檢查是否要繼續
雖然題目設定上一直都是找得到解答的，但如果找不到解答的話，
離開步驟6的迴圈後，則應該要回傳-1，表示找不到能搭建的橋
(也就是grid可能被給成只有一塊土地)

在上面的解題步驟中，步驟34是DFS ，
目的在於要找到第一塊島嶼，記錄邊界，
並將其值改動成2，用來跟第二塊島嶼區別；
而步驟610則是BFS ，
用來從邊界開始往外嘗試搭橋，
因此我們可以在找到連接到第二塊島嶼的時候，
因為一次是每種可能都走一步的特性，確定最小所需的步數，
也就是我們所要求的答案。

依此，寫成程式碼如下。

Python

為求簡單，這邊我們直接將grid改名為A，避免寫太多次。
我們可以利用簡單的dirs串列來標定四個方向，
從而縮減每次寫+1和-1的部分，
這個小技巧應該常碰到類似題目的同學大多看過。
另外，我們使用了一個set start，用來幫我們自動化簡加入的座標，
因為我們有可能加同樣的座標到queue裡面，
使用set可以有效避免這一點。

同時請留意到當A[x][y] == 0的時候，要加入的是(i, j)歐!
因為我們加入的是陸地的邊界(1)，而不是水(0)，
同理，後面起始的時候因為是從陸地開始起算，
所以step是從0而非從1開始。

Java

Java的部分則會稍微麻煩一點，
這邊將大多數的東西放在class variable的位置，
可以有效避免需要大量的傳遞參數；
Queue的部份我們使用ArrayDeque來處理，
那麼對應的取出和放入就會變成poll()和offer()。
(注意每次放入的時候都要產生一個新的int[]來放入)

另一方面，由於HashSet在Java當中用起來比較沒有像Python這麼彈性，
這邊採用visited的方式來處理，
我們將已經放入過q的(i, j)在visited中設定為true，
再每次檢查，即可得到相同效果。
此外，由於Java不接受回傳一個沒有回傳值的function，
因此27和28行會分成兩行來寫，先進行dfs完，再呼叫return。

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

「時間/空間複雜度？」
(O(n²)/O(n²)，在長和寬均為n的狀況下，最多也就是掃完整個grid)

相似及延伸

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

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

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

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

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

從LeetCode學演算法 - 113 BFS (4) / Queue (5)

Tue, 16 Feb 2021 00:00:00 +0800

1091. Shortest Path in Binary Matrix (Medium)

寫在前面

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

(新年優惠套組已截止囉！）

零元求職挑戰賽 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

In an N by N square grid, each cell is either empty (0) or blocked (1).

A clear path from top-left to bottom-right has length k if and only if it is composed of cells C_1, C_2, ..., C_k such that:

Adjacent cells C_i and C_{i+1} are connected 8-directionally (ie., they are different and share an edge or corner)
C_1 is at location (0, 0) (ie. has value grid[0][0])
C_k is at location (N-1, N-1) (ie. has value grid[N-1][N-1])
If C_i is located at (r, c), then grid[r][c] is empty (ie. grid[r][c] == 0).

Return the length of the shortest such clear path from top-left to bottom-right. If such a path does not exist, return -1.

Example 1

1

Input: [[0,1],[1,0]]

1

Output: 2

Example 2

1

Input: [[0,0,0],[1,1,0],[1,1,0]]

1

Output: 4

Note:

1 <= grid.length == grid[0].length <= 100
grid[r][c] is 0 or 1

分析/解題

在一個N x N的平方格子裡，每個格子可能是空的(0)，
不然就是阻塞住的(1)。

一個乾淨的路徑從左上到右下的長度為k，如果路徑上的格子都是8方向(也就是九宮格的對應)相連，且開頭是(0, 0)，結尾是(N-1, N-1)，且每一格都是空的(0)。請回傳從左上到右下最短的乾淨路徑長，若不存在則回傳-1。

這個題目其實可以有很多種不同的解決方式，
不過我們好久沒有使用到BFS了，就來試試看BFS的解法吧！
根據題目的定義，我們要找的是最短路徑，
所以可以從(0, 0)開始嘗試每次往8個方向各走一步，
並且將計數+1及標記已經走過，當在某步碰到了(N-1, N-1)時，
即表示我們找到了最短路徑(因為所有路線都是每次同時走一步)。
因此，我們需要一個Queue來記錄當前所有走到的點，
然後每次再將Queue的點取出，
找到8個方向的新的一步的點，加入到Queue中。
(不能超出邊界，不能已經走過，也不能被阻擋住)

那麼我們怎麼知道同一層的要做到哪裡呢？
很簡單，在這層開始之前，我們先記錄下當前Queue的長度，
這樣子同一層只要做完這麼多個點就可以啦！

依此，寫成程式碼如下：
(下面的程式碼中，我們直接把走過的路徑給標成block了，
這點相對較節省空間也較方便，但其實不是很正規，
如果面試時沒有說你可以動grid，請開出一個N x N的visited格子，
用來記錄有經過的點會比較好呦！)

Java

Java的部分，首先我們先檢查grid的狀況，
以及左上右下是否有阻擋住的狀況，有的話就直接回傳-1。
接著使用LinkedList作為我們的Queue，
可以使用add或者offer來加入新的元素。
當queue不為空時，每次取出一個點，往對應的8個方向取點並檢查：

走到右下角的話代表走完，直接回傳cnt。
如果點是合法的點的話，就將那格標記為1並加入queue中。
每輪做完別忘記將cnt遞增。

全部做完還沒有碰到右下角，代表沒有解，回傳-1。

Python

Python的部分則使用deque來操作，
留意到這個題目其實也可以擴展成矩形，
這邊示範使用r, c的方式來記錄，但其實區別不大。
但對deque來說，取出記得是使用popleft，請不要誤用成pop了！

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

「時間/空間複雜度？」
(O(N²)/O(N²)，最糟糕的狀況是擴散的很開的時候，
queue所需要的空間會很大，這個問題其實可以使用bi-directional的BFS來降低擴散的程度，可以再參考leetcode上別人的解法。)

相似及延伸

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

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

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

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

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

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

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

0112. Path Sum (Easy)

寫在前面

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

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

內容介紹：
這次選了40道難度加深的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學演算法 - 46 BFS (2) / Queue (3)

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

0199. Binary Tree Right Side View (Medium)

另外筆者昨天生日，快補祝我生日快樂XDDDDD

Question

Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example:

1
2
3


Input: [1,2,3,null,5,null,4]
Output: [1, 3, 4]
Explanation:

1
2
3
4
5


 1 <---
 / \
2 3 <---
 \ \
 5 4 <---

分析/解題

給定一棵二元樹，想像你站在樹的右邊往左看，
試回傳從上到下依序所看到的值。

這題一看就知道某種程度上屬於level-order traversal，
(還不清楚或不知道什麼是level-order的讀者請參閱這篇)
只是要求的部分有點不一樣而已，這邊只要求最右邊的數字。

那麼要注意囉！可能會有人想，我能不能只走最右邊 取值就好呢？
答案是當然不行！！！因為你可能會遇到類似這樣的狀況：

你看到的最右邊不是人家的最右邊XD

如果只取最右邊的話，顯然我們會走1-3-0然後就結束了，
但還有一個4落在中間，所以這題無論如何還是要乖乖遍歷所有節點才行。

我們可以用BFS的方式來解這題(DFS也行，但要用到遞迴，這裡暫不討論)，步驟如下：

先新增一個queue用來存放當層(level)的所有節點，
另外開一個串列res(result)用來存放結果。
記錄當下queue的總數cnt(count)。
執行一個cnt次數的迴圈，依序將當層的節點取出
每取出一個節點，就分別檢查其左右節點是否存在，
存在則以先左後右 的順序放入queue中。
迴圈執行完後，queue中應該全是下一層的節點；
同時最後一個取出的節點 ，就是每層最右邊的節點，
將其值取出放入res中。
重複2~5的動作，直到queue中沒有節點為止。

讀者會發現這樣的做法唯一的差別就是要記錄最後一個取出的節點 ，
其他和level-order traversal一樣，利用queue先進先出的原則，
每次恰好處理一層的節點。

依此我們可以寫成程式碼，
Java的部分List和Queue都可以使用LinkedList，
且TreeNode的部分由於Java必須給定值，故一開始last先行給定為null。

Java

Python的部分不要忘記當需要從左邊取值時deque 的速度會較List快，
另外last其實可以不用先給值也可以順利通過。

Python

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

「時間/空間複雜度？」
(O(N), O(N)，每個節點都會遍歷過，
同時因為使用Queue的時候中間會儲存整個level，
空間複雜度還是跟總數相關。)

「可以使用DFS嗎？」
(可以，但需要對每項記錄其level，解法相對較難處理，讀者可嘗試看看)

「如果題目改成從左邊看呢？」
(一樣要遍歷所有節點，但改成在每一層的第一項就將值置入到答案中)

相似及延伸

1.0102. Binary Tree Level Order Traversal

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

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

從LeetCode學演算法 - 43 BFS (1) / Queue (2)

Sat, 31 Aug 2019 00:00:00 +0800

1161. Maximum Level Sum of a Binary Tree (Medium)

Question

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.

Return the smallest level X such that the sum of all the values of nodes at level X is ** maximal**.

Example 1

1
2
3
4
5
6
7


Input: [1,7,0,7,-8,null,null]
Output: 2
Explanation:
Level 1 sum = 1.
Level 2 sum = 7 + 0 = 7.
Level 3 sum = 7 + -8 = -1.
So we return the level with the maximum sum which is level 2.

Note:

The number of nodes in the given tree is between 1 and 10^4.
-10^5 <= node.val <= 10^5

分析/解題

給定一個二元樹的根節點，若將該層(level)稱為1，
其子節點所在層稱為2，……以此類推，
嘗試找出最小的x層，這層的所有節點和是在所有層裡面最大的 。

這題其實存在不同的解法，若讀者有興趣的話也可以使用DFS的解法，
本篇只介紹BFS的作法。

如果有看過先前對於Tree的介紹的話，
我們應該有提到過不同方式的走訪，而這題問的，
如果限定在迭代法解的話，就適合使用層序走訪(level-order traversal) 。
層序走訪的概念很簡單：
每次先走完這一層的所有節點，再走下一層的所有節點 。

用遞迴來看的話顯然是沒辦法的，
因為每次往下都是走往下一層 (左子樹或右子樹)，
所以我們需要用非遞迴的方式，並使用Queue來作輔助。

大概步驟會像這樣子：(下面將Queue命名為q)

將根節點放入q中
當q中有節點時，先求q現在的節點數量cnt
(註：這個節點數量就是目前這整層的所有節點數 )
開始一個迴圈，這個迴圈執行cnt次 :
3-a. 每次從q中取出一個節點n ，並將其值加到當前總和total 中
3-b. 檢查左右節點，如果不是NIL則放進q中
(註：第3步做完以後，
q中前一層的cnt個節點應該已經全數移除，並加入下一層的所有節點)
檢查total是否大於當前的最大總和 ，
若是，則替換掉最大總和 及所求答案的層數
遞增當前的層數(level)
重複2~5的動作，直到q中沒有任何節點為止

由上面的步驟可知，每一次我們均藉由Queue來走遍所有同一層 的節點。
在非樹的題目中，類似的作法是先走所有離自己一步距離的可能，
再往下一層去處理，由於是先求廣度 ，
這樣子的作法我們稱之為廣度優先搜尋(BFS, Breadth-First Search) 。

Java的部分，我們可以使用不同的Queue的實作方式，
讀者可以選用ArrayList, LinkedList或ArrayDeque。
(一般來說ArrayList效率會較差，
有人說ArrayDeque號稱比LinkedList好，
但筆者實測看起來沒有明顯差異XD)

Java的Queue放入和取出的寫法是offer/poll ，總數使用size ，
檢查是否為空則用isEmpty 。

Java

Python的部分則使用前面提過的deque 來處理，
放入和取出分別是append 跟popleft ，總數使用len ，
是否為空則直接拿其本體來判斷 (裡面是空的則會是False )

Python

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

「時間/空間複雜度？」
(O(N), O(N)，因為會遍歷整棵樹，而空間占用最大的時候會占用最下面的一整層，所以最糟的狀況也會是O(N)。)

「題目有告訴我們node總數最大是10^4，如果這棵二元樹是處在平衡的狀態的話，有沒有比較方便的解法？」
(平衡二元樹代表中間該填滿的都填滿了，
所以可以利用這點去算最大的層數，
新增一個陣列/串列來記錄某一層的總和；
直接利用層數來進行DFS，將走到的點的值加到對應的位置，
最後加總完以後再來看哪一個level總和最大。)

「可以用DFS來解這題看看嗎？」
(可以，只是traversal的時候記得要傳遞層數的值，
並且開一個ArrayList/List來存放每層的總和。)

相似及延伸

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

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