712 - LeetCode Stack on 嗡嗡的隨手筆記

【Leetcode】python - [739] Daily Temperatures 個人解法筆記

Fri, 24 Jul 2026 16:06:03 +0800

題目出處

739. Daily Temperatures

難度

Medium

題目分類

Array, Stack, Monotonic Stack

2026-07-24 二刷

個人範例程式碼 - 二刷 (2026/07/24)

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        stack = [] # keep lower temp idx
        ans = [0] * len(temperatures)

        for today, temp in enumerate(temperatures):
            while stack and temp > temperatures[stack[-1]]:
                prev_temp_idx = stack.pop()
                ans[prev_temp_idx] = today - prev_temp_idx

            # must append today temp at least
            stack.append(today)

        return ans

算法說明

存一個 stack，只存比當前溫度低的全部，會是 desc 的順序
當發現更高溫度時，一路 pop idx，到今天不是更高溫為止

注意：今天每輪必存（放在最後 append），因為今天的判斷還沒結束，需要隔天的資訊。

monotonic stack 筆記：存 idx 還是存 temp, 建議存 idx, 當出現重複溫度時不麻煩

Time Complexity

O(n)

Space Complexity

O(n)

Boundary conditions

剩下找不到答案的要補 0 -> 一開始 Init 就給全 0

2022-04-28 一刷

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

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        if not temperatures:
            return []

        stack = []
        ans = [0 for _ in range(len(temperatures))]
        for today, temperature in enumerate(temperatures):
            while stack and temperatures[stack[-1]] < temperature: # today's temperature is higher
                idx = stack.pop(-1)
                ans[idx] = today - idx
            stack.append(today)

        return ans

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

stack 的經典題型，透過 stack 紀錄沿路上的過去史，
並不斷地以「今日」去比對「過去尚未產生結果的結果」

pop 至過去結果溫度「比今日小的所有結果」，相距日期則為「today - 該日」

input handling

如果沒有 input，return []

Boundary conditions

for 搜尋所有的天數，
如果過程中有發現更高的溫度，就去更新結果。

Reference

每日温度 · Daily Temperatures

【Leetcode】python - [155] Min Stack 個人解法筆記

Tue, 07 Jun 2022 18:58:16 +0800

題目出處

155. Min Stack

難度

easy

題目分類

Stack, Design

2022-06-07 一刷

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

class MinStack:

    def __init__(self):
        self.stack = []
        self.min_stack = []

    def push(self, val: int) -> None:
        self.stack.append(val)
        if len(self.min_stack) == 0: # min stack empty
            self.min_stack.append(val)
        else:
            self.min_stack.append(min(val, self.min_stack[-1])) # "new smallest" or "copy last smallest"

    def pop(self) -> None:
        result = self.stack.pop()
        del self.min_stack[-1] 

        return result

    def top(self) -> int:
        return self.stack[-1]


    def getMin(self) -> int:
        return self.min_stack[-1]


# Your MinStack object will be instantiated and called as such
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

算法說明

設計類題目，我們使用兩個 stack 來處理，
一個紀錄目前 stack 的狀況，另外一個用來記錄 min_stack 目前的排序。

input handling

x (設計類問題)

Boundary conditions

x (設計類問題)

Reference

带最小值操作的栈 · Min Stack

【Leetcode】python - [503] Next Greater Element II 個人解法筆記

Mon, 06 Jun 2022 01:56:25 +0800

題目出處

503. Next Greater Element II

難度

medium

題目分類

Array, Stack, Monotonic Stack

2022-06-06 一刷

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

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        if not nums:
            return []

        ans = [-1 for i in range(len(nums))] # default not found
        stack = []

        # first round
        for i, num in enumerate(nums):
            while stack and nums[stack[-1]] < num:
                idx = stack.pop()
                ans[idx] = num                
            stack.append(i) # push index in stack

        # sencond round, clear stack    
        for i, num in enumerate(nums):
            if not stack:
                break 
            while stack and nums[stack[-1]] < num:
                idx = stack.pop()
                ans[idx] = num                

        return ans

算法說明

本題的前一題為無迴圈版本，這題目的 array 為循環數組，前一題可參考：

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

像這類有「找後續/前綴」中比較大或比較小的第一個數字，
我們通常會用 stack 來保存「等待被決定的內容」。

當我們發現「stack[-1]」<「新的數字」，表示找到答案，
我們 pop[-1] 出 stack，並記錄「 pop 的答案就是當前數字」。

