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

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

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

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

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

& 用于兩個(gè)set的話，可以得到intersection

collections.defaultdict(lambda: 1) 因?yàn)槿绻麑?xiě)成int，默認(rèn)值將是0，這樣寫(xiě)是為了得到一個(gè)匿名函數(shù)

stack經(jīng)常只用來(lái)存儲(chǔ)index

迭代器的優(yōu)勢(shì)：在構(gòu)建迭代器的時(shí)候，不是將所有的元素一次性加載，而是等調(diào)用next方法時(shí)返回元素，所以不用考慮內(nèi)存的問(wèn)題

迭代器的使用場(chǎng)景：數(shù)列的數(shù)據(jù)規(guī)模巨大；數(shù)列有規(guī)律，但是不能使用列表推導(dǎo)式描述

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

判斷條件時(shí)，if 0 not in set，沒(méi)有那個(gè)is

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

most_common時(shí)間復(fù)雜度是O(nlogn)

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

sorted之后返回的是list

sort只適用于list，sorted可以對(duì)任何interable變量進(jìn)行sort

-1在計(jì)算機(jī)中表示：1的碼是0000....1，反碼是111111....0，因?yàn)樨?fù)數(shù)的表示是正數(shù)的反碼加1，所以-1是111111...1，左移31就是10000000，代表計(jì)算機(jī)能表示的最小數(shù)

string.lowercase包含26個(gè)英文小寫(xiě)字母

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

計(jì)算機(jī)里面都是存的補(bǔ)碼，是一個(gè)圈，最大數(shù)是127(01111111)，最小數(shù)是-128(10000000), 所以127+1后會(huì)出現(xiàn)溢出，然后就等于-128了

對(duì)于有符號(hào)位(最高位是1)，補(bǔ)碼等于反碼加1

~x = -x-1 因?yàn)閪x+1就是反碼加1，~x+1=-x

dictionary的setdefault和get是一樣的，如果key不在dictionary中時(shí)，dict.setdefault(key, default=None)會(huì)給一個(gè)默認(rèn)的key和value

segment tree

binary indexed tree

backtracking一般和dfs一起用

一是只要遇到字符串的子序列或配準(zhǔn)問(wèn)題首先考慮動(dòng)態(tài)規(guī)劃DP，二是只要遇到需要求出所有可能情況首先考慮用遞歸

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

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

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

itertools.combinations_with_replacement()

這里replacement的意思是，取出來(lái)后又會(huì)放回去，所以有AA，BB， CC， DD這種情況

heap的nlargest和nsmallest函數(shù)，返回的是一個(gè)數(shù)組

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函數(shù)彈出最小元素將另一個(gè)元素加入堆：

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

max heap頂端是最大的

Quickselect Algorithm：

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

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

異或或者與都可以直接對(duì)integer進(jìn)行操作

^位異或，&位與

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

對(duì)于回文問(wèn)題，使用Manacher's algorithm可以答到O(n)時(shí)間

遇到一個(gè)數(shù)組，如果是想求其最大，最小，最長(zhǎng)，最短值，而并不需要知道具體解的題，可以考慮使用動(dòng)態(tài)規(guī)劃

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()函數(shù)的，得到一個(gè)迭代器，迭代器有next()功能

Boyer-Moore Majority Vote algorithm

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

摩爾投票升級(jí)版，超過(guò)n/3的數(shù)最多只能有兩個(gè)；

建立hashtable的時(shí)候，key一定要是unique的，比如對(duì)一個(gè)字符串的index和value建立hashtable的時(shí)候，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.

拓?fù)渑判蛑锌梢杂玫紻FS和BFS，但是BFS是主流

set("HelloWorld") 得到結(jié)果是{'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)時(shí)間排序

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

拓?fù)渑判颍簩⒂邢驘o(wú)環(huán)圖的所有頂點(diǎn)排成一個(gè)線性序列，使得對(duì)圖中的任意兩個(gè)頂點(diǎn)u，v，如果存在邊u->v，那么在序列中u一定在v的前面，這個(gè)序列又叫拓?fù)湫蛄小?/p>

有向無(wú)環(huán)圖：如果一個(gè)有向圖的任何頂點(diǎn)都無(wú)法通過(guò)一些有向邊回到自己，那么這個(gè)有向圖叫有向無(wú)環(huán)圖(DAG: directed acyclic graph)

使用sqrt的時(shí)候，要加一個(gè)math.sqrt()

BFS 二叉樹(shù)的時(shí)候，注意如果在while循環(huán)里面使用了pop，則queue里面就沒(méi)有這個(gè)node啦，后面如果還想用就會(huì)出錯(cuò)；下圖中后面想用的時(shí)候就是空了

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

DFS有時(shí)候從大數(shù)開(kāi)始可以更快的得到結(jié)果

長(zhǎng)方形是rectangle，正方形是square

求距離場(chǎng)BFS是不二之選

想要得到最小步數(shù)等問(wèn)題，可以使用heap

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

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

python中g(shù)et()，如果鍵不存在，則會(huì)返回None，所以在計(jì)數(shù)的時(shí)候，不要當(dāng)做返回0來(lái)處理

DFS應(yīng)用在matrix的時(shí)候，一定要注意visited情況，如果visit過(guò)的再visit的話，很容易出現(xiàn)超時(shí)的情況，可以用設(shè)置visited為一個(gè)set，將visited過(guò)的加到set中去

from在python中是一個(gè)關(guān)鍵字，定義變量時(shí)不要用它

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

在寫(xiě)上面的code時(shí)，我經(jīng)常會(huì)犯錯(cuò)誤，就是把dfs(newStart)和if對(duì)其，這是不對(duì)的，因?yàn)閚ewStart是依賴上面一行得到的結(jié)果的

string.startswith(word) 應(yīng)該是string的一個(gè)常用函數(shù)，要學(xué)會(huì)利用起來(lái)

list不能當(dāng)做hashtable的key

如果一個(gè)數(shù)是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，一句一句弄懂，打印出來(lái)看，在本子上畫(huà)

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

Eulerian Path 歐拉回路

undirected graph: len(edges)就是node的個(gè)數(shù)

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

