学习数据结构与算法的心得体会
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/
