718 - LeetCode Tree on 嗡嗡的隨手筆記

【Leetcode】python - [543] Diameter of Binary Tree 個人解法筆記

Tue, 21 Jun 2022 01:43:54 +0800

題目出處

543. Diameter of Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Binary Tree

2022-06-21 一刷

個人範例程式碼 - 一刷 (2022/06/21)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:

        return self.helper(root)[0]

    def helper(self, root):
        # end of recursion
        if not root:
            return 0, 0

        # define and split
        left_longest, left_diameter = self.helper(root.left)
        right_longest, right_diameter = self.helper(root.right)

        longest = max(left_longest, right_longest, left_diameter + right_diameter)
        diameter = max(left_diameter, right_diameter) + 1

        return longest, diameter

算法說明

我們先來理解題意，這題目主要是在詢問在 Tree 中「最長可組成的邊 (diameter)」，
主要有兩種情況：

最長邊包含 root
最長邊不包含 root (最長存在子樹中)

因此我們需要同時記錄「子樹中，目前最長」與「目前最長的邊」。

目前最長的邊 + 1 = 向上一層的最長邊

input handling

在 dfs 內處理

Boundary conditions

在 dfs 內控制範圍，如果搜尋至 root = None，return 0, 0

Reference

二叉树的直径 · Diameter of Binary Tree

【Leetcode】python - [110] Balanced Binary Tree 個人解法筆記

Mon, 20 Jun 2022 17:24:02 +0800

題目出處

110. Balanced Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Binary Tree

2022-06-20 一刷

個人範例程式碼 - 一刷 (2022/06/20)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.isBalanced_and_get_height(root)[0]


    def isBalanced_and_get_height(self, root):        
        # end of recursion
        if not root:
            return True, 0

        # split
        left_is_balanced, left_height = self.isBalanced_and_get_height(root.left) 
        right_is_balanced, right_height = self.isBalanced_and_get_height(root.right)

        # define
        if not (left_is_balanced and right_is_balanced):
            return False, -1

        if abs(left_height - right_height) > 1:
            return False, -1

        return True, max(left_height, right_height)+1

算法說明

正常直接的想法是，我們的「所有子樹都必須要是 balanced」，
因此直覺會需要 recursion。

但因為要決定這個結果，我們還需要知道「當前子樹的最大高度」，
設計時，我們可以同時回傳「子樹的答案」+「當前子樹的最大高度」

input handling

一同在 dfs 內處理

Boundary conditions

如果沒有 root，結束遞迴

Reference

平衡二叉树 · Balanced Binary Tree

【Leetcode】python - [692] Top K Frequent Words 個人解法筆記 | 內含自定義排序 key function 的使用方法

Fri, 10 Jun 2022 02:00:44 +0800

題目出處

692. Top K Frequent Words

難度

medium

題目分類

Array, Hash Table, String, Trie, Sorting, Heap (Priority Queue), Bucket Sort, Counting

2022-06-10 一刷

個人範例程式碼 - 單 hashtable + 自定義排序 key function

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

        word_list = [(word, cnt) for word, cnt in word_to_counter.items()]
        word_list.sort(key = self.key_function)

        return [word_list[i][0] for i in range(k)]

    def key_function(self, word_tuple):
        # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)         
        # second compare: word alphabetically first (lexicographical)
        word, cnt = word_tuple
        return (-cnt, word)

return 那行使用的 list comprehension，同義於下方程式碼

return 那行優化後，我才寫成上面一行的形式，
原本的內容長下面那樣，
基本上面試時，建議以自己較能掌握的穩定寫法為主。

ans = []
for i in range(k):    
    ans.append(word_list[i][0])

return ans

算法說明

另外一個方法是我們一樣用 hashtable 先把所有數量都數出來，
可以想像做我們把所有的 word 變成 (word, count) 的形式，
再來我們要使用自定義排序，排成我們要的順序。

自定義排序 key function

一般來說，sort 都是幫我們單純直接照「數字大小排序」或是「照字母大小排序」，
但在這題目當中，我們需要同時「先考慮數字大小，再考慮字母順序」，
因此這樣的情況我們需要去特別定義排序的規則。

我們可以自己寫一個 key_fuction 給 key 去使用，
回傳一個 tuple 給 key 參考，
依照 tuple 的順序，就是我們比較的順序。

依照題目要的，數量越大的排序要越前面，因此我們排序結果應該要是
「5,4,3,2,1」(反序)，再來「照字母順序 a,b,c 排」(升序)
相對簡單的處理方式是，我們就直接讓數字前面加一個「負號」，
這樣「-5,-4,-3,-2,-1」就是升序的排列了!

因此我們回傳 (-cnt, word) 作為我們排序的依據。

word_list.sort(key = self.key_function)

def key_function(self, word_tuple):
    # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)
    # second compare: word alphabetically first (lexicographical)
    word, cnt = word_tuple
    return (-cnt, word)

input handling

Boundary conditions

用 for 來控制範圍

個人範例程式碼 - 雙 hashtable 紀錄 word_to_counter, counter_to_word

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

            current_word_count = word_to_counter[word]
            if current_word_count > 1: # existed word
                counter_to_word[current_word_count-1].remove(word)
            counter_to_word[current_word_count].append(word)

        # O(nlogN)
        counter_keys = sorted(counter_to_word.keys(), reverse=True)

        ans = []
        cnt = 0

        for key in counter_keys:
            if cnt >= k:
                break
            ans += sorted(counter_to_word[key])
            cnt += len(counter_to_word[key])

        return ans[:k]

算法說明

第一次看到這題目，想說都要計數了，然後還要排序，直覺就想說用兩個 hashtable，
分別存 word_to_counter, counter_to_word，
當存到 k 個的時候，就輸出結果。

但我們要注意，這題目有特別說明，取前 k 的時候，「有可能同數量，這時候我們就照字母順序取」

input handling

Boundary conditions

用 for 來控制範圍

Reference

最高频的K个单词 · Top K Frequent Words

【Leetcode】python - [103] Binary Tree Zigzag Level Order Traversal 個人解法筆記

Tue, 07 Jun 2022 18:42:04 +0800

題目出處

103. Binary Tree Zigzag Level Order Traversal

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-06-07 一刷

個人範例程式碼 - 一刷 (2022/06/07)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []

        ans = []
        this_layer = [root]
        reverse_flag = False

        while this_layer:
            this_layer_ans = []
            next_layer = []
            for node in this_layer:
                this_layer_ans.append(node.val)

                if node.left:
                    next_layer.append(node.left)
                if node.right:
                    next_layer.append(node.right)

            if reverse_flag:
                this_layer_ans.reverse()

            ans.append(this_layer_ans[:]) # deepcopy
            this_layer = next_layer
            reverse_flag = not reverse_flag

        return ans

算法說明

類似 level order traversal 的邏輯，只不過在 zigzag 中我們要做的是間隔 layer 反轉輸出的結果。

至於要反轉的話，加一個反轉 flag 即可輕鬆完成

input handling

如果沒有 root，return []

Boundary conditions

透過 layer 一層一層循環，直到下一層 layer 無東西為止。

Reference

Python List reverse()

【Leetcode】python - [572] Subtree of Another Tree 個人解法筆記

Mon, 06 Jun 2022 18:21:27 +0800

題目出處

572. Subtree of Another Tree

難度

easy

題目分類

Tree, Depth-First Search, String Matching, Binary Tree, Hash Function

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        # end of recursion
        if not root:
            return False

        # define
        if self.is_same_tree(root, subRoot):
            return True

        # split
        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

    def is_same_tree(self, root, subroot):
        # end of recursion
        if not root and not subroot:
            return True

        if not root or not subroot: # only one side left
            return False

        if root.val != subroot.val: 
            return False

        return self.is_same_tree(root.left, subroot.left) and self.is_same_tree(root.right, subroot.right)

