724 - LeetCode Binary Search on 嗡嗡的隨手筆記

【Leetcode】python - [153] Find Minimum in Rotated Sorted Array 個人解法筆記

Fri, 24 Jul 2026 02:36:25 +0800

題目出處

153. Find Minimum in Rotated Sorted Array

難度

medium

題目分類

Array, Binary Search

2026-07-24 二刷

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

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left, right = 0, len(nums) - 1
        while left < right:
            mid = (left + right) // 2 # left <= mid < right
            if nums[mid] < nums[right]: # ans in left side
                right = mid # mid can be ans (rotation start here)
            else: # ans in right side
                left = mid + 1

        return nums[left]

算法說明

第一次寫的時候我在 nums[mid] < nums[right] 中加了 early return (提前判 asc 而提早回傳答案)，
這解法合理但容易讓邏輯不夠乾淨，且 early return 省下的量級不多，還多一層判斷。

Time Complexity

O(logN)

Space Complexity

O(1)

Boundary conditions

[1]：直接出迴圈
[1,2]：right = mid 能處理
[2,1]：left = mid + 1 能處理
[1,2,3,4]：變 [1,2] 然後同 2.

2022-04-05 一刷

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

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

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if nums[mid] == nums[end]: # if special case exist
                start = mid
            elif nums[mid] > nums[end]: # still going up
                start = mid
            else: # [mid] < [end] # going down, move start yo get closer
                end = mid
        else:
            if(nums[start] <= nums[end]):
                return nums[start]
            else:
                return nums[end]

算法說明

binary search

input handling

處理沒有輸入的時候，return 0

Boundary conditions

正常的 start, end 要注意，此外

注意點 - 要比較的大小對象? First? Last?

請思考以下問題：

我們的 nums[mid] 應該要比較誰?

(A) > nums[first]
(B) >= nums[first]
(C) > nums[end]
(D) >= nums[end]

思考一下，答案為 (D) >= nums[end]

(B), (C) 基本上代表是同一個意思，而只比較 first 會出問題的地方在於 [2, 3, 1] 與 [1, 2, 3]

正常的 [2, 3, 1]，我們可以透過 2 > 1 處理掉，start 往中間移動，
但 [1, 2, 3]，我們會發現我們移動了 1 -> 2，start 被移動掉了，因此找不到正確答案。

而 (A) > nums[first]，就更不用提了。

Reference

寻找旋转排序数组中的最小值 · Find Minimum in Rotated Sorted Array

【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

算法說明

分成 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

算法說明

這題可以說是 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 - [53] Maximum Subarray 個人解法筆記

Thu, 23 Jul 2026 04:26:14 +0800

題目出處

53. Maximum Subarray

難度

Easy

題目分類

Array, Divide and Conquer, Dynamic Programming

2026-07-23 三刷

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

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        best_ending_here = best_so_far = nums[0]
        for i in range(1, len(nums)):
            # add best sums before will be better or not (then just take current)?
            best_ending_here = max(best_ending_here + nums[i], nums[i])
            best_so_far = max(best_so_far, best_ending_here)

        return best_so_far

算法說明

best_ending_here 比較包含這個的最大，兩種可能：

前面總和+自己比較大
自己比較大（發生於前面總和為負的情況）

這題基本上如果恆正只要一直加就能最大，只需要用以上方式處理有「前方總和有負」（不是單純此值為負）出現的情況

best_so_far 紀錄一直以來的最大

Time Complexity

O(n)

Space Complexity

O(1)

Boundary conditions

i = 1, best 為 nums[0], 拿去當預設結果
i = 2, best 可能為 nums[0], nums[1], nums[0]+nums[1], for loop 需要從 1 開始跑

2022-04-28 二刷

個人範例程式碼 - 2022/4/28

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

        current_max_with_this = [nums[0]]

        for i in range(1, len(nums)):
            current_max_with_this.append(max(current_max_with_this[i-1]+nums[i], nums[i]))

        return max(current_max_with_this)

算法說明

