演算法第一步（Python版）

第1章 認識演算法
1.1 演算法究竟是什麼
1.1.1 廣義的演算法
1.1.2 電腦領域的演算法
1.2 程式、程式設計和演算法之間的關係
1.2.1 演算法與程式
1.2.2 演算法與程式設計
1.2.3 學習演算法和程式設計的用處
1.3 學習演算法的深度
1.3.1 掌握演算法的5個層次
1.3.2 對應不同層次的講解方法
1.3.3 演算法驅動程式設計
1.3.4 演算法的難點：從原理到實現
 
第2章 萬事的抽象：控制流程
2.1 認識流程
2.1.1 順序
2.1.2 順序結構
2.1.3 條件（分支）
2.1.4 條件（分支）結構
2.1.5 迴圈（反覆運算）
2.1.6 迴圈（反覆運算）結構
2.2 用簡單的結構表達複雜的過程：控制結構的排列和嵌套
2.2.1 什麼是流程圖
2.2.2 極簡版流程圖符號表
2.2.3 最簡單的流程圖
2.3 流程圖的細微性與嵌套
2.3.1 細微性
2.3.2 嵌套
2.3.3 條件結構和迴圈結構的嵌套
2.3.4 細微性均衡的流程圖
 
第3章 電腦是如何運行的
3.1 數據
3.1.1 資訊數位化
3.1.2 資料化與資料
3.1.3 資料的組織
3.1.4 資料結構
3.2 電腦原理淺釋
3.2.1 電子電腦的前世今生
3.2.2 馮‧諾依曼結構
3.2.3 存儲空間的位址和內容
3.2.4 一條指令是如何被執行的
3.2.5 馮‧諾依曼結構的直觀解釋
3.2.6 馮‧諾依曼結構的應用
3.2.7 馮‧諾依曼結構的瓶頸
3.2.8 哈佛結構
 
第4章 萬物的抽象：資料結構
4.1 認識資料結構
4.1.1 陣列
4.1.2 鏈表
4.2 直觀理解資料結構
4.2.1 陣列與鏈表
4.2.2 陣列與鏈表之同
4.2.3 陣列與鏈表之異
4.3 預留給貨物的固定貨架：記憶體中的陣列
4.3.1 存儲空間
4.3.2 陣列：一塊連續的存儲空間
4.3.3 陣列的下標
4.3.4 陣列中的元素
4.3.5 陣列的元素值
4.3.6 陣列的特性
4.3.7 連續存儲惹的禍
4.4 見縫插針地擺放貨物：記憶體中的鏈表
4.4.1 鏈表
4.4.2 鏈表的編輯
4.5 資料結構的特性和發展
4.5.1 特性各異的鏈表與陣列
4.5.2 資料結構的發展
 
第5章 複雜一些的資料結構：圖和樹
5.1 圖
5.1.1 圖的定義和分類
5.1.2 相關概念和演算法
5.2 樹
5.2.1 樹的定義
5.2.2 二叉樹
5.3 遍歷演算法
5.3.1 樹的遍歷和圖的遍歷
5.3.2 二叉樹的深度優先遍歷演算法
5.3.3 二叉樹的廣度優先遍歷演算法
5.4 圖和樹的現實意義
5.4.1 圖的抽象
5.4.2 樹的抽象
5.5 圖和樹
5.5.1 樹是圖的真子集
5.5.2 樹比圖*加嚴謹
 
第6章 第一行Python代碼
6.1 跟你的電腦聊天：程式設計語言
6.1.1 什麼是程式設計語言
6.1.2 從低階語言到高級語言
6.1.3 編譯和解釋
6.2 直觀感受不同的程式設計語言
6.3 一條可愛的小蟒蛇：Python語言
6.3.1 主流程式設計語言
6.3.2 為什麼選擇Python
6.3.3 Python的特性
6.3.4 結合陣列與鏈表的優點的列表
6.4 Python的編輯、運行環境
6.4.1 順序安裝
6.4.2 創建項目
6.4.3 開始編寫第一個程式
6.5 第一個Python程式：讓Python小蟒蛇動起來
6.5.1 你好世界
6.5.2 運行Python程式的幾種方式
6.5.3 程式設計語言的基本概念
6.5.4 Python中的print()函數
 