算法說明

原本的 is_sub_tree，就已經可以幫助我們把大題目拆成小題目了，
我們只需要再多補上一個，比較兩個 tree 是否相同的函數即可。

input handling

if not root，return False (上層只要有一次 True 即可，因此用 or 比較其他答案)

Boundary conditions

用 not root，來判斷 Tree 的結尾。

Reference

另一个树的子树 · Subtree of Another Tree

【Leetcode】python - [226] Invert Binary Tree 個人解法筆記

Mon, 06 Jun 2022 16:57:53 +0800

題目出處

226. Invert Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left

        return root

算法說明

單純的一路一直把左右交換就好，
把題目切分成「更小的子樹，也需做一樣的事情」。

input handling

if not root (None)，直接 return root (None)

Boundary conditions

一路 DFS Tree 直到底部，中間過程 swap 「left, right」

Reference

【Leetcode】python - [105] Construct Binary Tree from Preorder and Inorder Traversal 個人解法筆記

Mon, 30 May 2022 03:40:04 +0800

題目出處

105. Construct Binary Tree from Preorder and Inorder Traversal

難度

medium

題目分類

Array, Hash Table, Divide and Conquer, Tree, Binary Tree

2022-05-30 一刷

個人範例程式碼 - 一刷 (2022/05/30)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder or not inorder:
            return None

        # preorder (M) L R
        # inorder L (M) R
        # use preorder get first node

        val = preorder[0] #  pre  [(3),9,20,15,7], [(20),15,7]
        root = TreeNode(val) 
        root_idx = inorder.index(val) # in [9,(3),15,20,7], [15,(20),7]]

        # preorder[1:root_idx+1] del first, inorder[:root_idx]) del idx
        root.left = self.buildTree(preorder[1:root_idx+1], inorder[0:root_idx]) 

        # preorder[root_idx+1:], inorder[root_idx+1:]) del idx
        root.right = self.buildTree(preorder[root_idx+1:], inorder[root_idx+1:])

        return root

算法說明

看似複雜的問題，其實我們可以從「拆成很多子問題下手」，

有上面的觀念之後，看來就是 recursion 的回合了！

我們決定好怎麼定義我們的左右子樹，

root.left 的部分

我們直接拿題目來分析，

preorder 我們先拿了第一個，作為我們的 root [(3),9,20,15,7]，
之後我們要去找，有多少東西在左樹內，
我們需要去 inorder 找所有 root 左側的內容，

root_idx = inorder.index(val) # inorder [9,(3),15,20,7]

因此我們知道左側的 inorder 範圍：
inorder[:root_idx])，我們刪除已經被我們當 root 的點，位於 idx

而左側的 preorder 範圍：
我們必須刪除第一個點，因為他是我們的 root，剩下的範圍會到 root，
(取範圍時要注意取到 idx+1，才會是到「包含」 idx 的範圍)，
因此，preorder 我們取 preorder[1:root_idx+1]

合併後得到 root.left = self.buildTree(preorder[1:root_idx+1], inorder[0:root_idx])

root.right 的部分

右側的部分稍微簡單一點，在上方取得 idx 後，我們後面的範圍都是 right 的範圍了。

一樣以題目來舉例：

preorder [(3),9,20,15,7]
inorder [9,(3),15,20,7]

inorder idx 3 以後的內容，都會是我們右子樹的內容，包含 preorder 範圍也是如此。

因此我們得到 root.right = self.buildTree(preorder[root_idx+1:], inorder[root_idx+1:])

input handling

處理沒有 input 的情況，return None
或是處理只有一個值的情況 [-1]，return [-1]

Boundary conditions

用 not list 來控制範圍，表示已經沒有內容物

Reference

前序遍历和中序遍历树构造二叉树 · Construct Binary Tree from Preorder and Inorder Traversal

【Leetcode】python - [222] Count Complete Tree Nodes 個人解法筆記

Sat, 28 May 2022 20:50:20 +0800

題目出處

222. Count Complete Tree Nodes

難度

medium

題目分類

Binary Search, Bit Manipulation, Tree, Binary Tree

2022-05-28 一刷

個人範例程式碼 - 一刷 (2022/05/28)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0

        left_depth = self.get_depth(root.left)
        right_depth = self.get_depth(root.right)

        if left_depth == right_depth: # (left completed)
            return 1 + (2**left_depth - 1) + self.countNodes(root.right)
        else: # left_depth > right_depth (right completed)
            return 1 + (2**right_depth - 1) + self.countNodes(root.left)

    def get_depth(self, root):
        if not root:
            return 0

        return 1 + self.get_depth(root.left)

算法說明

拆成兩路進行，兩路我們都直接找「最左下」，比較兩者的深度，此時會有兩種情況

當左右，表示左邊一定是 completed binary tree
當左 > 右，表示右邊一定是 completed binary tree

因此，我們簡略圖示一下，當「左右」，左邊一定是 completed

當「左 < 右」，右邊一定是 completed

我們可以搭配「2**depth -1」快速計算出 completed tree 的總 node 數。

input handling

處理沒有 root 的情況，return 0

Boundary conditions

用「not root」去控制 traverse tree 的結束。

Reference

统计完全树节点数 · Count Complete Tree Nodes

【Leetcode】python - [98] Validate Binary Search Tree 個人解法筆記

Tue, 10 May 2022 22:24:51 +0800

題目出處

98. Validate Binary Search Tree

難度

medium

題目分類

Tree, Depth-First Search, Binary Search Tree, Binary Tree

2022-05-10 一刷

個人範例程式碼 - DFS

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        return self.dfs(root, float("-inf"), float("inf"))

    def dfs(self, root, lowerbound, upperbound):
        # end of recursion
        # define and split
        ans = True
        if root.left: # left: update upperbound
            if lowerbound < root.left.val < root.val: 
                ans &= self.dfs(root.left, lowerbound, root.val) 
            else:
                return False

        if root.right: # right: update lowerbound
            if root.val < root.right.val < upperbound:
                ans &= self.dfs(root.right, root.val, upperbound)
            else:
                return False

        return ans

算法說明

DFS 中，我們需要特別注意 BST 的特性，也就是他上下的範圍，常見錯誤如下

如果「只注意他與上層的關係」，會出現下圖中「三角形的錯誤」，因此我們需要同時考慮上下界

然而，在 BST 中處理上下界並不難，上下界的特性也十分容易分析。
我們只需要注意兩個重點：

往左走時：更新 upperbound
往右走時：更新 lowerbound

見下圖：

input handling

同 DFS 一起處理

Boundary conditions

每個點都必須同時界於 lowerbound ~ upperbound，不然 return False

個人範例程式碼 - inorder traversal

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True

        stack = []
        node = root
        # 1. to left bottom
        while node:
            stack.append(node)
            node = node.left

        ans = []
        # 2. pop right, see right, to left bottom
        while stack:
            node = stack.pop(-1)
            ans.append(node.val)
            if node.right:
                node = node.right
                while node: # to left bottom
                    stack.append(node)
                    node = node.left

        # print(ans)
        # return ans == sorted(ans)
        for i, num in enumerate(ans):
            if i > 0 and ans[i-1] >= ans[i]:
                return False

        return True

算法說明

直接用 inorder traversal 把整個順序列出來，然後再依序比較後者必須比前者大。

input handling

如果沒有 root，return 0

Boundary conditions

inorder traversal 的 stack 流派

使用 stack

左到底
pop，找右一個，然後一樣往左邊底

在 pop 時紀錄，就會得到最終答案。

Reference

验证二叉查找树 · Validate Binary Search Tree

【Leetcode】python - [100] Same Tree 個人解法筆記

Tue, 10 May 2022 21:11:47 +0800

題目出處

100. Same Tree

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-05-10 一刷