建一個新的 array，記錄"包含自己"的當前最大用

當前最大 = max(當前數字, 當前數字+到前一個之前最大)

input handling

如果 input not nums (沒有數字)，return 0

Boundary conditions

for 控制範圍

2022-02-24 一刷

個人範例程式碼 - 2022/2/24

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [] # dp = the biggest answer 'include me'
        for i in range(len(nums)):
            if i == 0:
                dp.append(nums[i])
            else:
                bigger = max(nums[i], nums[i]+dp[i-1])
                dp.append(bigger)

        return max(dp)

說明

這題我使用的是 DP 的解法，
我宣告一個 DP 來儲存「包含自己的」時最好的答案。

換句話說，我將題目拆解成到「包含每一個 index 的當下」都是一個小題目，將題目的答案儲存進 dp 中。

所以假設原來的題目變成：
nums = [1,2,-1,4]
dp = [1,3,2,6]

【Leetcode】python - [191] Number of 1 Bits 個人解法筆記

Mon, 06 Jun 2022 16:23:17 +0800

題目出處

191. Number of 1 Bits

難度

easy

題目分類

Divide and Conquer, Bit Manipulation

2022-06-06 一刷

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

class Solution:
    def hammingWeight(self, n: int) -> int:

        # 7 (10) = 111 (2)
        # 4 (10) = 100 (2)
        # 3 (10) = 011 (2)

        cnt = 0
        while(n != 0):
            cnt += (n & 1) # and first bit
            n = n >> 1 # (// 2)
        return cnt

算法說明

簡單的位元運算題目，
我們可以先觀察「 10進位 (10) 與 2進位 (2) 」的變化，

7 (10) = 111 (2)

4 (10) = 100(2)

3 (10) = 11(2)

我們提取第一個位元 (最右側位元) 的方式是 (原數字 & 1)，
並一路往右 » 1，直到原值只剩下 0。

input handling

Boundary conditions

用 while 至 0 來控制範圍。

Reference

判断一个整数中有多少个1 · Number of 1 Bits

【Leetcode】python - [347] Top K Frequent Elements 個人解法筆記

Mon, 06 Jun 2022 04:15:49 +0800

題目出處

347. Top K Frequent Elements

難度

medium

題目分類

Array, Hash Table, Divide and Conquer, Sorting, Heap (Priority Queue), Bucket Sort, Counting, Quickselect

2022-06-06 一刷

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

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

        # O(N)
        counter = Counter(nums)
        freq_counter = defaultdict(list)

        # O(N)
        for key, value in counter.items():
            freq_counter[value].append(key)

        ans = []
        # O(NlogN)
        for key in sorted(freq_counter.keys(), reverse=True):
            ans += freq_counter[key]
            k -= len(freq_counter[key])
            if k <= 0:
                break

        return ans

直接使用 dict.items() + sorted tuple 排序

更俐落一點的寫法，直接把 dict.items() 轉作 tuple 來看後，直接排序
如果用法不熟，用上面方法即可。

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

        # O(N)
        counter = Counter(nums) # key: freq

        # O(NlogN)
        sorted_tuple_by_freq = sorted(counter.items(), key=lambda x: x[1], reverse=True)

        # print(sorted_tuple_by_freq)

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

        return ans

算法說明

我們先計算數字頻率，可以搭配內建函數 counter 快速實現，
再來針對出現次數進行排序，
然後選出前 K 個答案即可。

input handling

如果沒有 nums，return nums

Boundary conditions

用 for 來控制範圍

Reference

前K个高频元素 · Top K Frequent Elements

【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 - [300] Longest Increasing Subsequence 個人解法筆記

Mon, 23 May 2022 03:07:54 +0800

題目出處

300. Longest Increasing Subsequence

難度

Medium

題目分類

Array, Binary Search, Dynamic Programming

2022-05-23 一刷

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

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        # 1 3 5 4 7
        # 1 1 1 1 1
        # 1 2 3 3 4

        dp = [1 for _ in range(len(nums))]

        for i in range(1, len(nums)):
            for j in range(i):            
                if nums[j] < nums[i]:
                    dp[i] = max(dp[i], dp[j]+1)

        return max(dp)