union find的思想是每個(gè)個(gè)體先初始化成不同的群主，然后遍歷有關(guān)聯(lián)的兩個(gè)個(gè)體，如果發(fā)現(xiàn)find的值不同，則手動(dòng)將二者加入到一個(gè)群主，然后總?cè)褐鲾?shù)減1

union find的時(shí)候，是把rank小的合并到rank大的那個(gè)上，因?yàn)檫@樣可以少一些path compression的操作

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

union find用來(lái)解決network connectivity問(wèn)題

cmat = copy.deepcopy(mat) 如果直接傳mat，會(huì)修改mat的值，因?yàn)閜ython里面matrix，list屬于object，傳參數(shù)的時(shí)候傳的是inference也就是指針。像variable這種就沒(méi)關(guān)系

str object doesn't support item assignment

string 才能join，int不能join

list(N) N是整數(shù)，這是錯(cuò)誤的，整數(shù)不能被list

MSB：most significant bit

greedy算法

divide and conquer：把一個(gè)問(wèn)題分成等價(jià)的子問(wèn)題，分別進(jìn)行解答，最后再把結(jié)果合并

第一步：把每個(gè)結(jié)點(diǎn)的根節(jié)點(diǎn)指向它自己，這樣就有n個(gè)cluster，rank都初始化成0。find的過(guò)程把當(dāng)前結(jié)點(diǎn)和它的父母結(jié)點(diǎn)都指向root結(jié)點(diǎn)；在find中，當(dāng)這個(gè)結(jié)點(diǎn)不是根節(jié)點(diǎn)時(shí)，

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

path compression：每次尋找某個(gè)結(jié)點(diǎn)的root時(shí)，就把此node的所有父母結(jié)點(diǎn)指向root，這樣相當(dāng)于flat了整個(gè)cluster，下一次查找的時(shí)候就直接是O(1)時(shí)間了

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

無(wú)向連通圖：undirected graph.

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

collections.Counter()也是一個(gè)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:?

動(dòng)態(tài)規(guī)劃，當(dāng)前狀態(tài)需要依賴前一狀態(tài)的值

subarray必須是連續(xù)的

binary search：中間值下標(biāo)的計(jì)算，如果寫(xiě)成(l+h)/2，l+h有可能會(huì)溢出，從而導(dǎo)致數(shù)組訪問(wèn)出錯(cuò)；改進(jìn)的方法是l+((h-l)>>1)

sliding window: standard template：記錄左指針，右指針，每個(gè)循環(huán)更新左指針，右指針是當(dāng)前index；外循環(huán)遍歷整個(gè)數(shù)組，內(nèi)部一個(gè)while循環(huán)遵循題意要求；一個(gè)全局變量更新題意要求

binary search: while l<r，這里什么時(shí)候是小于號(hào)，什么時(shí)候是小于等于號(hào)

求極值的問(wèn)題，會(huì)用到dp

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

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

str()是把integer轉(zhuǎn)換成string

*也可用作解包，func(*args)函數(shù)時(shí)，相當(dāng)于把一個(gè)元組args拆開(kāi)，當(dāng)成參數(shù)傳進(jìn)函數(shù)中。

*代表該位置可以接受任意多個(gè)非關(guān)鍵字參數(shù)，在函數(shù)中將其轉(zhuǎn)化成元組

200 itertools.product(A,B)，依次取出A中的一個(gè)元素和B中的一個(gè)元素組成一個(gè)元組，然后將所有的元組形成一個(gè)列表返回。比如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)，不能這么寫(xiě)，前面不能加負(fù)號(hào)

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

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

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

193 動(dòng)態(tài)規(guī)劃解決0-1背包問(wèn)題步驟：（1）選擇一個(gè)給定物品i，需要比較選擇i形成的子問(wèn)題最優(yōu)解和不選擇i的子問(wèn)題最優(yōu)解，再對(duì)兩個(gè)子問(wèn)題進(jìn)行比較，選擇最優(yōu)的。https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/

192 部分背包問(wèn)題：總是選擇每一磅價(jià)值（Vi/Wi）最大的物品添加到背包中。解決過(guò)程：對(duì)每磅價(jià)值進(jìn)行排序，依次從大到小選擇添加進(jìn)背包中

191 0/1背包問(wèn)題：在選擇是否把一個(gè)物品加到背包中，需要對(duì)把這個(gè)物品加到背包的子問(wèn)題和不加到背包的子問(wèn)題進(jìn)行比較。這種方式形成的問(wèn)題導(dǎo)致了很多重疊子問(wèn)題，滿足動(dòng)態(tài)規(guī)劃的特征

190 0/1背包，動(dòng)態(tài)規(guī)劃；部分背包，貪心法

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

188 除以2，可以>>1，向右移動(dòng)一位

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

186 put n items to k buckets

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

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

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

182 python中g(shù)et()，如果鍵不存在，則會(huì)返回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，如果之后要斷掉某個(gè)連接，但之后還得用到這個(gè)連接，那就先保護(hù)好這個(gè)連接

178 怎么建立一個(gè)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已經(jīng)是一個(gè)linked list node了

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

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

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

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

172?collections.deque(maxlen=size)可以設(shè)置一個(gè)最長(zhǎng)len，這樣如果queue滿了，append進(jìn)來(lái)的數(shù)也會(huì)擠掉前面的數(shù)，不用再pop了

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

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

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

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

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

166 在計(jì)算機(jī)中，32bit最大能表示成2**31-1，因?yàn)樽罡呶皇欠?hào)位

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

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

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;另外一種更簡(jiǎn)單的方法是直接定義：d=collections.deque

159?union find:研究動(dòng)態(tài)連通性

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

157 find返回子字符串開(kāi)始的位置

156 for BST, inorder traverse is an ascending sequence

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

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

153 heap[0]是最上面那個(gè)數(shù)，stack[-1]是最上面那個(gè)數(shù)

152 如果是import heapq的話，調(diào)用任何heap相關(guān)函數(shù)，前面都要加heapq.

151 max heap就是min heap的invert

150 使用heapq的時(shí)候，直接import heapq就可以了

149 self只在類的方法中才有，在獨(dú)立的函數(shù)中是沒(méi)有必要帶的，self在定義類的方法時(shí)必須有，在調(diào)用的時(shí)候會(huì)自動(dòng)傳入；self就是指類實(shí)例對(duì)象本身