最後剩下在 stack 的內容，答案都是 -1

與前一題不同處

與前一題不同的地方是，因為這次題目給的 array 變成有循環 array，
因此我們只需要循環兩次即可。

在第二次循環的過程中，目標是處理掉 stack 剩下的內容，
如果最後都還處理不掉的話，就是 -1 (找不到的情況，我們 default 就先給 -1)

input handling

如果沒有 nums, 回傳 [] (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

下一个更大的数 II · Next Greater Element II

【Leetcode】python - [496] Next Greater Element I 個人解法筆記

Mon, 06 Jun 2022 01:51:25 +0800

題目出處

496. Next Greater Element I

難度

easy

題目分類

Array, Hash Table, Stack, Monotonic Stack

2022-06-06 一刷

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

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:

        ans_hashtable = {}
        stack = []

        for num in nums2:
            while stack and stack[-1] < num: # new is greater
                ans_hashtable[stack[-1]] = num # last number's answer = this num
                del stack[-1]            
            stack.append(num)

        for rest_element in stack:
            ans_hashtable[rest_element] = -1

        return [ans_hashtable[num] for num in nums1]

算法說明

像這類有「找後續/前綴」中比較大或比較小的第一個數字，
我們通常會用 stack 來保存「等待被決定的內容」。

當我們發現「stack[-1]」<「新的數字」，表示找到答案，
我們 pop[-1] 出 stack，並記錄「 pop 的答案就是當前數字」。

最後剩下在 stack 的內容，答案都是 -1

input handling

如果沒有 nums, 回傳 [] (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

下一个更大的数 I · Next Greater Element I

【Leetcode】python - [42] Trapping Rain Water 個人解法筆記

Thu, 12 May 2022 14:08:29 +0800

題目出處

42. Trapping Rain Water

難度

hard

題目分類

Array, Two Pointers, Dynamic Programming, Stack, Monotonic Stack

2022-05-12 一刷

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

class Solution:
    def trap(self, height: List[int]) -> int:
        left, right = 0, len(height)-1
        max_left, max_right = height[left], height[right]
        water_contains = 0

        while(left < right):
            # print(left, right, water_contains)
            if max_left <= max_right:
                left += 1
                water_contains += self.is_positive(min(max_left, max_right) - height[left])  # current
                max_left = max(max_left, height[left])
            else:
                right -= 1
                water_contains += self.is_positive(min(max_left, max_right) - height[right]) # current
                max_right = max(max_right, height[right])

        return water_contains

    def is_positive(self, num):
        return num if num > 0 else 0

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

考慮比較複雜的同向 two pointer 問題。
我們需要先推導出一個公式，
「當前水位 = min(左最高, 右最高) - 當前高度」

下圖的右邊，我們判斷左右高最矮的部分，可以計算當前「藍色最高為 1 」的水量 (必定，就算中間全空都會有)

你可能會考慮這樣的問題，問說左邊會怎麼算到 2，如果左邊真的能算到 2，那一定是從右邊一路過來，「有比 2 更高的事件發生 (下圖畫的不是很好，右側任意位置只要有出現比 2 更高的都可以!)」

否則，左邊最高會永遠維持 1，而不用擔心算錯最主要的原因是我們不會這麼早算這格，必須確定「1 or 2」才會算 (右側有比 2 高就確定了)

注意，處理時請注意負值

這裡要多注意一點，處理時，
因為我們是計算「min(left_max, right_max) - 當前高度」，因此很有可能會有計算到負值的可能。

這時候我們需要另外寫一個判斷式，專門處理 < 0 的情況，
可以用我上方的方法，或是使用以下方法，
都可以「保證最小是 0，如果 > 0 就是該值」

max(0, min(left_max, right_max))

input handling

Boundary conditions

透過 while(left < right): 處理

Reference

接雨水 · Trapping Rain Water

【Leetcode】python - [234] Palindrome Linked List 個人解法筆記 (內含 reverse LinkedList 方法)

Wed, 04 May 2022 03:42:30 +0800

題目出處

234. Palindrome Linked List

難度

easy

題目分類

Linked List, Two Pointers, Stack, Recursion

2022-05-04 一刷

個人範例程式碼 - Deque (比較進階)，空間 O(N)

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        dq = deque([])
        while(head):
            dq.append(head.val)
            head = head.next

        return self.is_palindrome(dq)

    def is_palindrome(self, dq):
        while(len(dq)>=2):
            if dq.popleft() == dq.pop():
                continue
            else:
                return False
        else:  # if len(dq) <mark> 1, True or len(dq) </mark> 0, True                         
            return True

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

Deque 解 palindrome 的題目真的是無敵，但因為是比較進階的資料結構，也許不一定是面試想要看到的解

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 pointer 搜尋至 None

個人範例程式碼 - 同向 two pointer, 使用空間 O(N/2) stack

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        slow = head
        fast = head.next

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        else:
            if not fast:
                return self.odd_case(head, slow, fast)
            else: # not fast
                return self.even_case(head, slow, fast)


    def odd_case(self, head, slow, fast):
        mid = slow
        stack = deque([])

        slow = slow.next
        while(slow):
            stack.append(slow.val)
            slow = slow.next

        # print(stack)
        while(stack):
            if head.val == stack.pop():
                head = head.next
            else:
                return False
        else:
            return True

    def even_case(self, head, slow, fast):
        mid = slow
        stack = deque([])

        slow = slow.next
        while(slow):
            stack.append(slow.val)
            slow = slow.next

        # print(stack)
        while(stack):
            if head.val == stack.pop():
                head = head.next
            else:
                return False
        else:
            return True

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

我猜此題目最多會要求到把使用空間壓縮至 O(1)，
這樣上面 Deque 的做法會因為空間 O(n) 而不能用。

如果要實現 O(1) 空間的話，
這題就可以考到 LinkedList 的反轉，同向 two pointer。

不過這邊求速度，就先不寫 LinkedList 的反轉，
使用 O(N/2) 空間的 stack 完成同樣的任務

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 slow, fast pointer 搜尋至 None，
注意結束條件的 fast and fast.next

個人範例程式碼 - 同向 two pointer，使用 reverse LinkedList 空間 O(1)

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        slow = head
        fast = head.next

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        else:
            if not fast:
                return self.odd_case(head, slow, fast)
            else: # not fast
                return self.even_case(head, slow, fast)

    def odd_case(self, head, slow, fast):
        dummy = self.reverse(slow)
        while dummy:
            # print(dummy.val, head.val)
            if dummy.val == head.val:
                head, dummy = head.next, dummy.next
            else:
                return False
        return True

    def even_case(self, head, slow, fast):
        dummy = self.reverse(slow.next)
        while dummy:
            # print(dummy.val, head.val)
            if dummy.val == head.val:
                head, dummy = head.next, dummy.next
            else:
                return False
        return True

    def reverse(self, node):
        prev = None
        while node:
            tmp = node.next
            node.next = prev
            prev = node
            node = tmp

        return prev # prev <- node(None)

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

同上 slow, fast 作法，但實現 O(1) 空間，利用 LinkedList 的反轉，同向 two pointer。

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 slow, fast pointer 搜尋至 None，
注意結束條件的 fast and fast.next

Reference

【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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

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

Boundary conditions

見上述說明

Reference

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

【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 檢查，
而只要發現能往右走，就往右走「一步」，然後依然「往左走到底」

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

Boundary conditions

當 stack 為空時，結束迴圈

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] 的位置。

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

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，因此要先事前拷貝一份。

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

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 實質意義上顛倒)

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