算法說明

經典題目 LIS，使用 DP 解題

# 1 3 5 4 7
# 1 1 1 1 1
# 1 2 3 3 4

init: dp 都 1
function: dp[i] = max(dp[i], dp[j]+1) if 0 <= j < i
ans: max(dp)

input handling

同 DP 內控制範圍

Boundary conditions

用 for loop 控制搜尋範圍

Reference

【Leetcode】python - [349] Intersection of Two Arrays 個人解法筆記

Thu, 12 May 2022 03:49:37 +0800

題目出處

349. Intersection of Two Arrays

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 一刷

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

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

算法說明

一個 set and 就結束了…
好舒服的 easy 題目…

input handling

set and 的過程會幫我們處理掉

Boundary conditions

Reference

【Leetcode】python - [350] Intersection of Two Arrays II 個人解法筆記

Thu, 12 May 2022 02:55:05 +0800

題目出處

350. Intersection of Two Arrays II

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 三刷

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

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        intersect_counter = (Counter(nums1) & Counter(nums2))

        ans = []
        for key, value in intersect_counter.items():
            for _ in range(value):
                ans.append(key)

        return ans

算法說明

此題目的前一題為不需要進行重複值處理，這題需要處理重複，可參考：

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

Counter & Counter：可以找到所有重複的數值 & 數量

input handling

dict and 的過程中會處理掉

Boundary conditions

2022-03-04 二刷

個人範例程式碼 - 2022/3/4 二刷 (set & counter 流)

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = []
        for ele in (set(nums1) & set(nums2)):
            for i in range(min(Counter(nums1)[ele], Counter(nums2)[ele])):
                ans.append(ele)
        return ans

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
不過沒關係，遇到重複了，我們還有 Counter!

先用 set 快速找出有重複的，
再用確定有重複的，計算數量後，取較少的即可得到答案。

corner case 特殊情況處理

記得要找的是兩個集合的 min，而不是「只找單邊」

Boundary conditions/ Edge conditions 邊際情況處理

2022-02-25 一刷

個人範例程式碼 - 2022/2/25 一刷 (two pointer 流)

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        # print(set(nums1) & set(nums2))
        nums1, nums2 = sorted(nums1), sorted(nums2)
        res = []
        pt1, pt2 = 0, 0
        while(pt1 < len(nums1) and pt2 < len(nums2)):
            if nums1[pt1] > nums2[pt2]:
                pt2 += 1
            elif nums1[pt1] < nums2[pt2]:
                pt1 += 1
            else: # nums1[pt1] == nums2[pt2]
                res.append(nums1[pt1])
                pt1 += 1
                pt2 += 1
        return res

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
因為它是允許有 [1,1,2,2] 去交集 [2,2] 的
所以如果我門直接用 set，會把重複的 2 給用掉。
因此這題不能用 set 的作法。

我們採用的是 sort 後並使用兩個 pointer，一個個對照，
只要發現比較小的那側，就往下一個數字前進，
而如果兩者是一樣的，我們就同時一起前進。

邊際情況處理

這題目需要處理的邊際情況為 pointer 什麼時候結束，
我們需要知道，當其中一個 pointer 已經「指完了全部的內容」，
就沒有繼續往下看的必要了。因為另外一個再往下看，也一定找不到一樣的值。

所以我們使用 while 設定範圍在 pt1 < len(nums1) 的範圍內，
就可以處理這個問題。

Reference

【Leetcode】python - [268] Missing Number 個人解法筆記

Wed, 04 May 2022 16:31:39 +0800

題目出處

268. Missing Number

難度

easy

題目分類

Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting

2022-05-04 一刷

個人範例程式碼

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

        num_set = set(nums)
        n = len(nums) + 1
        for i in range(n):
            if i not in num_set: # O(1)
                return i

算法說明

