Remove time complexity: remove from a set is O(1), remove from a list is O(n)

deque.popleft() is faster than list.pop(0), because the deque has been optimized to do popleft() approximately in O(1), while list.pop(0) takes O(n)

Remove all items:?clear()

Remove an item by index and get its value:?pop()

Remove an item by value:?remove()

Remove items by index or slice:?del

一個具有n個節點的完全二叉樹,其葉子節點的個數n0為: n/2 向上取整，或者(n+1)/2 向下取整

key = ''.join(sorted(string))? ?sorted函數返回時一個list，不是string，要特別注意

iterator next()作用在dictionary上返回的是key

float('-inf') -不能寫在‘’外面

& 用于兩個set的話，可以得到intersection

collections.defaultdict(lambda: 1) 因為如果寫成int，默認值將是0，這樣寫是為了得到一個匿名函數

stack經常只用來存儲index

迭代器的優勢：在構建迭代器的時候，不是將所有的元素一次性加載，而是等調用next方法時返回元素，所以不用考慮內存的問題

迭代器的使用場景：數列的數據規模巨大；數列有規律，但是不能使用列表推導式描述

The join() method is a string method and returns a string in which the elements of sequence have been joined by str separator.

split返回list

判斷條件時，if 0 not in set，沒有那個is

random.randint(a,?b)，?Return a random integer?N?such that?a?<=?N?<=?b

most_common時間復雜度是O(nlogn)

sorted作用于dictionary后，返回的是排序好的keys

sorted之后返回的是list

sort只適用于list，sorted可以對任何interable變量進行sort

-1在計算機中表示：1的碼是0000....1，反碼是111111....0，因為負數的表示是正數的反碼加1，所以-1是111111...1，左移31就是10000000，代表計算機能表示的最小數

string.lowercase包含26個英文小寫字母

sys.maxsize: reports the platform's pointer size, and that limits the size of Python's data structures such as strings and lists.

計算機里面都是存的補碼，是一個圈，最大數是127(01111111)，最小數是-128(10000000), 所以127+1后會出現溢出，然后就等于-128了

對于有符號位(最高位是1)，補碼等于反碼加1

~x = -x-1 因為~x+1就是反碼加1，~x+1=-x

dictionary的setdefault和get是一樣的，如果key不在dictionary中時，dict.setdefault(key, default=None)會給一個默認的key和value

segment tree

binary indexed tree

backtracking一般和dfs一起用

一是只要遇到字符串的子序列或配準問題首先考慮動態規劃DP，二是只要遇到需要求出所有可能情況首先考慮用遞歸

ord函數返回ASCII碼值，比如ord('a')等于97

strip() 方法用于移除字符串頭尾指定的字符（默認為空格或換行符）或字符序列。

http://www.runoob.com/python/att-string-strip.html

itertools.combinations_with_replacement()

這里replacement的意思是，取出來后又會放回去，所以有AA，BB， CC， DD這種情況

heap的nlargest和nsmallest函數，返回的是一個數組

Minimax (sometimes MinMax or MM[1]) is a decision rule used in artificial intelligence, decision theory, game theory, statistics and philosophy for minimizing the possible loss for a worst case (maximum loss) scenario.

https://univasity.iteye.com/blog/1170216

heapreplace函數彈出最小元素將另一個元素加入堆：

heapq.heapify復雜度是O(n)，in-place的。heapq.heappop時間復雜度是O(logn)

max heap頂端是最大的

Quickselect Algorithm：

https://www.geeksforgeeks.org/quickselect-algorithm/

ljust()?方法返回一個原字符串左對齊,并使用空格填充至指定長度的新字符串。如果指定的長度小于原字符串的長度則返回原字符串。str.ljust(width[, fillchar])? fillchar -- 填充字符，默認為空格。

異或或者與都可以直接對integer進行操作

^位異或，&位與

The bin() method returns the binary string equivalent to the given integer.

bin(5) = '0b101'

external sort:?

In principle, we want minimize the number of disk access during the run-time.

set和set可以用&求得它們的交集

https://www.w3schools.com/python/python_lambda.asp

對于回文問題，使用Manacher's algorithm可以答到O(n)時間

遇到一個數組，如果是想求其最大，最小，最長，最短值，而并不需要知道具體解的題，可以考慮使用動態規劃

Subsequences don't allow you to move characters around, only either keep them or remove them. Substrings don't allow you to remove anything and so must be contiguous.?

dict.items(): Return a?copy?of the dictionary’s list of (key, value) pairs.?

dict.iteritems(): Return an?iterator?over the dictionary’s (key, value) pairs.

takes more space and time initially, but accessing each element is fast, whereas the second takes less space and time initially, but a bit more time in generating each element.

dictionary是有iteritems()函數的，得到一個迭代器，迭代器有next()功能

Boyer-Moore Majority Vote algorithm

https://leetcode.com/problems/majority-element-ii/discuss/63520/Boyer-Moore-Majority-Vote-algorithm-and-my-elaboration

摩爾投票升級版，超過n/3的數最多只能有兩個；

建立hashtable的時候，key一定要是unique的，比如對一個字符串的index和value建立hashtable的時候，index是不同的，value是可以一樣的，所以key必須是index

stack.pop()和queue.pop()不一樣，stack是pop最上面的，queue是pop最右邊的

a tree is an undirected graph in which any two vertices are connected by?exactly?one path. In other words, any connected graph without simple cycles is a tree.

拓撲排序中可以用到DFS和BFS，但是BFS是主流

set("HelloWorld") 得到結果是{'e', 'H', 'r', 'W', 'o', 'd', 'l'}

items和iteritems?

https://www.cnblogs.com/life-need-high-power-laser-gun/p/7518803.html

入度：

常用的topological sort有兩種：O(n)時間排序

Kahn's Algorithm：BFS based, start from vertices with 0 incoming edge, insert them into list S, at the same time, we remove all outgoing edges, after that find new vertices with 0 incoming edges and so on

Tarjan's Algorithm: DFS based, loop through each node of the graph in an arbitrary order,?initiating a depth-first search that terminates when it hits any node that has already been visited since the beginning of the topological sort or the node has no outgoing edges

拓撲排序：將有向無環圖的所有頂點排成一個線性序列，使得對圖中的任意兩個頂點u，v，如果存在邊u->v，那么在序列中u一定在v的前面，這個序列又叫拓撲序列。

有向無環圖：如果一個有向圖的任何頂點都無法通過一些有向邊回到自己，那么這個有向圖叫有向無環圖(DAG: directed acyclic graph)

使用sqrt的時候，要加一個math.sqrt()

BFS 二叉樹的時候，注意如果在while循環里面使用了pop，則queue里面就沒有這個node啦，后面如果還想用就會出錯；下圖中后面想用的時候就是空了

這樣判斷是不是square數不行，要么就加一個int(num**0.5)==num

DFS有時候從大數開始可以更快的得到結果

長方形是rectangle，正方形是square

求距離場BFS是不二之選

