【LeetCode Book】图解算法数据结构（更新中）

原创

已于 2022-06-06 21:50:41 修改 · 1.7k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法 #leetcode

于 2022-05-19 22:17:20 首次发布

本文介绍了LeetCodeBook《图解算法数据结构》的个人笔记，涉及算法复杂度、数据结构概述，如时间复杂度、空间复杂度、常见数据结构及其操作，以及动态规划、搜索与回溯等核心概念的应用实例。

前言

个人整理的LeetCode Book 《图解算法数据结构》的笔记，用于后续复习。

作者：Krahets
链接：《图解数据结构与算法》
来源：力扣（LeetCode）著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

01 概述

算法复杂度

算法复杂度的两个角度：

时间复杂度： 假设各操作的运行时间为固定常数，统计算法运行的「计算操作的数量」，以代表算法运行所需时间；
空间复杂度： 统计在最差情况下，算法运行所需使用的「最大空间」。

问题的规模 $N$ ：

排序算法： $N$ 代表需要排序的元素数量；
搜索算法： $N$ 代表搜索范围的元素总和。

时间复杂度

时间复杂度具有「最差」、「平均」、「最佳」三种情况，分别使用 $O$ ， $\Theta$ ， $\Omega$ 三种符号表示， $O$ 是最常使用的时间复杂度评价符号。

根据从大到小排序，常见的算法时间复杂度主要有：
$O(\text{log}N) < O(N) < O(N\text{log}N) < O(N^2) < O(2^N) < O(N!)$
算法复杂度

示例：
$O(N^2)$ ：冒泡排序
$O(N\text{log}N)$ ：快速排序、归并排序、堆排序

空间复杂度

对于算法的性能，需要从时间和空间的使用情况来综合评价。优良的算法应具备两个特性，即时间和空间复杂度皆较低。而实际上，对于某个算法问题，同时优化时间复杂度和空间复杂度是非常困难的。降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。

由于当代计算机的内存充足，通常情况下，算法设计中一般会采取「空间换时间」的做法，即牺牲部分计算机存储空间，来提升算法的运行速度。

本文不对空间复杂度进行介绍，详见：《图解算法数据结构》空间复杂度

02 数据结构

数据结构简介

引言

数据结构是为实现对计算机数据有效使用的各种数据组织形式，服务于各类计算机操作。不同的数据结构具有各自对应的适用场景，旨在降低各种算法计算的时间与空间复杂度，达到最佳的任务执行效率。

如下图所示，常见的数据结构可分为「线性数据结构」与「非线性数据结构」，具体为：「数组」、「链表」、「栈」、「队列」、「树」、「图」、「散列表」、「堆」。

数据结构

数组

数组是将相同类型的元素存储于连续内存空间的数据结构，其长度不可变。
如下图所示，构建此数组需要在初始化时给定长度，并对数组每个索引元素赋值，两种赋值方式：

// 1)
// 初始化一个长度为 5 的数组 array
int array[5];
// 元素赋值
array[0] = 2;
array[1] = 3;
array[2] = 1;
array[3] = 0;
array[4] = 2;

// 2)
int array[] = {
   
   2, 3, 1, 0, 2};

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

链表

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

struct ListNode {
   
   
    int val;        // 节点值
    ListNode *next; // 后继节点引用
    ListNode(int x) : val(x), next(NULL) {
   
   }
};

如下图所示，建立此链表需要实例化每个节点，并构建各节点的引用指向。

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

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

栈

栈是一种具有 「先入后出」 特点的抽象数据结构，可使用数组或链表实现。
如下图所示，通过常用操作「入栈 push()」,「出栈 pop()」，展示了栈的先入后出特性。

stack<int> stk;

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

队列

队列是一种具有 「先入先出」 特点的抽象数据结构，可使用链表实现。

queue<int> que;

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

que.push(1); // 元素 1 入队
que.push(2); // 元素 2 入队
que.pop();   // 出队 -> 元素 1
que.pop();   // 出队 -> 元素 2

在这里插入图片描述

树

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

struct TreeNode {
   
   
    int val;         // 节点值
    TreeNode *left;  // 左子节点
    TreeNode *right; // 右子节点
    TreeNode(int x) : val(x), left(NULL), right(NULL) {
   
   }
};

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

// 初始化节点
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;

图

图是一种非线性数据结构，由 **「节点（顶点）vertex」**和「边 edge」组成，每条边连接一对顶点。根据边的方向有无，图可分为「有向图」和「无向图」。本文以无向图为例开展介绍。

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

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

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

邻接矩阵

int vertices[5] = {
   
   1, 2, 3, 4, 5};
int edges[5][5] = {
   
   {
   
   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}};

邻接表

int vertices[5] = {
   
   1, 2, 3, 4, 5};
vector<vector<int>> edges;

vector<int> edge_1 = {
   
   1, 2, 3, 4};
vector<int> edge_2 = {
   
   0, 3};