因為 list 搜尋是 O(N) 時間，
為了加速，先轉成 hashset，搜尋時間變成 O(1)

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

個人範例程式碼 - set

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

        num_set = set([x for x in range(len(nums)+1)])
        return (num_set - set(nums)).pop()

算法說明

set - set，找到缺少的內容

set.pop() 可以取得 set 裡面的內容，例如從 {2} 中取得 2

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

Reference

寻找缺失的数 · Missing Number

【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 - [167] Two Sum II - Input Array Is Sorted 個人解法筆記

Wed, 06 Apr 2022 19:34:18 +0800

題目出處

167. Two Sum II - Input Array Is Sorted

難度

medium

題目分類

Array, Two Pointers, Binary Search

2022-04-06 一刷

個人範例程式碼 - two pointers

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

        start, end = 0, len(numbers)-1
        while(start < end):
            if(numbers[start] + numbers[end] == target):
                return [start+1, end+1]
            elif(numbers[start] + numbers[end] < target): # smaller
                start+= 1
            else: # (numbers[start] + numbers[end] > target):
                end -= 1
        else:
            return [-1, -1]

算法說明

這題我們在之前的題目已經有詳細說明了，可參考：

【Leetcode】python - [1] Two Sum 個人解法筆記 (last update: 2022/04/06) | 內有 list comprehesion / dict comprehesion 整理

另外，這題因為有「已經排序」的特性，目的就是為了解決表格中的 sort，
加速 two pointers 做法的時間複雜度。

	hashmap	two pointers
空間複雜度	O(n)	O(1)
時間複雜度	O(1)	O(n), 但有前置步驟 sort = O(nlogN)

input handling

處理沒有 input 的狀況，return [-1, -1]

Boundary conditions

start < end，交錯或等於就結束

Reference

两数和 II-输入已排序的数组 · Two Sum II - Input array is sorted

【Leetcode】python - [162] Find Peak Element 個人解法筆記

Tue, 05 Apr 2022 18:31:43 +0800

題目出處

162. Find Peak Element

難度

medium

題目分類

Array, Binary Search

2022-04-05 一刷

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

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

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

算法說明

幾乎類似題： [852. Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)

可以參考那邊的做法，這邊簡單寫

binary search，仔細討論會發現 mid 總共有 4 種狀況

- [mid-1] < [mid] < [mid+1] ，正在往上走，把 start 移動往 mid (加速上坡) - [mid-1] > [mid] > [mid+1] ，正在往下走，把 end 移動往 mid (減少下坡) - [mid-1] < [mid] > [mid+1] ，paek 就是我們要的山峰 - [mid-1] > [mid] < [mid+1] ，valley 山谷，往兩側走都可

也可以再簡化，其實我們只要判斷一邊就好，
最後會縮小到一個範圍當中，其中一邊是高的，就是我們的局部最佳解。

input handling

處理沒有輸入的時候，return 0 (題目有保證不會有輸入問題)

Boundary conditions

binary search 的結束條件

Reference

寻找峰值 · Find Peak Element

【Leetcode】python - [852] Peak Index in a Mountain Array 個人解法筆記

Tue, 05 Apr 2022 18:21:52 +0800

題目出處

852. Peak Index in a Mountain Array

難度

easy

題目分類

Array, Binary Search

2022-04-05 一刷

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

class Solution:
    def peakIndexInMountainArray(self, arr: List[int]) -> int:
        if not arr:
            return 0

        start, end = 0, len(arr)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(arr[mid] < arr[mid+1]): # next go up, change start near to peak
                start = mid
            else: # next go down
                end = mid

        else:
            if arr[start] >= arr[end]:
                return start
            else:
                return end

算法說明

binary search，仔細討論會發現 mid 總共有 4 種狀況

也可以再簡化，其實我們只要判斷一邊就好，
最後會縮小到一個範圍當中，其中一邊是高的，就是我們的局部最佳解。

移動方式示意圖

觀察 start, end 的移動方法

input handling

處理沒有輸入的時候，return 0

Boundary conditions

