716 - LeetCode Linked List on 嗡嗡的隨手筆記

【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)

算法說明

在標準的解答中，大概念是我們要設計一個 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)

算法說明

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

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

input handling

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

Boundary conditions

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

Reference

LRU缓存策略 · LRU Cache

【Leetcode】python - [19] Remove Nth Node From End of List 個人解法筆記

Sun, 29 May 2022 01:45:09 +0800

題目出處

19. Remove Nth Node From End of List

難度

Medium

題目分類

Linked List, Two Pointers

2022-05-29 二刷

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

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

        dummy = ListNode(0)
        dummy.next = head
        slow = fast = dummy

        for i in range(n):
            fast = fast.next

        while(fast.next):
            fast = fast.next
            slow = slow.next
        else:
            slow.next = slow.next.next

        return dummy.next

算法說明

使用快慢指針，快慢的間距始終保持 n，
最後當找不到 fast.next (為 None，即最後一個數字時)

做一次「slow.next = slow.next.next」，即可刪除該數字，得到我們要的結果。

input handling

這題 input 有 cornet case 要處理，例如 [1], n = 1 的情況。

因此我們使用 dummy = ListNode(0)，並以 dummy.next 作為我們最終的解答。

Boundary conditions

使用 fast 來控制我們搜尋的範圍。

2021-06-19 一刷

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

大概念 - TwoPointers

我們可以想像成有兩個指標，一個跑比較快，一個跑比較慢

跑比較快的幫我們去找 head
跑比較慢的幫我們定位要刪除的 node

正常 case

遍歷停止條件

我們留意最後一個 front 停下來的地方，因為要固定間距 n，
所以當最後搜尋到 front.next 沒有東西時就應該要停下

刪除方法

而刪除的方法，則是靠 back 所在位置的 next 替換成 next.next

特殊 case

只有一個值時，front 會跑到空值，所以我們判斷 front 為空，
則回傳 head.next

示意圖

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

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        back = front = head
        for _ in range(n):
            front = front.next

        if not front:
            return head.next

        while(front.next):
            front, back = front.next, back.next

        # print(back.val)
        back.next = back.next.next
        return head

Reference

【Leetcode】python - [142] Linked List Cycle II 個人解法筆記 | 內含 python while-else 用法介紹

Thu, 12 May 2022 14:57:22 +0800

題目出處

142. Linked List Cycle II

難度

medium

題目分類

Hash Table, Linked List, Two Pointers

2022-05-12 一刷

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, x)
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return None

        slow = fast = head
        while(fast and fast.next):
            slow = slow.next
            fast = fast.next.next
            if fast == slow: # find loop
                break # out of while-else, no else
        else:
            return None

        while (head != slow):
            head = head.next
            slow = slow.next
        return head

算法說明

首先我們先找出是否有 loop，找到後我們在開始找迴圈的起點。

證明

假設迴圈的長度為 l
起點到迴圈入口的距離為 a
slow, fast 相遇處為 a+b (相距迴圈入口 b)

fast 走的距離，
= 可以是 a+l(走了一圈迴圈)+b
= 也等於 2*(a+b) = 兩倍的 slow 移動距離

這樣我們可以推得 a+l+b = 2*(a+b), 得到 l = a+b

我們現在想要求 a

a = l-b，注意圖上 l-b，也就是把相遇處剩下的路再繼續走完。

因此我們只要

從 head 走 a
從相遇處走 l-b

走到下一個相遇處就是我們要的 a。

input handling

如果沒有 head 或沒有 head.next，return None

Boundary conditions

透過 while(fast and fast.next) 控制搜尋範圍

python while-else 用法說明

一般來說，我們通常都只會使用到 while，
但其實在 python 中，while 是可以搭配 else 使用的。

邏輯如下：

while(條件成立):
    # 成立時循環
else: # 當不成立時，出現在這
    # 當條件不成立時，開始作這邊的事情

沒有錯!!!! 但是這個小細節，卻可以讓我們的程式碼邏輯更漂亮!

例如說當我們有無關 while 的相關內容，我們才應該擺在外面，
但有時候是剛結束迴圈時有一些收尾的相關內容要處理，這時候用 else 的寫法就相當漂亮了!

範例

假設我們要把一個 mylist 「純手動」印成 [1,2,3] 的樣子，
最後還要印出一個 finish!

mylist = [1,2,3]
idx = 0
print('[', end = '')
while(idx < len(mylist)):
    print(mylist[idx], ',')
    idx += 1
else:
    print(']')
print('finish!')

