数据结构与算法Rust语言描述 PDF 数据结构csdn

数据结构详解

• 【详解】数据结构

• 数据结构概念
• 数据结构类型

• 数组

• 可变数组

• 链表
• 栈
• 队列
• 树
• 图
• 散列表

• Hash函数设计

• 堆

【详解】数据结构

数据结构概念

数据结构是为了实现对计算机数据有效使用的各种数组组织结构形式，并且服务于各类计算机的操作。 不同的数据结构具有对应的适用场景，主要目的是为降低各种算法计算的时间和空间复杂度，使其能够达到最佳的任务执行效率。

数据结构类型

常见的数据结构分为：线性数据结构与非线性数据结构。具体细分为：数组、链表、栈、队列、数、图、散列表、堆。

数组

数组是将相同类型的元素存储于连续内存空间的数据结构，其长度大小不可变。

如下图所示，构建此数组需要在初始化时给定长度，并堆每个索引元素赋值，代码如下：

// 初始化一个长度为 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};

可变数组

可变数组是经常使用的数据结构，基于数组和扩容机制实现，相比普通数组更加灵活。常用操作有：访问元素、添加元素、删除元素。

// java code
// 初始化可变数组
List<Integer> array = new ArrayList<>();

// 向尾部添加元素
array.add(2);
array.add(3);
array.add(1);
array.add(0);
array.add(2);

# python code
# 初始化可变数组
array = []

# 向尾部添加元素
array.append(2)
array.append(3)
array.append(1)
array.append(0)
array.append(2)

链表

链表以节点为单位，每个元素都是一个独立对象，在内存空间的存储时非连续的。且链表的节点对象具有两个成员变量：值[value]和后续节点引用[next]。

// java code
class ListNode {
    int val;       // 节点值
    ListNode next; // 后继节点引用
    ListNode(int x) { val = x; }
}

# python code
class ListNode:
    def __init__(self, x):
        self.val = x     # 节点值
        self.next = None # 后继节点引用

如下图所示，建立链表需要是劣化每个节点，并构建各个节点的引用指向：

// java code
// 实例化节点
ListNode n1 = new ListNode(4); // 节点 head
ListNode n2 = new ListNode(5);
ListNode n3 = new ListNode(1);

// 构建引用指向
n1.next = n2;
n2.next = n3;

# python code
# 实例化节点
n1 = ListNode(4) # 节点 head
n2 = ListNode(5)
n3 = ListNode(1)

# 构建引用指向
n1.next = n2
n2.next = n3

栈

栈时一种具有 先入后出 特点的抽象数据结构，可使用数组或者链表进行实现。

// java code
Stack<Integer> stack = new Stack<>();

# python code
stack = [] # python可将列表作为栈使用

如下图所示，通过常用操作 入栈push() , 出栈pop()，展现栈的先入后出特性。

// java code
stack.push(1); // 元素 1 入栈
stack.push(2); // 元素 2 入栈
stack.pop();   // 出栈 -> 元素 2
stack.pop();   // 出栈 -> 元素 1

# python code
stack.append(1) # 元素 1 入栈
stack.append(2) # 元素 2 入栈
stack.pop()     # 出栈 -> 元素 2
stack.pop()     # 出栈 -> 元素 1

注意：通常情况下，不推荐使用 Java 的 Vector 以及其子类 Stack ，而一般将 LinkedList 作为栈来使用。详细说明请见：Stack，ArrayDeque，LinkedList 的区别 。

// java code
LinkedList<Integer> stack = new LinkedList<>();

stack.addLast(1);   // 元素 1 入栈
stack.addLast(2);   // 元素 2 入栈
stack.removeLast(); // 出栈 -> 元素 2
stack.removeLast(); // 出栈 -> 元素 1

队列

队列时一种具有 先入先出 特点的抽象数据结构，可使用来链表来实现：

// java code
Queue<Integer> queue = new LinkedList<>();

# python code
# Python 通常使用双端队列 collections.deque
from collections import deque

queue = deque()

如下图所示，通过常用操作 入队push()，出队pop()，展示了队列的先入先出特性。

// java code
queue.offer(1); // 元素 1 入队
queue.offer(2); // 元素 2 入队
queue.poll();   // 出队 -> 元素 1
queue.poll();   // 出队 -> 元素 2

# python code
queue.append(1) # 元素 1 入队
queue.append(2) # 元素 2 入队
queue.popleft() # 出队 -> 元素 1
queue.popleft() # 出队 -> 元素 2

树

树是一种非线性的数据结构，根据子节点可分为二叉树和多叉树，最顶层的节点称为根节点(root)。以二叉树为列，每个节点包含三个成员变量：值(value)、左子节点(left)、右子节点(right)。

