1.軟件設計思想---分層
邏輯層：實現功能需求的，
物理層：用語言開發，性能方面，實現方式
如，數組（ArrayList）、單鏈表（LinkedList）（物理層）實現List接口（邏輯層），List接口具有一些增刪改查的功能
二叉樹，以數組形式實現
二叉樹就是邏輯層，數組是物理層
樹是一個非線性結構，映射到物理層以線性結構存儲起來
如下圖所示，常見的數據結構可分為「線性數據結構」與「非線性數據結構」，具體為：「數組」、「鏈表」、「棧」、「隊列」、「樹」、「圖」、「散列表」、「堆」。
1.1 數組
數組是將相同類型的元素存儲於連續內存空間的數據結構，其長度不可變。
1.1.1 普通數組
如下圖所示，構建此數組需要在初始化時給定長度，並對數組每個索引元素賦值，代碼如下：
// 初始化一個長度為 5 的數組 array int[] array = new int[5]; // 元素賦值 array[0] = 2; array[1] = 3; array[2] = 1; array[3] = 0; array[4] = 2;
或者可以使用直接賦值的初始化方式，代碼如下：
int[] array = {2, 3, 1, 0, 2};
1.1.2 可變數組
「可變數組」是經常使用的數據結構，其基於數組和擴容機制實現，相比普通數組更加靈活。常用操作有：訪問元素、添加元素、刪除元素。
Java
// 初始化可變數組 List<Integer> array = new ArrayList<>(); // 向尾部添加元素 array.add(2); array.add(3); array.add(1); array.add(0); array.add(2);
python
# 初始化可變數組 array = [] # 向尾部添加元素 array.append(2) array.append(3) array.append(1) array.append(0) array.append(2)
1.2 鏈表
鏈表以節點為單位，每個元素都是一個獨立對象，在內存空間的存儲是非連續的。鏈表的節點對象具有兩個成員變量：「值 val」，「后繼節點引用 next」 。
Java
class ListNode {
int val; // 節點值
ListNode next; // 后繼節點引用
ListNode(int x) { val = x; }
}
Python
class ListNode:
def __init__(self, x):
self.val = x # 節點值
self.next = None # 后繼節點引用
如下圖所示，建立此鏈表需要實例化每個節點，並構建各節點的引用指向。
Java
// 實例化節點 ListNode n1 = new ListNode(4); // 節點 head ListNode n2 = new ListNode(5); ListNode n3 = new ListNode(1); // 構建引用指向 n1.next = n2; n2.next = n3;
Python
# 實例化節點 n1 = ListNode(4) # 節點 head n2 = ListNode(5) n3 = ListNode(1) # 構建引用指向 n1.next = n2 n2.next = n3
1.3 棧
棧是一種具有 「先入后出」 特點的抽象數據結構，可使用數組或鏈表實現。
Java
Stack<Integer> stack = new Stack<>();
Python
stack = [] # Python 可將列表作為棧使用
如下圖所示，通過常用操作「入棧 push()」,「出棧 pop()」，展示了棧的先入后出特性。
Java
stack.push(1); // 元素 1 入棧 stack.push(2); // 元素 2 入棧 stack.pop(); // 出棧 -> 元素 2 stack.pop(); // 出棧 -> 元素 1
Python
stack.append(1) # 元素 1 入棧 stack.append(2) # 元素 2 入棧 stack.pop() # 出棧 -> 元素 2 stack.pop() # 出棧 -> 元素 1
注意：通常情況下，不推薦使用 Java 的 Vector 以及其子類 Stack ，而一般將 LinkedList 作為棧來使用
LinkedList<Integer> stack = new LinkedList<>(); stack.addLast(1); // 元素 1 入棧 stack.addLast(2); // 元素 2 入棧 stack.removeLast(); // 出棧 -> 元素 2 stack.removeLast(); // 出棧 -> 元素 1
1.3 隊列
隊列是一種具有 「先入先出」 特點的抽象數據結構，可使用鏈表實現。
Java
Queue<Integer> queue = new LinkedList<>();
Python
# Python 通常使用雙端隊列 collections.deque from collections import deque queue = deque()
如下圖所示，通過常用操作「入隊 push()」,「出隊 pop()」，展示了隊列的先入先出特性。
Java
queue.offer(1); // 元素 1 入隊 queue.offer(2); // 元素 2 入隊 queue.poll(); // 出隊 -> 元素 1 queue.poll(); // 出隊 -> 元素 2
Python
queue.append(1) # 元素 1 入隊 queue.append(2) # 元素 2 入隊 queue.popleft() # 出隊 -> 元素 1 queue.popleft() # 出隊 -> 元素 2
1.4 樹
樹是一種非線性數據結構，根據子節點數量可分為 「二叉樹」 和 「多叉樹」，最頂層的節點稱為「根節點 root」。以二叉樹為例，每個節點包含三個成員變量：「值 val」、「左子節點 left」、「右子節點 right」 。
Java
class TreeNode {
int val; // 節點值
TreeNode left; // 左子節點
TreeNode right; // 右子節點
TreeNode(int x) { val = x; }
}
Python
class TreeNode:
def __init__(self, x):
self.val = x # 節點值
self.left = None # 左子節點
self.right = None # 右子節點
如下圖所示，建立此二叉樹需要實例化每個節點，並構建各節點的引用指向。
Java
// 初始化節點 TreeNode n1 = new TreeNode(3); // 根節點 root TreeNode n2 = new TreeNode(4); TreeNode n3 = new TreeNode(5); TreeNode n4 = new TreeNode(1); TreeNode n5 = new TreeNode(2); // 構建引用指向 n1.left = n2; n1.right = n3; n2.left = n4; n2.right = n5;
Python
# 初始化節點 n1 = TreeNode(3) # 根節點 root n2 = TreeNode(4) n3 = TreeNode(5) n4 = TreeNode(1) n5 = TreeNode(2) # 構建引用指向 n1.left = n2 n1.right = n3 n2.left = n4 n2.right = n5
1.5 圖
圖是一種非線性數據結構，由「節點（頂點）vertex」和「邊 edge」組成，每條邊連接一對頂點。根據邊的方向有無，圖可分為「有向圖」和「無向圖」。本文 以無向圖為例 開展介紹。
如下圖所示，此無向圖的 頂點 和 邊 集合分別為：
- 頂點集合： vertices = {1, 2, 3, 4, 5}
- 邊集合： edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)}
表示圖的方法通常有兩種：
- 鄰接矩陣： 使用數組 vertices存儲頂點，鄰接矩陣 edges存儲邊； edges[i][j] 代表節點 i + 1 和 節點 j + 1之間是否有邊。
Python
vertices = [1, 2, 3, 4, 5]
edges = [[0, 1, 1, 1, 1],
[1, 0, 0, 1, 0],
[1, 0, 0, 0, 1],
[1, 1, 0, 0, 1],
[1, 0, 1, 1, 0]]
Java
int[] vertices = {1, 2, 3, 4, 5};
int[][] edges = {{0, 1, 1, 1, 1},
{1, 0, 0, 1, 0},
{1, 0, 0, 0, 1},
{1, 1, 0, 0, 1},
{1, 0, 1, 1, 0}};
2.鄰接表： 使用數組 vertices存儲頂點，鄰接表 edges 存儲邊。 edges 為一個二維容器，第一維 i 代表頂點索引，第二維 edges[i]存儲此頂點對應的邊集和；
例如 edges[0] = [1, 2, 3, 4] 代表 vertices[0] 的邊集合為 [1, 2, 3, 4] 。
Python
vertices = [1, 2, 3, 4, 5]
edges = [[1, 2, 3, 4],
[0, 3],
[0, 4],
[0, 1, 4],
[0, 2, 3]]
Java
int[] vertices = {1, 2, 3, 4, 5};
List<List<Integer>> edges = new ArrayList<>();
List<Integer> edge_1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
List<Integer> edge_2 = new ArrayList<>(Arrays.asList(0, 3));
List<Integer> edge_3 = new ArrayList<>(Arrays.asList(0, 4));
List<Integer> edge_4 = new ArrayList<>(Arrays.asList(0, 1, 4));
List<Integer> edge_5 = new ArrayList<>(Arrays.asList(0, 2, 3));
edges.add(edge_1);
edges.add(edge_2);
edges.add(edge_3);
edges.add(edge_4);
edges.add(edge_5);
注意：
鄰接矩陣 VS 鄰接表 ：
鄰接矩陣的大小只與節點數量有關，即 N2，其中 N 為節點數量。因此，當邊數量明顯少於節點數量時，使用鄰接矩陣存儲圖會造成較大的內存浪費。
因此，鄰接表 適合存儲稀疏圖（頂點較多、邊較少）； 鄰接矩陣 適合存儲稠密圖（頂點較少、邊較多）。
1.6 散列表
散列表是一種非線性數據結構，通過利用 Hash 函數將指定的「鍵 key」映射至對應的「值 value」，以實現高效的元素查找。
例子：設想一個簡單場景：小力、小特、小扣的學號分別為 10001, 10002, 10003 。現需求從「姓名」查找「學號」。
則可通過建立姓名為 key ，學號為 value 的散列表實現此需求，代碼如下：
Java
// 初始化散列表
Map<String, Integer> dic = new HashMap<>();
// 添加 key -> value 鍵值對
dic.put("小力", 10001);
dic.put("小特", 10002);
dic.put("小扣", 10003);
// 從姓名查找學號
dic.get("小力"); // -> 10001
dic.get("小特"); // -> 10002
dic.get("小扣"); // -> 10003
Python
# 初始化散列表
dic = {}
# 添加 key -> value 鍵值對
dic["小力"] = 10001
dic["小特"] = 10002
dic["小扣"] = 10003
# 從姓名查找學號
dic["小力"] # -> 10001
dic["小特"] # -> 10002
dic["小扣"] # -> 10003
自行設計Hash函數
例子：假設需求：從「學號」查找「姓名」
將三人的姓名存儲至以下數組中，則各姓名在數組中的索引分別為 0, 1, 2 。
Java
String[] names = { "小力", "小特", "小扣" };
Python
names = [ "小力", "小特", "小扣" ]
此時，我們構造一個簡單的 Hash 函數（ \%% 為取余符號 ），公式和封裝函數如下所示：
Java
int hash(int id) {
int index = (id - 1) % 10000;
return index;
}
Python
def hash(id):
index = (id - 1) % 10000
return index
則我們構建了以學號為 key 、姓名對應的數組索引為 value 的散列表。利用此 Hash 函數，則可在 O(1)時間復雜度下通過學號查找到對應姓名，即：
names[hash(10001)] // 小力 names[hash(10002)] // 小特 names[hash(10003)] // 小扣
以上設計只適用於此示例，實際的 Hash 函數需保證低碰撞率、 高魯棒性等，以適用於各類數據和場景。
1.7 堆
堆是一種基於「完全二叉樹」的數據結構，可使用數組實現。以堆為原理的排序算法稱為「堆排序」，基於堆實現的數據結構為「優先隊列」。
堆分為「大頂堆」和「小頂堆」，大（小）頂堆：任意節點的值不大於（小於）其父節點的值。
完全二叉樹定義： 設二叉樹深度為 k ，若二叉樹除第 k 層外的其它各層（第 1 至 k−1 層）的節點達到最大個數，且處於第 k 層的節點都連續集中在最左邊，則稱此二叉樹為完全二叉樹。
如下圖所示，為包含 1, 4, 2, 6, 8 元素的小頂堆。將堆（完全二叉樹）中的結點按層編號，即可映射到右邊的數組存儲形式。
Java
// 初始化小頂堆 Queue<Integer> heap = new PriorityQueue<>(); // 元素入堆 heap.add(1); heap.add(4); heap.add(2); heap.add(6); heap.add(8); // 元素出堆（從小到大） heap.poll(); // -> 1 heap.poll(); // -> 2 heap.poll(); // -> 4 heap.poll(); // -> 6 heap.poll(); // -> 8
Python
from heapq import heappush, heappop # 初始化小頂堆 heap = [] # 元素入堆 heappush(heap, 1) heappush(heap, 4) heappush(heap, 2) heappush(heap, 6) heappush(heap, 8) # 元素出堆（從小到大） heappop(heap) # -> 1 heappop(heap) # -> 2 heappop(heap) # -> 4 heappop(heap) # -> 6 heappop(heap) # -> 8
2.算法思想
（1）算法思想，就是在我們遇到問題時候，沒有什么思路的時候，就可以朝這些方向去想，如；遞歸，動態規划，分治算法，查找
計算機里面的都是離散的，證明離散最好的方法，就是用數學歸納法
數學歸納法就是算法思想
遞歸，在邏輯層，是數學歸納法的體現；在物理層，是程序調用棧的使用
（2）遍歷算法（每個節點只能訪問一遍）
深度優先：
廣度優先：
按層次遍歷，使用隊列
參考：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/50e446/