這個例子應該就很好懂了，我們集中「把要處理 list 列印的動作」放在 while-else 裡面，
最後比較無關的 finish! 放在 while-else 外面，
這樣看起來程式碼邏輯有沒有比都放在外面更清楚了呢? (當然，見仁見智啦XDDD，我覺得有XD)

特殊用法 - while-else 搭配 break 使用的情況

這也是我近期解題才發現的，當 while - else 搭配 break 使用時，能發揮更好閱讀的效果!

請讀者先想像一下，下面的程式碼會印出什麼呢?

while(True):
    break
else:
    print(1)
print(2)

這樣我們就能夠更進階的使用這個功能了，

「透過 while 迴圈條件結束的，寫在 else 裡面」
「如果是透過 break 結束的，寫在最外面」

Reference

【Leetcode】python - [61] Rotate List 個人解法筆記

Thu, 05 May 2022 19:22:36 +0800

題目出處

61. Rotate List

難度

medium

題目分類

Linked List, Two Pointers

2022-05-05 一刷

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

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

        cur = head
        length = 0
        while(cur):
            length += 1
            prev = cur
            cur = cur.next
        else:
            prev.next = head # circular

        k = length - (k % length) # counterclockwise -> clockwise
        while(k > 0): # move k times (clockwise)
            k -= 1
            prev = head
            head = head.next
        else:
            prev.next = None  # tail
            return head # head

算法說明

網路上看到覺得最漂亮的算法，
既然都要 rotate 了，不如直接先串成一個環吧!

注意 rotate 逆時針

從題目敘述我們會發現 rotate 方向為「逆時針」，
這樣我們就有必要先計算總共有幾個元素，
再來透過 k = k - (k % length)，我們就可以得到「順時針要走多少 k 」

input handling

如果沒有 input head，return head

Boundary conditions

while loop 控制 k 的搜尋範圍，
先弄成環之後，處理環的前後。

Reference

旋转链表 · Rotate List

【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

算法說明

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

算法說明

我猜此題目最多會要求到把使用空間壓縮至 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)

算法說明

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

input handling

處理沒有 head 的情況，return False

Boundary conditions

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

Reference

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

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

題目出處

114. Flatten Binary Tree to Linked List

難度

medium

題目分類

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

2022-04-21 一刷

個人範例程式碼 - iterative 解

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

        stack = deque([root])

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


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

        return

算法說明

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

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

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

個人範例程式碼 - recursive 解

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

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

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

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

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

算法說明

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

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

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

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

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

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

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

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

算法說明

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

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

input handling

當沒有 root 時，直接回傳

Boundary conditions

搜尋至 None 時，return

Reference

453 · Flatten Binary Tree to Linked List

【Leetcode】python - [2] Add Two Numbers 個人解法筆記

Sat, 16 Apr 2022 22:37:42 +0800

題目出處

2. Add Two Numbers

難度

medium

題目分類

Linked List, Math, Recursion

2022-04-16 一刷

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

基本版本

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0

        while(l1 and l2):
            this_val = l1.val + l2.val + carry
            carry = this_val // 10            
            head.next = ListNode(this_val % 10)
            l1 = l1.next
            l2 = l2.next
            head = head.next
        else:
            while(l1):
                this_val = l1.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l1 = l1.next
                head = head.next
            while(l2):
                this_val = l2.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l2 = l2.next
                head = head.next
            if carry:
                head.next = ListNode(carry)

        return dummy.next

算法說明

- 當 l1, l2 還有值時，為第一階段 - 其中一個沒有值時，用 while 去將剩下的 l1 或 l2 掃完 - 最後判定有沒有剩餘的 carry

input handling

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

Boundary conditions

注意 LinkList 的結束條件：

結束的 None 也算是一個節點。會被 if node 判為 False。

優化版本

優化，將 l1, l2, carry 有無剩餘的內容一起看，一路處理到沒剩餘內容為止。

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0
        while(l1 or l2 or carry): # something still exist
            if l1:
                carry += l1.val
                l1 = l1.next
            if l2:
                carry += l2.val
                l2 = l2.next

            head.next = ListNode(carry % 10)
            head = head.next
            carry = carry // 10
        else:
            return dummy.next

Reference

Is this Algorithm optimal or what?

【Leetcode】python - [876] Middle of the Linked List 個人解法筆記

Thu, 07 Apr 2022 18:55:28 +0800

題目出處

876. Middle of the Linked List

難度

easy

題目分類

Linked List, Two Pointers

2022-04-07 一刷