Reference

453 · Flatten Binary Tree to Linked List

【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()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

老實說個人覺得，Tree 系列的題目用 recursive 的概念是最接近原本學習知識觀念的解法XD。
寫起來非常直覺，而且稍微變化一下其他的解就都能直接跑出來。

主要變化的範圍如下，然後依照 (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 直接回傳。

另外一種漂亮的解法：直接只處理「if 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

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

我們可以往右就右到底。

先加 (M)，存左，往右走

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()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

老實說個人覺得，Tree 系列的題目用 recursive 的概念是最接近原本學習知識觀念的解法XD。
寫起來非常直覺，而且稍微變化一下其他的解就都能直接跑出來。

主要變化的範圍如下，然後依照 (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 直接回傳。

另外一種漂亮的解法：直接只處理「if 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

算法說明

直覺上的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS。
Stack 為 pop() 或 pop(-1) 就可以直接實現。

以下筆記手寫，字醜傷眼注意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 此時取值)，並向右

做完第二步就繼續左到底，如果不行就 pop，如此反覆

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

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 直接回傳。

另外一種漂亮的解法：直接只處理「if 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

算法說明

直覺上的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS。
Stack 為 pop() 或 pop(-1) 就可以直接實現。

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

你可能會想問這麼注意順序為什麼不用 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 - [232] Implement Queue using Stacks 個人筆記

Wed, 09 Mar 2022 14:47:36 +0800

題目出處

232. Implement Queue using Stacks

難度

easy

題目分類

Stack, Design, Queue

2022-03-09 一刷

個人筆記

這篇比較偏程式架構設計，我專注在分析答案，就不特別解。

算法說明

「兩個 Stack 可以拼出一個 Queue」，
對於這個問題我們可以這樣想，
Stack 作為 FILO 的資料結構，先進入的資料會放在底層
而當有兩個 Stack，FILO，再一次 FILO (此時位於底層的資料，就會被拿上來到頂層)，
總合起來就會得到 FIFO 了！

研究別人的解法

這裡我研究的解法是：Share my python solution (32ms)

class MyQueue:
    def __init__(self):
        self.inStack = []
        self.outStack = []

    def push(self, x):
        while self.outStack:
            self.inStack.append(self.outStack.pop())
        self.outStack.append(x)
        while self.inStack:
            self.outStack.append(self.inStack.pop())

    def pop(self):
        return self.outStack.pop()

    def peek(self):
        return self.outStack[-1]

    def empty(self):
        return (not self.outStack and not self.inStack)


# Your MyQueue object will be instantiated and called as such
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

初始化就是兩個 Stack，分成 in, out 兩組，
「記得我們的大概念就是要兩個 FILO + FILO = FIFO」

init：初始化兩組 inStack, outStack
push：放一個資料進入 inStack
pop：從 outStack 拿出一筆資料，在這之前應該會需要經過把 inStack 的資料全部以 FILO 放入 outStack
peek：與 pop 類似，但 pop 會需要回傳並刪除 Queue 中的內容，而 peek 只是我們想看看即將被 pop 的項目是什麼，而不做 pop 的動作。
empty：我們需要同時檢查 inStack, outStack 是否為空

移動過程：作為移動 inStack 的資料內容至 outStack 的內容使用，這裡有個重點「outStack此時必須為空」，因為我們可以將每次的 move 視為一組，而當這組的 Queue 順序順利清空前，「不能」再放新資料進去，否則會造成順序錯誤。

圖例

下圖我們做的步驟是

先放入 123
準備拿出 123，但沒一次全拿
放入 456

準備繼續拿出數字，這時我們會發現不能先移動 456，順序會亂掉，需要等待前一組「123」全部都移除完才能夠進行再次移動下一組的動作。

Reference

Share my python solution (32ms)

【Leetcode】python - [20] Valid Parentheses 個人解法筆記內含用 python List 組出 Stack, Queue 的方法整理

Sun, 06 Mar 2022 21:30:19 +0800

題目出處

20. Valid Parentheses

難度

easy

題目分類

String, Stack

2022-03-06 一刷

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

我們先宣告一個字典，我們可以藉由字典查出對應的括弧。

class Solution:
    def isValid(self, s: str) -> bool:
        checkdict = {
            "(":")",
            "[":"]",
            "{":"}",

        }
        stack = [] # append <-> pop(-1) #FILO Last out!!!
        for ele in s:
            if ele in checkdict.keys():
                stack.append(checkdict[ele])
            elif not len(stack)<mark>0 and stack.pop(-1) </mark> ele:
                pass
            else:
                return False

        return len(stack)==0

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

這題是非常經典的 Stack 考題

注意了：請務必自己想清楚為什麼是 Stack 而不是 Queue，以確保觀念清楚

基本上我們就用一個 list 來當作 Stack 儲存，
python 裡面，撇除直接使用 package，
我們可以使用 append 與 pop 的組合，用 list 拼湊出 Queue 與 Stack

可參考：【Python】python list 清除, 移除內容元素 remove, pop, del, clear相關用法整理 sample code (內含範例程式碼)

用 List 拼出 Queue

Queue 可以由 list append + pop(0) 組合而成

先進先出，所以我們先拿第 0 個。

用 List 拼出 Stack

Stack 可由 list append + pop(-1) 組合而成

或是也可以用 pop()，但個人不會這樣使用的原因是因為覺得 pop(-1) 對於觀念感覺會更清楚
因為 -1 也可以說明我們是拿最後一個，先進會後出