715 - LeetCode Design Data Structure 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)

最近在練習程式碼本身就可以自解釋的 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

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

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

題目出處

155. Min Stack

難度

easy

題目分類

Stack, Design

2022-06-07 一刷

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

class MinStack:

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

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

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

        return result

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


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


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

算法說明

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

input handling

x (設計類問題)

Boundary conditions

x (設計類問題)

Reference

带最小值操作的栈 · Min Stack

【Lintcode】python - [659] Encode and Decode Strings 個人解法筆記

Mon, 06 Jun 2022 03:34:37 +0800

題目出處

659 · Encode and Decode Strings

難度

medium

題目分類

Array, String, Design

2022-06-06 一刷

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

class Solution:
    """
    @param: strs: a list of strings
    @return: encodes a list of strings to a single string.
    """
    def encode(self, strs):
        # write your code here
        return " ".join(strs)

    """
    @param: str: A string
    @return: dcodes a single string to a list of strings
    """
    def decode(self, str):
        # write your code here
        return str.split(" ")

算法說明

這題是應用的 design 類問題，
因為我們在傳輸數據時，大部分都沒有辦法直接傳遞「我們定義好的資料結構」，
通常我們都會先進行 encoding 把資料加密，例如把資料轉成文字化。

等待送達目的後，再對資料進行 decoding 解密，把文字化資料轉回「我們要的資料結構」，
而這題概念上大概就是要我們實作這樣的概念，方法有無限多種，
但以考題來說，這題應該是理解概念就好。

input handling

x (design 類問題)

Boundary conditions

x (design 類問題)

Reference

编码和解码字符串 · Encode and Decode Strings

【Lintcode】python - [642] Moving Average from Data Stream 個人解法筆記

Fri, 29 Apr 2022 03:51:44 +0800

題目出處

642 · Moving Average from Data Stream

難度

easy

題目分類

Array, Design, Queue, Data Stream

2022-04-29 一刷

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

class MovingAverage(object):
    """
    @param: size: An integer
    """
    def __init__(self, size):
        # do intialization if necessary
        self.size = size
        self.queue = collections.deque([])
        self.sum = 0.0

    """
    @param: val: An integer
    @return:  
    """
    def next(self, val):
        # write your code here
        self.queue.append(val)
        self.sum += val
        if len(self.queue) > self.size:
            self.sum -= self.queue.popleft()
        return self.sum/len(self.queue)

# Your MovingAverage object will be instantiated and called as such
# obj = MovingAverage(size)
# param = obj.next(val)

算法說明

Data Stream 的題型，基本上看到 data stream 就要先有意識到，
現在我們要設計的是一個「動態」的數據結構，
也就是說輸入的資料不會是「一次性的」，而是「連續性的」

有這個概念之後我們就可以開始來設計了，
這題還算簡單，不需要講太多

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

input handling

x (題目沒有特別要求)

Boundary conditions

因為不是一次性操作，因此沒有邊界限制，
而動態的操作要注意「允許儲存的上限 = size」

Reference

数据流滑动窗口平均值 · Moving Average from Data Stream

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

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

題目出處

208. Implement Trie (Prefix Tree)

難度

medium

題目分類

Hash Table, String, Design, Trie

2022-04-26 一刷

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

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

class Trie:

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

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

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


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

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

算法說明

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

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

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

一個 TrieNode 會有，

childrens：紀錄往下的字母

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

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

Trie (字典樹) 範例圖

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

input handling

Boundary conditions

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

Reference

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

【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 - [232] Implement Queue using Stacks 個人筆記

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

題目出處

232. Implement Queue using Stacks

難度

easy

題目分類

Stack, Design, Queue

2022-03-09 一刷

個人筆記

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

算法說明

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

研究別人的解法

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

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

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

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

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

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


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

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

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

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

圖例

下圖我們做的步驟是

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

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

Reference

Share my python solution (32ms)