個人範例程式碼 - two pointers

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

        slow = head 
        fast = slow.next
        while(fast is not None and fast.next is not None):
            slow = slow.next
            fast = fast.next.next
        else:
            if(fast is None): # odd case
                return slow
            else: # fast is not None, fast.next is None: # even case
                return slow.next

算法說明

同向的快慢 pointers，這題目雖然簡單，但很考慮細節的處理。

這部分可以看下圖，說明請見 Boundary conditions ：

input handling

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

Boundary conditions

我們依照上面的圖片繼續說明：

基本上拆成兩種狀況討論：

odd case：奇數情況，特性為 fast 直接指到 None 上，return slow
even case：偶數情況，特性為 fast.next 才指到 None 上 (或 fast 有值卻進入了 else part)，return slow.next

結束條件

fast or fast.next is None 的時候，我們再來分析情況

(至少要自己本身能指到 None)

Reference

链表的中点 · Middle of Linked List

【Leetcode】python - [83] Remove Duplicates from Sorted List 個人解法筆記

Sun, 06 Mar 2022 19:50:25 +0800

題目出處

83. Remove Duplicates from Sorted List

難度

easy

題目分類

Linked List

2022-03-06 一刷

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

記得上述所說的，我們需要先宣告 None 作為結尾

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        while cur and cur.next: # [1,1,1]
            if cur.val == cur.next.val:
                cur.next = cur.next.next # pass one # need check many times
            else:
                cur = cur.next # duplicat 1 in index 0 moved !!!

        return head

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

利用先前提到的 remove 方法，
操作「cur.next cur.next.next」的時機。

part2 remove 操作請參考： [【Leetcode】python – [203] Remove Linked List Elements 個人解法筆記 (內含範例程式碼) 內含 Linked List remove 操作 part 2 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-203/)

corner case 特殊情況處理

一同整理在下方「邊際情況處理」

Boundary conditions/ Edge conditions 邊際情況處理

這題很可惜沒有一次就寫對，我只有思考到以下前三種情況：

- [] - [1] - [1,1] - [1,1,1]

至於為什麼第四種情況會出問題?

當時我的 code 長這樣

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        while cur and cur.next: # [1,1,1]
            if cur.val == cur.next.val:
                cur.next = cur.next.next # pass one # need check many times
            cur = cur.next # duplicat 1 in index 0 moved !!!

        return head

讀者可以先閱讀一下，看看能不能自己發現問題點在哪? (但我註解好像已經寫了 Orz)

總之是以上操作會有一個問題是，每一次必做 cur = cur.next，
當有類似 [1,1,1] 的 case 時，判斷完前兩個相同，第一個 1 就當作沒問題往下走了，
下一步會是第三個位置，但第一三位置的重複沒有判斷到 !!!

Reference

【Leetcode】python - [206] Reverse Linked List 個人解法筆記內含 Linked List reverse 反轉操作 part 3 (for 新手教學)

Sun, 06 Mar 2022 19:33:52 +0800

題目出處

206. Reverse Linked List

難度

easy

題目分類

Linked List, Recursion

2022-03-06 一刷

Linked List reverse 反轉操作 part 3

part1 基本概念請參考： [【Leetcode】python – [21] Merge Two Sorted Lists 個人解法筆記 (內含範例程式碼) 內含 Linked List 基本操作 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-21/)

這邊我們要來研究 Linked list 的反轉操作，
一樣的，這操作硬要說也不難，但只要思緒不夠清楚，
一定是轉了半天轉不出來XDD 最後絕望放棄XD

我們試著來把概念講的簡單一點吧!

這裡作者有找到一個超棒的動畫解釋，有興趣可以看，「真的很讚的動畫」： Easy [C++/Java/Python/JavaScript] Explained+Animated

試試看講簡單一點

做反轉動作來說，最簡單我們都需要「三個紀錄點」，
分別代表「過去」、「現在」、「未來」，
每一個記錄點都非常重要，
我們一定要注意「不能在過程中失去任何重要紀錄點，一旦被蓋掉就再也找不回來了!」

因此我們基本的策略就有了下圖，1 ~ 3，
我們移動的方式一定是：

- 過去 = 現在 - 現在 = 未來 - 未來 = 更未來

到這邊，「務必務必謹守上述這個原則」，
再來我們再來討論反轉，什麼時候適合做反轉呢?
就是在做上述的「移動 1~3」之前，所以「更改」反轉的線，就是在第 0 步驟，

初始化

這裡有個小重點，不論如何，我們的 Linklist 最終「必須結束於 None」，
因此我們要先宣告個「新結束點」給他，
那想當然，可以讓一開始 prev 擔任這個步驟。