個人範例程式碼 - 一刷 (2022/05/10)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        return self.dfs(p, q)

    def dfs(self, p, q):
        # end of recursion
        if not p and not q:
            return True
        if not p or not q: 
            return False

        # define
        if p.val == q.val: # True
            # split
            return self.dfs(p.left, q.left) and self.dfs(p.right, q.right)
        else:
            return False

算法說明

基本的 Tree traverse 變形，用 dfs 實作。

input handling

一同在 dfs 內部處理

Boundary conditions

dfs 結束條件

正確結束:

if not p and not q, return True

錯誤情況:

not p 但還有 q，或相反，return False
p.val 不等於 q.val，return False

Reference

Shortest+simplest Python

【Leetcode】python - [2261] K Divisible Elements Subarrays 個人解法筆記 | 291th LeetCode Weekly Contest (內含 substring 常見作法)

Tue, 03 May 2022 02:09:01 +0800

題目出處

2261. K Divisible Elements Subarrays

難度

medium

題目分類

Array, Hash Table, Trie, Rolling Hash, Hash Function, Enumeration

2022-05-03 一刷

個人範例程式碼 - 同向 two pointers, 正三角

class Solution:
    def countDistinct(self, nums: List[int], k: int, p: int) -> int:
        self.ans = set()

        # decide start (one side)
        for i in range(len(nums)):
            self.dfs(nums, i, i, k, p) # decide end

        # print(self.ans)
        return len(self.ans)

    def dfs(self, nums, start, end, k, p):
        # end of recursion
        if end >= len(nums):
            return

        # define
        if nums[end] % p == 0:
            k -= 1
        if k < 0:
            return
        self.is_valid_ans(nums, start, end, k, p)

        # split
        self.dfs(nums, start, end+1, k, p)

    def is_valid_ans(self, nums, start, end, k, p):            
        if k < 0:
            return

        subset = tuple(nums[start:end+1]) # start~end
        # print(subset, k)
        if subset in self.ans:
            return
        else:
            self.ans.add(subset)

算法說明

用 dfs 搭配同向的 two pointers 控制頭尾(dfs 控制尾巴移動)，組出全部的結果。

input handling

x (題目沒有特別要求要處理)

Boundary conditions

控制 recursion 結束條件 if end >= len(nums)

個人範例程式碼 - 反向 two pointers, 反三角

class Solution:
    def countDistinct(self, nums: List[int], k: int, p: int) -> int:
        self.ans = set()

        # decide start (one side)
        for i in range(len(nums)-1, -1, -1):
            self.dfs(nums, i, i, k, p) # decide end

        # print(self.ans)
        return len(self.ans)

    def dfs(self, nums, start, end, k, p):
        # end of recursion
        if start < 0:
            return

        # define
        if nums[start] % p == 0:
            k -= 1
        if k < 0:
            return
        self.is_valid_ans(nums, start, end, k, p)

        # split
        self.dfs(nums, start-1, end, k, p)

    def is_valid_ans(self, nums, start, end, k, p):            
        if k < 0:
            return

        subset = tuple(nums[start:end+1]) # start~end
        # print(subset, k)
        if subset in self.ans:
            return
        else:
            self.ans.add(subset)

算法說明

用 dfs 搭配反向的 two pointers 控制頭尾(dfs 控制頭移動)，組出全部的結果。

input handling

x (題目沒有特別要求要處理)

Boundary conditions

控制 recursion 結束條件 if start < 0

Reference

[Python3] DFS

【Leetcode】python - [212] Word Search II 個人解法筆記

Wed, 27 Apr 2022 04:00:00 +0800

題目出處

