784 - LeetCode 重要題型 on 嗡嗡的隨手筆記

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

Tue, 29 Sep 2026 02:47:15 +0800

題目出處

236. Lowest Common Ancestor of a Binary Tree

難度

medium

題目分類

Tree, Depth-First Search, Binary Tree

2026-09-29 二刷

個人範例程式碼 - 二刷 (2026/09/29)

# 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':
        if root is None or root is p or root is q: # found or leaf (base case)
            return root

        left = self.lowestCommonAncestor(root.left, p, q) # search until found then up
        right = self.lowestCommonAncestor(root.right, p, q) # search until found then up

        if left and right: # found from two sons
            return root

        return left or right # return if found, or both not found

算法說明

經典的 LCA 重要題型，建議要背（或習慣）。

透過回傳代表下方子樹的狀態，分為「左邊找到」「右邊找到」「都沒找到」三種情況。
透過遞迴的特性，一路向下搜尋，找到了就會回傳（不用擔心沒找到）。
3.1. 判斷如果同時從 left or right 分別找到，那 root 就是 LCA。
3.2. 重點：由於找到其中一個 (如p) 就會提前回傳，另外一個 (如q) 必定存在於另一側或子孫中。
也就是說，如果另外一側找不到，則必定在子孫中。（可以推敲一下這句話）

細節：建議使用 is None, is p, is q，因為 eq (也就是 ==) 是可以被複寫的
雖然這裡兩個都沒問題，但 is 語意會更精準。

Time Complexity

O(n) # 接近遍歷所有樹

Space Complexity

O(h) # 用於儲存遞迴的深度，就是樹高 h

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。

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

Reference

474 · Lowest Common Ancestor II

【Leetcode】python - [133] Clone Graph 個人解法筆記 | Graph 的基本操作 #重要題型

Tue, 29 Sep 2026 01:16:42 +0800

題目出處

133. Clone Graph

難度

medium

題目分類

Hash Table, Depth-First Search, Breadth-First Search, Graph Theory

2026-09-29 二刷

個人範例程式碼 - 二刷 (2026/09/29)

"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

from typing import Optional
class Solution:
    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        if not node:
            return node

        visited = {} # key: origin node / value: clone node

        # each dfs will clone single
        # (and if neighbors not cloned, clone the neighbors first)
        def dfs(n):
            if n in visited:
                return visited[n]

            clone = Node(n.val) # clone new node
            visited[n] = clone # pair the origin to new node

            for neighbor in n.neighbors:
               clone.neighbors.append(dfs(neighbor)) # clone the neighbors (if not exist, create it)

            return clone

        return dfs(node)

算法說明

graph 的經典題型，目前我覺得還不夠熟悉架構，還需要多練練。

主要需要 clone node，並建立一個 visited dict 同時負責存已經建立的 clone node，與查詢「舊 -> 新」的配對
使用 dfs 來進行解題，一次的 dfs 就是處理好一個 clone node 與對應的 neighbors
你可能會想問，如果 neighbors clone node 還沒產生怎麼辦? 透過掃鄰居的過程，會優先把鄰居也建立好，
追到最深沒有新的 visited (clone node 都已經初步產生) 才開始一層一層 return 並把鄰居關係 (Edge) 建立好。

Time Complexity

O(V+E)

V: 查 visited 的時間
E: 內層的 for neighbors 的時間

你可能會想問 dfs 遞迴沒有時間嗎? 基本上沒有只是跑建立一個 node 的過程，而且大部分已經建立了 (在 visited) 就 return

Space Complexity

O(V)

V: visited 的存放空間

2022-04-16 一刷

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

"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        root = node
        if node is None:
            return node

        # traverse, get all nodes by BFS
        old_nodes = self.get_all_nodes(node)
        # print(len(nodes))

        # clone all nodes
        mapping = {}
        for old_node in old_nodes:
            mapping[old_node] = Node(old_node.val)

        # clone all edges
        for old_node in old_nodes: # 
            new_node = mapping[old_node]
            for neighbor in old_node.neighbors:
                new_neighbor = mapping[neighbor]
                new_node.neighbors.append(new_neighbor)

        return mapping[root]


    def get_all_nodes(self, node):
        queue = [node]
        result = set([node])
        while queue:
            head = queue.pop(0)
            for neighbor in head.neighbors:
                if neighbor not in result:
                    result.add(neighbor)    
                    queue.append(neighbor)

        return result

算法說明

不好處理的題目，題目本身不難，但基本上可以視為 Graph 的基本操作題型。

我們分成三大步驟

- 找到所有的點，透過 BFS traverse - 複製所有的點 - 複製所有的邊

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

input handling

處理 input 為空的情況，這裡我是直接回傳 node。

Boundary conditions

注意 BFS 的結束條件：