148 query疑問(wèn)，質(zhì)問(wèn)

147 dic.pop('key', None)刪除字典中的key，如果key不存在，返回None，因?yàn)椴粫?huì)產(chǎn)生keyerror

146 decimal小數(shù)的

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

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

143 list.pop()默認(rèn)是pop最后的那個(gè)元素，所以我們?nèi)绻雙op最開(kāi)始的元素，需要把參數(shù)設(shè)置成0

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

141 注意注意注意：push到heap中，是按照push進(jìn)去的第一個(gè)緯度來(lái)衡量最小值的！??！比如計(jì)算最小步數(shù)，一定要把steps放在最前面哇

140?type start: List[int]?

139 總是忘記把heap寫(xiě)進(jìn)heapq.heappop(heap)中去

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

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

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

135 lookup的時(shí)候，set比list快

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

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

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

131 string.split()返回list

130 string.split()會(huì)改變string本身嗎？還是會(huì)產(chǎn)生一個(gè)copy。貌似不改變本身

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

128 maxheap

127 heapify()以線性時(shí)間將一個(gè)列表轉(zhuǎn)換成堆

126 刪除并返回heap中最小的元素，使用heapify()和heappop()來(lái)實(shí)現(xiàn)

125?set.remove(item)

124 denomination面值

123 從0變成1，從1變成0，可以用1-matrix[i][j]來(lái)實(shí)現(xiàn)

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

121 寫(xiě)新的內(nèi)部函數(shù)的時(shí)候，一定要放在最前面，方便調(diào)用

120 寫(xiě)程序時(shí)寫(xiě)完一句就檢查一下，養(yǎng)成一遍寫(xiě)好所有程序的習(xí)慣

119 看到別人的好建議，就馬上執(zhí)行

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 只寫(xiě)return，代表的就是return None，只是在這省略了None；

115?consonant 輔音字母

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

113 局部函數(shù)一般寫(xiě)在前面

112 yield是一個(gè)類似return的關(guān)鍵字，只是這個(gè)函數(shù)返回的是一個(gè)生成器

111 generator可以有效節(jié)約系統(tǒng)資源，避免不必要的系統(tǒng)占用

110 帶有yield的函數(shù)在python中稱為generator；這個(gè)函數(shù)和普通函數(shù)不一樣，看起來(lái)像函數(shù)調(diào)用，但不會(huì)執(zhí)行任何代碼，直到對(duì)其調(diào)用next()才開(kāi)始執(zhí)行，在for循環(huán)中自動(dòng)調(diào)用next()。每執(zhí)行到一個(gè)yield語(yǔ)句就會(huì)中斷，并返回一個(gè)迭代值，下次執(zhí)行從yield的下一個(gè)語(yǔ)句開(kāi)始執(zhí)行

109 兩個(gè)矩陣相乘，第一個(gè)矩陣的列數(shù)要和第二個(gè)矩陣的行數(shù)相等，最后的出來(lái)的矩陣行數(shù)是第一個(gè)矩陣的行數(shù)。列數(shù)是第二個(gè)矩陣的列數(shù)

108?forty 四十

107 bin函數(shù)返回的就是string

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

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

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

102 python中逗號(hào)

101 線性時(shí)間就是O(n)

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

99 for循環(huán)本質(zhì)上是通過(guò)不斷調(diào)用next()函數(shù)實(shí)現(xiàn)的

98 iterator甚至可以表示一個(gè)無(wú)限大的數(shù)據(jù)流，比如全體自然數(shù)，但使用list是不可能存儲(chǔ)所有自然數(shù)的

97 可以把這個(gè)數(shù)據(jù)流看成是一個(gè)有序數(shù)列，但我們不能提前知道這個(gè)有序數(shù)列的長(zhǎng)度，只能不斷通過(guò)next()函數(shù)實(shí)現(xiàn)按需計(jì)算下一個(gè)數(shù)據(jù)。所以iterator的計(jì)算是惰性的，只有在需要下一個(gè)數(shù)據(jù)的時(shí)候，它才會(huì)計(jì)算

96 可以被next()函數(shù)不斷調(diào)用并返回下一個(gè)值的對(duì)象稱為iterator；可以作用于for循環(huán)的對(duì)象稱為iterable，比如list，tuple，str，dict，set，generator；list，str，dict是iterable，但不是iterator；iter()函數(shù)可以把list，str，dict等iterable轉(zhuǎn)成iterator；iterator對(duì)象表示的是一個(gè)數(shù)據(jù)流，可以被next()函數(shù)不斷調(diào)用返回下一個(gè)值，直到?jīng)]有數(shù)據(jù)。

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

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

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

92 index超出范圍，總是出這樣的錯(cuò)，一定要細(xì)心啊; 一定要從最簡(jiǎn)單的開(kāi)始考慮

91 在紙上寫(xiě)testcase

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

89 list和string都有count函數(shù)

88 創(chuàng)建一個(gè)圖，首先也得創(chuàng)建一個(gè)root

87 union find，并查集，是解決動(dòng)態(tài)連通性的一種很高效的數(shù)據(jù)結(jié)構(gòu)。

86 queue因?yàn)槭莑ist，所以添加元素的時(shí)候，可以用queue+= i

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

84 從現(xiàn)在開(kāi)始，看到一道題，就模擬是在面試，認(rèn)真讀題，積極思考，用英語(yǔ)說(shuō)

83 id, type也是關(guān)鍵字

82 在最開(kāi)始時(shí)除了要初始化好需要用的stack什么的，也要注意初始化一個(gè)返回array，或者返回value

81 deque是雙端隊(duì)列，可以從兩端append數(shù)據(jù)；如果想實(shí)現(xiàn)隨機(jī)訪問(wèn)，用list好些；queue是隊(duì)列，先進(jìn)先出

80 二分圖：指頂點(diǎn)可以分成兩個(gè)不相交的集，同一個(gè)集內(nèi)的頂點(diǎn)不相鄰，即沒(méi)有共同邊

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

78 undirected graph: 無(wú)向圖，邊沒(méi)有方向；G=<V,E> V是頂點(diǎn)集，E是邊集，是由V中元素構(gòu)成的無(wú)序二元組

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