而我們真正作為起頭的 head ，可以先給予他 cur (代表現在)，
由於此時我們還不確定有沒有 head 存在，因此還不能直接給 head.next (會跳錯)

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

記得上述所說的，我們需要先宣告 None 作為結尾

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None # must have a None end.
        if head: # init 
            cur = head
            head = head.next
            cur.next = prev # must have a None end.
        else: # special case
            return head

        # loop
        while head:   
            prev = cur
            cur = head  
            head = head.next
            cur.next = prev # reverse

        return cur

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

遍歷一次 head 是一定要的，問題是我們該怎麼移除，
移除的方法我們上面也提到過了，
只需要把「下個」替換成「下下個」就可以輕鬆解決，
只是要多考慮一些「不存在的邊際情況」，這邊我們下面會提。

corner case 特殊情況處理

一同整理在下方「邊際情況處理」

Boundary conditions/ Edge conditions 邊際情況處理

我們把題目稍微分析一下，我這裡大概把題目分類成於以下三種情況，

- [None] - [1] - [1,2,3] <- 正常情況

其中我們來看看 1.2. 我們該怎麼辦。

1. [None]

如果一開始 if head 就沒東西，我們就直接 return head

2. [1]

我們已經把 cur = head，而 while head 會直接判找不到東西，
因此回傳 cur，沒有問題。

Reference

【Leetcode】python - [203] Remove Linked List Elements 個人解法筆記內含 Linked List remove 操作 part 2 (for 新手教學)

Sat, 05 Mar 2022 15:36:05 +0800

題目出處

203. Remove Linked List Elements

難度

easy

題目分類

Linked List, Recursion

2022-03-05 一刷

Linked List remove 操作 part 2

part1 請參考： [【Leetcode】python – [21] Merge Two Sorted Lists 個人解法筆記 (內含範例程式碼) 內含 Linked List 基本操作 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-21/)

這邊我們要來研究 Linked list 的 remove，
說 remove 其實也不難，最麻煩的應該是要考慮的邊際情況很多，

大觀念來說，我們只要「把下一個替換成下下一個」，就可以順利完成，
這觀念聽起來就超簡單的XDDD

但問題就是在要處理一些特殊狀況
這個我們在後續的「邊際問題處理」再來提

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

我們會習慣宣告假開頭為 dummy，並給予任意值 (這裡給 -1)，
反正我們要用的是 dummy.next 之後的東西，
就當是一種解題習慣吧。

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = cur = ListNode(-1)
        cur.next = head # start from head, if wrong will pass later

        while cur.next: # head exist, we need to parse all Linkedlist
            if cur.next.val == val: # check next
                cur.next = cur.next.next # pass next (remove)
            else:
                cur = cur.next # save one ans
            head = head.next # move        

        return dummy.next

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

corner case 特殊情況處理

一同整理在下方「邊際情況處理」

Boundary conditions/ Edge conditions 邊際情況處理

這題問題本身不難，麻煩的是在考慮的邊際情況很多，
這些問題是我自己想的，「一定有些對於讀者來說是可以不用思考的問題」，
總之只要考慮周全就是好方法，不一定要照我的XD

0. (一般情況) 在中間，要移除

沒什麼問題，當 cur.next = cur.next.next 我們就會看到下一個不是的了
-> 我們觀察的值為 (cur.next).val

1. 如果你要移除的，已經是最後一個?

當 cur.next = cur.next.next 我們就會看到 None 了
-> 我們觀察的值為 (cur.next).val

2. 如果最後連續 N 個，都是要移除的?

當 cur.next = cur.next.next ，不斷替換 cur.next 我們遲早就會看到 None 了
-> 我們觀察的值為 (cur.next).val

3. 如果全部都是要移除的?

當 cur.next = cur.next.next 直到我們看到 None，而我們要確保「cur 與 cur 之前的答案都是可行的」
-> 我們觀察的值為 (cur.next).val

4. 如果沒有值?

cur.next 為 None 我們會發現。

5. 如果開頭就是要移除的?

我們的開頭設為「cur.next = head」，也就是說我們只希望讓 cur 之後的答案為正確的。

Reference

【Leetcode】python - [21] Merge Two Sorted Lists 個人解法筆記內含 Linked List 基本操作 (for 新手教學)

Sat, 05 Mar 2022 14:31:19 +0800

題目出處

21. Merge Two Sorted Lists

難度

easy

題目分類

Linked List, Recursion

2022-03-05 一刷

Linked List 操作 (for 新手教學)