想要得到最小步數等問題，可以使用heap

要返回True和False的話，初始化dp數組的時候，就初始化成True或者False，不能寫成0或者1，在python里是不一樣的

dic.get(key)可以防止返回key錯誤

python中get()，如果鍵不存在，則會返回None，所以在計數的時候，不要當做返回0來處理

DFS應用在matrix的時候，一定要注意visited情況，如果visit過的再visit的話，很容易出現超時的情況，可以用設置visited為一個set，將visited過的加到set中去

from在python中是一個關鍵字，定義變量時不要用它

pop還有刪除的功能，所以在需要取出和刪除操作時，就直接用pop

在寫上面的code時，我經常會犯錯誤，就是把dfs(newStart)和if對其，這是不對的，因為newStart是依賴上面一行得到的結果的

string.startswith(word) 應該是string的一個常用函數，要學會利用起來

list不能當做hashtable的key

如果一個數是ugly number，則它乘以2 or 3 or 5也是ugly number

Ugly numbers are?positive numbers?whose prime factors only include?2, 3, 5.?

1?is typically treated as an ugly number.

還是要多在本子上話，這樣容易得到思路一些

遇到不懂的code，一句一句弄懂，打印出來看，在本子上畫

dic[x].pop(0)直接省去remove的操作了

Eulerian Path 歐拉回路

undirected graph: len(edges)就是node的個數

更新rank的時候，如果兩個rank不一樣的話，把小的merge到大的，這樣都不用更新rank，但如果兩個rank一樣的話，需要更新rank值

union find的思想是每個個體先初始化成不同的群主，然后遍歷有關聯的兩個個體，如果發現find的值不同，則手動將二者加入到一個群主，然后總群主數減1

union find的時候，是把rank小的合并到rank大的那個上，因為這樣可以少一些path compression的操作

x = parent[x] = i, j? 代表(i, j)做為一個tuple賦值給x和parent[x]

union find用來解決network connectivity問題

cmat = copy.deepcopy(mat) 如果直接傳mat，會修改mat的值，因為python里面matrix，list屬于object，傳參數的時候傳的是inference也就是指針。像variable這種就沒關系

str object doesn't support item assignment

string 才能join，int不能join

list(N) N是整數，這是錯誤的，整數不能被list

MSB：most significant bit

greedy算法

divide and conquer：把一個問題分成等價的子問題，分別進行解答，最后再把結果合并

第一步：把每個結點的根節點指向它自己，這樣就有n個cluster，rank都初始化成0。find的過程把當前結點和它的父母結點都指向root結點；在find中，當這個結點不是根節點時，

union by rank：rank的話可以看成是平均長度，把low rank的cluster merge到high rank的cluster，這樣可以 減少做path compression的次數

path compression：每次尋找某個結點的root時，就把此node的所有父母結點指向root，這樣相當于flat了整個cluster，下一次查找的時候就直接是O(1)時間了

union find: 有find和union，find的話就是找某個node的root或者叫cluster id。總的node數是n。union是merge兩個cluster。查找兩個node是否在同一個cluster中，就是看它們的root是不是同一個，查找時間是O(1)

無向連通圖：undirected graph.

alphanumeric 代表數字字母兩種；s[l].isalnum()判斷是否是字母和數字

collections.Counter()也是一個hash table

enumerate也可用在string上

sliding window+substring template: the question is always that given a string, and need to find a substring which satisfy some restrictions. A general way is to use a hashmap with two pointers.?https://leetcode.com/problems/minimum-window-substring/discuss/26808/Here-is-a-10-line-template-that-can-solve-most-'substring'-problems

1 check whether the substring is valid; 2 two pointers: one to tail and one head; 3 get the length of substring; 4 initialize the hash map; 5 while loop:?

動態規劃，當前狀態需要依賴前一狀態的值

subarray必須是連續的

binary search：中間值下標的計算，如果寫成(l+h)/2，l+h有可能會溢出，從而導致數組訪問出錯；改進的方法是l+((h-l)>>1)

sliding window: standard template：記錄左指針，右指針，每個循環更新左指針，右指針是當前index；外循環遍歷整個數組，內部一個while循環遵循題意要求；一個全局變量更新題意要求

binary search: while l<r，這里什么時候是小于號，什么時候是小于等于號

求極值的問題，會用到dp

sum(list)直接就可以得到和。不需要sum(n for n in list)

dic=collections.defaultdict()? sorted(dic, key=lambda k: dic[k]) 得到的是

str()是把integer轉換成string

*也可用作解包，func(*args)函數時，相當于把一個元組args拆開，當成參數傳進函數中。

*代表該位置可以接受任意多個非關鍵字參數，在函數中將其轉化成元組

200 itertools.product(A,B)，依次取出A中的一個元素和B中的一個元素組成一個元組，然后將所有的元組形成一個列表返回。比如itertools.product([1,2,3],[100,200])，返回[(1, 100), (1, 200),(2, 100),(2, 200),(3, 100),(3, 200)]

199 tuple一旦初始化就不能修改了

198 hash tables: hash set和hash map

197 -first, indf = heapq.heappop(heap)，不能這么寫，前面不能加負號

196 全局變量要加self，比如self.global

195 string中找到所有字母''.join(re.split(r'[A-z]',licensePlate))

194 re中[A-z] 等于[A-Za-z]表示匹配所有大小寫字母

193 動態規劃解決0-1背包問題步驟：（1）選擇一個給定物品i，需要比較選擇i形成的子問題最優解和不選擇i的子問題最優解，再對兩個子問題進行比較，選擇最優的。https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/

192 部分背包問題：總是選擇每一磅價值（Vi/Wi）最大的物品添加到背包中。解決過程：對每磅價值進行排序，依次從大到小選擇添加進背包中

191 0/1背包問題：在選擇是否把一個物品加到背包中，需要對把這個物品加到背包的子問題和不加到背包的子問題進行比較。這種方式形成的問題導致了很多重疊子問題，滿足動態規劃的特征

190 0/1背包，動態規劃；部分背包，貪心法

189 0/1背包問題：0/1 knapsack problem，for each number, we can pick it or not。https://blog.csdn.net/crayondeng/article/details/15784093

188 除以2，可以>>1，向右移動一位

187 判斷是奇數偶數，還可以和1按位與，如果與的結果是0，則為偶數，否則為奇數

186 put n items to k buckets

185 求取約束條件下最小路徑的題，用dynamic programming

184 extend()用于在隊列末尾一次性追加另一個序列中的多個值

183 hash table and trie 時間和空間復雜度比較https://leetcode.com/explore/learn/card/trie/147/basic-operations/1048/

182 python中get()，如果鍵不存在，則會返回None

181 Binary search: search for a specific value in an ordered collection

180?ret = [None]*k可以得到[[],[],[]];?ret = [1]*k 得到[1,1,1]

179 linked list，如果之后要斷掉某個連接，但之后還得用到這個連接，那就先保護好這個連接

178 怎么建立一個cyclic linked list