76 看找到思路了，再去看別人的答案，思路都不知道，就去看答案，肯定看不懂，就會(huì)浪費(fèi)很多時(shí)間

77 DFS中是一定會(huì)存在遞歸調(diào)用的，在dfs循環(huán)體中值需要考慮當(dāng)前節(jié)點(diǎn)就行，下面的直接遞歸調(diào)用

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

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

74?dividend：被除數(shù)，divisor：除數(shù)

73 通常用于求解某種具有最優(yōu)性質(zhì)的問(wèn)題，一般用于多階段決策問(wèn)題。

72 貪心算法，greedy algorithm，只是局部最優(yōu)解，沒(méi)有從整體最優(yōu)上加以考慮

71 鏈表的node，是包含值和指針的，指針就是指向的地址，所以當(dāng)我們把head node放置在隊(duì)伍中去的時(shí)候，因?yàn)橛兄羔?，所以就可以找到它后面的node

70 建立dummy head和head一樣，建好后一般會(huì)設(shè)置一個(gè)curr指針來(lái)幫助建立后面的node

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

68 Queue類，F(xiàn)IFO；Queue.PriorityQueue, lowest valued entry retrieved first.

67 復(fù)制鏈表的方法：創(chuàng)建一個(gè)hashmap，舊節(jié)點(diǎn)是key，新節(jié)點(diǎn)是value

66 next()返回迭代器的下一個(gè)項(xiàng)目

65 items函數(shù)，將一個(gè)字典以列表的形式返回，因?yàn)樽值涫菬o(wú)序的，所以返回的列表也是無(wú)序的，比如a = {‘a(chǎn)’:1, 'b':2}, a.items(), 輸出的結(jié)果是a = [('a',1), ('b', 3)]; iteritems()返回的是一個(gè)迭代器，b=a.iteritems(), list(b)=[('a',1), ('b', 2)],?字典.iteritems()方法在需要迭代結(jié)果的時(shí)候使用最合適，而且工作效率很高

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

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

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

61 collections模塊中有一個(gè)子類OrderedDict，可以對(duì)字典對(duì)象中的元素進(jìn)行排序，會(huì)根據(jù)輸入的順序放置

60 建立字典樹(shù)Trie需要先建立一個(gè)TrieNode, init函數(shù)里有self.children； 建立binary tree也需要建立一個(gè)TreeNode的class，init函數(shù)里是當(dāng)前節(jié)點(diǎn)的self.val=x, self.left=None, self.right=None; Linked list有ListNode， init函數(shù)里特有屬性self.val=x, self.next=None

59 trie也叫prefix tree

58 DFS就像走迷宮，一條路走到頭了再返回走另外一條路。比如下面一張圖，從1開(kāi)始搜索，找到了2，2又找到3，3找到4，4找到5，然后無(wú)路可走（因?yàn)?周?chē)淖哌^(guò)了），返回到4，從4到6

BFS的話，就是從1開(kāi)始，2和5找到了，然后從2開(kāi)始找，3找到了，再?gòu)?找，4找到了，接著走3，沒(méi)有路可走，再?gòu)?開(kāi)始，6找到了；BFS的話就是要找到與該節(jié)點(diǎn)相鄰的所有節(jié)點(diǎn)

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

56 極值的問(wèn)題考慮使用動(dòng)態(tài)規(guī)劃

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

54 operator.mul()

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

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

51 遇到排列組合，可以結(jié)合stack做，因?yàn)閟tack返回的就是list，表示成[]，返回到res中就是一個(gè)一個(gè)[]，最后是[[]]

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

49 combinations是backtracking的一個(gè)application

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

47 列出所有結(jié)果的題用recursive

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

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

44 list也是個(gè)關(guān)鍵字

43 還是沒(méi)有徹底弄清楚DFS和BFS

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

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

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

40?memorization存儲(chǔ)調(diào)用函數(shù)的結(jié)果，當(dāng)相同的參數(shù)傳進(jìn)來(lái)的時(shí)候，直接返回值就行了。在遞歸函數(shù)中用得比較多

39 memorization技術(shù)：就是把每次函數(shù)執(zhí)行的結(jié)果存儲(chǔ)在鍵值對(duì)中，在接下來(lái)的執(zhí)行中，現(xiàn)在鍵值對(duì)中查找是否有相應(yīng)執(zhí)行過(guò)的值，如果有，直接返回該值，沒(méi)有的話才真正執(zhí)行函數(shù)體的求值部分。在鍵值中找值比去執(zhí)行函數(shù)快多了。

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

37 遇到Parenthesis的題，就可以用count來(lái)做

36 backtracking回溯法，是一種搜索嘗試過(guò)程，當(dāng)發(fā)現(xiàn)不滿足條件時(shí)，就退回來(lái)尋找新的路徑，退回來(lái)這個(gè)過(guò)程就是回溯。是一種系統(tǒng)搜索問(wèn)題解的方法。使用DFS的方法。適用于求解組合數(shù)較大的問(wèn)題?；厮輪?wèn)題遞歸函數(shù)模板：

1 ）最開(kāi)始寫(xiě)好跳出條件，滿足條件才加到總結(jié)果中

2） 已經(jīng)拿過(guò)的數(shù)不再拿

3）遍歷過(guò)當(dāng)前節(jié)點(diǎn)后，為了回溯到上一步，需要去掉已經(jīng)加入到list中的當(dāng)前節(jié)點(diǎn)

35 open parenthesis 是左括號(hào)的意思

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

33 對(duì)于stack來(lái)說(shuō)，最上面的元素可以通過(guò)stack[-1]來(lái)得到

32 設(shè)計(jì)一個(gè)class，class的成員函數(shù)間是可以調(diào)用的，我經(jīng)常忘記調(diào)用其他的函數(shù)

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

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

29 迷宮問(wèn)題：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遞歸需要棧，所以空間復(fù)雜度是O(logn)；BFS也需要用隊(duì)列，也需要extra space