新手如我，最不熟悉 Linked List 的操作，剛好網路上有其他大神分享，
我們來簡單的重新敘述一下他教學的內容：

參考：Python3 Solution with a Detailed Explanation - dummy explained

pointer 跟著移動?

假設我們定義一個 head = temp = ListNode(0)，
(這樣寫太難懂的話，請理解為 temp = ListNode(0)， head = temp)

在 Linked List 操作中可能最讓人困惑的就是，當我們去移動 temp 時，head 會不會跟著移動?
在 python 裡面，我們進行 temp = temp.next 的動作，
實際上我們只有移動「temp 指向的位置」，我們可以理解「temp.next」在此只是一個「位置的代稱」，
就像我們說
b = 1
a = b
b = 2
最後會知道 a = 1, b = 2 而不是 a, b = 2，

不要像作者我在一開始因為開始有點複雜，就被搞亂了。

好啊，那 pointer 不移動，為啥 temp 去改能影響到 head?

head 一開始指到的記憶體位置與 temp 是相同的，
而我們控制 temp 在此點的指向，因此 head 確實可以從這個記憶體位置往下找。

比喻

我們可以想像我們現在正在挖金礦，我們順著線索 1 -> 2 -> 3 不斷往前，
但我們如果要告訴後來的人這條路該怎麼走，我們是必要紀錄起始點的位置。
因此這裡就會分為 head, temp， head 幫助我們保留起始位置，而 temp 負責幫我們移動。
中間的每一個線索都已經由 temp 在過程中建立好正確連結，
因此 head 尋著 temp 打通的道路再走一次，就是走 temp 開過的路。

ListNode(0)? return head.next

不用想那麼多，這只是建立一個供我們參考的基準點。
從我們最後 return head.next 就知道，我們只在乎這個基準點之後的事情。

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        head = temp = ListNode(0)
        while list1 and list2: 
            if list1.val < list2.val:
                temp.next = list1 # ans next Node
                list1 = list1.next
            else:
                temp.next = list2 # ans next Node
                list2 = list2.next # move next
            temp = temp.next # ans move next
        temp.next = list1 or list2 # remain things
        return head.next

Time Complexity

O(m+n)

Space Complexity

O(1)

算法說明

如上面介紹所述

corner case 特殊情況處理

注意沒有值的情況，例如開頭就沒有的時候

Boundary conditions/ Edge conditions 邊際情況處理

終止條件

注意沒有值的情況，
我們大原則是每次都會檢查「this Node 是否為 None」再開始接續動作。

提取剩餘內容

另外最後的 list1 or list2 是個非常漂亮的做法，
可以快速把剩餘的內容提取出來。

Reference

【Leetcode】python - [141] Linked List Cycle 個人解法筆記

Sat, 05 Mar 2022 13:04:23 +0800

題目出處

141. Linked List Cycle

難度

easy

題目分類

Hash Table, Linked List, Two Pointers

2022-03-05 一刷

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

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow = fast = head 
        # while slow.next and fast.next.next:  # check exist
        # while fast.next and fast.next.next:  # check exist
        while fast and fast.next:  # check exist
            slow = slow.next
            fast = fast.next.next
            if slow is fast: # has cycle
                return True
        return False # no cycle

Time Complexity

Space Complexity

算法說明

這題考 Linked List 的遍歷操作，
最麻煩的應該是邊界控制，這我們下面再提。

Floyd Cycle Detection Algorithm, Tortoise and Hare Algorithm (龜兔賽跑演算法)

演算法使用的是「Floyd Cycle Detection Algorithm, Tortoise and Hare Algorithm (龜兔賽跑演算法)」

或簡稱 Floyd Cycle 之類的，簡單來說就是當一個東西有環，
我們放一個跑比較快(step2)的兔子跟跑比較慢(step1)的烏龜，
兔子跟烏龜在有環的情況下，它們遲早會相會。

corner case 特殊情況處理

要處理沒有東西 [] 的情況… 被搞到

Boundary conditions/ Edge conditions 邊際情況處理

這題我犯了兩次錯誤，

第一次我寫 while slow.next and fast.next.next:

會跳錯，因為 slow 並不重要，fast 跑在前都會先檢查過了，
當會跳錯的地方在於「fast.next」不存在。

第二次我寫 while fast.next and fast.next.next:

還是錯，原因是這樣沒有處理到當「fast」不存在的情況。

第三次 while fast and fast.next 就是正確的了，

補充 - 系統思維加速 (面試題)

也可以用 hashset() 的方式來實作，hash pointer。