// java code
class TreeNode {
    int val;        // 节点值
    TreeNode left;  // 左子节点
    TreeNode right; // 右子节点
    TreeNode(int x) { val = x; }
}

# python code
class TreeNode:
    def __init__(self, x):
        self.val = x      # 节点值
        self.left = None  # 左子节点
        self.right = None # 右子节点

如下图所示，建立此二叉树需要实列化每个节点，并构建各个节点的引用指向：

// java code
// 初始化节点
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 code
# 初始化节点
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

图

图是一种非线性的数据结构，由节点(顶点 vertex)和边(edge)组成，每条边连接一对顶点。根据边的方向有无，图可以分为有向图 和 无向图 。

以无向图为例：

如下图所示，此无向图的顶点和边集合分别为：

• 顶点集合：vertices = {1, 2, 3, 4, 5}
• 边结合：edges = {(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 5), (4, 5)}

表示图的方法通常有两种：

1、邻接矩阵：使用数组vertices存储顶点，邻接矩阵edges存储边；edges[i][j]代表节点 i + 1 和节点 j + 1 之间是否有边。

// java code
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}};

# python code
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]]

2、邻接表： 使用数组vertices存储顶点，邻接表edges存储边。 edges为一个二维容器，第一维 i 代表顶点索引，第二维 edges[i]存储此顶点对应的边集和；例如 edges[0] = [1, 2, 3, 4]代表 vertices[0]的边集合为 [1, 2, 3, 4][1,2,3,4] 。

// java code
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);

# python code
vertices = [1, 2, 3, 4, 5]
edges = [[1, 2, 3, 4],
         [0, 3],
         [0, 4],
         [0, 1, 4],
         [0, 2, 3]]

邻接矩阵 VS 邻接表：

1、邻接矩阵的大小只与节点数量有关，即 N^2，其中 N 为节点数量。

2、因此，当边数量明显少于节点数量时，使用邻接矩阵存储图会造成较大的内存浪费。
3、邻接表适合存储稀疏图（顶点较多、边较少）；

4、邻接矩阵适合存储稠密图（顶点较少、边较多）。

散列表

散列表是一种非线性的数据结构，通常利用Hash函数将指定的键(key)映射至对应的值(value)，来实现高效的元素查找。

假想一个简单场景： 小力、小特、小扣的学号分别为 10001, 10002, 10003 。
现需求从姓名查找学号。

则通关建立姓名为key，学号为value的散列表实现此需求，代码如下：

// java code
// 初始化散列表
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 code
# 初始化散列表
dic = {}

# 添加 key -> value 键值对
dic["小力"] = 10001
dic["小特"] = 10002
dic["小扣"] = 10003

# 从姓名查找学号
dic["小力"] # -> 10001
dic["小特"] # -> 10002
dic["小扣"] # -> 10003

Hash函数设计

案例：从学号查找姓名

将三人的姓名存储至一下数组中，则各姓名在数组中的索引分别为0，1，2。

// java code
String[] names = { "小力", "小特", "小扣" };

# python code
names = [ "小力", "小特", "小扣" ]

此时，构造一个简单的Hash函数(%为取余符号)，公式和封装函数如下所示：

// java code
int hash(int id) {
    int index = (id - 1) % 10000;
    return index;
}

# python code
def hash(id):
    index = (id - 1) % 10000
    return index

构建了以学号为 key 、姓名对应的数组索引为 value 的散列表。利用此 Hash 函数，则可在 O(1)O(1) 时间复杂度下通过学号查找到对应姓名，即：

names[hash(10001)] // 小力
names[hash(10002)] // 小特
names[hash(10003)] // 小扣

以上设计只适用于此示例：实际的 Hash 函数需保证低碰撞率、 高鲁棒性等，以适用于各类数据和场景。

堆

堆是一种基于完全二叉树的数据结构，可使用数组来实现。以堆为原理的排序算法称为堆排序，基于堆实现的数据结构为优先队列。堆分为大顶堆和小顶堆。大(小)顶堆：任意节点的值不大于(小于)其父节点的值。

完全二叉树定义： 设二叉树深度为 k ，若二叉树除第 k 层外的其它各层（第 1 至 k-1 层）的节点达到最大个数，且处于第 k 层的节点都连续集中在最左边，则称此二叉树为完全二叉树。

**如下图所示，为包含 1, 4, 2, 6, 8 元素的小顶堆。将堆（完全二叉树）中的结点按层编号，即可映射到右边的数组存储形式。 **

通常使用优先队列的 压入push() 和 弹出pop() 操作，即可完成堆排序，实现代码如下：

// java code
// 初始化小顶堆
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 code
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