第7章 開始用Python語言編寫程式
7.1 資料值和資料類型
7.1.1 資料的抽象和具象含義
7.1.2 資料類型
7.2 識別字
7.3 字面量、變數和常量
7.4 變數賦值
7.4.1 賦值的方式
7.4.2 賦值前無須聲明類型
7.4.3 賦值後不能隱性轉換類型
7.5 Python中的陣列
7.5.1 邏輯上的陣列
7.5.2 清單和元素
7.5.3 列表的賦值和複製
7.6 Python中的流程控制
7.6.1 用縮進劃分代碼塊
7.6.2 關鍵字
7.6.3 Python中的3種控制結構
7.6.4 不同類型結構的嵌套
 
第8章 實現第一個演算法並衡量其優劣
8.1 從*簡單的演算法開始學：順序查找
8.1.1 什麼是查找演算法
8.1.2 查找演算法的要素
8.1.3 順序查找
8.2 順序查找的資料結構和控制流程
8.2.1 資料結構
8.2.2 控制流程
8.3 用Python實現順序查找演算法
8.3.1 用變數和賦值重繪流程圖
8.3.2 代碼實現
8.4 用for語句實現順序查找演算法
8.4.1 Python迴圈關鍵字：for和while
8.4.2 用for迴圈實現順序查找演算法
8.5 如何衡量演算法的性能
8.5.1 時間複雜度
8.5.2 常見演算法的時間複雜度
8.5.3 空間複雜度
 
第9章 簡單但有用的經典查找演算法
9.1 猜數遊戲
9.1.1 遊戲規則
9.1.2 不限制猜測次數的遊戲的必勝攻略
9.1.3 限制猜測次數的猜數遊戲
9.2 從“挨著找”到“跳著找”
9.3 二分查找：從原理到形式化描述
9.3.1 二分查找的原理
9.3.2 結構化的自然語言描述――流程圖
9.3.3 形式化描述第一步――變數和賦值
9.4 二分查找的程式設計實現
9.4.1 形式化流程控制
9.4.2 從流程圖到代碼
9.5 二分查找的性能
9.5.1 二分查找的時間複雜度
9.5.2 二分查找的空間複雜度
 
第10章 程式中的函數
10.1 電腦領域的函數
10.1.1 程式設計中的函數
10.1.2 函數的定義
10.1.3 函數的調用
10.1.4 二分查找函數
10.2 函數的作用
10.2.1 重用
10.2.2 抽象和封裝
10.2.3 從程式之外獲得資料
10.3 函數的參數
10.3.1 函數的參數及其值的變化
10.3.2 Python的函數參數傳遞
10.3.3 函數參數問題的簡化理解
 
第11章 程式設計實現猜數遊戲
11.1 用Python實現猜數遊戲
11.1.1 猜數遊戲與二分查找
11.1.2 編寫猜數遊戲攻擊者輔助程式
11.2 修改後的猜數小助手為什麼輸了
11.3 Bug
11.4 Bug的天敵――Debug
11.4.1 什麼是Debug
11.4.2 常用Debug方法：列印變數中間值
11.5 和Bug鬥智鬥勇
11.5.1 Bug的嚴重性
11.5.2 產生Bug的原因
11.5.3 防止Bug產生危害的方法
 
第12章 二分查找的變形
12.1 二分查找變形記：重複數列二分查找
12.1.1 包含重複元素數列的二分查找
12.1.2 包含重複元素數列的二分查找的變形
12.2 讓變形更高效：與經典二分查找相同的時間複雜度
12.2.1 包含重複元素數列的二分查找的時間複雜度
12.2.2 時間複雜度的計算
12.2.3 包含重複元素數列的二分查找的O(log(n))演算法
12.3 二分查找再變形：旋轉數列二分查找
12.3.1 有序數列的旋轉
12.3.2 不包含重複元素旋轉數列的二分查找
12.3.3 演算法實現
12.3.4 代碼優化
12.4 包含重複元素旋轉數列的二分查找
 