binary search 的結束條件

Reference

山脉序列中的最大值 · Maximum Number in Mountain Sequence

【Leetcode】python - [658] Find K Closest Elements 個人解法筆記

Tue, 05 Apr 2022 02:32:16 +0800

題目出處

658. Find K Closest Elements

難度

medium

題目分類

Array, Two Pointers, Binary Search, Sliding Window, Sorting, Heap (Priority Queue)

2022-04-05 一刷

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

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        start, end = 0, len(arr) - 1
        while(start + 1 < end):
            mid = (start + end) // 2
            if arr[mid] == x: 
                start = mid
            elif arr[mid] < x:
                start = mid
            else: # a[mid] > x
                end = mid
        else:
            return self.find_k_neighbors(arr, x, k, start, end) 


    def find_k_neighbors(self, arr, x, k, start, end):
        # print(start, end)
        ans = []
        while(k > 0):
            if((start >= 0) and (end < len(arr)) and (x - arr[start] <= arr[end] - x)): # smaller first
                ans.append(arr[start])
                start -= 1
            elif((start >= 0) and (end < len(arr)) and (x - arr[start] > arr[end] - x)):
                ans.append(arr[end])
                end += 1
            elif(start < 0):
                ans.append(arr[end])
                end += 1
            else: # end >= len(a)
                ans.append(arr[start])
                start -= 1
            k -= 1
            # print(ans)

        return sorted(ans)

算法說明

方法是一樣 binary search 找到中間後 O(logN)，往兩邊搜尋 K 個 O(K)。 = O(logN+K)

個人覺得這題 LintCode 版本出的比較好，Leetcode 出的版本最後多了一個排序，
只是我覺得光是找最近的 K 的結果就已經找到的關鍵，就不用再排序了!

LintCode 版本的題目：460 · Find K Closest Elements

Leetcode 版本的差別只差在我最後多補了一個 sorted 給他。

input handling

應該要做但我沒做XD，不過題目有保證輸入正確就是

Boundary conditions

binary search 的邊界條件

這裡有兩個 Boundary conditions 要注意，一個是一開始的 binary search 的邊界條件

find K 的邊界條件

另外一個要注意的是在找 K 個鄰近的數值時，我們需要注意「不能找到範圍之外」。

Reference

在排序数组中找最接近的K个数 · Find K Closest Elements

【Leetcode】python - [278] First Bad Version 個人解法筆記

Tue, 05 Apr 2022 02:22:32 +0800

題目出處

278. First Bad Version

難度

easy

題目分類

Binary Search, Interactive

2022-04-05 一刷

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

# The isBadVersion API is already defined for you.
# def isBadVersion(version: int) -> bool

class Solution:
    def firstBadVersion(self, n: int) -> int:
        # isBadVersion = true 
        # OOO(X)XXX
        # FFF(T)TTT <- notice this!
        if not n: 
            return 0

        start, end = 1, n

        while(start + 1 < end):
            mid = (start + end) // 2
            if isBadVersion(mid): # [mid] = false (still good version.), move end to search after     
                end = mid
            else: # if isBadVersion(mid) == True: # [mid] = true, move start to search behind
                start = mid

        else:
            if isBadVersion(start):
                return start
            elif isBadVersion(end):
                return end
            else:
                return 0

        return 0

算法說明

變化版本的 binary search，採用的策略為先縮小範圍再得到答案。

也就是說 left, right 縮小至最小範圍的 left, right，再去判斷答案。

當然比較常見的方法是：left, right 找 mid，mid 直接找到答案會更為簡潔。

input handling

注意 input nums 為 0 的時候的處理，return 個 0 給他 (題目好像沒特別提到這個，我自己加的)

Boundary conditions

start 與 end 的處理一直都是 binary search 常出錯的地方，這邊要細心一些。

我採用網路上看到的 start + 1 < end 的方式，先縮小 left, right 範圍
並且不把目標放在直接找到 mid 做為答案。

再從最小範圍 left, right 中找到最終解答。

其他重點