vector<int> edge_3 = {
   
   0, 4};
vector<int> edge_4 = {
   
   0, 1, 4};
vector<int> edge_5 = {
   
   0, 2, 3};
edges.push_back(edge_1);
edges.push_back(edge_2);
edges.push_back(edge_3);
edges.push_back(edge_4);
edges.push_back(edge_5);

Note

邻接矩阵 VS 邻接表：
邻接矩阵的大小只与节点数量有关，即 $N^2$ ，其中 $N$ 为节点数量。因此，当边数量明显少于节点数量时，使用邻接矩阵存储图会造成较大的内存浪费。
因此，邻接表适合存储稀疏图（顶点较多、边较少）； 邻接矩阵适合存储稠密图（顶点较少、边较多）。

散列表

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

例：可通过建立姓名为 key ，学号为 value 的散列表实现从「姓名」查找「学号」，代码如下：

// 初始化散列表
unordered_map<string, int> dic;

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

// 从姓名查找学号
dic.find("小力")->second; // -> 10001
dic.find("小特")->second; // -> 10002
dic.find("小扣")->second; // -> 10003

哈希表
Hash 函数需保证 低碰撞率 、 高鲁棒性 等，以适用于各类数据和场景。

堆

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

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

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

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

// 初始化小顶堆
priority_queue<int, vector<int>, greater<int>> heap;

// 元素入堆
heap.push(1);
heap.push(4);
heap.push(2);
heap.push(6);
heap.push(8);

// 元素出堆（从小到大）
heap.pop(); // -> 1
heap.pop(); // -> 2
heap.pop(); // -> 4
heap.pop(); // -> 6
heap.pop(); // -> 8

Note

堆是一种非线性结构，可以把堆看作一个数组，也可以被看作一个完全二叉树，通俗来讲堆其实就是利用完全二叉树的结构来维护的一维数组，但堆并不一定是完全二叉树。

普通树占用的内存空间比它们存储的数据要多。普通树必须为节点对象以及左/右子节点指针分配额外的内存。堆仅仅使用数组，且不使用指针。

参考：堆排序

题目

剑指 Offer 09. 用两个栈实现队列

思路：
使用两个栈A、B维护队列。A维护队尾部分，A.top() 存放队尾元素；B维护队首部分，B.top() 存放队首元素。

队列尾部插入整数时，只操作队尾，直接将整数压入A；
队列头部删除整数时，分以下几种情况：
1. B不为空，直接返回队尾整数；
2. B为空：
  1）A也为空，说明整个队列为空，返回-1；
  2）A不为空，将A压入B，再返回队尾元素。

由于A、B将整个队列分为队尾和队首两个互不影响的部分，在删除数据后，不需要再将B中的数据还原到A中。

代码：

class CQueue {
   
   
public:
    stack<int> stk;   // stk.top()存放队尾元素
    stack<int> stk_r; // stk_r.top()存放队首元素

    CQueue() {
   
    }
    
    void appendTail(int value) {
   
   
        stk.push(value);//直接压入stk
    }
    
    int deleteHead() {
   
   
        // 1. stk_r不为空，直接弹栈
        // 2. stk_r为空
        //      1) stk不为空，将stk压入stk_r，再弹栈
        //      2) stk为空，返回 -1
        if(stk_r.empty()) {
   
   
            if(stk.empty()) {
   
   
                return -1;
            } else {
   
   
                while(!stk.empty()) {
   
   
                    stk_r.push(stk.top());
                    stk.pop();
                }
            }
        }
        int res = stk_r.top();
        stk_r.pop();
        return res;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

剑指 Offer 30. 包含 min 函数的栈

思路：
普通栈的 push() 和 pop() 函数的复杂度为 $O (1)$ ；而获取栈最小值 min() 函数需要遍历整个栈，复杂度为 $O (N)$ 。

本题难点：将 min() 函数复杂度降为 $O (1)$ 。可借助辅助栈实现：

数据栈 A ： 栈 A 用于存储所有元素；
辅助栈 B ： 栈 B 中存储栈 A 中所有 非严格降序 元素的子序列，则栈 A 中的最小元素始终对应栈 B 的栈顶元素。此时， min() 函数只需返回栈 B 的栈顶元素即可。

因此，只需设法维护好栈 B 的元素，使其保持是栈 A 的非严格降序元素的子序列，即可实现 min() 函数的 $O (1)$ 复杂度。

代码：

class MinStack {
   
   
public:
    /** initialize your data structure here. */
    stack<int> A;
    //如果只用int保存min，在pop时min无法维护
    stack<int> A_min; //辅助栈，存放A中所有非严格降序元素的子序列
    MinStack() {
   
   }    
    void push(int x) {
   
   
        A.push(x);

        if(A_min.empty() || A_min.top() >= x) {
   
   
            A_min.push(x);
        }

    }
    
    void pop() {
   
   
        if(A.