當 queue 為空，所有的點都為 visited

Reference

克隆图 · Clone Graph

【Leetcode】python - [46] Permutations 個人解法筆記 #重要題型

Mon, 17 Aug 2026 01:30:29 +0800

題目出處

46. Permutations

難度

medium

題目分類

Array, Backtracking

2026-08-17 二刷

個人範例程式碼 - 二刷 (2026/08/17)

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        ans = []
        used = [False] * len(nums)
        path = []

        def backtrack():
            if len(path) == len(nums):
                ans.append(path[:])
                return

            for i, num in enumerate(nums):
                if not used[i]:
                    used[i] = True
                    path.append(num)
                    backtrack()
                    used[i] = False
                    path.pop()

        backtrack()
        return ans

算法說明

Time Complexity

O(n*n!)

說明：n! 來自於數學的排列本來就是 n! 種組合，n 來自於複製陣列會需要遍歷一次當前 Path 的狀態。

Space Complexity

O(n) # 用來儲存 path 的長度，其餘 ans, used 所需要的空間也沒有造成空間數量級的增加

Boundary conditions

[1] 留意會不會沒辦法處理單個項目
[0, 1] 留意有沒有重複結果的問題

2022-04-24 一刷

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

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

        self.ans = []
        self.dfs(nums, [])
        return self.ans

    def dfs(self, nums, permutations):        
        # end of recursion
        if not nums:
            self.ans.append(list(permutations)) # deepcopy
            return 

        # define and split
        for i, num in enumerate(nums):
            permutations.append(num)
            # temporarily remove element i = start[0:i] + start[i+1:]
            self.dfs(nums[:i] + nums[i+1:], permutations)
            permutations.pop() # backtracking

算法說明

排列類型的題目，使用 dfs 去搜尋全部的結果，

另外在處理順序時，我們使用傳入「start[0:i] + start[i+1:]」的方式，暫時移除了 start[i] 的元素，
這樣的操作方式會複製一個新的 list，而不會影響到原本的 list

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

input handling

當沒有 nums 時，return nums

Boundary conditions

搜尋至 no nums 時，添加結果回傳 (表示元素已使用完畢)

Reference

全排列 · Permutations

【Leetcode】python - [424] Longest Repeating Character Replacement 個人解法筆記 #重要題型

Fri, 07 Aug 2026 01:43:45 +0800

題目出處

424. Longest Repeating Character Replacement

難度

medium

題目分類

Hash Table, String, Sliding Window

2026-08-07 三刷

個人範例程式碼 - 三刷 (2026/08/07)

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        max_length = 0
        left = 0
        window_count = {}
        max_freq = 0

        for right, c in enumerate(s):
            window_count[c] = window_count.get(c, 0) + 1 # always add new
            window_size = right - left + 1
            max_freq = max(max_freq, window_count[c])

            if window_size - max_freq > k: # over replace
                window_count[s[left]] -= 1 # del left character
                left += 1 # move
                # no need to update max_freq, keep maximum possible window size
                # max_freq = max(max_freq, window_count[left])

            max_length = max(max_length, right - left + 1)

        return max_length

算法說明

這題目因為最終的「合法 windows 大小」只會單調遞增，因此當發現一個可能的 windows 新大小，可以不斷的移動，直到發現下一次能增大的機會。
（只要是不合法的狀況，left, right 都同時右移，直到出現合法，才會只有 right 右移，同時 windows 增大）

需要維護 max_freq 去算目前 windows_size 最大的頻率。

Time Complexity

O(n)

Space Complexity

O(1) # 留意因為這題只有大寫，所以只有 O(26) = O(1)

Boundary conditions

s=""
s=“A”

注意邊界處理

2026-07-23 二刷

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

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        count = {}
        max_freq = 0
        max_window_size = 0
        left = 0
        for right, c in enumerate(s):
            count[c] = count.get(c, 0) + 1
            max_freq = max(max_freq, count[c])
            window_size = right - left + 1
            if window_size - max_freq > k: # invalid
                count[s[left]] -= 1
                left += 1
            # right and left move 1 step, keep the max window size same
            # and try to find the longer window
            max_window_size = max(max_window_size, right - left + 1)

        return max_window_size

算法說明

這題特別之處在於只求最長，因此當已經發現最長 window 時，當出現 invalid 的情況可以直接平移（此長度已經存在答案）
直到出現下一組合法解。

至於判斷合法的部分，透過維護 max_freq 來實驗，但也因為這題只求最長 window 的特性，
其實可以不用讓當前 max_freq 實際等於 windows 內實際的 max_freq (要也可以，但更大的 max_freq 都無法通過，更小的值一定也不會過。)

Time Complexity

O(n)

Space Complexity

O(1), 因為只有大寫字母約 O(26)