第13章 認識排序演算法
13.1 處處可見的排行榜
13.1.1 什麼是排序
13.1.2 排序演算法的江湖地位
13.1.3 無處不在的排行榜
13.2 排序演算法的分類
13.2.1 排序演算法的分類方式
13.2.2 比較排序
13.2.3 比較排序的局限和優勢
13.3 排序演算法的基本操作：兩兩交換陣列中的元素
13.3.1 查找演算法和排序演算法
13.3.2 兩兩交換陣列中的元素
13.3.3 swap()函數
13.3.4 沒有返回值的swap()函數
 
第14章 幾種簡單排序演算法
14.1 撲克牌遊戲
14.1.1 用撲克牌做一個小遊戲
14.1.2 排序要解決的問題
14.1.3 基於直覺的排序演算法
14.2 選擇排序
14.2.1 演算法原理
14.2.2 資料結構
14.2.3 演算法步驟
14.2.4 程式設計實現
14.3 起泡排序
14.3.1 歷史
14.3.2 演算法原理
14.3.3 演算法步驟
14.3.4 程式設計實現
14.3.5 演算法優化
14.4 插入排序
14.4.1 演算法原理：又見撲克牌
14.4.2 在陣列中插入元素
14.4.3 演算法步驟
14.4.4 程式設計實現
14.5 簡單排序概述
14.5.1 排序的時間複雜度
14.5.2 排序的空間複雜度
14.5.3 簡單排序演算法性能總結
 
第15章 必須掌握的排序演算法
15.1 快速排序
15.1.1 一個“笑話”
15.1.2 演算法原理
15.1.3 演算法的江湖地位
15.1.4 演算法步驟
15.2 快速排序的時間複雜度
15.2.1 時間複雜度的計算
15.2.2 最佳時間複雜度
15.2.3 最差時間複雜度
15.2.4 平均時間複雜度
15.2.5 理解快速排序的平均時間複雜度
15.3 快速排序的空間複雜度
15.3.1 簡單的分區函數
15.3.2 優化分區函數
15.4 解讀分區演算法原始程式碼
15.4.1 “人肉電腦”法
15.4.2 列印解讀法
15.5 程式設計實現快速排序演算法
15.5.1 分治策略
15.5.2 快速排序的分與治
15.5.3 程式設計實現快速排序演算法
 
第16章 遞迴實現快速排序
16.1 遞迴：像“貪吃蛇”一樣“吃掉”自己
16.1.1 歷史悠久的概念
16.1.2 無效遞迴
16.1.3 有效遞迴
16.1.4 分形
16.1.5 斐波那契數列
16.2 遞迴函數
16.2.1 遞迴和分治
16.2.2 遞迴函數
16.2.3 最簡單的遞迴函數
16.2.4 Python 限制遞迴深度
16.2.5 限制運行次數的遞迴函數
16.2.6 遞迴實現斐波那契數的計算
16.3 實現遞迴式快速排序
16.3.1 遞迴式快速排序的原理
16.3.2 遞迴式快速排序的程式設計實現
16.3.3 演算法性能
16.4 測試演算法程式
16.4.1 構造測試資料集
16.4.2 安裝 pip 和用 pip 安裝模組
16.4.3 用生成資料測試快速排序
16.4.4 分區函數帶來的差異
 
第17章 演算法精進
17.1 如何算學會了一個演算法
17.1.1 以二分查找為例瞭解“掌握演算法的幾個層次”
17.1.2 依據掌握的知識解決問題
17.1.3 學習演算法的誤區
17.2 學會之後――創新
17.3 如何自學演算法
17.3.1 自學三要素
17.3.2 學習材料和內容
17.3.3 學習目的和深度
17.3.4 學習方法
17.3.5 如何閱讀代碼
17.3.6 練與實踐
17.4 說說刷題