26?self.sums = [[0 for j in range(c+1)] for i in range(r+1)] 因?yàn)閷?duì)于matrix來(lái)說(shuō)，是list[list[int]]，所以初始化的時(shí)候要兩對(duì)[]，其中里面那對(duì)先按照column遍歷，因?yàn)槠浯鎯?chǔ)的就是一行，然后外面一層才是按row遍歷

25 在草稿紙上多寫(xiě)幾個(gè)例子找規(guī)律

24 for b in zip(*xmap) 在這句code中，zip中是unpacked的individual字符串，每一個(gè)individual字符串是32長(zhǎng)度的num轉(zhuǎn)換來(lái)的，這樣在每一次for循環(huán)中，b先取每個(gè)字符串的第一位，這樣b的長(zhǎng)度就是32的tuple，然后調(diào)用tuple.count()

23 總是忘記使用string.count()這個(gè)函數(shù)，比如想統(tǒng)計(jì)string中‘a(chǎn)’的個(gè)數(shù)，可以寫(xiě)成string.count('a')

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

21?'{:032b}'.format的作用是將輸入?yún)?shù)轉(zhuǎn)換成32位無(wú)符號(hào)數(shù)字符串

22 set()和{}都可以用來(lái)創(chuàng)建集合，但要?jiǎng)?chuàng)建一個(gè)空集合的話，只能用set()，因?yàn)閧}是創(chuàng)建字典的。創(chuàng)建過(guò)程是{‘a(chǎn)’, 'o', 'e', 'i', 'u'}, set('aoeiu')，set('aoeiu')運(yùn)行后為set([‘a(chǎn)’, 'o', 'e', 'i', 'u'])。原來(lái)set中也是一個(gè)list，無(wú)序不重復(fù)結(jié)合

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

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

19 str.format()，可以接受很多個(gè)參數(shù)，可以在format函數(shù)里面對(duì)應(yīng)賦值，也可以在format()函數(shù)里面給變量賦值

18 一定要避免使用兩個(gè)for loop，一般都會(huì)time limited

17 每刷一題，分析時(shí)間復(fù)雜度和空間復(fù)雜度

16 sum是python關(guān)鍵字，可以用sums

15 二叉搜索是，每個(gè)節(jié)點(diǎn)的值比它左子樹(shù)的任意節(jié)點(diǎn)值大，比它右子樹(shù)的任意節(jié)點(diǎn)值小

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

13 二叉查找樹(shù)的中序遍歷是遞增序列

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

11 trie的兩個(gè)應(yīng)用，詞頻統(tǒng)計(jì)，也可以用hash和堆來(lái)做，可是沒(méi)有trie節(jié)省空間，因?yàn)樽址墓睬熬Y是用同一個(gè)節(jié)點(diǎn)來(lái)存的

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

9 由于trie可以最大限度地減少字符串比較，所以可用于詞頻統(tǒng)計(jì)和大量字符串排序；優(yōu)點(diǎn)是最壞情況時(shí)間復(fù)雜度此hashtable好。也有key到value的映射，但這里的key是字符串

8 trie中的key通常是字符串，根節(jié)點(diǎn)不包含字符，除根節(jié)點(diǎn)以外的所有節(jié)點(diǎn)都包含一個(gè)字符，從根節(jié)點(diǎn)到某一個(gè)節(jié)點(diǎn)，所有的字符連接起來(lái)，就是該節(jié)點(diǎn)的字符；每個(gè)節(jié)點(diǎn)的所有子節(jié)點(diǎn)包含的字符串不相同。

7 set.add() list.append()

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

1 collection是python中的一個(gè)集合模塊，里面包含很多集合類，和隊(duì)列相關(guān)的集合類是deque

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

3 hashMap和hashSet的區(qū)別：hashMap實(shí)現(xiàn)了map接口，hashSet實(shí)現(xiàn)了set接口；hashMap調(diào)用put添加元素，hashSet調(diào)用add添加元素；hashMap是鍵值對(duì)，hashSet只有值；hashMap相對(duì)于hashSet來(lái)說(shuō)快些，因?yàn)槭鞘褂梦ㄒ坏逆I值獲取對(duì)象；hashMap使用鍵值獲得hashcode，hashSet使用對(duì)象得到hashcode

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

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

5 因?yàn)閎isect_left和bisect_right是為了查找需要插入的位置，所以bisect_left就返回插入數(shù)在最左邊的位置就好了，因?yàn)椴迦脒M(jìn)去也是會(huì)插入到這個(gè)位置；但是bisect_right是會(huì)返回當(dāng)前位置加1的，因?yàn)椴迦氲脑挄?huì)插到當(dāng)前位置加1上；bisect.insort_left的話是真正把這個(gè)元素插進(jìn)去了，返回插入后的序列，left的話就插在左邊，right的話就插在右邊

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

200 在python里面，/做除法的時(shí)候，如果想得到小數(shù)部分，floating point的結(jié)果，可以把除數(shù)寫(xiě)成float的形式

199 sum vector is O(n) time

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

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

196 dic.get(key, value) 尋找key對(duì)應(yīng)的值，如果key不在dic中，則返回默認(rèn)值

195 dic.setdefault(key, value)和get()方法類似，都是得到相應(yīng)鍵對(duì)應(yīng)的值，所不同的是，對(duì)于dic.setdefault(key, value)，如果key不在字典中，則添加進(jìn)去，默認(rèn)值為value，如果沒(méi)有默認(rèn)值，則設(shè)置為None

194 string中數(shù)字的處理一定要注意，要用int轉(zhuǎn)換成數(shù)字

193 string不能被賦值，只能轉(zhuǎn)換成list才能賦值

192 string.startswith(j)代表這個(gè)string是以j開(kāi)頭的

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

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

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

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

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

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

186 寫(xiě)類的function的時(shí)候，function的第一個(gè)參數(shù)都是self。self是指類實(shí)例本身

185 _init_是初始化一個(gè)類，是在類實(shí)例創(chuàng)建之后調(diào)用，對(duì)當(dāng)前實(shí)例的一些初始化

184 要注意看note

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

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

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

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

179 多在紙上畫(huà)

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

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

176 merge sort每次都是比較最開(kāi)頭的元素，然后調(diào)用遞歸