177?when you delete a node, you will delete its left child and its right child before you delete the node itself.

176 cur = cur.next的前提是cur.next已經是一個linked list node了

175 對于鏈表，只要node.next變了，之前的連接就是斷了的; 指針并不是node

174?return [hashmap[i] for i in sorted(hashmap)] 可以直接對hashmap進行sort

173 iterative方法中，在中間只要不滿足條件的，就返回False，直到最后所有條件都滿足時，才返回True；

172 BFS和queue的時候，在while queue循環的時候，queue = [kid for q in queue for kid in (q.left, q.right) if kid]省memory

172?collections.deque(maxlen=size)可以設置一個最長len，這樣如果queue滿了，append進來的數也會擠掉前面的數，不用再pop了

171 deque: 建立一個deque，d=collections.deque(); 加入元素是d.append(); 從左邊加入元素是d.appendleft(); 從左邊刪除元素是d.popleft(); 寫成d=collections.deque()了，就不需要import deque了

;170?collections.defaultdict(lambda: defaultvalue) lambda在這里的作用是代表設置的默認值

169?defaultdict()為字典提供默認值，防止出現keyerror異常

168 "/".join(stack) 如果stack中只有一個element，則/不作用在此element上，比如stack中是home，運行這個code后，還是變成home

167 建立一個heap，直接heap = []就行，之后再進行heapq.heappush(heap, k)等操作

166 在計算機中，32bit最大能表示成2**31-1，因為最高位是符號位

165 str.split()要里面真有space才行，比如“12”，split后還是‘12’，并不會得到‘1’和‘2‘

164 遇到circle的，就可以把list復制兩份連在一起

163 set require its items are hashable: such as immutable types, string, tuple and number

162 list is mutable and can't be used as a key for dict

161 unhashable type: 'list'

160 deque的定義要么是：from collections import deque;另外一種更簡單的方法是直接定義：d=collections.deque

159?union find:研究動態連通性

158 ".join()和‘ ’.join()中間有無空格時不一樣的

157 find返回子字符串開始的位置

156 for BST, inorder traverse is an ascending sequence

155 random.randint(a,b)生成一個指定范圍內的整數，即生成的整數n滿足：a<=n<=b

154?heapq.heapify(self.heap)是in-place的，不要寫成self.heap =?heapq.heapify(self.heap)

153 heap[0]是最上面那個數，stack[-1]是最上面那個數

152 如果是import heapq的話，調用任何heap相關函數，前面都要加heapq.

151 max heap就是min heap的invert

150 使用heapq的時候，直接import heapq就可以了

149 self只在類的方法中才有，在獨立的函數中是沒有必要帶的，self在定義類的方法時必須有，在調用的時候會自動傳入；self就是指類實例對象本身

148 query疑問，質問

147 dic.pop('key', None)刪除字典中的key，如果key不存在，返回None，因為不會產生keyerror

146 decimal小數的