LeetCode 版本，標準非常高，基本上沒實作出 Trie 一定 TLE： [212. Word Search II](https://leetcode.com/problems/word-search-ii/)

LintCode 版本，基本版先通過這個就好 (本文的內容)： [132 · Word Search II](https://www.lintcode.com/problem/132/)

難度

hard

題目分類

Array, String, Backtracking, Trie, Matrix

2022-04-27 一刷

個人範例程式碼 - 一刷 (2022/04/27)

from typing import (
    List,
)

DIRECTIONS = [
    (1, 0),
    (0, 1),
    (-1, 0),
    (0, -1) 
]

class TrieNode():
    def __init__(self):
        self.children = {}
        self.isWord = False

class Trie():
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for c in word:
            if c not in node.children:
                node.children[c] = TrieNode()
            node = node.children[c]
        node.isWord = True

    def search(self, word):
        node = self.root
        for c in word:
            if c in node.children:
                node = node.children[c]
            else:
                return False
        return node.isWord

    def startswith(self, prefix):
        # print(prefix)
        node = self.root
        for c in prefix:
            if c in node.children:
                node = node.children[c]
            else:
                return False
        return True

class Solution:
    """
    @param board: A list of lists of character
    @param words: A list of string
    @return: A list of string
    """
    def word_search_i_i(self, board: List[List[str]], words: List[str]) -> List[str]:
        if not board:
            return []

        # self.prefix_set = self.make_prefix_set(words)
        self.trie = Trie()
        for word in words:
            self.trie.insert(word)
        self.ans = []


        for x in range(len(board)):
            for y in range(len(board[0])):
                self.dfs(board, words, x, y, set(), "")

        return self.ans        


    def dfs(self, board, words, x, y, visited, prefix):
        # print(prefix)
        # end of recursion
        if not words: # all finished
            return

        if prefix in words:
            self.ans.append(prefix[:])
            words.remove(prefix[:]) # prevent duplicate

        # if prefix != "" and prefix not in self.prefix_set:
        if prefix != "" and not self.trie.startswith(prefix):
            return 


        # define and split
        if not self.is_in_bound(x, y, board):
            return 

        if (x,y) in visited:
            return 

        visited.add((x, y))
        for dx, dy in DIRECTIONS:
            self.dfs(board, words, x+dx, y+dy, visited, prefix+board[x][y])
        visited.remove((x, y)) # backtracking


    def is_in_bound(self, x, y, board):
        m, n = len(board), len(board[0])
        return 0 <= x < m and 0 <= y < n

# def make_prefix_set(self, words)
#         prefix_set = set()
# for word in words
# for i in range(len(word))
#                 prefix_set.add(word[:i+1])

#         return prefix_set

算法說明

此題目的前一題為「單純找一個單字」就好，並只需要回傳 True/False，可參考：

https://wongwongnotes.com/posts/algorithm-practice/search-algorithms/dfs/leetcode-python-79/

非常難的題目，最主要難的點是在會 TLE 的部分，特別是 LeetCode 設定的標準，
對使用 python 而言非常的嚴苛。

最主要是實作 Trie 的內容與矩陣的四方向移動，
在矩陣的四方向移動，可以先參考以下比較簡單的題目：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-54/

注意：可繼續搜尋的項目

例如： [“app”, “apple”]，不能搜尋到 app 就 return，會找不到 apple

input handling

當沒有 matrix 時，return []

Boundary conditions

用 Trie 判斷全部搜尋結果是很簡單的，只是需要各種的搶時間以避免 TLE。

Reference

這邊我試跑 Leetcode 其他人的解答也幾乎都 TLE…，這 Leetcode 標準到底設定有多硬…

【Leetcode】python - [208] Implement Trie (Prefix Tree) 個人解法筆記

Tue, 26 Apr 2022 03:48:14 +0800

題目出處

208. Implement Trie (Prefix Tree)

難度

medium

題目分類

Hash Table, String, Design, Trie

2022-04-26 一刷

個人範例程式碼 - 一刷 (2022/04/26)

class TrieNode:
    def __init__(self):
        self.children = {}
        self.hasword = False # only True if exist word, 
        # apple in dict, but app not in, False

class Trie:

    def __init__(self):
        self.root = TrieNode()        

    def insert(self, word: str) -> None:
        cur = self.root
        for c in word:
            if c not in cur.children:
                cur.children[c] = TrieNode()
            cur = cur.children[c]                
        cur.hasword = True

    def search(self, word: str) -> bool:
        cur  = self.root
        for c in word:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return cur.hasword


    def startsWith(self, prefix: str) -> bool:
        cur = self.root
        for c in prefix:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return True

# Your Trie object will be instantiated and called as such
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

算法說明

資料結構設計類型的題目，考的就是設計資料結構的能力，比較難。
這邊要實作的有三個功能，startsWith, search, insert，

我們先來了解 Trie (字典樹)

Trie (字典樹) 是用來特化搜尋「前綴文字 Prefix」用的資料結構，
特色就是我們把每個單字建成一個樹狀，而當我們搜尋一個前綴字時，能夠快速順著字典往下，

一個 TrieNode 會有，

childrens：紀錄往下的字母

hasword：到此本身是否有這個文字

特別注意 hasword 的功能，例如 apple 在字典中，
但沿著路徑我們會搜尋到 app，為了反映 app 這個字不屬於字典的字，
我們用 hasword 來記錄這個點。(apple 紀錄在 e 上，app 如果有，會記錄在最後一個 p 上。)

Trie (字典樹) 範例圖

input handling

Boundary conditions

注意搜尋的過程中，有時候可以有搜尋到路徑，但實際上沒有那個文字，所以我們會需要 hasword 這個 bool，
例如我們有 apple 在 Trie 中，
沿路會看到 app，但不表示搜尋到 app 就有 app 這個字。

Reference

实现 Trie（前缀树） · Implement Trie (Prefix Tree)

【Leetcode】python - [140] Word Break II 個人解法筆記

Sat, 23 Apr 2022 19:55:23 +0800

題目出處

140. Word Break II

難度

hard

題目分類

Array, Hash Table, String, Dynamic Programming, Backtracking, Trie, Memoization

2022-04-23 一刷

個人範例程式碼 - 一刷 (2022/04/23)

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
        if not s:
            return []

        self.memo = {}
        return self.dfs(s, wordDict)

    def dfs(self, s, word_dict):
        if s in self.memo:
            return self.memo[s]

        # end of recursion
        if len(s) == 0:
            return []

        # define and split
        partitions = []

        # full match
        if s in word_dict:
            partitions.append(s)

        # part match
        for idx in range(0, len(s)):
            prefix = s[:idx+1] # 0 to idx
            # print(prefix)
            if prefix not in word_dict:
                continue

            sub_partitions = self.dfs(s[idx+1:], word_dict) # start from idx+1
            for partition in sub_partitions:
                partitions.append(prefix + " " + partition)

        self.memo[s] = partitions
        return partitions

算法說明

此題的前一題，只需要判斷可不可行就好，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-139/

這題可以先嘗試寫一個基本的版本，用 dfs 搜索出全部的結果，
這題很佛心不會 TLE，但真的很慢XDDD

思考方式為用一個 start 作為 pointer，切出「到目前為止之前的全部內容」

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
        if not s:
            return False

        self.ans = []
        self.dfs(s, 0, wordDict, [])
        return self.ans

    def dfs(self, s, start, word_dict, prefix_words):

        # end of recursion
        if start > len(s):
            return
        if start == len(s):
            self.ans.append(" ".join(prefix_words))
            return 

        # define and split
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                prefix_words.append(prefix)
                self.dfs(s, idx+1, word_dict, prefix_words)
                prefix_words.pop() # backtracking
            else:
                continue
        return

記憶化搜索 memoization 加速

加速的思路，是來自我們思考每次在遞迴的過程中，
最終都會有一段處理相同文字的過程。
(可以想像，每次的開頭不同時，結尾我們都在反覆處理一樣的東西)

因此我們用一個 memo 紀錄一下，紀錄「相同的文字」，我們上次處理的結果

input handling

當沒有 s 時，return []

Boundary conditions

搜尋至 start = len(s) 時，剛好抵達結束搜尋的範圍 (其他狀況應該是無法抵達的)

Reference

单词拆分II · Word Break II

【Leetcode】python - [139] Word Break 個人解法筆記

Sat, 23 Apr 2022 19:05:13 +0800

題目出處

139. Word Break

難度

medium

題目分類

Array, Hash Table, String, Dynamic Programming, Trie, Memoization

2022-04-23 一刷

個人範例程式碼 - 一刷 (2022/04/23)

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        if not s:
            return False

        self.memo = {}
        return self.dfs(s, 0, wordDict)

    def dfs(self, s, start, word_dict):
        if start in self.memo:
            return self.memo[start]

        # end of recursion
        if start > len(s):
            return False
        if start == len(s):
            return True

        # define and split
        ans = False
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                ans = ans or self.dfs(s, idx+1, word_dict) 
            else:
                continue

        # Memoization search
        self.memo[start] = ans        
        return ans

算法說明

這題可以先嘗試寫一個基本的版本，能夠通過大部分的 case，但是會 TLE

思考方式為用一個 start 作為 pointer，指出「到目前為止之前的全部內容」

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        if not s:
            return False

        return self.dfs(s, 0, wordDict)

    def dfs(self, s, start, word_dict):

        # end of recursion
        if start > len(s):
            return False
        if start == len(s):
            return True

        # define and split
        ans = False
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                ans = ans or self.dfs(s, idx+1, word_dict) 
            else:
                continue

        return ans

上面的方法基本沒有太大問題，只是速度太慢而已，此時我們可以用記憶化搜索的方式加速

記憶化搜索 memoization 加速

加速的思路，是來自我們思考每次在遞迴的過程中，
最終都會有一段處理相同結尾的過程。
(可以想像，每次的開頭不同時，結尾我們都在反覆處理一樣的東西)

因此我們用一個 memo 紀錄一下，「從 start 開始往後」的結果，在之前的判斷中，答案為 True or False

input handling

當沒有 s 時，return False

Boundary conditions

搜尋至 start > len(s) 時，超過結果，為 False
搜尋至 start len(s) 時，剛好結束，為 True

Reference

单词拆分（一） · Word Break

【Lintcode】python - [901] Closest Binary Search Tree Value II 個人解法筆記 #綜合難題

Fri, 22 Apr 2022 17:06:02 +0800

題目出處

901 · Closest Binary Search Tree Value II

難度

hard

題目分類

Two Pointers, Stack, Tree, Depth-First Search, Binary Search Tree, Heap (Priority Queue), Binary Tree

2022-04-22 一刷

個人範例程式碼 - 一刷 (2022/04/22)

from typing import (
    List,
)
from lintcode import (
    TreeNode,
)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the given BST
    @param target: the given target
    @param k: the given k
    @return: k values in the BST that are closest to the target
             we will sort your return value in output
    """
    def closest_k_values(self, root: TreeNode, target: float, k: int) -> List[int]:
        if not root or k == 0:
            return []

        # write your code here
        lower_stack = self.get_stack(root, target) # init to found target
        upper_stack = list(lower_stack)

        # delete duplicate closest element, change wrong lower[-1] or upper[-1]
        if lower_stack[-1].val < target:
            self.move_upper(upper_stack)
        else:
            self.move_lower(lower_stack)

        ans = []
        for i in range(k):
            if self.is_lower_closer(lower_stack, upper_stack, target):
                ans.append(lower_stack[-1].val)
                self.move_lower(lower_stack)
            else:
                ans.append(upper_stack[-1].val)
                self.move_upper(upper_stack)
        return ans

    def is_lower_closer(self, lower_stack, upper_stack, target):
        if not lower_stack: # has nothing
            return False
        if not upper_stack:
            return True

        return target - lower_stack[-1].val < upper_stack[-1].val - target

    def move_lower(self, stack):
        if stack[-1].left: # has left, move to the right bottom
            node = stack[-1].left
            while node:
                stack.append(node)
                node = node.right
        else: # no left, move to the first turn right parent
            node = stack.pop()
            while stack and stack[-1].left == node:
                node = stack.pop()

    def move_upper(self, stack):
        if stack[-1].right: # has right, move to the left bottom
            node = stack[-1].right
            while node:
                stack.append(node)
                node = node.left
        else: # no right, move to the first turn left parent
            node = stack.pop()
            while stack and stack[-1].right == node:
                node = stack.pop()

    def get_stack(self, root, target):
        stack = []
        while root:
            stack.append(root)
            if target <= root.val:
                root = root.left
            else:
                root = root.right

        return stack

算法說明

BST iteration 集大成的最難題目，能考的都考了。

這題最難的部分在於實作 iteration (當然，要重新 traverse 絕對是更簡單的方法，不過速度上會慢)，

分成兩種狀況討論：

往更小「一個」移動
往更大「一個」移動

往更小「一個」移動

說到小，就先想到 left

這裡又分成兩種情況，

如果有 left，往 left 的最右底點移動 (才會是「第一個」更小)
如果沒有 left，找第一個 edge 右彎的 parent

看不懂就看下圖可能會比較好懂… 一點點XD

往更大「一個」移動

說到大，就先想到 right

這裡又分成兩種情況，

如果有 right，往 right 的最左底點移動 (才會是「第一個」更大)
如果沒有 right，找第一個 edge 左彎的 parent

看不懂就看下圖可能會比較好懂… 一點點XD

input handling

當 k = 0 或是沒有 root 時，return []

Boundary conditions

見上述說明

Reference

二叉搜索树中最接近的值 II · Closest Binary Search Tree Value II

【Lintcode】python - [900] Closest Binary Search Tree Value 個人解法筆記

Fri, 22 Apr 2022 13:33:30 +0800

題目出處

900 · Closest Binary Search Tree Value

難度

easy

題目分類

Binary Search, Tree, Depth-First Search, Binary Search Tree, Binary Tree

2022-04-22 一刷

個人範例程式碼 - 一刷 (2022/04/22)

from lintcode import (
    TreeNode,
)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the given BST
    @param target: the given target
    @return: the value in the BST that is closest to the target
    """
    def closest_value(self, root: TreeNode, target: float) -> int:
        # write your code here
        if not root:
            return -1

        upper = float("inf")
        lower = float("-inf") 

        stack = collections.deque([root])
        while stack:
            node = stack.pop()
            if node.val > target:
                upper = min(node.val, upper)
                if node.left:
                    stack.append(node.left)
            elif node.val < target:
                lower = max(node.val, lower)
                if node.right:
                    stack.append(node.right)
            else: # same value
                return node.val

        return upper if (upper - target < target - lower) else lower

算法說明

算是考 BST 的基本定義，這邊可以用圖來說明一下發生的現象。

由圖上我們可以發現隨著搜尋過程中，target 區間正在不斷的縮小，此題就是利用這個特性。

input handling

root 沒東西時，回傳 -1

Boundary conditions

搜尋到沒有東西，或是搜尋到「等於 target (必定為最近)」，直接 return 了

Reference

二叉搜索树中最接近的值 · Closest Binary Search Tree Value

【Leetcode】python - [173] Binary Search Tree Iterator 個人解法筆記 #重要題型

Fri, 22 Apr 2022 12:43:34 +0800

題目出處

173. Binary Search Tree Iterator

難度

medium

題目分類

Stack, Tree, Design, Binary Search Tree, Binary Tree, Iterator

2022-04-22 二刷

個人範例程式碼 - 2022/4/22 版本 (優化版)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class BSTIterator:

    def __init__(self, root: Optional[TreeNode]):
        self.stack = []
        self.to_left_bottom(root)

    def next(self) -> int:
        node = self.stack.pop()
        if node.right is not None:
            node_right = node.right
            self.to_left_bottom(node_right) 
        return node.val

    def hasNext(self) -> bool:
        return len(self.stack) > 0

    def to_left_bottom(self, root):
        while root:
            self.stack.append(root)
            root = root.left

# Your BSTIterator object will be instantiated and called as such
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

算法說明

思路來源

與之前的相比，優化了 stack 的使用，不使用 top 的功能，只使用 pop 使程式碼更簡潔。

一樣保持往左走到底的觀念，不過這次我們不扣住頂端，這樣的好處是 pop 會直接回到頂端不用再用另外一個 while loop 檢查，
而只要發現能往右走，就往右走「一步」，然後依然「往左走到底」

input handling

Boundary conditions

當 stack 為空時，結束迴圈

2022-04-21 一刷

個人範例程式碼 - 2022/4/21 版本

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class BSTIterator:

    def __init__(self, root: Optional[TreeNode]):
        self.stack = []
        self.to_left_bottom(root)

    def next(self) -> int:
        cur = node = self.stack[-1]
        if node.right is not None:
            node = node.right
            self.to_left_bottom(node) # do not pop parent
        else:
            node = self.stack.pop()
            while self.stack and self.stack[-1].right == node: # until parent's right = n, next node = parent
                node = self.stack.pop()

        return cur.val

    def hasNext(self) -> bool:
        return len(self.stack) > 0


    def to_left_bottom(self, root):
        while root:
            self.stack.append(root)
            root = root.left




# Your BSTIterator object will be instantiated and called as such
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

算法說明

這題考的是程式設計，很多設計上的細節需要注意。

而大方向如下：

- 當到達一個新 node 時，往左邊存 stack 直到底 - 每 pop 一個 node 時，先檢查有沒有右側，有的話一樣往右做 1 (此 node 於 stack 尚未 pop)，沒有的話做 3 - 當已經找不到右邊時，下一個節點位於「一路 pop，直到 parent.right != node」(往右走的路都退回，找第一個左彎的點)，然後他的 parent 就是我們要的下一個 node

input handling

Boundary conditions

當 stack 為空時，結束迴圈

Reference

【Lintcode】python - [448] Inorder Successor in BST 個人解法筆記

Fri, 22 Apr 2022 03:09:03 +0800

題目出處

448 · Inorder Successor in BST

難度

medium

題目分類

Tree, Depth-First Search, Binary Search Tree, Binary Tree

2022-04-22 一刷

個人範例程式碼 - recursive 版本

"""
Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
"""


class Solution:
    """
    @param: root: The root of the BST.
    @param: p: You need find the successor node of p.
    @return: Successor of p.
    """
    def inorderSuccessor(self, root, p):
        # write your code here

        if not root:
            return None

        self.found = False
        self.ans = None
        self.dfs(root, p)
        return self.ans

    def dfs(self, node, p):
        if not node:
            return

        self.dfs(node.left, p)
        if self.found == True: # next node
            self.ans = node
            self.found = False
        if node == p:
            self.found = True
        self.dfs(node.right, p)

算法說明

inorder 排序的延伸，這裡要先知道 Successor 的定義比較好解

而討論可能的相對位置 (不清楚可以想一下 inorder 定義)
：

如果有右子樹，就是右樹的第一個 node
如果沒有右樹，就是往上方的 node 尋找第一個左彎的 node

借一下 BST iterator 的圖3，相對位置就是 next

不過說實在，這樣還要討論太麻煩了，不如就直接無腦開始 traverse 還比較快XD

這也是我最後的做法，只需要注意修改 inorder 的中間位置，
這邊要增加讀取 val，且發現上一個為 p 時，需要做一下記號。

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

Reference

Finding the In-Order Successor of a Node

【Leetcode】python - [230] Kth Smallest Element in a BST 個人解法筆記

Fri, 22 Apr 2022 02:09:26 +0800

題目出處

230. Kth Smallest Element in a BST

難度

medium

題目分類

Tree, Depth-First Search, Binary Search Tree, Binary Tree

2022-04-22 一刷

個人範例程式碼 - recursive 版本

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        self.k = k
        self.final_ans = -1
        self.dfs(root)

        return self.final_ans

    def dfs(self, root):
        if not root:
            return 

        self.dfs(root.left)
        self.k -= 1
        if self.k == 0:
            self.final_ans = root.val
        self.dfs(root.right)

        return

算法說明

建立一個 global 的計數器 (這設計可能不太好)，然後照 BST 的概念下去找第 K 小的值。

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

個人範例程式碼 - iterative 版本

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        self.stack = deque()
        self.to_left_bottom(root)

        while(k > 0):
            cur = node = self.stack[-1]
            if node.right is not None:
                node = node.right
                self.to_left_bottom(node)
            else:
                node = self.stack.pop()
                while self.stack and self.stack[-1].right == node:
                    node = self.stack.pop()

            k -= 1 # get one node
            if k == 0:
                return cur.val
        else:
            return -1

    def to_left_bottom(self, node):
        while(node):
            self.stack.append(node)
            node = node.left

算法說明

iterative 的解法，我們借用 Binary Search Tree Iterator 的概念來使用，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-173/

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

Reference

【Leetcode】python - [114] Flatten Binary Tree to Linked List 個人解法筆記

Thu, 21 Apr 2022 19:57:16 +0800

題目出處

114. Flatten Binary Tree to Linked List

難度

medium

題目分類

Linked List, Stack, Tree, Depth-First Search, Binary Tree

2022-04-21 一刷

個人範例程式碼 - iterative 解

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return 

        stack = deque([root])

        while stack:
            node = stack.pop()
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)


            node.right = stack[-1] if stack else None # prev node -> current node
            node.left = None

        return

算法說明

個人覺得很酷的一題，直接把 Tree 改成 Linked List，考了非常多資料結構的操作。

把前一個 node 連結至 stack[-1] 的位置。

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

個人範例程式碼 - recursive 解

class Solution:
    """
    @param root: a TreeNode, the root of the binary tree
    @return: nothing
    """
    def flatten(self, root: TreeNode):
        # write your code here
        if not root:
            return

        self.prev = None
        self.dfs(root)
        return 

    def dfs(self, root):
        if not root:
            return 

        if self.prev is not None:
            self.prev.left = None
            self.prev.right = root

        self.prev = root
        tmp_right = root.right
        self.dfs(root.left)
        self.dfs(tmp_right) # root.right 回到此處時已經被修改

算法說明

這做法要注意的是，因為我們是 in-place 的改 node right，
在 dfs 回來之後已經不是原來我們預期的那個 node.right，因此要先事前拷貝一份。

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

個人範例程式碼 - recursive 解 (使用 global 變數，個人覺得比較不直覺一點)

class Solution:
    """
    @param root: a TreeNode, the root of the binary tree
    @return: nothing
    """
    def flatten(self, root: TreeNode):
        # write your code here
        if not root:
            return

        self.prev = None
        self.dfs(root)
        return 

    def dfs(self, root):
        if not root:
            return 

        # divide
        self.dfs(root.right)
        self.dfs(root.left)

        # conquer  right -> prev(deeper node)
        root.right = self.prev
        root.left = None
        self.prev = root

算法說明

這個方法使用了 class 的 global 變數，使用好不好見仁見智，
但邏輯清楚一些，每次都記錄前一個 node 作為 prev，並把 current node 連結 prev node。

這裡有個比較不直覺的地方，prev node 紀錄的是「相對比較底層的」node，
因此是用 return 過程時的路徑 node.right 去連接 prev (這部分概念有點跟 prev 實質意義上顛倒)

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

Reference

453 · Flatten Binary Tree to Linked List

【Leetcode】python - [236] Lowest Common Ancestor of a Binary Tree 個人解法筆記 #重要題型

Thu, 21 Apr 2022 04:01:12 +0800

題目出處

236. Lowest Common Ancestor of a Binary Tree

難度

medium

題目分類

Tree, Depth-First Search, Binary Tree

2022-04-21 一刷

個人範例程式碼 - 一刷 (2022/04/21)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, x)
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.lca(root, p, q)

    def lca(self, root, p, q):
        if not root:
            return None
        if root <mark> p or root </mark> q:
            return root

        # divide
        found_left = self.lca(root.left, p, q)
        found_right = self.lca(root.right, p, q)

        # conquer
        if found_left is not None and found_right is not None:
            return root
        elif found_left:
            return found_left
        elif found_right:
            return found_right
        else: # not found
            return None