175 *是該變量可以接收多個(gè)參數(shù)，并將參數(shù)轉(zhuǎn)化成元組；**是該變量可以接收多個(gè)參數(shù)，但是將參數(shù)轉(zhuǎn)化成字典[key:value, key:value]

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

173 為什么merge sort到鏈表的時(shí)候空間復(fù)雜度從O(n)變到O(1)了，這是因?yàn)閷?duì)于鏈表來(lái)說(shuō)，只需要改變指針就可以了，不需要額外的空間

172 merge sort對(duì)于鏈表來(lái)說(shuō)是in-place的sort，不需要額外的空間，而且merge sort穩(wěn)定，所以sort list的時(shí)候用merge sort

171 L.next = head 可以理解成L節(jié)點(diǎn)的next指針指向head節(jié)點(diǎn)

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

169 dummy head就是在head前面再加一個(gè)節(jié)點(diǎn)，這樣就可以把head和后面的節(jié)點(diǎn)一起處理了，不用單獨(dú)再考慮head節(jié)點(diǎn)，返回時(shí)返回dummy->head就行了

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

167 將鏈表一分為二的時(shí)候，比如找到了中間節(jié)點(diǎn)，需要將中間節(jié)點(diǎn)指向NULL，這樣才代表真正將鏈表一分為二了

166 merge sort (歸并排序)和quick sort一樣，時(shí)間復(fù)雜度都是O(nlogn)，都是將array分成兩部分，對(duì)每一部分再遞歸調(diào)用，但是merge sort需要額外的O(n)存儲(chǔ)空間，從這一點(diǎn)上沒(méi)有quick sort有優(yōu)勢(shì)，但是相對(duì)于quick sort，merge sort更加穩(wěn)定。merge sort是將數(shù)組分成兩部分，對(duì)每一部分進(jìn)行排序，最后進(jìn)行合并。merge sort更適合于linked list sort，quick sort更適合于數(shù)組排序

165 bucket sort algorithm: 是最快的也最耗空間的一種排序，比quick sort還快；bucket sort algorithm用于數(shù)字是在固定區(qū)間，比如學(xué)生的分?jǐn)?shù)是在[0,100]間：先將original array中的元素分別放在buckets中，再對(duì)每個(gè)bucket進(jìn)行排序，最后再gather所有的元素

164 dic[key]是放在中括號(hào)中的，不是小括號(hào)

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

162 函數(shù)沒(méi)有返回值的時(shí)候，默認(rèn)返回的是None；return后沒(méi)有值也是返回None

161 dic.get(key, specified value) 好處是當(dāng)key不存在時(shí)，就會(huì)返回specified value， 如果沒(méi)有這個(gè)默認(rèn)值的話，就會(huì)返回None

160 命名一個(gè)dictionary就叫dic好了，簡(jiǎn)潔明了，也不會(huì)和關(guān)鍵字dict重合

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

158 dictionary中鍵與值之間用冒號(hào)隔開(kāi)，每一對(duì)用逗號(hào)隔開(kāi)，整體放在花括號(hào)中。所以初始化一個(gè)dictionary的時(shí)候，可以這樣：hashmap{0:1}

157 設(shè)置變量的時(shí)候要注意，要避免關(guān)鍵字，比如sum就是關(guān)鍵字，不能用來(lái)當(dāng)變量

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

155 需要無(wú)限循環(huán)的時(shí)候，就用while True

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

153 filter(function, iterable)，過(guò)濾掉不符合條件的元素，后面輸入是一個(gè)list，其中的每一個(gè)element會(huì)送到function中進(jìn)行驗(yàn)證，返回的是過(guò)濾后的list；此處的function是判斷函數(shù)，整個(gè)filter函數(shù)返回判斷函數(shù)得到為T(mén)rue的iterable

152 枚舉enumerate(('Thousand', 'Million', 'Billion'), 1)，第一個(gè)參數(shù)要用括號(hào)括起來(lái)

151 enumerate(iterable, start) start默認(rèn)為0，即從0開(kāi)始count，如果設(shè)置成1，則從1開(kāi)始

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

149 string也有自帶的count成員函數(shù)，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是不能賦值的，只能轉(zhuǎn)換成list后再賦值

146 定義雙指針的時(shí)候，可以使用while循環(huán)

145 map函數(shù)就是返回一個(gè)list，使用的時(shí)候不需要額外加[]

144 python中有dict函數(shù)，輸入兩組數(shù)，就可以建立一個(gè)dictionary

143?[traverse(row+ x,col+ y)for(x, y)in((0,1), (1,0), (0, -1), (-1,0))] 雖然里面是個(gè)函數(shù)，但因?yàn)橛泻芏喾N情況，所以也需要用[]裝起來(lái)

142?什么時(shí)候定義局部函數(shù)？如果局部函數(shù)需要用到上一級(jí)函數(shù)的參數(shù)，可以定義成局部函數(shù)；如果有很多其他函數(shù)調(diào)用這個(gè)函數(shù)，可以寫(xiě)成全局函數(shù)

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

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

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

138 inorder traversal: 中序遍歷。先中序遍歷左子樹(shù)，根節(jié)點(diǎn)，再中序遍歷右子樹(shù)；preorder traversal: 前序遍歷。先遍歷根節(jié)點(diǎn)，再前序遍歷左子樹(shù)，再前序遍歷右子樹(shù)，每次遍歷子樹(shù)的時(shí)候，依舊采取前序遍歷。postorder traversal：后序遍歷，先后序遍歷左子樹(shù)，再后序遍歷右子樹(shù)，再訪問(wèn)根節(jié)點(diǎn)。

137 馬拉車(chē)算法：首先在每一個(gè)字符的前后加#，整個(gè)字符串的首尾也加#，這樣不管原始字符串的長(zhǎng)度是奇數(shù)還是偶數(shù)，加上#后長(zhǎng)度都變成奇數(shù)了，因?yàn)槭?*n+1；需要用一個(gè)數(shù)組來(lái)存儲(chǔ)以T[i]為中心的回文長(zhǎng)度，返回?cái)?shù)組中最大的那個(gè)數(shù)就行了

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

135 *代表拆開(kāi)list中的元素

134 python中的星號(hào)*（*list）代表的意思是把list中的元素都當(dāng)做位置參數(shù)傳進(jìn)去；**是接受字典key和value