注意 isBadVersion 是「錯的」回傳「True」，
這個雙重否定有弄到我XD，
概念要剛好相反。

Reference

第一个错误的代码版本 · First Bad Version

【Leetcode】python - [34] Find First and Last Position of Element in Sorted Array 個人解法筆記

Fri, 01 Apr 2022 16:33:35 +0800

題目出處

34. Find First and Last Position of Element in Sorted Array

難度

easy

題目分類

Array, Binary Search

2022-04-01 一刷

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

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

        ans = []
        ans.append(self.find_first_position(nums, target))
        ans.append(self.find_last_position(nums, target))
        return ans


    def find_first_position(self, nums, target):
        if not nums:
            return -1

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(nums[mid] == target): # find first, move end
                end = mid
            elif(nums[mid] < target):
                start = mid
            else: #(nums[mid] > target):
                end = mid
        else: # when quit loop
            if(nums[start] == target): # find first
                return start
            elif(nums[end] == target):
                return end
            else:
                return -1
        return -1


    def find_last_position(self, nums, target):
        if not nums:
            return -1

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(nums[mid] == target): # find last, move start
                start = mid
            elif(nums[mid] < target):
                start = mid
            else: #(nums[mid] > target):
                end = mid
        else: # when quit loop
            if(nums[end] == target): # find last 
                return end
            elif(nums[start] == target):
                return start
            else:
                return -1
        return -1

算法說明

此題為以下兩題的綜合題：

因為重複的問題，算法又要求 log(N)，如果同時做左右搜尋會顯得程式碼比較難以閱讀與 debug，
不如就拆成兩個來寫，時間 2*O(logN) = O(logN)

基本的 binary search，採用的策略為先縮小範圍再得到答案。

也就是說 left, right 縮小至最小範圍的 left, right，再去判斷答案。

當然比較常見的方法是：left, right 找 mid，mid 直接找到答案會更為簡潔。

input handling

注意 input nums 為 [] 的時候的處理，return 個 -1 給他

Boundary conditions

start 與 end 的處理一直都是 binary search 常出錯的地方，這邊要細心一些。

我採用網路上看到的 start + 1 < end 的方式，先縮小 left, right 範圍
並且不把目標放在直接找到 mid 做為答案。

再從最小範圍 left, right 中找到最終解答。

Reference

在排序数组中查找元素的第一个和最后一个位置 · Find First and Last Position of Element in Sorted Array

【Leetcode】python - [704] Binary Search 個人解法筆記

Fri, 01 Apr 2022 16:20:32 +0800

題目出處

704. Binary Search

難度

easy

題目分類

Array, Binary Search

2022-04-01 一刷

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

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] == target: # to find first, move end
                end = mid
            elif nums[mid] < target:
                start = mid
            else: # nums[mid] > target:
                end = mid
        else: # when quit loop
            if nums[start] == target:
                return start
            elif nums[end] == target:
                return end
            else:
                return -1

        return -1

算法說明

基本的 binary search，採用的策略為先縮小範圍再得到答案。

也就是說 left, right 縮小至最小範圍的 left, right，再去判斷答案。

當然比較常見的方法是：left, right 找 mid，mid 直接找到答案會更為簡潔。

input handling

注意 input nums 為 [] 的時候的處理，return 個 -1 給他

Boundary conditions

start 與 end 的處理一直都是 binary search 常出錯的地方，這邊要細心一些。

我採用網路上看到的 start + 1 < end 的方式，先縮小 left, right 範圍
並且不把目標放在直接找到 mid 做為答案。

再從最小範圍 left, right 中找到最終解答。

Reference

Binary Search · Binary Search

【Leetcode】python - [74] Search a 2D Matrix 個人解法筆記

Sat, 05 Mar 2022 12:33:26 +0800

題目出處

74. Search a 2D Matrix

難度

medium

題目分類

Array, Binary Search, Matrix