Boundary conditions

留意 invalid 條件 = window_size - max_freq > k (<= k 都可以用題目條件說明的進行文字替換而合規)

2022-06-07 一刷

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

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:

        ans = 0
        window_counter = defaultdict(int)
        max_counter = 0
        start = 0

        for end in range(len(s)):
            # print(start, end, s[start:end+1])
            new_word = s[end]
            window_counter[new_word] += 1
            max_counter = max(max_counter, window_counter[new_word])

            # end - start + 1 = window length (delete max duplicate <= k)
            if (end - start + 1) - max_counter <= k:
                ans = max(ans, end - start + 1)     
            else: # wrong case, move window (first delete then move)
                delete_word = s[start] 
                window_counter[delete_word] -= 1
                start += 1

        return ans

算法說明

讓我們先來理解題目，這題目主要是在詢問我們在「允許替換最多 k 個文字的情況下」，
我們能夠組出的最長文字。

我們使用「sliding window」的概念，配合 counter，計算最多重複的字元。

我們可以藉由不斷移動 end，當發現 window 不滿足條件時，
我們「不改變 window 的大小 (已經是最大)」，去不斷的 move start 直到 window 有機會變得更大。

window 大小只會變大，「當發現不符合規則時，我們只會繼續移動 window，不會縮小 window」

input handling

一同在 for 內處理

Boundary conditions

用 for 來控制範圍

Reference

替换后的最长重复字符 · Longest Repeating Character Replacement

【Leetcode】python - [33] Search in Rotated Sorted Array 個人解法筆記 #重要題型

Thu, 23 Jul 2026 23:04:42 +0800

題目出處

33. Search in Rotated Sorted Array

難度

Medium

題目分類

Array, Binary Search

2026-07-23 四刷

個人範例程式碼 - 四刷 (2026/07/23)

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-1
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            
            # seperate and find asc
            if nums[left] <= nums[mid]: # left is asc side?
                if nums[left] <= target < nums[mid]: # target in asc
                    right = mid - 1
                else:
                    left = mid + 1
            else: # right is asc side
                if nums[mid] < target <= nums[right]: # target in asc
                    left = mid + 1
                else:
                    right = mid - 1

        return -1

算法說明

分邊, 先確認值是否在 Mid 位置
找 asc 那邊
判斷 asc 那側, target 是否在區間裡面不是就去另外一邊找
看哪邊需要 right = mid - 1, left = mid + 1

Time Complexity

O(logN)

Space Complexity

O(1)

Boundary conditions

單一元素：[5]
left <= right, at least check mid once
[1,3], target 3
left += 1, then found
[3,1], target 1
left += 1, then found
特別留意鎖定 asc 範圍時的邊界 nums[left] <= target, target <= nums[right]
另外一邊因為前面已經有比較過 target == nums[mid] 等於反而沒意義, 前面就會抓到
另外還需要留意找 asc 時, nums[left] <= nums[mid] 可包含等於, 這才能處理當 target 在另外一側時, 此等於的邏輯能成功的讓 left, right 更新正確的值

2022-06-07 三刷

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        start = 0
        end = len(nums) - 1

        while start + 1 < end:
            mid = (start + end) // 2
            # print(start, mid, end)
            # print(nums[start], nums[mid], nums[end])

            if nums[mid] == target:
                return mid

            if nums[start] < nums[mid]: # front: simple go up
                if nums[start] <= target < nums[mid]:
                    end = mid   
                else:
                    start = mid
            else: # back: simple go up
                if nums[mid] < target <= nums[end]:
                    start = mid
                else:
                    end = mid

        else:
            if nums[start] == target:
                return start
            elif nums[end] == target:
                return end
            else:
                return -1

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

算法說明

分成 2 種 case 討論，2 種 case 底下又有兩種 case，

先看 mid 的落點，
分成「start < mid」或「mid < end」

再來各自看 target 的落點，(看有沒有落在單純上升的範圍)。

最後我們可以整理成：

「start < mid」

「start < target < mid」：純上升範圍
「else」：亂的範圍 (依然是 rotated sorted array)

「mid < end」

「mid < target < end」：純上升範圍
「else」：亂的範圍 (依然是 rotated sorted array)

input handling

處理沒有輸入的時候，return -1

Boundary conditions

binary search 的結束條件

2022-04-05 二刷

個人範例程式碼 - 二刷 (2022/04/05)

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

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(nums[mid] >= nums[end]):
                if(nums[start] <= target <= nums[mid]):
                    end = mid
                else:
                    start = mid
            else: # (nums[mid] < nums[end]):
                if(nums[mid] <= target <= nums[end]):
                    start = mid
                else:
                    end = mid

        else:
            if(nums[start] == target):
                return start
            elif(nums[end] == target):
                return end
            else:
                return -1

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