算法說明

這已經是系列題目的第三題了，前面可參考

此系列題目的第一題，由於設計上多了 parent node，相對來說比較沒有考到 LCA 的經常考點：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-474/

此系列題目的第二題，BST 與 BT 只多了比較好找數字，基本上有正確實作 LCA 其實也不用管數字排序：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-235/

LCA 的基本寫法，非常重要的題目。

拆成四路分析，左右返回是否有找到 A or B

討論 case 如下

如果兩側各返回 found，表示一邊各找到一個，此 node 即為答案
如果只有 left/right 返回 found，表示已經在下層找到答案，正在往上回傳。
如果都沒有 found，表示目前往下還找不到，返回 None

而特殊的 case 為

當 A 為 root，而 B 在此 root 之下，或相反的情況，
此時我們做的處理為返回 root，因為兩者的交集就是在 root 是兩者同時的 LCA。

Reference

474 · Lowest Common Ancestor II

【Leetcode】python - [235] Lowest Common Ancestor of a Binary Search Tree 個人解法筆記

Thu, 21 Apr 2022 03:48:49 +0800

題目出處

235. Lowest Common Ancestor of a Binary Search Tree

難度

easy

題目分類

Tree, Depth-First Search, Binary Search Tree, Binary Tree

2022-04-21 一刷