133 map(f, list), 使得list中每個(gè)元素都經(jīng)過(guò)函數(shù)f，然后返回一個(gè)新的list

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

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

130 字符串是不可變對(duì)象（tuple也是），不能通過(guò)下標(biāo)的方式進(jìn)行賦值，比如S[8]='g'是不允許的

129 str.sort()不能對(duì)string片段進(jìn)行排序，需使用sorted函數(shù)產(chǎn)生一個(gè)copy再賦值回去

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

127? list[list]不能用set函數(shù)來(lái)除去duplicate，如果想要除掉duplicate，可以先把list[list]中的list先轉(zhuǎn)化成tuple，然后再使用set

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

125 str.lower() str.upper()

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

123 可以使用str.isnumeric()函數(shù)來(lái)監(jiān)測(cè)str是不是數(shù)字

122 遇到比對(duì)兩個(gè)字符串的時(shí)候，可以試著使用雙指針

121 backtracking

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

119 dummy node的作用是保護(hù)head不會(huì)在刪除操作中丟失，一般用在single list沒(méi)有前向指針的問(wèn)題；一般遇到head節(jié)點(diǎn)會(huì)變的時(shí)候，就會(huì)引入dummy node

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

117 linked list序號(hào)是從1開(kāi)始的，linked list中的元素為空時(shí)，可以這樣判斷：if fast==None，因?yàn)閜ython中沒(méi)有null，只有None

116 可以通過(guò)遍歷一次鏈表得到鏈表的長(zhǎng)度

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

114 遇到兩個(gè)新知識(shí)點(diǎn)：backtracking和memorization

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

112 preorder traversal 先序遍歷

111 list.reverse()和reversed(list)區(qū)別，list.reverse()會(huì)改變?cè)衛(wèi)ist，沒(méi)有返回值；reversed(list)不會(huì)改變?cè)衛(wèi)ist，有返回值，而且返回的不是list，如果需要返回list，需要寫(xiě)成list(reversed(list))

110 有時(shí)候需要一個(gè)flag，就取名叫flag就好了，簡(jiǎn)單明了

109 if not root: return []，寫(xiě)成一行，還有各種各樣變量的定義，也寫(xiě)成一行，看上去會(huì)簡(jiǎn)潔很多

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

107 Two's component 補(bǔ)碼，補(bǔ)碼是把正數(shù)所有位取反，然后加1

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

105 1也是丑陋數(shù)字

104 if key in hashmap 或者 if key not in hashmap，判斷語(yǔ)句是這樣寫(xiě)的，沒(méi)有is；還有判斷的時(shí)候是判斷key是否在hashmap中，不是判斷值有沒(méi)有在hashmap中，key沒(méi)在hashmap中的話就需要建立一個(gè)key到value的connection，如果存在相應(yīng)key的話，只需要把值加進(jìn)去就行了；判斷值在不在hashmap中是沒(méi)有意義的，肯定每次都會(huì)不同，但是一個(gè)key可以對(duì)應(yīng)很多值

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

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

101 str是個(gè)關(guān)鍵字，在白板上寫(xiě)程序的時(shí)候要注意

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

99 s=" ", 字符長(zhǎng)度不是0，因?yàn)槔锩嬗锌崭穹?；也不是空字符串，因?yàn)槔锩嬗锌崭穹?/p>

98 txt.split()默認(rèn)就是空格符，txt是一個(gè)字符串，txt.split()會(huì)得到一個(gè)字符串list

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

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

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

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

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

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

91 python沒(méi)有sqrt函數(shù)，求平方根可以用a**0.5

90 a/b就已經(jīng)是整數(shù)部分了，不需要再在前面加個(gè)int

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

88 L1=L和L1=L[:]的區(qū)別，第一是把L1指向L的地址，第二個(gè)是把L中的值復(fù)制到L1中，改變L1不會(huì)改變?cè)瓉?lái)L的值；第一個(gè)改變L1的值會(huì)改變?cè)瓉?lái)L的值，因?yàn)榈刂肥侵赶騆的

87 當(dāng)numbers[i]看上去很復(fù)雜然后又要用到很多次的時(shí)候，可以將它賦值給一個(gè)字母，比如a =?numbers[i]，看著就不會(huì)那么累

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

85?partition algorithm/?quick sort

84 動(dòng)態(tài)規(guī)劃有時(shí)候只是和前兩個(gè)值相關(guān)，所以為了減少空間復(fù)雜度，可以只保留前面兩個(gè)值就行了

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

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

81 [::-1]倒敘輸出，[:-1]除掉最后一個(gè)元素的數(shù)

80 zip函數(shù)可以將兩個(gè)數(shù)組打包成元祖

79 注意位移符號(hào)優(yōu)先級(jí)很低，沒(méi)有加減號(hào)高，所以在一起使用的時(shí)候，位移處要打括號(hào)：比如(1<<leftDepth)+self.countNodes(root.right)

78 class里面調(diào)用成員函數(shù)時(shí)，需要加self.

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

76 若滿二叉樹(shù)的高度是n（包括根節(jié)點(diǎn)），則所以節(jié)點(diǎn)的個(gè)數(shù)是2**n-1

75 完全二叉樹(shù)一個(gè)最重要的性質(zhì)是：如果左子樹(shù)最左邊的深度等于右子樹(shù)最右邊的深度，則此完全二叉樹(shù)是滿二叉樹(shù)

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

73 位運(yùn)算很省時(shí)間，比如<<比math.pow省時(shí)間很多

72 二叉樹(shù)的深度是指節(jié)點(diǎn)數(shù)，直徑是指connections的個(gè)數(shù)

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

70 binary search tree是可以沒(méi)有左子樹(shù)或者右子樹(shù)的

69 寫(xiě)程序的時(shí)候，變量中最好能看出含義

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

67 堆(heap)和棧(stack)的區(qū)別，堆是金字塔式泥沙堆，棧是直立性的一個(gè)桶；heap是priority queue即優(yōu)先隊(duì)列；堆是完全二叉樹(shù)，每一個(gè)父節(jié)點(diǎn)的值小于等于其子節(jié)點(diǎn)的值；heap(k)<=heap(2k+1), heap(k)<=heap(2k+2)，最小值是root，即heap(0)；創(chuàng)建一個(gè)heap，用[]，也可以將一個(gè)populated list轉(zhuǎn)換成heap，用函數(shù)heapify()，線性時(shí)間，in-place