算法說明

這題可以說是 binary search 的最 #重要問題，
主要因為要寫得出這題，基本上要對 binary search 的各種細節幾乎都已經非常清楚才寫得出來。

注意幾個討論的重點，我們可以把整個題目拆成 2*2 個 case，

比 start 還大的情況 (等同於 >= end 的情況)
比 end 還小的情況

然後再針對這兩個情況，再拆成兩種 mid 的情況：

比 start 還大的情況 (等同於 >= end 的情況)

start < target < mid 的情況
else

比 end 還小的情況

else
mid < target < end 的情況

我們要注意移動的時候要移動 start 還是 end，可以從圖上觀察而出。

此外，邊界條件的處理也是此題相當重要的關鍵。

「>= end」

這個觀念我們在【Leetcode】python – [153] Find Minimum in Rotated Sorted Array 個人解法筆記
已經有詳細討論過，如果不清楚可以去看看

「邊界有沒有等於」?

這問題也非常重要，因為這會影響我們要移動 start 或是 end，
而我們需要讓邊界「等於」，因為如果 mid 正好是解答，

我們需要讓「移動側 = mid = target」，因此邊界條件中會有「包含等於的條件」

input handling

處理沒有輸入的時候，return -1

Boundary conditions

binary search 的結束條件

2021-07-07 一刷

個人解法筆記 (解法重點) - 2021/7/7 一刷

示意圖

注意事項

注意 corner case 的處理
範例： [5, 1, 3]

需要注意判斷非 ascending 時，是否該值會出現在對應的區間。

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        l_idx , r_idx = 0, len(nums)-1

        while l_idx <= r_idx:
            mid_idx = (l_idx + r_idx)//2

            if nums[mid_idx] == target:
                return mid_idx

            # search left
            if nums[l_idx] <= nums[mid_idx]:
                if nums[l_idx] <= target and target < nums[mid_idx]: # ascending side
                    r_idx = mid_idx - 1
                else:
                    l_idx = mid_idx + 1

            # search right
            else: 
                if nums[mid_idx] < target and target <= nums[r_idx]: # ascending side
                    l_idx = mid_idx + 1
                else:
                    r_idx = mid_idx - 1


        return -1

Reference

【Leetcode】python - [146] LRU Cache 個人解法筆記 #重要題型

Sun, 19 Jun 2022 01:49:10 +0800

題目出處

146. LRU Cache

難度

Medium

題目分類

Hash Table, Linked List, Design, Doubly-Linked List

2022-06-19 二刷

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

class Node:
    def __init__(self,key, val):
        self.key = key
        self.val = val
        self.next = None
        self.prev = None

class LRUCache:

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hash = {}
        self.head = Node(-1, -1)
        self.tail = Node(-1, -1)
        self.head.next = self.tail
        self.tail.prev = self.head


    def get(self, key: int) -> int:
        if key not in self.hash:
            return -1
        node = self.hash[key]
        self.remove_node(node)
        self.move_to_tail(node)
        return node.val


    def put(self, key: int, value: int) -> None:
        if self.get(key) != -1: # old key
            self.hash[key].val = value
            return

        # new key
        if len(self.hash) >= self.capacity:
            self.pop_front()
        node = Node(key, value)
        self.move_to_tail(node)
        self.hash[key] = node

    def remove_node(self, node):
        node.prev.next = node.next # remove front-> node
        node.next.prev = node.prev # remove node -> next

    def move_to_tail(self, node):
        node.prev = self.tail.prev # tail.prev <- node
        node.next = self.tail # node -> tail

        node.prev.next = node # tail.prev -> node
        self.tail.prev = node # node <- tail


    def pop_front(self):
        del self.hash[self.head.next.key]
        self.head.next = self.head.next.next
        self.head.next.prev = self.head



# Your LRUCache object will be instantiated and called as such
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

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

算法說明

在標準的解答中，大概念是我們要設計一個 Linked List 配合 hashtable 進行 node 的快速查找，

我們可以把功能進行拆分，大致上我們會需要：

get：(取得新元素，題目需要)
put：(加入新元素，題目需要)
remove_node：移除一個元素 node
move_to_tail：將一個元素新增至 tail
pop_front：處理當 capacity 滿的時候，將最舊的元素移除

而為了快速且方便的能在 Linked List 中移動，
我們使用雙向的 Linked List，這樣在「查找前面一個元素」時，會非常方便

input handling

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Boundary conditions

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

2022-05-18 一刷

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

有解出來，但不是題目要的 (queue + hashtable)