2022-03-05 一刷

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

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        n = len(matrix[0])
        l = 0 # left
        r = m*n-1 # right

        # matrix[idx//n][idx%n]
        while(l <= r):
            mid = (l+r)//2
            if matrix[mid//n][mid%n] == target: # found
                return True
            elif matrix[mid//n][mid%n] < target: # mid smaller than target
                l = mid+1
            else: # mid bigger smaller than target
                r = mid-1

        return False

Time Complexity

O(logN)

Space Complexity

O(1)

算法說明

「查詢」的重要概念

這題帶出了「查詢的重要觀念」，
查詢這件事情基本上的時間複查度，

通常一般會是：

O(n): 每一個都看過
O(1): 有 hash map，用空間換取時間

這題目很明顯已經排好順序了，我們可以每次很輕鬆的進行對半切的動作，
這樣的概念就是「binary search」，之後在 tree 會更常使用。

處理成一維陣列

我們處理的重點就是在 binary search，
我們直接把這個矩陣當一個一維陣列來看，轉換方式為：

m = len(matrix)
n = len(matrix[0])

而 matrix[idx//n][idx%n] 的 idx 就可以代表我們想要的位置。

尋找過程

l = 0 # left
r = m*n-1 # right

我們找 mid = (l + r) //2

當 matrix[mid] target，找到了!
當 matrix[mid] > target，我們比目標大，mid - 1
當 matrix[mid] < target，我們還是比目標小，mid + 1

然後重複濃縮 mid 的範圍

直到 l >= r (因為一直有 +1 -1的操作)，遲早會重疊。

corner case 特殊情況處理

當只有一行時，需要注意處理 idx+1，idx-1 都會出錯

Boundary conditions/ Edge conditions 邊際情況處理

計算到 l >= r (因為一直有 +1 -1的操作)，遲早會重疊。

Reference

Don’t treat it as a 2D matrix, just treat it as a sorted list

【Leetcode】C++ - [53] Contains Duplicate 個人解法筆記內含 C++ vector max 用法整理

Thu, 24 Feb 2022 22:58:52 +0800

題目出處

53. Maximum Subarray

難度

Easy

題目分類

Array, Divide and Conquer, Dynamic Programming

2022-02-24 一刷

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

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp;
        for(int i=0; i< nums.size(); i++){
            if(i == 0){
                dp.push_back(nums[i]); // record 'include me' biggest
            }
            else{
                dp.push_back((nums[i] > nums[i]+dp[i-1]) ? nums[i] : nums[i]+dp[i-1]); // record 'include me' biggest
            }
        }      
        auto it = std::max_element(dp.begin(), dp.end());  
        // std::vector<int>::iterator it;
        // cout << *it << endl;

        // int max_value = *std::max_element(dp.begin(), dp.end());
        // cout << max_value << endl;

        return *it;
    }
};

說明

這題我使用的是 DP 的解法，
我宣告一個 DP 來儲存「包含自己的」時最好的答案。

換句話說，我將題目拆解成到「包含每一個 index 的當下」都是一個小題目，將題目的答案儲存進 dp 中。

所以假設原來的題目變成：
nums = [1,2,-1,4]
dp = [1,3,2,6]

C++ vector max 用法整理

vector 想必是 C++ 最常被使用的資料型態了。
因此如何取 max 我們應該也要來好好記錄一下

以下方法基本上兩者大同小異，但因為 vector 需要透過 iterator 遍歷，
這邊就沒有像 python 那麼方便了。

vector 取 max 方法一 - iterator

基本上就是很標準的寫法，使用的是 std 裡面定義的 std::max_element，
會回傳位址，需要用 *it 取得該值。

vector<int> dp;
auto it = std::max_element(dp.begin(), dp.end());  
// std::vector<int>::iterator it;
cout << *it << endl;

vector 取 max 方法二 - 繞過 iterator 直接取值

我們直接將 max_element 取得的 iterator 直接取值，
(這也才是我們想要的)
就可以直接得到值了，不用另外宣告 iterator。

vector<int> dp;
int max_value = *std::max_element(dp.begin(), dp.end());
cout << max_value << endl;