145 str.isalpha()只是字符，像[這種特殊字符，并不能用這個來判斷

144?[::-1] the the best and the fastest way to reverse a list.

143 list.pop()默認是pop最后的那個元素，所以我們如果想pop最開始的元素，需要把參數設置成0

142 list.index(element)返回element的index，time complexity是O(n)

141 注意注意注意：push到heap中，是按照push進去的第一個緯度來衡量最小值的！！！比如計算最小步數，一定要把steps放在最前面哇

140?type start: List[int]?

139 總是忘記把heap寫進heapq.heappop(heap)中去

138?float('inf') 里面是有‘’的

137 re.findall(pattern, string)，返回string中與pattern相匹配的所有字串，返回形式為list

136 c.items()返回的就是list，比如

135 lookup的時候，set比list快

134 s.lower(), s.upper()不要記混淆成s.lowercase()

133 正則表達式的split: re.split(“\W+”,paragraph)

132?\w：用于匹配字母，數字或下劃線字符； \W：用于匹配所有與\w不匹配的字符；

131 string.split()返回list

130 string.split()會改變string本身嗎？還是會產生一個copy。貌似不改變本身

129?heappushpop() 將值插入到堆中同時彈出堆中的最小值。?heapq.heappushpop(heap, item)?????#首先判斷添加元素值與堆的第一個元素值對比，如果大于則刪除最小元素，然后添加新的元素值，否則不更改堆

128 maxheap

127 heapify()以線性時間將一個列表轉換成堆

126 刪除并返回heap中最小的元素，使用heapify()和heappop()來實現

125?set.remove(item)

124 denomination面值

123 從0變成1，從1變成0，可以用1-matrix[i][j]來實現

122 初始化一個矩陣，dp = [[1]*n for i in range(m)]是先弄一整行，然后再traverse行數

121 寫新的內部函數的時候，一定要放在最前面，方便調用

120 寫程序時寫完一句就檢查一下，養成一遍寫好所有程序的習慣

119 看到別人的好建議，就馬上執行

118?Btw, it's extremely useful to write down your thought/demo in comments before you actually start to write the code, especially during interview.?Even if you do not solve the problem finally, the interviewer at least get to know what you're thinking.?And if you don't get the problem right, he/she will have a chance to correct you.

117?Divide And Conquer(分治法)：

116 只寫return，代表的就是return None，只是在這省略了None；

115?consonant 輔音字母

114?for i in range(len(rooms)):? 老是忘記寫range

113 局部函數一般寫在前面

112 yield是一個類似return的關鍵字，只是這個函數返回的是一個生成器

111 generator可以有效節約系統資源，避免不必要的系統占用

110 帶有yield的函數在python中稱為generator；這個函數和普通函數不一樣，看起來像函數調用，但不會執行任何代碼，直到對其調用next()才開始執行，在for循環中自動調用next()。每執行到一個yield語句就會中斷，并返回一個迭代值，下次執行從yield的下一個語句開始執行

109 兩個矩陣相乘，第一個矩陣的列數要和第二個矩陣的行數相等，最后的出來的矩陣行數是第一個矩陣的行數。列數是第二個矩陣的列數

108?forty 四十

107 bin函數返回的就是string

106 int(a, 2)代表以2為base，即把string a按照base為2轉換，比如int('11',2)=3, 如果是int('11')=11，默認base是10

105 不管是Counter還是hashmap，都有values這個成員函數，collections.Counter(tasks).values()

104 python的數據類型分為mutable和immutable兩種類型，mutable: list和dict，immutable：int,string, float, tuple

102 python中逗號

101 線性時間就是O(n)

100?sorted(L, key = len) 按len來排序

99 for循環本質上是通過不斷調用next()函數實現的

98 iterator甚至可以表示一個無限大的數據流，比如全體自然數，但使用list是不可能存儲所有自然數的

97 可以把這個數據流看成是一個有序數列，但我們不能提前知道這個有序數列的長度，只能不斷通過next()函數實現按需計算下一個數據。所以iterator的計算是惰性的，只有在需要下一個數據的時候，它才會計算

96 可以被next()函數不斷調用并返回下一個值的對象稱為iterator；可以作用于for循環的對象稱為iterable，比如list，tuple，str，dict，set，generator；list，str，dict是iterable，但不是iterator；iter()函數可以把list，str，dict等iterable轉成iterator；iterator對象表示的是一個數據流，可以被next()函數不斷調用返回下一個值，直到沒有數據。

95 escape character轉義字符；\n換行，\t橫向制表符?ASCII Horizontal Tab (TAB)

94 DFA：deterministic finite automaton，是一個含有5個元素的tuple（S，q0，T,? F，），S：狀態的集合，q0：初始化狀態，T：transition function, F: 結束狀態的集合，??是全部的字母表。

93 str.isalpha()全部是字母就返回True，否則返回False

92 index超出范圍，總是出這樣的錯，一定要細心啊; 一定要從最簡單的開始考慮

91 在紙上寫testcase

90 二分查找法時間復雜度：O(logn)

89 list和string都有count函數

88 創建一個圖，首先也得創建一個root

87 union find，并查集，是解決動態連通性的一種很高效的數據結構。

86 queue因為是list，所以添加元素的時候，可以用queue+= i

85 any() 和 all()的區別。any()判斷對象是否為空對象，如果都是空，0，false，返回false，如果不都返回空，0，false，返回True；all()，如果里面所有元素不為0，空，false，則返回True，但是all(x)如果x是個空對象，則返回True

84 從現在開始，看到一道題，就模擬是在面試，認真讀題，積極思考，用英語說

83 id, type也是關鍵字

82 在最開始時除了要初始化好需要用的stack什么的，也要注意初始化一個返回array，或者返回value

81 deque是雙端隊列，可以從兩端append數據；如果想實現隨機訪問，用list好些；queue是隊列，先進先出

80 二分圖：指頂點可以分成兩個不相交的集，同一個集內的頂點不相鄰，即沒有共同邊

79? 圖的遍歷既可以用BFS，也可以用DFS

78 undirected graph: 無向圖，邊沒有方向；G=<V,E> V是頂點集，E是邊集，是由V中元素構成的無序二元組

77?temp, i = divisor, 1 寫成兩行就TLE了？

76 看找到思路了，再去看別人的答案，思路都不知道，就去看答案，肯定看不懂，就會浪費很多時間

77 DFS中是一定會存在遞歸調用的，在dfs循環體中值需要考慮當前節點就行，下面的直接遞歸調用

76 if not i這樣的判斷語句代表如果i為False，就可以執行if下面的語句

75 python中is和==的比較：==是對比兩個對象的內容是不是一樣的，即內存地址可以不一樣，只要內容一樣就行；is是判斷兩個對象的內存地址是不是一樣，是不是同一個對象

74?dividend：被除數，divisor：除數

73 通常用于求解某種具有最優性質的問題，一般用于多階段決策問題。

72 貪心算法，greedy algorithm，只是局部最優解，沒有從整體最優上加以考慮

71 鏈表的node，是包含值和指針的，指針就是指向的地址，所以當我們把head node放置在隊伍中去的時候，因為有指針，所以就可以找到它后面的node

70 建立dummy head和head一樣，建好后一般會設置一個curr指針來幫助建立后面的node

69 heap和stack區別：heap像一堆金字塔型泥沙，stack像一個直立垃圾桶；heap也是priority queue，按照元素的優先級取出元素；heap性質：任意節點小于或大于它的所有后裔，最小元或者最大元在堆的根上；heap總是一顆完全樹，即除了最底層，其它層的節點都被元素填滿，且最底層盡可能地從左到右填入；heap實現：主要是插入和刪除最小元素，元素值本身是優先級鍵值，小元素享有最高優先級；插入或者刪除之后，heap還是要保持為一顆完全樹，即完全二叉樹和每個節點值都小于或者等于它的子節點

68 Queue類，FIFO；Queue.PriorityQueue, lowest valued entry retrieved first.

67 復制鏈表的方法：創建一個hashmap，舊節點是key，新節點是value

66 next()返回迭代器的下一個項目

65 items函數，將一個字典以列表的形式返回，因為字典是無序的，所以返回的列表也是無序的，比如a = {‘a’:1, 'b':2}, a.items(), 輸出的結果是a = [('a',1), ('b', 3)]; iteritems()返回的是一個迭代器，b=a.iteritems(), list(b)=[('a',1), ('b', 2)],?字典.iteritems()方法在需要迭代結果的時候使用最合適，而且工作效率很高

64 map查找時間是O(logn)，hashmap查找時間是O(1)

63 單鏈表插入刪除的時間復雜度為O(n)，雙鏈表為O(1)

62 del用于list列表操作，刪除一個或者連續幾個元素，比如a=[1,2,3,4], del a[0], 則a=[2,3,4]

61 collections模塊中有一個子類OrderedDict，可以對字典對象中的元素進行排序，會根據輸入的順序放置

60 建立字典樹Trie需要先建立一個TrieNode, init函數里有self.children； 建立binary tree也需要建立一個TreeNode的class，init函數里是當前節點的self.val=x, self.left=None, self.right=None; Linked list有ListNode， init函數里特有屬性self.val=x, self.next=None

59 trie也叫prefix tree

58 DFS就像走迷宮，一條路走到頭了再返回走另外一條路。比如下面一張圖，從1開始搜索，找到了2，2又找到3，3找到4，4找到5，然后無路可走（因為5周圍的走過了），返回到4，從4到6

BFS的話，就是從1開始，2和5找到了，然后從2開始找，3找到了，再從5找，4找到了，接著走3，沒有路可走，再從4開始，6找到了；BFS的話就是要找到與該節點相鄰的所有節點

57 初始化一個矩陣code：[[1,2,3,4,5],? [1,2,3,4,5] ]，每一行和每一行之間用‘，’連接，每一行所有元素間用[]包括，每個元素間用‘，’連接；所以如果要全部初始化為0，則code為：[[0 for i in range(0,n)] for j in range(0,n)]

56 極值的問題考慮使用動態規劃

55 已知三角形兩邊a和b，以及夾角C，則三角形面積是1/2*absinC

54 operator.mul()

53 reduce函數會對參數序列中的元素進行累積；reduce(function, iterable)，如果fucntion中有兩個參數，比如lambda函數，則將集合中的第一第二個元素進行操作，再和之后的元素進行依次操作

52 list+list=list，比如[1, 2, 3]+[4, 5 ,6]=[1, 2, 3, 4, 5, 6]

51 遇到排列組合，可以結合stack做，因為stack返回的就是list，表示成[]，返回到res中就是一個一個[]，最后是[[]]

50 一直讓loop循環，知道滿足條件再跳出循環，可以用while True

49 combinations是backtracking的一個application

48 從大到小遍歷，要用range(max, min, -1)，此處的-1不能省掉

47 列出所有結果的題用recursive

46 backtracking: ORT原則，options, restraints, termination

45?[::-1]是reverse的意思，time complexity is O(n), [:-1]才是去掉最后一個字符的意思

44 list也是個關鍵字

43 還是沒有徹底弄清楚DFS和BFS

42 ord()將character轉換成unicode integer 或ASCii碼值；‘a’的ASCii值是97，‘A’的ASCii碼值是65

42 range(1, n+1)我老是喜歡寫成range(1:n+1)

41 遇到困惑就要去解決，比如知道刷了的題還是會忘記，那就在第二天，第四天，第八天。。。花很短的時間去復習下

40?memorization存儲調用函數的結果，當相同的參數傳進來的時候，直接返回值就行了。在遞歸函數中用得比較多

39 memorization技術：就是把每次函數執行的結果存儲在鍵值對中，在接下來的執行中，現在鍵值對中查找是否有相應執行過的值，如果有，直接返回該值，沒有的話才真正執行函數體的求值部分。在鍵值中找值比去執行函數快多了。

38 2的3次方，2 to the power of 3

37 遇到Parenthesis的題，就可以用count來做

36 backtracking回溯法，是一種搜索嘗試過程，當發現不滿足條件時，就退回來尋找新的路徑，退回來這個過程就是回溯。是一種系統搜索問題解的方法。使用DFS的方法。適用于求解組合數較大的問題。回溯問題遞歸函數模板：

1 ）最開始寫好跳出條件，滿足條件才加到總結果中

2） 已經拿過的數不再拿

3）遍歷過當前節點后，為了回溯到上一步，需要去掉已經加入到list中的當前節點

35 open parenthesis 是左括號的意思

34 deque.popleft獲取最左邊的元素并刪除

33 對于stack來說，最上面的元素可以通過stack[-1]來得到

32 設計一個class，class的成員函數間是可以調用的，我經常忘記調用其他的函數

31 queue.peek()只是看這個值，并沒有刪除這個值的意思

30 Manhattan distance: 曼哈頓距離，兩點之間南北方向和東西方向的距離之和

29 迷宮問題：maze problem

28?perfect binary tree：all leaf nodes at the same level, and all internal node has degree 2; full binary tree: each node has zero or two children;?

27 DFS遞歸需要棧，所以空間復雜度是O(logn)；BFS也需要用隊列，也需要extra space

26?self.sums = [[0 for j in range(c+1)] for i in range(r+1)] 因為對于matrix來說，是list[list[int]]，所以初始化的時候要兩對[]，其中里面那對先按照column遍歷，因為其存儲的就是一行，然后外面一層才是按row遍歷

25 在草稿紙上多寫幾個例子找規律

24 for b in zip(*xmap) 在這句code中，zip中是unpacked的individual字符串，每一個individual字符串是32長度的num轉換來的，這樣在每一次for循環中，b先取每個字符串的第一位，這樣b的長度就是32的tuple，然后調用tuple.count()

23 總是忘記使用string.count()這個函數，比如想統計string中‘a’的個數，可以寫成string.count('a')

22 python中*的作用是unpack list to individual arguments，比如zip(*['0100','1110','0010'])等于zip('0100','1110','0010')

21?'{:032b}'.format的作用是將輸入參數轉換成32位無符號數字符串

22 set()和{}都可以用來創建集合，但要創建一個空集合的話，只能用set()，因為{}是創建字典的。創建過程是{‘a’, 'o', 'e', 'i', 'u'}, set('aoeiu')，set('aoeiu')運行后為set([‘a’, 'o', 'e', 'i', 'u'])。原來set中也是一個list，無序不重復結合

21 set的in operation比string的in operation要快些，所以在做lookup的時候，盡量用set

20 map(f, list)將f函數作用在list的每一個元素上，一個一個mapping，所以叫map函數

19 str.format()，可以接受很多個參數，可以在format函數里面對應賦值，也可以在format()函數里面給變量賦值

18 一定要避免使用兩個for loop，一般都會time limited

17 每刷一題，分析時間復雜度和空間復雜度

16 sum是python關鍵字，可以用sums

15 二叉搜索是，每個節點的值比它左子樹的任意節點值大，比它右子樹的任意節點值小

14 先要把題意弄明白，然后想明白該怎么做，最后再寫code

13 二叉查找樹的中序遍歷是遞增序列

12 set(['John','Jane','Jack','Janice'])中存字符串是這樣存的，set([1, 2, 3]) 存number

11 trie的兩個應用，詞頻統計，也可以用hash和堆來做，可是沒有trie節省空間，因為字符的公共前綴是用同一個節點來存的

10 trie的insert和search time complexity都是O(k)，k是key的長度，trie的缺點是space complexity高；

9 由于trie可以最大限度地減少字符串比較，所以可用于詞頻統計和大量字符串排序；優點是最壞情況時間復雜度此hashtable好。也有key到value的映射，但這里的key是字符串

8 trie中的key通常是字符串，根節點不包含字符，除根節點以外的所有節點都包含一個字符，從根節點到某一個節點，所有的字符連接起來，就是該節點的字符；每個節點的所有子節點包含的字符串不相同。

7 set.add() list.append()

6 普通dict和collections.defaultdict()的區別，普通dict添加和查找元素都可以用dict[key]=value來實現，但是在查找的時候，如果key不在字典中，則會出現keyError；但是 collections.defaultdict()就能解決這個問題，當key不存在時，可以返回default factory function的默認值，這里factory function可以是set, list, str，int，set的默認值是set()，list默認值是[]，str默認是是空字符串，int默認值是0

1 collection是python中的一個集合模塊，里面包含很多集合類，和隊列相關的集合類是deque

2 初始化一個queue，collections.deque(maxlen=size)這里需要初始化queue的長度

3 hashMap和hashSet的區別：hashMap實現了map接口，hashSet實現了set接口；hashMap調用put添加元素，hashSet調用add添加元素；hashMap是鍵值對，hashSet只有值；hashMap相對于hashSet來說快些，因為是使用唯一的鍵值獲取對象；hashMap使用鍵值獲得hashcode，hashSet使用對象得到hashcode

https://www.cnblogs.com/codercui/p/6841730.html

4 bisect模塊，在使用這個模塊前，要確保array是排好序了的；bisect模塊的幾個函數，第一個是bisect.bisect_left(L, x)查找x在L中的位置，如果x在L中，則返回x左側的位置，如果不在L中，則返回插入的位置；bisect_right(L,x)，如果x在L中，返回x右側的位置，如果不在L中，返回應該插入的位置；bisect.insort()就是插入元素之后還是保持array是排序的; 調用bisect.bisect的時候，其實是在調用bisect.bisect_right; 調用bisect.insort的時候，其實是在調用bisect.insort_right

5 因為bisect_left和bisect_right是為了查找需要插入的位置，所以bisect_left就返回插入數在最左邊的位置就好了，因為插入進去也是會插入到這個位置；但是bisect_right是會返回當前位置加1的，因為插入的話會插到當前位置加1上；bisect.insort_left的話是真正把這個元素插進去了，返回插入后的序列，left的話就插在左邊，right的話就插在右邊

201 bisect.insort()是插入后再排序，時間復雜度是O(n)

200 在python里面，/做除法的時候，如果想得到小數部分，floating point的結果，可以把除數寫成float的形式

199 sum vector is O(n) time

198 想建立一個固定長度的array，比如一個固定長度的sliding window，可以是[0]*size，我之前是self.window = [:size]，這樣是不行的

197?collections.defaultdict(list)和dict.setdefault()等價，但是collections.defaultdict()比dict.setdefault()更快

196 dic.get(key, value) 尋找key對應的值，如果key不在dic中，則返回默認值

195 dic.setdefault(key, value)和get()方法類似，都是得到相應鍵對應的值，所不同的是，對于dic.setdefault(key, value)，如果key不在字典中，則添加進去，默認值為value，如果沒有默認值，則設置為None

194 string中數字的處理一定要注意，要用int轉換成數字

193 string不能被賦值，只能轉換成list才能賦值

192 string.startswith(j)代表這個string是以j開頭的

191 s.split()返回的是一個list，里面的element是一個string

190 得到某個元素在list中的index，可以是list.index(value)

190 list.pop(index)默認是-1，也可以指定index

189 list.insert(index, object)在list的指定位置插入一個元素

188 stack.pop()和stack.top()的區別是，stack.pop()會刪除頂端這個元素，stack.top()只是讀頂端這個元素

187 類是抽象的模板，會把必須綁定的屬性放在init函數里邊

186 寫類的function的時候，function的第一個參數都是self。self是指類實例本身

185 _init_是初始化一個類，是在類實例創建之后調用，對當前實例的一些初始化

184 要注意看note

183 string.split('@') split的字符是在括號里面的

182 python和python3一個最重要的區別是：在python里面，1/2是0，在python3里面，1/2是0.5；在python3里面。//取代了/操作

181 if s[i] in "+-*/" 是沒有is的

180 list.sort()平均時間復雜度是O(nlog(n))，最快時間復雜度是O(n)，用的是Timsort

179 多在紙上畫

178 three-way-partition 方法把數組分為< = >三部分，只需要一次掃描

177 quick sort中經常用到Lomuto partition algorithm；quick sort中用partition將數組分成兩組，對每組再遞歸調用quick sort方法；有一排小球，有紅黃綠三種顏色，需要將三種顏色的球排好，相同顏色的球球相鄰排著，這是經典的Dutch national flag problem

176 merge sort每次都是比較最開頭的元素，然后調用遞歸

175 *是該變量可以接收多個參數，并將參數轉化成元組；**是該變量可以接收多個參數，但是將參數轉化成字典[key:value, key:value]

174 quick sort在最壞情況下時間復雜度是O(n^2)

173 為什么merge sort到鏈表的時候空間復雜度從O(n)變到O(1)了，這是因為對于鏈表來說，只需要改變指針就可以了，不需要額外的空間

172 merge sort對于鏈表來說是in-place的sort，不需要額外的空間，而且merge sort穩定，所以sort list的時候用merge sort

171 L.next = head 可以理解成L節點的next指針指向head節點

170 dummy =? ListNode(None) 是建立一個listNode，其中None是傳入到init的參數，也就是dummy.val

169 dummy head就是在head前面再加一個節點，這樣就可以把head和后面的節點一起處理了，不用單獨再考慮head節點，返回時返回dummy->head就行了

168 快速排序是選擇一個鍵值，一般選第一個，將所有比它小的放在左邊，所有比它大的放在右邊，然后再遞歸調用

167 將鏈表一分為二的時候，比如找到了中間節點，需要將中間節點指向NULL，這樣才代表真正將鏈表一分為二了

166 merge sort (歸并排序)和quick sort一樣，時間復雜度都是O(nlogn)，都是將array分成兩部分，對每一部分再遞歸調用，但是merge sort需要額外的O(n)存儲空間，從這一點上沒有quick sort有優勢，但是相對于quick sort，merge sort更加穩定。merge sort是將數組分成兩部分，對每一部分進行排序，最后進行合并。merge sort更適合于linked list sort，quick sort更適合于數組排序

165 bucket sort algorithm: 是最快的也最耗空間的一種排序，比quick sort還快；bucket sort algorithm用于數字是在固定區間，比如學生的分數是在[0,100]間：先將original array中的元素分別放在buckets中，再對每個bucket進行排序，最后再gather所有的元素

164 dic[key]是放在中括號中的，不是小括號

163 在字典中，key必須不一樣

162 函數沒有返回值的時候，默認返回的是None；return后沒有值也是返回None

161 dic.get(key, specified value) 好處是當key不存在時，就會返回specified value， 如果沒有這個默認值的話，就會返回None

160 命名一個dictionary就叫dic好了，簡潔明了，也不會和關鍵字dict重合

159 想要得到dictionary中某個鍵對應的值，可以有兩種方法，第一種是dictt[鍵]，但這種方法不優雅，容易觸發keyError的問題；第二種方法是用成員函數get，dictt.get(鍵)，這種方法不會觸發keyError，如果輸入key不存在，則返回None，同時也可以接受兩個key，第一個key不存在，就返回第二個key對應的值

158 dictionary中鍵與值之間用冒號隔開，每一對用逗號隔開，整體放在花括號中。所以初始化一個dictionary的時候，可以這樣：hashmap{0:1}

157 設置變量的時候要注意，要避免關鍵字，比如sum就是關鍵字，不能用來當變量

156 若想要得到一個array中出現頻率最多的次數：可以使用下面兩句code，task = collections.Counter(tasks).values()? ? ?M=max(task)

155 需要無限循環的時候，就用while True

154 string.replace(old, new)，會建立一個新的copy

153 filter(function, iterable)，過濾掉不符合條件的元素，后面輸入是一個list，其中的每一個element會送到function中進行驗證，返回的是過濾后的list；此處的function是判斷函數，整個filter函數返回判斷函數得到為True的iterable

152 枚舉enumerate(('Thousand', 'Million', 'Billion'), 1)，第一個參數要用括號括起來

151 enumerate(iterable, start) start默認為0，即從0開始count，如果設置成1，則從1開始

150 string.split()將一個string split，將返回一個list

149 string也有自帶的count成員函數，s.count('A'); 還可以判斷某些字符串是不是在S中，比如‘LLL’是否在s中，則if ‘LLL’ not in s

148?if A==B and len(set(A))<len(A): return True

147 string是不能賦值的，只能轉換成list后再賦值

146 定義雙指針的時候，可以使用while循環

145 map函數就是返回一個list，使用的時候不需要額外加[]

144 python中有dict函數，輸入兩組數，就可以建立一個dictionary

143?[traverse(row+ x,col+ y)for(x, y)in((0,1), (1,0), (0, -1), (-1,0))] 雖然里面是個函數，但因為有很多種情況，所以也需要用[]裝起來

142?什么時候定義局部函數？如果局部函數需要用到上一級函數的參數，可以定義成局部函數；如果有很多其他函數調用這個函數，可以寫成全局函數

141 stack.append(root)和stack.pop()操作對象都是node，不是node.val

140 iterative, binary tree, BFS 用queue，DFS用stack

139 二叉樹遍歷右兩種方法，一種是遞歸，時間復雜度是O(n)，空間復雜度是O(logn) （遞歸棧的原因）；還有種方法是iterative（迭代），用棧來實現，時間復雜度也是O(n)，空間復雜度是O(logn) 。

138 inorder traversal: 中序遍歷。先中序遍歷左子樹，根節點，再中序遍歷右子樹；preorder traversal: 前序遍歷。先遍歷根節點，再前序遍歷左子樹，再前序遍歷右子樹，每次遍歷子樹的時候，依舊采取前序遍歷。postorder traversal：后序遍歷，先后序遍歷左子樹，再后序遍歷右子樹，再訪問根節點。

137 馬拉車算法：首先在每一個字符的前后加#，整個字符串的首尾也加#，這樣不管原始字符串的長度是奇數還是偶數，加上#后長度都變成奇數了，因為是2*n+1；需要用一個數組來存儲以T[i]為中心的回文長度，返回數組中最大的那個數就行了

136 map(None, )可以用作transpose matrix，在空缺的地方補None，https://leetcode.com/problems/valid-word-square/discuss/91126/1-liner-Python

135 *代表拆開list中的元素

134 python中的星號*（*list）代表的意思是把list中的元素都當做位置參數傳進去；**是接受字典key和value

133 map(f, list), 使得list中每個元素都經過函數f，然后返回一個新的list

132 字符也可以直接比大小？比如‘c’>'a'

131 如果是一個sorted的array，而且需要在此array中尋找某個target，為了減少時間復雜度，可以使用binary search

130 字符串是不可變對象（tuple也是），不能通過下標的方式進行賦值，比如S[8]='g'是不允許的

129 str.sort()不能對string片段進行排序，需使用sorted函數產生一個copy再賦值回去

128 nums[::-1]不是in-place的，是有一個copy的

127? list[list]不能用set函數來除去duplicate，如果想要除掉duplicate，可以先把list[list]中的list先轉化成tuple，然后再使用set

126 初始化一個list，list中element是字符串的，初始化為['']

125 str.lower() str.upper()

124 判斷一個string是否是字母，可以用str.isalpha()，不分大小寫的

123 可以使用str.isnumeric()函數來監測str是不是數字

122 遇到比對兩個字符串的時候，可以試著使用雙指針

121 backtracking

120 十進制轉換成其他進制的方法，比如八進制，用十進制數除以8得到商1余數1，再用商1除以8得到商2余數2.。。。。一直到商為0余數n，則最后八進制為（余數n，余數n-1,。。。，余數2，余數1）

119 dummy node的作用是保護head不會在刪除操作中丟失，一般用在single list沒有前向指針的問題；一般遇到head節點會變的時候，就會引入dummy node

118 linked list中的node是有value和指針的

117 linked list序號是從1開始的，linked list中的元素為空時，可以這樣判斷：if fast==None，因為python中沒有null，只有None

116 可以通過遍歷一次鏈表得到鏈表的長度

115 one pass表示在linked list中，只能traverse一次

114 遇到兩個新知識點：backtracking和memorization

113 bool函數將參數轉換成bool型，bool()參數為空的情況下，返回False；bool(0)返回False

112 preorder traversal 先序遍歷

111 list.reverse()和reversed(list)區別，list.reverse()會改變原有list，沒有返回值；reversed(list)不會改變原有list，有返回值，而且返回的不是list，如果需要返回list，需要寫成list(reversed(list))

110 有時候需要一個flag，就取名叫flag就好了，簡單明了

109 if not root: return []，寫成一行，還有各種各樣變量的定義，也寫成一行，看上去會簡潔很多

108 matrix.reverse()是把按列reverse的，也就是說，把第一行換到第n-1行

107 Two's component 補碼，補碼是把正數所有位取反，然后加1

106?if byte >=128 and byte <=191:寫成兩下，不要寫成if 128<=byte<=191

105 1也是丑陋數字

104 if key in hashmap 或者 if key not in hashmap，判斷語句是這樣寫的，沒有is；還有判斷的時候是判斷key是否在hashmap中，不是判斷值有沒有在hashmap中，key沒在hashmap中的話就需要建立一個key到value的connection，如果存在相應key的話，只需要把值加進去就行了；判斷值在不在hashmap中是沒有意義的，肯定每次都會不同，但是一個key可以對應很多值

103 sorted('cab') 會得到['a', 'b', 'c']

102 collections.Counter()相當于建立了一個hashtable，將hash到同一個value的objects放在了一起

101 str是個關鍵字，在白板上寫程序的時候要注意

100 abs(a-b)不是abs(a, b)

99 s=" ", 字符長度不是0，因為里面有空格符；也不是空字符串，因為里面有空格符

98 txt.split()默認就是空格符，txt是一個字符串，txt.split()會得到一個字符串list

97?[k for k, v in Counter(nums).most_common(k)], 通過k和v檢索的方式得到

96 quicksort(快速排序)的時間復雜度是O(nlogn)

95?list.sort是in-place的，不能寫成a =?list.sort(reverse=True), 直接寫成list.sort(reverse=True）就行了

94 list.sort()比sorted()要快些，因為list.sort()是in-place的，不需要create copy; list.sort(reverse=True)可以得到reversed的list

93 計算質因子中5的個數，用floor(n/5)，但是像25，125這種，本身是有2個5的，所以總的5的個數=floor(n/5)+floor(n/25)+floor(n/125)

92 0！也即0的階乘等于1

91 python沒有sqrt函數，求平方根可以用a**0.5

90 a/b就已經是整數部分了，不需要再在前面加個int

89?for i in xrange(length, -1, -1): 一定要寫后面那個-1，代表降序，不然返回null

88 L1=L和L1=L[:]的區別，第一是把L1指向L的地址，第二個是把L中的值復制到L1中，改變L1不會改變原來L的值；第一個改變L1的值會改變原來L的值，因為地址是指向L的

87 當numbers[i]看上去很復雜然后又要用到很多次的時候，可以將它賦值給一個字母，比如a =?numbers[i]，看著就不會那么累

86 STL: standard template library. STL中用的是quick sort（快速排序）

85?partition algorithm/?quick sort

84 動態規劃有時候只是和前兩個值相關，所以為了減少空間復雜度，可以只保留前面兩個值就行了

83 list.index(element)可以返回element在list中的index

82 要看清題目，比如說了是binary search tree，那就得利用binary search tree的特性

81 [::-1]倒敘輸出，[:-1]除掉最后一個元素的數

80 zip函數可以將兩個數組打包成元祖

79 注意位移符號優先級很低，沒有加減號高，所以在一起使用的時候，位移處要打括號：比如(1<<leftDepth)+self.countNodes(root.right)

78 class里面調用成員函數時，需要加self.

77 不管是滿二叉樹還是完全二叉樹，一直往左遍歷，就能得到二叉樹的高度

76 若滿二叉樹的高度是n（包括根節點），則所以節點的個數是2**n-1

75 完全二叉樹一個最重要的性質是：如果左子樹最左邊的深度等于右子樹最右邊的深度，則此完全二叉樹是滿二叉樹

74 能用迭代的時候用迭代（iterative），比遞歸（recursive）省時間些

73 位運算很省時間，比如<<比math.pow省時間很多

72 二叉樹的深度是指節點數，直徑是指connections的個數

71 full binary tree/ complete binary tree，完全二叉樹，假設深度為h，則1~h-1層都打到了最大節點數，第h層的所有節點都聚集在最左邊。滿二叉樹一定是完全二叉樹，完全二叉樹不一定是滿二叉樹；最后的h層最多有2**h個節點

70 binary search tree是可以沒有左子樹或者右子樹的

69 寫程序的時候，變量中最好能看出含義

68 判斷是否是回文，在python里面可判斷a==a[::-1]

67 堆(heap)和棧(stack)的區別，堆是金字塔式泥沙堆，棧是直立性的一個桶；heap是priority queue即優先隊列；堆是完全二叉樹，每一個父節點的值小于等于其子節點的值；heap(k)<=heap(2k+1), heap(k)<=heap(2k+2)，最小值是root，即heap(0)；創建一個heap，用[]，也可以將一個populated list轉換成heap，用函數heapify()，線性時間，in-place

66 二維條件表達式：[a,b][a>b], 如果第二個中括號為True，則返回b，若為Fasle，則返回a

63 bin(a)得到的就是一個string

62 modify數組in-place的時候，不要用return，直接就是在之前數組上改的

61?Manacher是查找一個字符串中最長回文串的線性算法

60 range里面是用逗號連接的，list里面是分號

59 python 函數里面寫函數的話，不用self參數

58 一個數若是合數的話，必然能找到兩個數相乘得到這個數，必然是一個小于根號n，一個大于根號n，或者兩個都是根號n。所以在尋找質因數的時候，只需要循環到根號n就可以了，因為如果在小于等于根號n的循環中都找不到質因數的話，在大于根號n里更找不到了

57 BFS和DFS區別，BFS是一石激起千層浪，DFS是不撞南墻不回頭；BFS和隊列有關，DFS和遞歸有關

56 a[:-1]是去掉最后一個元素；a[-1]取出最后一個元素

55 對稱數：0，1，6，8，9

54 DFS深度優先遍歷

53?Fibonacci sequence?斐波那契數列 F(1)=F(2)=1 F(n)=F(n-1)+F(n-2) (n>=3)

52?lexicographical 詞典編纂的

51 string字符串

50 動態規劃核心步驟是寫出狀態轉移方程，需要維護局部最小，局部最大，全局最大三個變量

49 要特別注意corner case

48 list就是array

47 map就是dictionary

46 只有list有append，str沒有

45 兩個嵌套for循環，時間復雜度是O(n**2)，如果直接寫兩個并排的for循環，則時間復雜度為O(n)

44 對list進行排序的兩種方法，一是list的成員函數sort，在本地進行排序，不返回副本；二是build-in sorted函數，返回函數，原始list不變，reverse=True為降序，reverse=False為升序

45?Manacher‘s Algorithm的時間復雜度是線性的

44 range從大到小，遍歷的時候不包括最小的那個數

43 拿到一道題，從最簡單的例子想起，先把思路先想清楚

42 要對比誰小的時候，設置變量應該設置一個很大的值

41 二分查找法，binary search，時間復雜度O(logn)

40 range的index是從0開始的，假如有整數n，那么index=0的時候，n=1，index=1的時候，n=2

39 range和xrange的區別：當range()里面的參數特別大的時候，容易出現memory的錯誤，而xrange是一個生成器，就不會出現這種錯誤，所以在參數特別大的時候，用xrange函數。range是生成一個序列，xrange是生成一個生成器，所以當參數很大的時候，需要開辟一塊很大的內存空間，性能不如xrange好

1 python中tuple和list區別，list[], tuple()，tuple一旦定義就固定了，不能刪除不能插入

2?collections.Counter()中Counter是大寫，是Counter不是Count

3 split()默認字符是空格

4?' '.join([A, B])還可以簡化成A+“ ”+B

5 binary tree的diameter長度是指edges不是nodes數

6 Python3的除法要用//

7 搶錢題：動態規劃

8 二分搜索法：最好情況下時間復雜度是O(1)，最壞情況下（平均情況）時間復雜度是O(log n)

9 two-sum，如果用兩層循環，時間復雜度必定是O(n^2)，如果用hashtable，就只需要遍歷一遍就行

10 two-sum hashtable, 如果target-num[i]在hash table里面的話，就說明前面已經出現num[i]了，而num[i]的index存在了hashtable里的，所以這時候只需要return當前的index就可以

11 break跳出整個循環，continue跳出當前循環，開始下一個循環

12 對于while語句，用得還是不溜

13 if和else的時候，把簡單的留在最后面返回

14 寫每一句code的時候都要細心

15?maxProfit, minPrice= 0, float('inf')? 學會用float('inf')

16 str 不能寫成for i in str這種形式，沒有循環

17?enumerate 枚舉就是一一列舉的意思，如果apply了enumerate函數，就會得到序列號和值的pair

18 dummy head for link list: ListNode(0)

19 要返回鏈表的話，返回鏈表的頭指針就可以

20 若返回的是matrix，則定義這個matrix的時候定義成[]就行，調用append函數的時候，也是一個row一個row的往上append

21 substring和subsequence不一樣，substring必須是原string的一個part，有前后順序，subsequence沒有順序

22 要返回什么，你就得在最開始定義

23 定義一個map為a = {}，則取其中的元素的時候，要用中括號，比如a[]

24 二分法查找：binary search

25 prime number質數也叫素數，大于1的natural number中，只能被1和本身整除的數；合數是composite number；1既不是prime number也不是composite number

26 python中power用**

27 求某個范圍內自然數中質數的個數，有埃氏篩法

28 unicode: unique binary code for every char in every language, the goal is to address the handle requirement for multi-language, multi-platform.

29 ASCii碼是對英文字母，數字，特殊字符做的編碼，為二進制編碼形式

30 ord()返回對應字符的ascii碼值，十進制形式。配對的是chr()函數

31 list.pop([index=-1])返回從列表中刪除的對象，默認是刪除最后一個元素，默認index=-1

32 list的初始化，[1]*n這樣就有n個1了，list加是把兩個list連起來

33 用reversed(s) s在這是string，可以返回reversed的string

34 n位數和n位數相乘的積最多也是2n位數

35 做coding題的時候，先把思路全部理清了，給面試官說清楚了，再開始寫code

36 m位的數和n位數相乘的位數最大是m+n位，最小是m+n-1位

37 乘法中的zero-padding是指用0補充的意思

38 若一個list，從index=3開始取值，則為list[3:]，就是中括號，沒有小括號

most_common