個人範例程式碼 - 一刷 (2022/04/21)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, x)
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.lca(root, p, q)

    def lca(self, root, p, q):
        if not root:
            return None
        if p <mark> root or q </mark> root:
            return root

        # divide
        found_left = self.lca(root.left, p, q)
        found_right = self.lca(root.right, p, q)

        # conquer
        if found_left is not None and found_right is not None: # two side found
            return root
        elif found_left: # found left
            return found_left
        elif found_right: # found right
            return found_right
        else: # not found
            return None

算法說明

此題的前一題，由於設計上多了 parent node，相對來說比較沒有考到 LCA 的經常考點：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-474/

LCA 的基本寫法，非常重要的題目。

拆成四路分析，左右返回是否有找到 A or B

討論 case 如下

如果兩側各返回 found，表示一邊各找到一個，此 node 即為答案
如果只有 left/right 返回 found，表示已經在下層找到答案，正在往上回傳。
如果都沒有 found，表示目前往下還找不到，返回 None

而特殊的 case 為

當 A 為 root，而 B 在此 root 之下，或相反的情況，
此時我們做的處理為返回 root，因為兩者的交集就是在 root 是兩者同時的 LCA。

Reference

474 · Lowest Common Ancestor II

【Leetcode】python - [113] Path Sum II 個人解法筆記

Wed, 20 Apr 2022 00:21:55 +0800

題目出處

113. Path Sum II

難度

medium

題目分類

Backtracking, Tree, Depth-First Search, Binary Tree

2022-04-20 一刷

個人範例程式碼 - 一刷 (2022/04/20)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        ans = []
        self.dfs(root, targetSum, [], ans)
        return ans

    def dfs(self, root, target, path, ans):
        # None
        if not root:
            return 

        path.append(root.val)
        # Leaf
        if not root.left and not root.right:
            if sum(path) == target:
                ans.append(path[:]) # copy a new one
                path.pop()
                return

        # not leaf
        self.dfs(root.left, target, path, ans)
        self.dfs(root.right, target, path, ans)
        path.pop()

        return

