2020.4.1-2020.4.7 魔笛手Pied pier周记
4.1?周三?第一天
本周序言：
? ? ? ?《算法圖解》這類書是學習用書，讀起來是沒有積極性的，畢竟誰會沒事讀教材，這不是跟自己過不去嗎，但是我還必須得跟自己過不去，于是用寫博客的形式記錄下我的學習筆記。本書一共11章，每天讀一章的話11天才能讀完，一想到11天我就難受，但是要達到速戰速決，還得每天的堅持，這個也是難得一匹，折衷想法是每天至少讀一章，長痛不如短痛。
第一章：算法簡介
（1）主要知識：二分查找，大O表示法
? ? ?1.1?二分查找：輸入要求是一個有序序列，例如經典的猜數問題，就是根據每次將中值和要找的值進行比對，根據大了還是小了調整查找范圍，直到查找范圍縮小到上限等于下限。對于二分查找，每次淘汰的是查找范圍一半的數值，因此就是相當于除以2，故按照這種猜法，只需要看能被2除幾次，直到商小于1為止（淘汰的數字的至少為1嘛，小于1就是淘汰環節終止），換句話說就是查找范圍的總數等于幾個2連乘，也就是取以2為底的對數（取對數就是冪運算的逆運算）。
? ? ?1.2?大O表示法：O是指operator，也即操作數的次數，陳斌老師講的，也就是看的賦值語句的次數（因為賦值語句里面同時包含表達式計算和變量存儲，是一個好的衡量運行時間的標準，當然，操作次數具體是T(n)，O()是T(n)的主導部分）。大O是主導部分的原因是因為它是算法運行時間隨著問題規模n增大時的參與貢獻最大的部分，也就是主要靠著它在拉動增長，那么它就是O()的括號里面填的內容，它甚至不需要系數，因為加上系數的增長也不及隨著n的增大它本身的增大，而且它是最糟情況的下限(還有別的表示法：大歐米伽，大seita)。常見的幾種運行時間有：對數時間（O(logn)）、線性時間O(n)，O(nlog(n))、O(n!)等。其中我們熟悉的排序算法，例如快速排序就是O(nlog(n))，選擇排序就是O()。如果能用O(n!)衡量，那么是很耗時間的算法，因為n!的增速比還要快，所謂n的階乘，就是全排列問題，n=20時，時間消耗用你的一生衡量都太短，等結果出來了，太陽都沒了。
（2）經典代碼
? ? 二分查找實現（Python）：
? ?def? binary_search(num_list,number):
? ? low=0
? ? high=len(num_list)-1
? ? while low<=high:
? ? ? ? ? ?? mid=(low+high)//2? ? ? ? ? ?#python里面地板除是//
? ? ? ? ? ? ?if num_list[mid]==number:
? ? ? ? ? ? ? ? ? ? ? ? return mid
? ? ? ? ? ? ?else if num_list[mid]<number:? ? #用中值去猜，猜的數是小了，那么我就要刷新下限，上限不變，每次只刷新一邊。
? ? ? ? ? ? ? ? ? ? ? ? low=mid+1
? ? ? ? ? ? ?else:
? ? ? ? ? ? ? ? ? ? ? ? high=mid-1
? ? return None
（3）小結感悟
? ? ? ? ? 開設“經典代碼”模塊是因為過去我很抵觸這個，導致相關的，我就很抵觸科研，但是其實代碼寫起來很有意思，尤其是當你慢慢地信手拈來，實現了一些比較酷炫的功能之后。所以，不要停止在想象的印象里，而要動手操作起來感受智趣，值得一提，代碼是沒看自己寫的，一遍成功，但是只是鼓勵下，因為這不是什么值得高興的事，這是應該的，在內行看來這簡直就是1+1=2。還好這本是python版本，不然真的這本書我直接就會以語言原因不看了，那樣我會很心疼，心疼的是我的錢。說起來，數據結構和算法和語言密切相關，因為對同一算法的實現的性能不僅和算法本身相關，也和語言密切相關，當然算法本身是本質區別，之前看到那本紫色封面的清華出版社的嚴老師的教材，有個括號：C語言版，我當時還覺得干嘛標注語言，現在明白了，用啥實現也很有關系，必須要有針對性。至于為啥和語言相關，是因為現在接觸到的編程語言基本都是高級語言，都是在機器語言上的演繹，而演繹方式各有不同，導致操作相同的話也會有不同的運行時間，而不像機器語言是統一標準的。
4.4?周六?第四天
? ? ? ?第二天就憑拖延實力說話，連續兩天都沒有看一頁，第四天了，今天一天要看三章，真的有點嗚嗚嗚，誰讓我懶懶兩天的，拖延的我的眼淚不值錢。（一段想要劃掉的回憶，拖延加后悔無限循環，我什么時候有長進5555）
第二章 ：選擇排序
（1）主要知識：數組和鏈表、選擇查找
數組和鏈表：這兩種數據結構主要是存儲方式上的區別，數組是連續存儲，鏈表是非連續存儲，一個數組或者鏈表里面的元素數據類型需要一致。存儲方式上的區別導致優勢劣勢的區分：數組的元素都在一塊，相對固定，利于隨機訪問，不利于插入和刪除元素；鏈表由于非連續存儲，前一元素的存儲除了值之外還要存儲下一元素的地址值，在訪問方式上就只能從第一個開始訪問，是順序訪問，訪問方式上占下風，但是由于自由散漫，因此利于插入和刪除。由于各有千秋，因此最好的方式就是各取所長的鏈表數組，數組的每一個元素都指向的是一個鏈表，這樣既可以隨機訪問，又可以隨時插入和刪除。例如facebook存儲用戶名，按照首字母存儲的鏈表數組，查找的時候首先查找首字母，再在對應字母的鏈表里面添加。
選擇查找：就是陳斌老師講的簡單查找，第一步遍歷所有元素，找到最小元素，并轉移到新的地方，第二步遍歷剩下的元素，找到最小元素，依次類推。第一次查找次數是n,之后依次是n-1,n-2,n-3,...,1。加起來就是n(n+1)/2，忽略系數的話就是O()。我還是覺得陳老師講的方法比較能推廣，就是從程序里面分析T(n)，計算賦值語句的執行次數，再算復雜度。
（2）經典代碼：選擇查找（定義兩個函數，一個是找最小值，并返回下標，另一個是依次遍歷數組，轉移）
def smallest(arr)：
smallest_num=arr[0]
smallest_index=0
for i in range(len(arr)):
? ? ? if arr[i]<smallest_num:
? ? ? ? ? ? ? ? ?smallest_num=arr[i]
? ? ? ? ? ? ? ? ?smallest_index=i
return smallest_index
def? ?choose_search(arr)：
newarr=[]
for i in range(len(arr)):
? ? ? ?smallnum=smallest(arr)
? ? ? ?newarr.append(arr.pop(smallnum))? ?
return newarr
（3）小結感悟：好的，又是一氣呵成的代碼，雖然又是特別基礎的。不過又有了一點感覺，今早躺在床上想，自己沒有用代碼實現的算法都不算被自己真正掌握的算法。實現的過程就相當于當老師，把這個東西吸收成自己的講給學生聽，是理論到實踐的飛躍，所以工程師是很厲害的。目前到第二章，還是沒有超過我視頻里面看到的東西，視頻講的更系統，更全面，更科學，但是書也是一種新思路，開闊眼界了。
第三章 ：遞歸
（1）主要知識：遞歸（遞歸條件和基線條件）、調用棧
遞歸是一種自己調用自己的函數，在函數內部又調用自己，每調用自己一次，就縮小問題的規模一次，這就是遞歸條件，當然參數有所變化，一層一層的轉化，直到化為可以直接返回的地步，這個地步就是基線條件。例如經典的求階乘，就是從大數的階乘一層一層縮小到最后只有1的階乘，再從1開始返回，是一個連續的過程，既然連續，就能用到堆棧這種數據結構去解決，call stack(調用棧)，所有函數調用都是使用堆棧實現的。堆棧的功能的特點就是連續性，可以連續插入或者彈出，例如當前運行函數1，函數1?的內存區域在堆棧的最底部，函數1運行到一部分時調用到函數2，那么函數2這時候就進來了，如果函數2還有調用就以此類推的進來，直到新進來的函數可以返回，開始返回之后就會接連地彈出，直到最后函數1的彈出，程序結束。遞歸是函數調用的一種特殊情況，也就是新進來的函數還是自己，只不過參數有所變化。最后總結，所謂堆棧，就是在執行中調用到新的就進來，直到新的可以開始返回，就輪到下面的舊函數執行了。
（2）經典代碼：求階乘
def factorial(x):
? ? ? if x==1:
? ? ? ? ? ? ? return 1
? ? ?else:
? ? ? ? ? ? ?return x*factorial(x-1)
（3）小結感悟：之前看嚴老師的書，總覺得堆棧很神秘很費勁，單獨整一個堆棧有什么用，今天才理解原來函數調用是這樣利用堆棧的，堆棧很有用啊，基本上是基石了，害，讀書少，多見怪了，還有一個關于堆棧的就是據說黑客攻擊會從堆棧下手，這是我覺得神秘的原因。另外，還有一個點有被驚艷到，就是說遞歸這個思想的概念很重要，遞歸能解決的問題用循環也能解決，但是用遞歸的方式去解釋，就更直觀，尤其是某些語言沒有循環，只有將算法轉化為遞歸才可以寫，例如Haskell語言。不過其實我第一次接觸遞歸的時候我覺得很難，很抽象，想半天想不明白，不過我真的就是那種笨笨的、反應慢，需要花時間才能理解的人，這樣想就不慌一點。
第四章：選擇排序
（1）主要知識：由遞歸引出的分而治之思想（DIVIDE AND CONQUER）、快速排序
分而治之思想：介紹“如何把一塊地分成若干個最大方塊的問題”，使用歐幾里得思想：適用于小塊地的最大方塊也是適用于整塊地的最大方塊。這道題的基線條件就是一塊地的長等于寬的兩倍，那么直接就可以分成兩個邊長為寬的正方形。遞歸過程是首先按照寬去分解盡可能多的方塊，再對剩下的土地執行相應的操作。
快速排序：指導思想是分而治之，每次選擇一個基準值，根據基準值將剩下的數分成兩個組，一個組是大于基準值，另一個則相反，再對分好的兩個組執行相同的操作，直到小組里面只剩一個值或者沒有值。注意這里基準值的選取對算法復雜度有直接影響，應該隨機選取，使得平均水平為O(nlogn)。最糟糕的水平呢，就是O()。這一講一句，還有一個合并排序（Merge sort），它的復雜度也是O(nlogn)，且一直是這個數，但是為啥還是用快速排序呢，因為復雜度水平相同時，這個時候常量的影響力就出來了，之前我們忽略常量是因為復雜度不可同日而語，但是一樣的時候就該比較常量了。快速排序的常量比合并排序要小，因此依然選擇看起來不穩定但實際上更為簡潔的快速排序。
（2）經典代碼：以數組的第一個元素為基準值
def quick_sort(arr):
if len(arr)<2:
? ? ? ? ?return arr
else:
? ? ? ? ?pivot=arr[0]
? ? ? ? ?less=[for j in arr if j<pivot]
? ? ? ? ?greater=[for k?in arr if k>pivot]
? ? ? ? ?return quick_sort(less)+pivot+quick_sort(greater)
（3）小結感悟：Python真有用。（最近沒怎么讀書，思想很貧瘠，有看出來吧
4.5?第五天?周日
? ? 今天也是瘋狂趕進度的一天。對，我又在4.6趕4.5的進度，又在心里小聲罵昨天的自己。
第五章：散列表
（1）主要知識：散列表及其內部機制（實現、沖突、散列函數
散列表：散列表的本質是一種映射關系，類似于函數，能通過已知的自變量的值迅速得到因變量的值的一種數據結構，在Python里面是“字典”。字典的特點是一個鍵對應一個值，且鍵的數值是不能重復的。因此關于這種數據結構就可以用來1.表征映射關系 2.需要防重復的設計 3.作為存儲數據的結構（例如服務器會對常用訪問網頁進行存儲，中央處理器中的Cache高速緩沖器，都是利用了這類數據結構查找、插入、刪除的復雜度都是O(1)的特點）。散列表的內部核心是散列函數，即利用什么樣的方式去選定存儲位置的索引，比如利用字符串的長度來區分、或者利用字符串的首字母來區分等等，散列函數的設計很關鍵，萬一設計不好，就會導致沖突，也就是說不同的鍵會分配到相同的存儲位置的索引，這樣也不是不行，這樣的話一個位置當然放不下，就會生成一個鏈表，這個索引的位置就是存儲的鏈表，本來查找就是一對一比較快，這樣的話找到位置了還要面對一個鏈表進行二次選擇，那就違背我的初衷遼，因此呢，我的散列函數的設計就是要1.分散 2.均勻（再品一品“散列”兩個字，是不是覺得這個名字完全就是濃縮的精華），也沒有完美的散列函數，面對紛繁復雜的數據都能做到分散均勻的，總是不免出現一個多個鍵影射到一個位置或者分布相對較滿的情況，于是呢，需要調整，一旦被填充的部分占所有位置的比例超過百分之七十，那么就需要resize數組空間，然后將原來的鍵映射到新的寬敞的數組空間中來，降低這個填充比例。即使有這樣一個resize的過程，使用散列表這種數據結構去存儲查找的速度依然比數組去存儲要快很多，當然是在平均情況下啦。
（2）經典代碼：使用字典作為投票檢查器和使用字典作為服務器緩存
1.book={}
def one_vote(name):
? ? ? if book[name]:
? ? ? ? ? ? ? ? print('Go home and come back to your mother')
? ? ? ?else:
? ? ? ? ? ? ?book[name]=True
? ? ? ? ? ? ?print('You can vote now')
2.cache={}
def storage(url):
? ? ? ? if cache.get(url):
? ? ? ? ? ? ? ? return cache[url]
? ? ? ? else:
? ? ? ? ? ? ? cache[url]=get_data_from_server(url)? ? ? ? ? #從服務器中找到這個url對應的網址并存儲在cache中
? ? ? ? ? ? ? return cache[url]
（3）小結感悟：雖然Python編程語言很高級，很多東西都封裝好了，幾乎沒有底層的東西，很好上手，這樣看好像不需要了解內部機制是什么樣的，但是了解底層才對這個東西的掌握程度更好，就像買一件衣服，你還知道這衣服的面料以及加工過程，那么你在穿的時候就更能選擇a more proper occasion.(沉迷這種體了，騷瑞)，學習底層的東西很有必要，俺的個人看法。
第六章：廣度優先搜索
（1）主要知識：數據結構圖（有向圖和無向圖）、廣度優先搜索（查找最短路徑）、隊列（先進先出的數據結構）
廣度有限搜索用于解決最短路徑，其使用的主要方法是圖算法。所謂圖，由節點（node）和邊（edge）組成，節點之間由邊連接起來，邊分為單向和雙向，單向則為有向圖，雙向則為無向圖。對于要求最短路徑的目標，我們先轉化為“有路徑嗎”的問題。先看從起點開始，一步能到達的地方，再看兩步能到達的地方，以此類推，我們的終點出現在三步能到達的地方，因此，三步就是最短路徑，這就是核心思想，朋友里面沒有你要找的人，那么再看朋友的朋友里面有沒有你要找的人，注意找的時候不要出現重復查找的情況，也就是你的朋友和你朋友的朋友是同一個人的情況，這樣不僅效率低下，而且還可能出現死循環的情況。如何實現先從朋友里面找，再在朋友的朋友里面找的順序呢？采用隊列這種數據結構。隊列和對堆棧正好相反，是先進先出（First in First Out），保證了能夠按照添加順序進行檢查。另外，使用字典實現”朋友的朋友“這種對應關系。
（2）經典代碼：
from collection import deque
graph={} #利用字典建立對應關系
graph['you']=['Alice','Bob','Claire']
graph['Bob']=['anuj','peggy']? ?#此處僅添加這兩個?不作一一列舉
def search(name):
? ? ??search_sequence=deque()#建立隊列實現按照添加順序查找
? ? ? search_sequence+=graph[name]
? ? ? searched=[]
? ? ? while search_queue:
? ? ? ? ? ? ? person=search_queue.popleft()
? ? ? ? ? ? ? if person not in searched:
? ? ? ? ? ? ? ? ? ? ? ? if person_is_seller(person):
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?print person+'is a mango seller'
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?return True
? ? ? ? ? ? ? ? ? ? ? ? else:
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? search_quene+=graph[person]? #這個人不是芒果商?于是把這個人的朋友加入隊列進行檢查
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? searched.append(name) #記錄已經檢查過的不是芒果商的人
? ? ? ? return False #如果到這里說明找完了朋友，也找完了朋友的朋友，朋友的朋友的朋友等等，沒找到，所以就沒有芒果商
search('you')
（3）小結感悟：不同的數據結構有他適應的問題，分析問題所需，選擇對應的數據結構，另外，有一個小技巧，是防止重復的，可以新建一個列表，用于記錄已經操作過的數字，在每次操作之前判斷一下是in還是not in就可以。
4.10?周五（我太懶了?我接受了?不掙扎了?我看我不配有被要求 哼！！！氣人?開頭的十一天真的一點都不長哦！甚至太短了！
第七章：狄克斯特拉算法
（1）主要知識：廣度優先搜索找出的是段數最少的路徑，對象是沒有加權的圖。狄克斯特拉算法對象是有向無環加權圖(注意與無向圖實際上就是有環圖，因為無向圖就是兩個節點之間互相相連，另外狄克斯特拉算法僅針對的是權重為正的，也就是“單增性”，總結下為有向加權圖，對于負權圖，應采用Bellman-Ford算法)。列一張表，對當前沒有被更新過的最便宜的開銷節點，計算當前點到終點的最近距離從而更新有關系的節點，如果最終不僅想計算最小開銷，還想知道最短路徑，只需要再在表格里面加一列“父節點‘即可，也即每次更新的時候順便將對應的父節點記錄下來。最終順著終點-終點的父節點-父節點的父節點這樣的順序回溯回去就能得到最短路徑。
（2）經典代碼：
2.1 數據結構準備：三個字典和一個列表，分別存儲有向加權圖、開銷表、父節點表以及處理過的節點。第一，graph['節點A'][’節點A的下一節點‘]=’權重值‘，graph['節點']本身就是一個字典，所以這是一個二級字典，是字典的字典，可以通過graph['A'].keys()訪問和節點A相連的所有節點。開銷表和父節點表就是兩個一級字典，鍵值就是所有節點。處理過的節點列表為processed。另外，無窮大在python里面表示為float('inf')
2.2 主函數和子函數
主函數：node=find_lowest_cost_node(cost) #最初選取最便宜的節點，且最便宜的節點沒有被處理過
? ? ? ? ? ? ? while node is not None:
? ? ? ? ? ? ? ? ? ? ? ? ? cost=cost[node]
? ? ? ? ? ? ? ? ? ? ? ? ? neighbors=graph[node]
? ? ? ? ? ? ? ? ? ? ? ? ? for n in neighbors.keys():
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?if neighbor[node]+cost<cost[n]:
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? cost[n]=neighbor[node]+cost
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? father[n]=node
? ? ? ? ? ? ? ? ? ? ? ? ? ?processed.append(node)
? ? ? ? ? ? ? ? ? ? ? ? ? ?node=find_lowest_cost_node(cost)
子函數：def find_lowest_cost_node(cost):
? ? ? ? ? ? ? ? ? ? ? ? low_cost=float('inf')
? ? ? ? ? ? ? ? ? ? ? ? low_cost_node=None
? ? ? ? ? ? ? ? ? ? ? ? for n in cost and not in processed:
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?cost=cost[n]
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? if cost<low_cost:
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? low_cost=cost
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? low_cost_node=n
? ? ? ? ? ? ? ? ? ? ? ? ?return low_cost_node
（3）小結感悟：算法原理和實際實現之間有一定的距離，這個距離就是數據結構的準備。所以在實現算法的時候，首先整理好合適的數據結構，再動手寫代碼。狄克斯特拉狄克斯特拉狄克斯特拉，我真的記不住這個名字。
第八章：貪婪算法
（1）主要知識：所謂NP完全問題，就是無法在有限時間內完成的事情。算法復雜度在指數級別甚至階乘級別的，其時間消耗隨著問題規模的增長是爆炸式的，是在有生之年無法解決的，例如本書中列舉的集合覆蓋問題和旅行商問題，集合覆蓋問題需要列出所有集合組合的情況，組合數相加的和是2的階乘；旅行商問題是將要去的地方進行排列，我們知道全排列是n的階乘。人生苦短，既然找到全局最優解是不可能滴，那么我們在有限時間內找到接近全局最優解的局部最優解也是好的，不求完美，優秀也是極好的。貪婪算法就是一種近似算法，是試圖以局部最優解去代替全局最優解的算法。貪婪算法的主要思想是每次都找當前最優的做法，以背包問題為例的話就是每次都拿剩下的物品中最值錢的東西。
（2）經典代碼：以集合覆蓋問題為例，每次都覆蓋剩下區域最多的廣播臺為best station，直到不剩下區域需要覆蓋
while states_need:
? ? ? ? best_station=None
? ? ? ? state_covered=set()? ? ?#初始化最大重疊區域
? ? ? ? for state,station in station.items():? ?#遍歷廣播站，找到和當前剩下區域重疊最大的廣播站
? ? ? ? ? ? ? ? ? ?cover=state_needed&station
? ? ? ? ? ? ? ? ? ?if len(cover)>len(state_covered):? ? ? ? ??
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?best_station=state
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?state_covered=cover? #一旦找到最大重疊的就賦值給它
? ? ? ? ?state_needed-=state_needed
? ? ? ? final_station.append(best_station)
（3）小結感悟：處理問題的時候先看看是不是NP完全問題，如果是的話就可以用貪婪算法。
第九章：動態規劃
(1)主要知識：動態規劃（找有限制條件下的最優解）的基本思想和遞歸是一樣的，都是將大問題轉化為子問題來解決，找到每步的遞推式，因此能用動態規劃的一般也都能用遞歸解決。動態規劃是自底向上的解決方法，遞歸是自頂向下的解決方法。在具體實現上，動態規劃多是列表問題，有的是一維列表，有的是二維列表，具體看限制條件。例如經典的背包問題，就是二維列表，總容量限制為5磅，那么我們就從1磅開始看，1磅最多能裝多少價值的，然后2磅，3磅依次填下去。表格的橫軸是磅數，縱軸就是各種物品，一行一行地填，每新加1磅，就看能不能放下當前行的物品，如果可以的話計算總價值=當前物品價值+剩余磅數的價值（這個之前就算出來了，在表格里面有），不可以的話就直接照抄左邊的值，這就是遞推式。關于為啥從1磅開始，因為最小的物品就是重1磅，按照這個最小物品的重量去定顆粒度。另外，動態規劃的經典應用還有“最長公共子序列”和“最長公共子串‘的問題，也都是二維列表，橫軸縱軸當然就是需要比較的兩個字串了。”最長公共子序列’的遞推式就是當前的橫軸縱軸對應的字母是否相同，相同的話就由左上角的對角格的數加一，否則就是0；“最長公共子串”的遞推式也是同樣的判斷，如果相同的話也是一樣計算，不相同的話就照抄左邊格子和上邊格子中的大的值。
(2)經典代碼：代碼沒有什么好講的，主要就是幾個if判斷，二位列表的計算等。
(3)小結感悟：這類算法還是需要多刷題，難點在于識別這類問題和找出遞推式，另外注意遞推式的初始值是需要自己找的。
第十章：K近鄰算法
（1）主要知識：K近鄰是一種分類或者回歸算法，而分類問題就是分組問題，回歸問題就是預測值問題。怎么分組和預測值呢？首先將分類對象特征化，對每個對象進行“編號‘，使用這個編號去代表它，所以這個特征是否具有代表性就很大程度地決定算法性能。再計算編號之間的”距離’或者“夾角‘來判斷是否相似。和誰相似自然就是和誰一組，到這里分組已經解決，預測值的話就是把和他相近的這幾個人的值處理一番后得到新的值就大功告成了。所謂K近鄰就是分組或者預測值的時候，找幾個人來參考。找5個人就是5近鄰。推薦系統就有利用K近鄰的原理去做，首先計算相似度，找到最相似的K個人，通過這K個人的數據去給這個人推薦電影或者預測這個人對某部電影的打分。
（2）經典代碼：重在思想，沒有列代碼，在python里面也應該主要是調包了，scipy/sklean等。
（3）小結感悟：這本書很厲害的一點就是把枯燥的算法講的深入淺出，看起來很高端的算法被他講的好像也很好理解和上手。
第十一章：算法進階
（1）主要知識：對基礎算法有簡單了解之后，本書作者繼續介紹了更加深入的10類算法。
1.樹：之前介紹的二分法查找是需要對有序列表進行查找，那么二叉搜索樹（左小右大）就是一種適應這種算法的數據結構，但是二叉搜索樹可能存在不平衡（一邊特別長）的問題，所以就還有紅黑樹、B樹、堆和伸展樹。
2.反向索引：主要是搜索方面的應用，例如建立搜索關鍵詞為鍵值、網頁為值的字典，這種是為服務用戶的反向索引。
3.傅里葉變換：BetterExplained這么解釋傅里葉變換：如果你給他一杯沙冰，他能給你分析出有什么成分。
4.并行算法：將任務分解為一個個子任務，子任務不同的處理器中運行，最終再將結果合并。
5.Mapreduce:是一種需要很多處理器的分布式算法，可以在短時間內處理海量工作。其中map是映射函數，可以對列表中的每一個數做相同的操作，reduce是歸并函數，也就是將列表中的所有數進行某個迭代式的運算，最終輸出一個值。
6.布隆過濾器和Hyperloglog：當準確查找需要很大的工作量的時候，可以使用這樣一種算法：結果不保證完全正確，但是大概率是準確的，可能出現錯報，但是不可能出現漏報。以判定網站是否被搜集為例，如果返回”這個網頁已經被搜集’，那么也很可能沒有被搜集；但是如果返回“這個王爺沒有被搜集”，那么這網頁就是一定沒有被搜集。
7.SHA算法：回顧一下之前學的散列函數（哈希函數），就是將數據映射到存儲空間的某個位置的函數，那么這個SHA呢，就是secure hash algorithm，安全哈希函數。同樣是映射，這個算法可以將對象映射到一個字符串，而且這個字符串不能倒推回原始對象，也就是說可以用來加密，也可以用來比對較大的文件，計算他們的哈希值并比較即可，節約時間。另外就是可以存儲用戶密碼，存儲密碼的哈希值即可，每次輸入密碼，計算哈希值并和數據庫里面的哈希值進行比對。
8.局部敏感的哈希算法：之前介紹的哈希算法對輸入對象相差不大的情況是沒有顯現的，也就是說即使是相差不大的兩個東西，那么他們的哈希值也可能是大不相同的，局部敏感的哈希算法就是解決了這類問題，將這一特征體現在哈希值上，改進為局部敏感的，當輸入差不多的時候，那么他們的哈希值也是相差不大的，便于在相似情況下的比對。
9.diffie-hellman密鑰交換：雙方不需要知道加密算法，不需要協調要使用的加密算法，而且非常難以破解。DH算法使用公鑰和密鑰，公鑰是公開的，發件人使用公鑰進行加密，收件人使用私鑰進行解密。
10.線性規劃：線性規劃是作者知道的最酷的算法之一，他是在給定條件下最大限度地改善指定的指標的算法。所有的圖算法都可以用線性規劃來解決。
（2）小結感悟：學海無涯。
總結
以上是生活随笔為你收集整理的2020.4.1-2020.4.7 魔笛手Pied pier周记的全部內容，希望文章能夠幫你解決所遇到的問題。