class LRUCache: # recently

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hashtable = {}
        self.queue = deque()


    def get(self, key: int) -> int:
        if key not in self.queue:
            return -1

        value = self.hashtable[key]
        self.queue.remove(key)
        self.queue.append(key)
        # print(self.queue)

        return value

    def put(self, key: int, value: int) -> None:
        if key in self.queue:
            self.queue.remove(key)
        self.queue.append(key)
        self.hashtable[key] = value

        if len(self.queue) > self.capacity:
            key = self.queue.popleft()
            # del self.hashtable[key]
        # print(self.queue)


# Your LRUCache object will be instantiated and called as such
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

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

算法說明

LRU cache 的設計方式，主要是由 linked list + hashtable

概念就是透過 linked list 保持順序性，而透過 hashtable 去查詢。

input handling

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Boundary conditions

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Reference

LRU缓存策略 · LRU Cache

【Lintcode】python - [431] Connected Component in Undirected Graph 個人解法筆記 | 內含 BFS 模板 #重要題型

Wed, 08 Jun 2022 03:23:11 +0800

題目出處

431 · Connected Component in Undirected Graph

難度

medium

題目分類

Depth-First Search, Breadth-First Search, Union-Find, Graph Theory

2022-06-08 三刷

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

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

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here
        if not nodes:
            return nodes

        visited = set()
        ans = []
        for node in nodes:
            if node not in visited:
                ans.append(self.get_connected_parts(nodes, visited, node))

        return ans

    def get_connected_parts(self, nodes, visited, start_node):
        queue = [start_node]
        ans = []
        visited.add(start_node)

        while queue:
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors:
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

BFS 搜尋圖，並把同一組的歸類再一起。

input handling

Boundary conditions

用 for 配合 visited 來尋找 start_node，
bfs 內部用 queue 來掌控搜尋範圍。

2022-06-07 二刷

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

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

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here

        visited = set()
        ans = []
        for node in nodes:
            if node not in visited:
                ans.append(self.bfs(nodes, node, visited))

        return ans

    def bfs(self, nodes, start_node, visited):
        ans = []
        queue = [start_node]
        visited.add(start_node)

        while queue:
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors:
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

BFS 搜尋圖，並把同一組的歸類再一起。

input handling

Boundary conditions

用 for 配合 visited 來尋找 start_node，
bfs 內部用 queue 來掌控搜尋範圍。

2022-06-01 一刷

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

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

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here
        if not nodes:
            return []

        ans = []
        visited = set()
        for node in nodes:
            if node in visited:
                continue
            visited.add(node)
            ans.append(self.bfs(node, visited))

        return ans

    def bfs(self, start_node, visited):
        ans = []
        queue = [start_node]
        while(queue):
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors: # add all not visited neighbor
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

經典的 bfs 問題，可以複製此架構變化的 BFS 題目很多。

最外圈，先透過 for 確保所有 node 都會被搜尋，再搭配上 visited，確保不重複搜尋。
內圈的 BFS，我們透過 while 不斷地新增 nighbor，直到 visited 全滿不能再新增，就結束回傳答案。

由於題目有要求回傳的答案要是 sorted，請注意先 sorted 後再回傳。

input handling

處理沒有 input 的情況，return []

Boundary conditions

用 for 配合 visited 來尋找 start node，
bfs 內部用 queue 來掌控搜尋範圍。

Reference

找无向图的连通块 · Connected Component in Undirected Graph

【Lintcode】python - [92] Backpack 個人解法筆記 | 內含背包問題模板 #重要題型

Wed, 01 Jun 2022 16:50:25 +0800

題目出處