66 二維條件表達(dá)式：[a,b][a>b], 如果第二個(gè)中括號(hào)為T(mén)rue，則返回b，若為Fasle，則返回a

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

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

61?Manacher是查找一個(gè)字符串中最長(zhǎng)回文串的線性算法

60 range里面是用逗號(hào)連接的，list里面是分號(hào)

59 python 函數(shù)里面寫(xiě)函數(shù)的話，不用self參數(shù)

58 一個(gè)數(shù)若是合數(shù)的話，必然能找到兩個(gè)數(shù)相乘得到這個(gè)數(shù)，必然是一個(gè)小于根號(hào)n，一個(gè)大于根號(hào)n，或者兩個(gè)都是根號(hào)n。所以在尋找質(zhì)因數(shù)的時(shí)候，只需要循環(huán)到根號(hào)n就可以了，因?yàn)槿绻谛∮诘扔诟?hào)n的循環(huán)中都找不到質(zhì)因數(shù)的話，在大于根號(hào)n里更找不到了

57 BFS和DFS區(qū)別，BFS是一石激起千層浪，DFS是不撞南墻不回頭；BFS和隊(duì)列有關(guān)，DFS和遞歸有關(guān)

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

55 對(duì)稱數(shù)：0，1，6，8，9

54 DFS深度優(yōu)先遍歷

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

52?lexicographical 詞典編纂的

51 string字符串

50 動(dòng)態(tài)規(guī)劃核心步驟是寫(xiě)出狀態(tài)轉(zhuǎn)移方程，需要維護(hù)局部最小，局部最大，全局最大三個(gè)變量

49 要特別注意corner case

48 list就是array

47 map就是dictionary

46 只有l(wèi)ist有append，str沒(méi)有

45 兩個(gè)嵌套for循環(huán)，時(shí)間復(fù)雜度是O(n**2)，如果直接寫(xiě)兩個(gè)并排的for循環(huán)，則時(shí)間復(fù)雜度為O(n)

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

45?Manacher‘s Algorithm的時(shí)間復(fù)雜度是線性的

44 range從大到小，遍歷的時(shí)候不包括最小的那個(gè)數(shù)

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

42 要對(duì)比誰(shuí)小的時(shí)候，設(shè)置變量應(yīng)該設(shè)置一個(gè)很大的值

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

40 range的index是從0開(kāi)始的，假如有整數(shù)n，那么index=0的時(shí)候，n=1，index=1的時(shí)候，n=2

39 range和xrange的區(qū)別：當(dāng)range()里面的參數(shù)特別大的時(shí)候，容易出現(xiàn)memory的錯(cuò)誤，而xrange是一個(gè)生成器，就不會(huì)出現(xiàn)這種錯(cuò)誤，所以在參數(shù)特別大的時(shí)候，用xrange函數(shù)。range是生成一個(gè)序列，xrange是生成一個(gè)生成器，所以當(dāng)參數(shù)很大的時(shí)候，需要開(kāi)辟一塊很大的內(nèi)存空間，性能不如xrange好

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

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

3 split()默認(rèn)字符是空格

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

5 binary tree的diameter長(zhǎng)度是指edges不是nodes數(shù)

6 Python3的除法要用//

7 搶錢(qián)題：動(dòng)態(tài)規(guī)劃

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

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

10 two-sum hashtable, 如果target-num[i]在hash table里面的話，就說(shuō)明前面已經(jīng)出現(xiàn)num[i]了，而num[i]的index存在了hashtable里的，所以這時(shí)候只需要return當(dāng)前的index就可以

11 break跳出整個(gè)循環(huán)，continue跳出當(dāng)前循環(huán)，開(kāi)始下一個(gè)循環(huán)

12 對(duì)于while語(yǔ)句，用得還是不溜

13 if和else的時(shí)候，把簡(jiǎn)單的留在最后面返回

14 寫(xiě)每一句code的時(shí)候都要細(xì)心

15?maxProfit, minPrice= 0, float('inf')? 學(xué)會(huì)用float('inf')

16 str 不能寫(xiě)成for i in str這種形式，沒(méi)有循環(huán)

17?enumerate 枚舉就是一一列舉的意思，如果apply了enumerate函數(shù)，就會(huì)得到序列號(hào)和值的pair

18 dummy head for link list: ListNode(0)

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

20 若返回的是matrix，則定義這個(gè)matrix的時(shí)候定義成[]就行，調(diào)用append函數(shù)的時(shí)候，也是一個(gè)row一個(gè)row的往上append

21 substring和subsequence不一樣，substring必須是原string的一個(gè)part，有前后順序，subsequence沒(méi)有順序

22 要返回什么，你就得在最開(kāi)始定義

23 定義一個(gè)map為a = {}，則取其中的元素的時(shí)候，要用中括號(hào)，比如a[]

24 二分法查找：binary search

25 prime number質(zhì)數(shù)也叫素?cái)?shù)，大于1的natural number中，只能被1和本身整除的數(shù)；合數(shù)是composite number；1既不是prime number也不是composite number

26 python中power用**

27 求某個(gè)范圍內(nèi)自然數(shù)中質(zhì)數(shù)的個(gè)數(shù)，有埃氏篩法

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碼是對(duì)英文字母，數(shù)字，特殊字符做的編碼，為二進(jìn)制編碼形式

30 ord()返回對(duì)應(yīng)字符的ascii碼值，十進(jìn)制形式。配對(duì)的是chr()函數(shù)

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

32 list的初始化，[1]*n這樣就有n個(gè)1了，list加是把兩個(gè)list連起來(lái)

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

34 n位數(shù)和n位數(shù)相乘的積最多也是2n位數(shù)

35 做coding題的時(shí)候，先把思路全部理清了，給面試官說(shuō)清楚了，再開(kāi)始寫(xiě)code

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

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

38 若一個(gè)list，從index=3開(kāi)始取值，則為list[3:]，就是中括號(hào)，沒(méi)有小括號(hào)

most_common