算法說明

此題的前一個題目，不同處在於需要多求出完整路徑，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-112/

基礎的 DFS 用來 traverse Tree 裡面的內容，並沿路計算總和。

input handling

如果沒有正確結果，回傳 []

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

False

if not root:
    return

Leaf

判斷是否總和正確，如果是則加入目前的 path

# Leaf
if not root.left and not root.right:
    if sum(path) == target:
        ans.append(path[:]) # copy a new one
        path.pop()
        return

define of recursion

增加路過的路徑。

path.append(root.val)

重要：這邊務必注意，因為 list 在 python function 中，pass by assignment 可以變更 mutable object，所以勢必要注意對應的 pop() 位置在哪。

path.pop()

split of recursion

拆成兩路，同樣的也如同我們上面說要注意的點。
我們先把結果拿回來，再把 path 的內容先 pop 出來後，再把 ans 回傳。

# not leaf
self.dfs(root.left, target, path, ans)
self.dfs(root.right, target, path, ans)
path.pop()

Reference

【Leetcode】python - [112] Path Sum 個人解法筆記

Wed, 20 Apr 2022 00:02:52 +0800

題目出處

112. Path Sum

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-04-20 一刷

個人範例程式碼 - 一刷 (2022/04/20)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:

        return self.dfs(root, targetSum, [])

    def dfs(self, root, target, path):
        # Null
        if not root:
            return False

        path.append(root.val)
        # leaf
        if not root.left and not root.right:
            if sum(path) == target:
                path.pop()
                return True

        # not leaf
        ans = self.dfs(root.left, target, path) or self.dfs(root.right, target, path) # need pop path before return
        path.pop()

        return ans

算法說明

基礎的 DFS 用來 traverse Tree 裡面的內容，並沿路計算總和。

input handling

如果沒有正確結果，回傳 False

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

False

# Null
if not root:
    return False

Leaf

判斷是否總和正確，如果是回傳 True

# leaf
if not root.left and not root.right:
    if sum(path) == target:
        path.pop()
        return True

define of recursion

增加路過的路徑。

path.append(root.val)

重要：這邊務必注意，因為 list 在 python function 中，pass by assignment 可以變更 mutable object，所以勢必要注意對應的 pop() 位置在哪。

path.pop()

split of recursion

拆成兩路，同樣的也如同我們上面說要注意的點。
我們先把結果拿回來，再把 path 的內容先 pop 出來後，再把 ans 回傳。

# not leaf
ans = self.dfs(root.left, target, path) or self.dfs(root.right, target, path) # need pop path before return

Reference

【Leetcode】python - [257] Binary Tree Paths 個人解法筆記

Tue, 19 Apr 2022 23:43:34 +0800

題目出處

257. Binary Tree Paths

難度

easy

題目分類

String, Backtracking, Tree, Depth-First Search, Binary Tree

2022-04-19 一刷

個人範例程式碼 - 一刷 (2022/04/19)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        ans = []
        self.dfs(root, "", ans)
        return ans

    def dfs(self, root, path, ans):
        if not root: # Null point
            return

        if not root.left and not root.right: # last point
            path += f"{root.val}"
            ans.append(path)
            return

        path += f"{root.val}->"
        self.dfs(root.left, path, ans)            
        self.dfs(root.right, path, ans)

        return

算法說明

基礎的 DFS 用來 traverse Tree 裡面的內容，並回傳路徑。

input handling

如果沒有內容，回傳 []

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

if not root: # Null point

Leaf

if not root.left and not root.right: # last point

define of recursion

單純增加路過的路徑。

path += f"{root.val}->"

split of recursion

拆成兩路

self.dfs(root.left, path, ans)            
self.dfs(root.right, path, ans)

Reference

480 · Binary Tree Paths

【Leetcode】python - [107] Binary Tree Level Order Traversal II 個人解法筆記

Thu, 07 Apr 2022 21:03:10 +0800

題目出處

107. Binary Tree Level Order Traversal II

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-04-07 一刷

個人範例程式碼 - 一刷 (2022/04/07)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []

        ans = []
        queue = [root]
        while(queue):
            tmp_ans = []
            tmp_queue = []
            for node in queue:
                tmp_ans.append(node.val)
                if node.left is not None:
                    tmp_queue.append(node.left)
                if node.right is not None:
                    tmp_queue.append(node.right)
            ans.append(tmp_ans)
            queue = tmp_queue
        else:
            return ans[::-1]

算法說明

這題有幾乎相同的類似題，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-102/

BFS traversal，搭配 Queue 即可完成。
這題沒有發揮 Queue 的 FIFO 特性，但要使用也是可以的。

無聊記：Queue = pop(0)，Q 長的很像 0…
比較 Stack = pop(-1) 或 pop ()

input handling

處理 input 為 None 的情況，輸出 []。

Boundary conditions

注意：BFS 結束條件為，「當 Queue 不再有東西的時候」。

Reference

二叉树的层次遍历 II · Binary Tree Level Order Traversal II

【Leetcode】python - [102] Binary Tree Level Order Traversal 個人解法筆記

Thu, 07 Apr 2022 12:43:11 +0800

題目出處

102. Binary Tree Level Order Traversal

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-04-07 二刷

個人範例程式碼 - 第二版：2022/4/7

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []

        queue = [root]
        ans = []
        while(queue):
            tmp_queue = []
            tmp_ans = []
            for ele in queue:
                tmp_ans.append(ele.val)
                if ele.left is not None:
                    tmp_queue.append(ele.left)
                if ele.right is not None:
                    tmp_queue.append(ele.right)
            ans.append(tmp_ans)
            queue = tmp_queue
        else:
            return ans

算法說明

BFS traversal，搭配 Queue 即可完成。
這題沒有發揮 Queue 的 FIFO 特性，但要使用也是可以的。

無聊記：Queue = pop(0)，Q 長的很像 0…
比較 Stack = pop(-1) 或 pop ()

input handling

處理 input 為 None 的情況，輸出 []。

Boundary conditions

注意：BFS 結束條件為，「當 Queue 不再有東西的時候」。

2022-03-19 一刷

個人範例程式碼 - 第一版：2022/3/19

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = []
        this_level = [root]
        if root:
            while(this_level):
                this_level_val = []
                next_level = []   
                for node in this_level:
                    this_level_val.append(node.val)
                    if node.left:
                        next_level.append(node.left)
                    if node.right:
                        next_level.append(node.right)
                ans.append(this_level_val)
                this_level = next_level

        return ans

算法說明

既然是 level order，我們的思路是使用一層一層的方式下去把答案兜出來。

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

原本的做法我是到最後一層才做檢查「if root」，
不過如果是採取這樣的作法，會多一層只有「None 的 layer」，
我們需要特別留意儲存的最後一層。

Reference

【Leetcode】python - [145] Binary Tree Postorder Traversal 個人解法筆記

Sat, 19 Mar 2022 10:10:49 +0800

題目出處

145. Binary Tree Postorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-19 一刷

解 Tree 樹問題的重點整理

這一篇的前身是以下連結，我們繼續在這篇整理重點

【Leetcode】python – [144] Binary Tree Preorder Traversal 個人解法筆記 (內含範例程式碼) 內含處理 Tree 樹問題的重點

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

個人範例程式碼 - recursive 版

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        self.dfs(root, ans)
        return ans

    def dfs(self, root, ans):
        if root:
            self.dfs(root.left, ans)
            self.dfs(root.right, ans)
            ans.append(root.val)

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我們需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

主要變化的範圍如下，然後依照 (M)RL、R(M)L、RL(M) 改一下順序，全部的解法就都出來了!

self.dfs(root.left, ans)
self.dfs(root.right, ans)
ans.append(root.val)

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        stack = [root]     
        # LR(M) -> (M)RL
        while(stack):
            if root: # left to leaf
                ans.append(root.val) # add M first
                stack.append(root.left) # record later
                root = root.right
            else: # can not left
                root = stack.pop(-1)       

        return ans[::-1]