92 · Backpack

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param m: An integer m denotes the size of a backpack
    @param a: Given n items with size A[i]
    @return: The maximum size
    """
    def back_pack(self, m: int, a: List[int]) -> int:
        # write your code here
        # define: dp[i][j], i = this round take, j = volume
        # dp[i][j] = dp[i-1][j] # last round take
        #          = dp[i-1][j - A[i-1]] # inherit last take, we take new can succeed (only when j - A[i-1] >= 0)

        # ans: last True dp[i][volume?]

        # init: dp[all][0] = True, other False
        dp = [[False]*(m+1) for _ in range(len(a)+1)] # i = m, j = count nums
        dp[0][0] = True

        for i in range(1, len(a)+1):
            dp[i][0] = True
            for j in range(1, m + 1):
                dp[i][j] = dp[i-1][j]
                if j - a[i-1] >= 0: # can take this
                    dp[i][j] = dp[i][j] or dp[i-1][j - a[i-1]]

        # print(dp)
        for i in range(m+1):
            if dp[-1][m-i]: # check max volume
                return m-i

        return -1 # not found

算法說明

本題是背包系列問題的第 1 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

最經典的背包問題，我們用 dp 去解，
要理解背包問題，建議自己畫過一次表，會比較容易理解 DP 邏輯運作的奧妙。

用圖解析 DP 的分析過程

在這題目裡面，因為我們只有單純拿，因此我們不需要注意順序，不用花 O(nlogn) 的時間先 sort()

state

分析概念：我們建立一張表 dp[i][j]， i 位置表示我們這回合要處理的新增物品，j 表示背包目前已經有的大小。

init

初始化時：dp[i][0], dp[0][j] 都為 True，其他 init 為 False

define

dp[i][j] = dp[i-1][j] # default 情況，我們複製上個階段的所有結果。

特殊情況： last_volume = j - nums[i-1] # 表示如果本次我們選擇拿新東西，是否有可能有這個組合的大小。
dp[i][j] = dp[i][j] or dp[i-1][last_volume] # 任意 True 即可

ans

dp[-1][j] # 從最大直到找到第一個 True，就是結果。

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for size (表示我們選擇新的項目)
內層 for volume (表示紀錄目前已有的選擇下，可否達到裝滿的目標)

Reference

背包问题 · Backpack

【Leetcode】python - [62] Unique Paths 個人解法筆記 #重要題型

Mon, 23 May 2022 13:56:05 +0800

題目出處

62. Unique Paths

難度

Medium

題目分類

Math, Dynamic Programming, Combinatorics

2022-05-23 一刷

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

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if not m or not n:
            return 0

        dp = [[1 for _ in range(n)] for _ in range(m)]

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i][j-1] + dp[i-1][j]

        return dp[-1][-1]

算法說明

也是經典的二維 DP 問題，
透過建立下方的圖片，就可以求得所有路徑的答案

(DP 記錄到達那一格的所有方法數)

input handling

如果沒有 m 或 n，return 0 (無方法)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

【Leetcode】python - [78] Subsets 個人解法筆記 #重要題型

Mon, 23 May 2022 13:09:00 +0800

題目出處

78. Subsets

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        ans = []
        self.dfs(nums, 0, [], ans)

        # print(ans)        
        return ans

        # [] 
        # [1] [12] [123]
        #     [13]
        # [2] [23]
        # [3]

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion        
        # define and split (use or not use)
        for i in range(start, len(nums)):       
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop() # backtracking

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

算法說明

經典 DFS 的組合問題，思考方式如下：

每一層我們都可以決定「取特定數字或不取」，但取或不取，順序都要一直往後。

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 · Subsets

【Leetcode】python - [90] Subsets II 個人解法筆記 #重要題型

Mon, 23 May 2022 13:01:52 +0800

題目出處

90. Subsets II

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        nums.sort()

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

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion, define ans split
        for i in range(start, len(nums)):
            if i > start and nums[i] == nums[i-1]: # only take first duplicate
                continue
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop()

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

算法說明

此題的前一題為無重複版本，這題要多處理重複，可參考：

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

經典 DFS 的組合問題，這題要多處理重複的部分，

我們先 sort() 確保有一致的順序，
我們利用 i > start 來確保跟開始項目相同時，第一組重複有被計算到

注意：不是 i > 0，而是 i > start
start 位置就是代表重複字母的第一個字，除了第一次判斷會拿之外，後面都不會再拿。

if i > start and nums[i] == nums[i-1]: # only take first duplicate
    continue

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 II · Subsets II

【Leetcode】python - [322] Coin Change 個人解法筆記 | 內含 DP 背包問題模板 #重要題型

Wed, 18 May 2022 02:28:31 +0800

題目出處

322. Coin Change

難度

Medium

題目分類

Array, Dynamic Programming, Breadth-First Search

2022-05-18 一刷

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

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        if not coins:
            return -1

        dp = [float("inf") for _ in range(amount+1)]
        dp[0] = 0

        for i in range(1, amount+1):
            for coin in coins:
                if i >= coin and dp[i-coin] != float("inf"):
                    dp[i] = min(dp[i], dp[i-coin]+1) # last dp add this coin

        return -1 if dp[-1] == float("inf") else dp[-1]

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

算法說明

完全背包問題可以把公式解開

初始化，全部 INF，多留一個欄位

dp[0] = 0
dp[i] = INF (無解的情況，保持原樣)
dp[i] = min(dp[i], dp[i-可行的目標]+1) (+1 就是代表替換為此目標，例如可以用5元「換一次 [i-5]+1 個五元」的結果)

input handling

如果沒有 coins，return -1，
最後 dp[-1] 即為答案 (如果是保持 INF 不變，那就回傳 -1)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

换硬币 · Coin Change

【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 - [75] Sort Colors 個人解法筆記 #重要題型 #常錯題型

Thu, 14 Apr 2022 19:51:56 +0800

題目出處

75. Sort Colors

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-14 一刷

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

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # only 0, 1, 2
        self.partition(nums, 2, 0, len(nums)-1)
        return 


    def partition(self, nums, pivot, start, end):
        if pivot == 0:
            return 

        left, right = start, end

        while(left <= right):
            while(left <= right and nums[left] < pivot): # 0, 1
                left += 1
            while(left <= right and nums[right] >= pivot): # 2
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                # check twice
                # left += 1
                # right -= 1
        else: # after left and right cross, all 0, 1 will be left, 2 will be right
            # start, right(0, 1), left(2), end            
            # start, right(0), left(1), end

            self.partition(nums, pivot-1, 0, right)

算法說明

此題是考 partition 的延伸題，也可以單純使用三指標來快速解掉，
不過之後還有一題多顏色的題目，基本上 partition 還是要會解。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

while(left <= right):
    while(left <= right and nums[left] < pivot): # 0, 1
        left += 1
    while(left <= right and nums[right] >= pivot): # 2
        right -= 1
    if(left <= right):
        nums[left], nums[right] = nums[right], nums[left]

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

這題本身較簡單，但其實不需要拆到那麼複雜，
但為了後續的 partition 題目方便，這裡就先用最泛用的方式解

self.partition(nums, pivot-1, 0, right)

遞迴的中止

如果 pivot = 0，return

一樣也是因為這題題目相對單純，因此我們可以這樣寫死。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

Reference

颜色分类 · Sort Colors

【Lintcode】python - [5] Kth Largest Element 個人解法筆記 #重要題型 #常錯題型

Wed, 13 Apr 2022 23:45:45 +0800

題目出處

5 · Kth Largest Element

難度

medium

2022-04-13 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param k: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    def kth_largest_element(self, k: int, nums: List[int]) -> int:
        # write your code here
        if not nums:
            return -1 # not found

        # 1, 2, 3,  first: idx = 2 = len(s)-k (k=1)
        return self.quickselect(k-1, nums, 0, len(nums)-1)

    def quickselect(self, k, nums, start, end):
        if not nums:
            return -1

        # recursion end
        if start == end:
            return nums[k]

        # recursion define
        left, right = start, end
        pivot = nums[(start + end) // 2]
        while(left <= right):
            while(left <= right and nums[left] > pivot): # bigger go to left, descending sorting
                left += 1
            while(left <= right and nums[right] < pivot):
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
                right -= 1
        else: # recursion split # start < right < left < end
            # print(nums)
            if start <= right and right >= k: # search left and still need sorting
                return self.quickselect(k, nums, start, right)
            elif left <= end and left <= k: # search right and still need sorting
                return self.quickselect(k, nums, left, end)
            else:
                return nums[k]

算法說明

此題有類似題，可參考：

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

最大的差別只在於 smallest 變 largest，簡單處理把 ascending 換成 descending 即可。

這題用到 QuickSelect 的概念，簡單來說就是藉由「每一次都切一半，減少一半的搜尋範圍」，
分出剩餘的另外一半後，再去嘗試切一半，進行 O(logN) 的快速尋找。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

這裡我自己錯好多次，總之不熟悉處理起來很麻煩，

導入 quickselect 的概念，我們把原本要搜尋的範圍切成兩半，
將比 pivot 小的往左擺，大的往右擺，一樣大的先不管

(管了會出事，會有無限迴圈：例 [3, 9, 4, 8]: 9 never moves.)

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

可附加條件為「right >= k」、「left <= k」，我們可以提早結束 k 的搜尋。

start ~ right, right >= k：左側還比 k 多，需要再排序
left ~ end, left <= k：右側還比 k 少 (= 左側比 k 多)，需要再排序

遞迴的中止

如果 start end，return nums[k] ，

怎麼保證這一定會發生就是個大問題了，這也是最常出錯的地方，我錯好多次…
簡單來說我們可以想一些比較極端的 case，程式也都要能正常結束。

例如： [1,1]，k = 1 (index 0), k = 2(index 1)

這邊我暫時先這樣想，哪天有更好的想法再回來補吧。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

Reference

无序数组K小元素 · Kth Smallest Numbers in Unsorted Array

【演算法筆記 #3】QuickSort 重點整理筆記，包含 Partition, Pivot 常見錯誤討論 #重要題型

Sun, 10 Apr 2022 03:29:01 +0800

前言

QuickSort 算是面試中或是演算法中經典的問題，非常重要，
而且最容易搞錯「他的範圍」，因此這邊來將自己的常見錯誤做個整理。

先一個正式版本

基本上，要講出 QuickSort 的核心精神，人人幾乎都不太會犯錯，
但程式非常容易寫錯，特別是在區間的控制過程。

QuickSort 的核心精神

QuickSort 的核心精神就是選定一個 pivot (可以頭可以尾)，
將剩下的數字透過 pivot 分成「 < pivot 」與「 > pivot 」兩組。

最容易出錯的地方 - 決定邊界

在撰寫程式的時候，如果沒有仔細思考，或甚至已經仔細思考了都還經常會寫錯。

注意：這邊示範的並「不是」主流的教科書寫法，而是用釐清觀念候「用自己的方式」寫的。

我們的目的如上圖，就是希望在循環結束時，能夠

讓 left 左邊的一切都是 smaller (than pivot)
讓 right 右邊的一切都是 bigger (than pivot)

因此 (以下為說明用的程式碼，並不完整)

while(left <= right):
    while(left <= right and a[left] < pivot):
        left += 1
    while(left <= right and a[right] > pivot):
        right -= 1
    if left <= right:
        a[left], a[right] = a[right], a[left]

注意啦! 光上面這裡有很多細節了!

left <= right

首先是 left <= right，如果寫 left < right 達不到交錯的效果，有可能出迴圈要多做處理

不是不能這樣寫，就是要多做一些處理，沒有什麼不能的寫法

a[left] < pivot, a[right] > pivot

注意這裡不處理等於，原因是處理等於也不一定好，
等於表示與 pivot 相等，用於處理重複的 array，
但如果硬要處理等於的情況，在 [1,1,1,1,1] 類似這樣的 case，
一定會用 worst case 的 O(n) 時間去解，而不是平均的 O(nlogN)。

可以先理解 QuickSort 的 worst case 是什麼情況及為什麼會發生，
這樣更能夠懂為什麼會舉到上面的例子。

此種類的完整的 QuickSort 程式碼

    def partition(self, nums, start, end):
        # recusion end
        if start >= end:
            return 

        # recursion define
        left, right = start+1, end
        pivot = nums[start]

        while(left <= right):
            while(left <= right and nums[left] < pivot):
                left += 1
            while(left <= right and nums[right] > pivot):
                right -= 1
            if left <= right:
                nums[left], nums[right] = nums[right], nums[left]
        else:
            nums[start], nums[right] = nums[right], nums[start]

        print(nums, left, right)

        # recursion split
        self.partition(nums, start, right-1)
        self.partition(nums, left, end)

抓 partition 與 pivot 的重點

我們設計的思想是

一開始： pivot(start) < (left, start+1) < (right, end)

- 結束時，交換前 (注意交錯)：

(start) < start+1 < right < left < end

務必注意交錯的位置的「 right < left 」，這是最最重要的部分。

結束時，交換後 (注意交錯)：

start < right-1 < pivot(right) < left < end

而 start ~ right-1 都比 pivot 小
left < end 都比 pivot 大。

結束迴圈 recursion 「start >= end」

不論是

self.partition(nums, start, right-1)
self.partition(nums, left, end)

right 會越來越逼近 start，直到重疊 start >= end
而 left 也會越來越逼近 end (因為 left 與 right 是交錯，只會更逼近 end)

另外一種寫法

建議先嘗試閱讀以下程式碼，思考一下
(這我寫過的東西，我也想了很久為什麼)

while(left <= right)
    if a[left] < pivot:
        left += 1
    elif a[right] > pivot:
        right -= 1
    else:
        a[left], a[right] = a[right], a[left]
        # left += 1
        # right -= 1

建議想好後再看，這樣才會更印象深刻。

注意 left <= right

一樣要注意的 left <= right，因為一定要交錯。

「left += 1」、「right -= 1」可有可無

其中「left += 1」、「right -= 1」可有可無，
沒有當下處理也會在之後的迴圈被處理掉。

此種類的完整的 QuickSort 程式碼

def partition(self, nums, start, end):
        # recusion end
        if start >= end:
            return 

        # recursion define
        left, right = start+1, end
        pivot = nums[start]

        while(left <= right):
            if nums[left] < pivot:
                left += 1 
            elif nums[right] > pivot:
                right -= 1 
            else:
                nums[left], nums[right] = nums[right], nums[left]
        else:
            nums[start], nums[right] = nums[right], nums[start]

        # recursion split
        self.partition(nums, start, right-1)
        self.partition(nums, left, end)

抓 partition 與 pivot 的重點

我們設計的思想是

一開始： pivot(start) < (left, start+1) < (right, end)

- 結束時，交換前 (注意交錯)：

(start) < start+1 < right < left < end

務必注意交錯的位置的「 right < left 」，這是最最重要的部分。

結束時，交換後 (注意交錯)：

start < right-1 < pivot(right) < left < end

而 start ~ right-1 都比 pivot 小
left < end 都比 pivot 大。

結束迴圈 recursion 「start >= end」

不論是

self.partition(nums, start, right-1)
self.partition(nums, left, end)

right 會越來越逼近 start，直到重疊 start >= end
而 left 也會越來越逼近 end (因為 left 與 right 是交錯，只會更逼近 end)