算法說明

我們要處理的問題變得比較麻煩一些，變成 LR(M),
但因為我們其實都是在控制 (M) 出現的時機，
因此比較好的方式是我們把它提造最前面去做，

因此我們以 (M)RL 去做一棵樹，而最後「再反序」。
我們分兩個 part

可以往下走的情況， (此處是往右先)

我們可以往右就右到底。

if root: # left to leaf
   ans.append(root.val) # add M first
   stack.append(root.left) # record later
   root = root.right

不能往下走，就往左走的情況

表示上述「if root」找不到結果的情況，
pop 出「最後一個」「分歧點」，
也就是「回到上一個岔路往左走」。

else: # can not left
   root = stack.pop(-1)

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

Reference

此系列解法個人的其他文章

個人認為整理的最完整的解法

Summary of preorder, inorder, postorder, four traversal ways for each

很用心的 DFS 製圖

All DFS traversals (preorder, inorder, postorder) in Python in 1 line

結合 visited 的很酷的 solution

Python 3 - All Iterative Traversals - InOrder, PreOrder, PostOrder - Similar Solutions

- [Python solutions (recursively and iteratively).](https://leetcode.com/problems/binary-tree-preorder-traversal/discuss/45290/Python-solutions-(recursively-and-iteratively).) - [Python recursive and iterative solutions.](https://leetcode.com/problems/binary-tree-postorder-traversal/discuss/45786/Python-recursive-and-iterative-solutions.)

【Leetcode】python - [94] Binary Tree Inorder Traversal 個人手寫解法筆記內含處理 Tree 樹問題的重點

Sun, 13 Mar 2022 22:26:12 +0800

題目出處

94. Binary Tree Inorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-13 一刷

解 Tree 樹問題的重點整理

這一篇的前身是以下連結，我們繼續在這篇整理重點

【Leetcode】python – [144] Binary Tree Preorder Traversal 個人解法筆記 (內含範例程式碼) 內含處理 Tree 樹問題的重點

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

個人範例程式碼 - recursive 版

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        self.dfs(root, ans)
        return ans

    def dfs(self, root, ans):
        if root:
            self.dfs(root.left, ans)            
            ans.append(root.val)
            self.dfs(root.right, ans)

        else:
            return

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我們需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

主要變化的範圍如下，然後依照 (M)RL、R(M)L、RL(M) 改一下順序，全部的解法就都出來了!

self.dfs(root.left, ans)
ans.append(root.val)
self.dfs(root.right, ans)

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # left mid right
        nodeStack = []
        ans = []
        while root or nodeStack:
            if root:
                nodeStack.append(root) 
                root = root.left # repeat put left if exist
            else: # nothing left
                curNode = nodeStack.pop()
                ans.append(curNode.val) # append left
                root = curNode.right              

        return ans

算法說明

以下筆記手寫，字醜傷眼注意XDD

由上圖，我們可以發現，我們會先

向左走到底，一邊存 node 進 stack 當中，
發現沒辦法向左之後，pop一個值，此值就是我們拿 inorder 中間值的時候
pop 後往右

注意：由於「後處理要先放」，因此順序會是「先右後左」

你可能會想問這麼注意順序為什麼不用 Queue?
因為「先進先出」的結構我們沒辦法保存應該要後處理的東西。

例如第一層的左右，加入第二層後，
第一層的右一定會先出後，才會做第二層，因此沒辦法。

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

結論 - 處理樹的重點

直接的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS

Stack 為 pop() 或 pop(-1) 就可以直接實現，注意「後處理要先放」。

interative 的重點

我們可以發現，不論是哪一種 interative 方法，「向左走到底都是必須的」，
因此，我們就只要專心的看何時是我們該拿值的地方，
就可以順著把這三題都解出來

我們 traversal tree 主要分成兩種情況

向左走到底，一邊存 node 值 (preorder 此時取值) <– (M)RL
無法向左的情況，從 stack pop 出一個值 (inorder 此時取值)，並向右

而我們也可以分析出，類似相關的題目中

inorder - R(M)L：拿時存答案
preorder - (M)RL：先放值(mid)，再拿
postoreder - RL(M)：先放值(mid)，再拿，最後反序

postorder我們處理時會比較特別，因為他是 RL(M) 的結構，
而我們 traversal tree 時，通常都一定會先從根開始看，
因此比較好的處理方式，我們會一開始就先把順序倒過來看，
變成我們處理 (M)LR，最後再反序。

Reference

個人認為整理的最完整的解法

Summary of preorder, inorder, postorder, four traversal ways for each

很用心的 DFS 製圖

All DFS traversals (preorder, inorder, postorder) in Python in 1 line

結合 visited 的很酷的 solution

Python 3 - All Iterative Traversals - InOrder, PreOrder, PostOrder - Similar Solutions

【Leetcode】python - [144] Binary Tree Preorder Traversal 個人解法筆記內含處理 Tree 樹問題的重點

Wed, 09 Mar 2022 16:43:45 +0800

題目出處

144. Binary Tree Preorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-09 一刷

個人範例程式碼 - recursive 版

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # pre = m l r
        if not root:
            return []
        else:
            ans = [] # in-place change
            self.dfs(root, ans)
            return ans

    def dfs(self, node, ans):
        if not node:
            return
        else:
            ans.append(node.val) # mid
            self.dfs(node.left, ans) # l
            self.dfs(node.right, ans) # r

        return ans

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我門需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # pre = m l r
        ans = []
        node_stack = [root]
        while node_stack:
            cur_node = node_stack.pop()
            if cur_node:
                ans.append(cur_node.val)
                node_stack.append(cur_node.right)
                node_stack.append(cur_node.left)

        return ans

算法說明

注意：由於「後處理要先放」，因此順序會是「先右後左」

你可能會想問這麼注意順序為什麼不用 Queue?
因為「先進先出」的結構我們沒辦法保存應該要後處理的東西。

例如第一層的左右，加入第二層後，
第一層的右一定會先出後，才會做第二層，因此沒辦法。

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

結論 - 處理樹的重點

直接的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS

Stack 為 pop() 或 pop(-1) 就可以直接實現，注意「後處理要先放」。

Reference

Python solutions (recursively and iteratively).

【Leetcode】python - [104] Maximum Depth of Binary Tree 個人手繪解法筆記

Fri, 02 Apr 2021 00:34:35 +0800

題目出處

https://leetcode.com/problems/maximum-depth-of-binary-tree/

難度

Easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2021-04-02 一刷

個人手繪解法筆記 (解法重點)

這題就是簡單考樹的遍歷，
用 while 來一層一層刷出深度。

從 list 翻譯樹的長相

示意圖: (我們就是照著紅色箭頭方向一個個節點看左右的。)

基本的確認，我們先確認有沒有這棵樹

總是會有一些要多考慮的事情… 沒有樹的話我們要先處理
(很討厭這種整個算法幾乎都寫對，結果錯「最簡單現象」的感覺XDD)

一層層的遍歷，每個節點左右都看一下

每一層遍歷各節點的左右，這邊可以抓一個感覺，
樹的成長 (level)，大概是照著 1 -> 2 -> 4 -> 8 -> 16
這樣的數值在快速變化的。

個人範例程式碼 - 一刷 (2021/04/02)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        depth = 0
        if root:
            level = [root]
        else:
            level = []

        while(level):
            depth += 1
            next_level = []
            for ele in level:
                if ele.left:
                    next_level.append(ele.left)
                if ele.right:
                    next_level.append(ele.right)

            level = next_level 

        return depth

Reference

https://leetcode.com/problems/maximum-depth-of-binary-tree/discuss/34345/Python-BFS-solution