数据结构与算法 on Clarity

堆

Sun, 24 May 2026 00:00:00 +0000

堆是一棵完全二叉树，使用数组实现堆，堆分为两种：

最大堆：父节点大于任意子节点（因此堆顶为最大值）
最小堆：父节点小于任意子节点（因此堆顶为最小值）

对于第i个节点（i从0开始计数）：

父节点：(i-1)/2
左子节点：2i+1
右子节点：2i+2

若包含sz个节点，则第一个非叶子节点的序号为(sz - 2) / 2

插入节点

插入节点时，进行下列操作：

将元素添加到数组末尾；（相当于叶节点接入堆中）
和父节点进行比较，如果大于父节点(以最大堆为例)，则与父节点交换，一直比较交换到根节点

 1/********************************************
 2 * 向堆中插入元素
 3 *  hole：新元素所在的位置
 4 ********************************************/
 5template <class value>
 6void _push_heap(vector<value> &arr,int hole){
 7    value v = arr[hole]; //取出新元素，从而产生一个空洞
 8    int parent = (hole - 1) / 2;
 9    //建最大堆，如果建最小堆换成 arr[parent] > value
10    while(hole > 0 && arr[parent] < v){
11        arr[hole] = arr[parent];
12        hole = parent;
13        parent = (hole - 1) / 2;
14    }
15    arr[hole] = v;
16}

删除堆顶

删除实际上是将堆顶元素移入数组末尾，并不是真的删除。删除节点时，进行下列操作：

保存数组末尾元素(存如临时变量v)，将堆顶元素存入数组末尾
将原来堆顶元素的两个子节点中较大的一个移入堆顶(以最大堆为例)，填补空缺，此时产生新的空缺，继续此步骤，直到空缺为一个叶子节点
将v中存储的值移到空缺叶子节点的位置
对上一步中的新叶子节点完成向上比较交换操作

 1/********************************************
 2 * 删除堆顶元素
 3 ********************************************/
 4template <class value>
 5void _pop_heap(vector<value> &arr,int sz)
 6{
 7    value v = arr[sz - 1];
 8    arr[sz - 1] = arr[0];
 9    --sz;
10    int hole = 0;
11    int child = 2 * (hole + 1); //右孩子
12    while(child < sz){
13        if(arr[child] < arr[child - 1])
14            --child;
15        arr[hole] = arr[child];
16        hole = child;
17        child = 2 * (hole + 1);
18    }
19    if(child == sz){
20        arr[hole] = arr[child - 1];
21        hole = child - 1;
22    }
23    arr[hole] = v;
24    _push_heap(arr,hole);
25}

建堆

堆的大小固定(且所有元素已知)：按“序号从大到小”的顺序遍历所有非叶子节点，将这些节点与左右子节点较大者(以最大堆为例)交换，执行siftdown一直到叶子节点，因此，每遍历到一个节点时，其左子树和右子树都已经是最大堆，只需对当前节点执行siftdown操作
堆的大小未知(如数据流)：可以通过插入操作来构建堆

 1/********************************************
 2 * 建堆
 3 *  sz：删除堆顶元素后的大小
 4 *  v： 被堆顶元素占据的位置原来的元素的值
 5 ********************************************/
 6template <class value>
 7void _make_heap(vector<value> &arr)
 8{
 9    int sz = arr.size();
10    int parent = (sz - 2) / 2;
11    while(parent >= 0){
12        int hole = parent;
13        int child = 2 * (hole + 1); //右孩子
14        value v = arr[hole];
15        while(child < sz){
16            if(arr[child] < arr[child - 1])
17                --child;
18            arr[hole] = arr[child];
19            hole = child;
20            child = 2 * (hole + 1);
21        }
22        if(child == sz){
23            arr[hole] = arr[child - 1];
24            hole = child - 1;
25        }
26        arr[hole] = v;
27        _push_heap(arr,hole);
28        --parent;
29    }
30}

复杂度

插入节点：时间复杂度为O(logn)
删除堆顶：时间复杂度为O(logn)
建堆：
- 堆的大小固定(且所有元素已知)：每个siftdown操作的最大代价是节点被向下移动到树底的层数。在任意一棵完全二叉树中，大约有一半的节点是叶节点，因此不需要向下移动。四分之一的节点在叶节点的上一层，这样的节点最多只需要移动一层。每向上一层，节点的数目就为前一层的一般，而子树高度加1，因此移动层数加一。时间复杂度为O(n)
- 堆的大小未知(如数据流)：由于插入节点的时间代价为O(logn)，对于n个元素，每个执行一次插入操作，所以时间复杂度为O(nlogn)

二叉树

Sun, 24 May 2026 00:00:00 +0000

两种特殊二叉树

满二叉树（下图左）：除叶子节点外的所有分支节点都含有2个非空子节点的二叉树
完全二叉树（下图右）：除了最后一层，其余层都是“满”的，这样的二叉树是完全二叉树

二叉树定理

1）任意二叉树度数为2节点的个数等于叶节点个数减1

当只有1个节点时，度为0。每派生出1度，就会多出1个节点。派生出的度和派生出的节点数一定相等。那么就得出了总度数和节点总数的关系：

节点总数 = 总度数 + 1

设度数为2的节点数为X2，度数为1的节点数为X1，度数为0的节点数为X0。可以得出如下关系式：

X2 + X1 + X0 = 2X2 + X1 + 1，推出 X2 = X0 - 1

因此，度数为2的节点个数等于叶节点数减1

2）满二叉树定理：非空满二叉树的叶节点数等于其分支节点数加1

如果已知前一个结论，那么这个定理显然成立。下面分析如果不知道前一个结论，怎么证明

对于只有1个节点的树，该定理成立。从这开始思考，每产生1个分支节点(度数为2)。叶子节点数也会加1。因为要产生一个分支节点，那么这个新的分支节点必然是原来的叶子节点，而新的分支节点又生成了2个新的叶子节点。因此叶子节点的总数先是减1然后加2，因此总数加1。因此，产生n个分支节点时，也产生了n个叶子节点，由于最初只有1个叶子节点，所以该定理成立

3）一颗非空二叉树空子树的数目等于其节点数目加1

考虑只有1个根节点的二叉树：它有2个空子树，1个节点，因此结论成立。从这里开始考虑，每产生1个节点。空子树便会先减1然后加2。就和上面结论中每多出1个分支节点，叶子节点的变化一样。因此在原来结论的基础上，由于空子树和节点等量增长。所以结论成立

前中后序遍历

前序遍历：根->左->右
中序遍历：左->根->右
后序遍历：左->右->根

假设树节点的定义如下：

1struct TreeNode {
2    int val;
3    TreeNode *left;
4    TreeNode *right;
5    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
6};

递归版

 1//前序遍历
 2void preorderTraversalRecursion(TreeNode *node)
 3{
 4    if(!node) return;
 5    cout << node->val << " ";//操作当前节点
 6    preorderTraversalRecursion(node->left);
 7    preorderTraversalRecursion(node->right);
 8}
 9
10//中序遍历
11void inorderTraversalRecursion(TreeNode *node)
12{
13    if(!node) return;
14    inorderTraversalRecursion(node->left);
15    cout << node->val << " ";//操作当前节点
16    inorderTraversalRecursion(node->right);
17}
18
19//后序遍历
20void postorderTraversalRecursion(TreeNode *node)
21{
22    if(!node) return;
23    postorderTraversalRecursion(node->left);
24    postorderTraversalRecursion(node->right);
25    cout << node->val << " ";//操作当前节点
26}

迭代版

需要使用一个栈作为辅助空间

哈希表

Sun, 24 May 2026 00:00:00 +0000

哈希：把关键码值映射到表中的位置来访问记录的过程
哈希函数：将关键码值映射到位置的函数
槽：哈希表中的一个位置
冲突：不同的关键码经过哈希函数哈希后，映射到相同槽的情况
探查序列：冲突解决策略的闭哈希方法中，如果基位置冲突，需要根据探查函数查找下一个空槽，这个过程产生的序列加上基位置组成了某个关键码的探查序列
基本聚集：在探查函数的设计中，如果不同基位置关键码产生的探查序列发生重合，会导致对剩余空槽的选择概率不均等。产生的后果是会导致很长的探查序列。这种现象就是基本聚集
二次聚集：基位置相同的关键码，产生的探查序列一样。如果哈希函数在某个基位置聚集，仍然会保持聚集

哈希方法不适用于下列场景：

不适用于范围检索
不能找到具有最大或最小关键码值的记录
不能按关键码值的顺序访问记录

哈希方法既适合基于内存的检索，也适合基于磁盘的检索。是组织存储在磁盘上的大型数据库的主要方法之一（另一种是B树）

槽总数的选择

关键码范围较小

由于关键码范围比较小，可以使用一个槽总数大于关键码总数的表。直接使用槽的下标作为关键码值，此时，不需要将关键码值作为记录的一部分进行存储。哈希函数可以直接设计成h(K)=K，但是这种情况比较少见

关键码范围较大

如果可能的关键码范围较大，而同一时间段内存储的记录总数较少时。如果槽数的设计和前者匹配通常意味着空间的浪费，而如果和后者匹配又容易导致冲突

除此之外，如果对关键码值的分布特性不了解，也会使得哈希函数的设计更为困难。如果了解关键码值的分布特性，应对使用一个依赖于分布的哈希函数，避免把一组相关的关键码值映射到表的同一个槽中（例如，如果对英文单词进行哈希，就不应当对第一个字符的值哈希，因为这样很可能使分布不均）

简单的哈希函数

关键码为数值的哈希函数的设计：

取模：哈希函数的返回值(槽的位置)只依赖于关键码的最低几位，由于这些位的分布可能很差，结果分布也就可能很差
平方取中：一个很好的用于数值的哈希函数。对于长度为2^r的表，取出平方后结果的中间r位作为槽的位置。由于关键码值的大多数位或者所有位都对结果有所贡献，所有效果很好

关键码为字符串的哈希函数的设计：

所有字母ASCII值求和对M取模

冲突解决策略

尽管哈希函数的目标是使冲突最少，但实际上冲突是无法避免的。冲突解决技术可以分为两类：

开哈希(单链表)法
闭哈希(开放地址)法

开哈希法

开哈希(单链表)法把冲突记录存储在表外，一种简单的形式是把哈希表中的每个槽定义为一个链表的表头，哈希到一个槽的所有记录都放到该槽的链表内，每个链表可以按如下方式组织记录：

按插入次序排序：实现简单
按关键码值次序排序：一旦到达比要检索的关键码大的节点，说明不存在，就可以停止检索
按访问频率次序排序：访问较高的记录能快速检索到

在磁盘中用一种很有效的方式存储一个开哈希表是很困难的，因为一个链表中的多个元素能存储在不同的磁盘块中。这就会导致检索一个关键码值需要多次磁盘访问，从而抵消了哈希方法的好处

闭哈希法

闭哈希(开放地址)法把冲突记录存储在表中另一个槽内。每条记录i有一个基位置，即由哈希函数计算出的槽。如果要插入一条记录R，而另一条记录已经占据了R的基位置，那么就把R存储在表中的其他槽内，由冲突解决策略决定应该是哪个槽。自然，检索时也要像插入一样，遵循同样的策略，以便重复进行冲突解决过程，找出在某位置没有找到的记录

1）桶式哈希

插入：将M个槽分成B个桶，每个桶中包含M/B个槽。哈希函数把每条记录分配到某个桶的第一个槽中。如果该槽被占用，就顺序地沿着桶查找，直到找到一个空槽。如果一个桶全部被占满，那么就把这条记录存储在表后具有无限容量的溢出桶中，所有桶共享一个溢出桶
检索：确定桶，然后在桶中检索记录，如果没找到并且桶内有空槽，则检索结束。否则，检索溢出桶

桶式哈希适用于实现基于磁盘的哈希表，因为可以把桶的大小设置为磁盘块的大小。当检索时，就把整个桶读入内存。处理插入或检索操作只需进行一次磁盘访问，除非桶已经满了。如果桶满，需要从磁盘中检索溢出桶，自然应该使溢出很小，以最小化不必要的磁盘访问

2）线性探查

探查序列：通过哈希函数计算出关键码的基位置，如果基位置发生冲突，根据探查函数去寻找下一个槽，直到找到一个空槽，这个过程产生的一组槽序列，就是探查序列

线性探查就是探查函数线性递增的冲突解决策略，如果基位置为30，整个探查序列会是30,31,32,33...

线性探查的问题在于，会产生基本聚集，基本聚集是指不同基位置的关键码产生的探查序列会发生重合，导致对剩余空槽的选择概率不均等。产生的后果是会导致很长的探查序列

在上图a）中，如果使用线性探查，基位置为0,1,2的关键码在探查后都会选择序号为2的槽，同样，基位置为7,8,9的关键码在探查后都会选择序号为9的槽，这就使得剩余槽被选择的概率不相等。在图b）中，这个问题会更明显，如果下一个记录插入了序号为9的槽，则序号为2的空槽被插入记录的概率将是6/10

系数大于1的线性探查(对线性探查函数添加常数C跳过一些槽)，即：(h(K) + iC) mod M

比如当C为2时，基位置为1和2产生的探查序列为1,3,5..和2,4,6..这个方法对于不同关键码，将关键码值分成了几个集合，每个集合中的关键码只会探查所有槽中的一个部分。同时，相同集合中的关键码还是可能聚集

为了使探查序列走遍表中所有的槽，常数C必须与M互质（即C为质数或M为质数），如果C与M互质，那么任何关键码的探查序列都会走遍所有的槽

3）解决聚集的方法

二次探查：探查函数为i的平方，即基位置为30的关键码，产生的探查序列为30,31,34,39..这种方法的缺陷在于并不是哈希表中所有的槽都在探查序列中

上述方法虽然能解决基本聚集，但是对于基位置相同的关键码，产生的探查序列还是一样。如果哈希函数在某个基位置聚集，那么上面的方法仍然会保持聚集。也就是所谓的二次聚集。解决二次聚集可以使用双哈希

双哈希：要使具有相同基位置的关键码产生不同的探查序列，那么探查函数也应该是基于关键码的函数。假设这个函数为h2(K)，一种方式是根据这个函数产生线性探查序列，即i*h2(K)。例如，如果h2(K)=2，那么基位置为30的关键码产生的探查序列是：30，32，34...，由于h2是基于关键码值的函数，所以基位置相同的不同关键码会产生不同的探查序列，因此可以解决二次聚集

排序

Sun, 24 May 2026 00:00:00 +0000

内排序
- 1.插入排序（稳定）
- 2.冒泡排序（稳定）
- 3.选择排序（不稳定）
- 4.shell排序（不稳定）
- 5.快速排序（不稳定）
- 6.归并排序（稳定）
- 7.堆排序（不稳定）
外排序
- 1.多路归并

稳定性：相同的元素在排序前和排序后的前后位置是否发生改变，没有改变则排序是稳定的，改变则排序是不稳定的 ——八大排序算法的稳定性

1.插入排序

逐个处理待排序的记录，每个记录与前面已排序已排序的子序列进行比较，将它插入子序列中正确位置

代码

1template<class Elem>
2void inssort(Elem A[],int n)
3{
4    for(int i = 1;i < n;i++)
5        for(int j = i;j >= 1 && A[j] < A[j-1];j--)
6            swap(A,j,j-1);
7}

性能

最佳：升序。时间复杂度为O(n)
最差：降序。时间复杂度为O(n^2)
平均：对于每个元素，前面有一半元素比它大。时间复杂度为O(n^2)

如果待排序数据已经“基本有序”，使用插入排序可以获得接近O(n)的性能

优化

 1template<class Elem>
 2void inssort(Elem A[],int n)
 3{
 4    for(int i = 1;i < n;i++){
 5        int j = i;
 6        int tp = A[j];
 7        for(;j >= 1 && tp < A[j-1];j--)
 8            A[j] = A[j - 1];
 9        A[j] = tp;
10    }
11}

2.冒泡排序

从数组的底部比较到顶部，比较相邻元素。如果下面的元素更小则交换，否则，上面的元素继续往上比较。这个过程每次使最小元素像个“气泡”似地被推到数组的顶部

代码

1template<class Elem>
2void bubsort(Elem A[],int n)
3{
4    for(int i = 0;i < n - 1;i++)
5        for(int j = n - 1;j > i;j--)
6            if(A[j] < A[j-1])
7                swap(A,j,j-1);
8}

性能

冒泡排序是一种相对较慢的排序，没有较好的最佳情况执行时间。通常情况下时间复杂度都是O(n^2)

优化

增加一个变量flag，用于记录一次循环是否发生了交换，如果没发生交换说明已经有序，可以提前结束

3.选择排序

第i次“选择”数组中第i小的记录，并将该记录放到数组的第i个位置。换句话说，每次从未排序的序列中找到最小元素，放到未排序数组的最前面

代码

 1template<class Elem>
 2void selsort(Elem A[],int n)
 3{
 4    for(int i = 0;i < n - 1;i++){
 5        int lowindex = i;
 6        for(int j = i + 1;j < n;j++)
 7            if(A[j] < A[lowindex])
 8                lowindex = j;
 9        swap(A,i,lowindex);//n次交换
10    }
11}

性能

不管数组是否有序，在从未排序的序列中查找最小元素时，都需要遍历完最小序列，所以时间复杂度为O(n^2)

平衡查找树

Sun, 24 May 2026 00:00:00 +0000

总结自《算法》(第4版)

平衡查找树

平衡查找树

一般的二插查找树如果节点有序插入，树的高度会是n，因此无法实现logn的查找，平衡查找树保证树的高度平衡，因此不管节点插入顺序如何，都可以满足logn的查找

2-3查找树

一棵2-3查找树或为一棵空树，或由以下节点组成：

2-节点：含有1个键（及其对应的值）和2条链接，左链接指向的2-3树中的键都小于该节点，右链接指向的2-3树中的键都大于该节点
3-节点：含有2个键（及其对应的值）和3条链接，左链接指向的2-3树中的键都小于该节点，中链接指向的2-3树中的键都位于该节点的两个键之间，右链接指向的2-3树中的键都大于该节点

1. 查找

先将查找的键与根节点中的键比较。如果和其中任意一个相等，则查找命中；否则根据比较的结果找到指向相应区间的链接，并在其指向的子树中递归地继续查找。如果这是个空链接，查找未命中

2. 插入

1）向2-节点中插入新键

如果未命中的查找结束于一个2-节点，只要把这个2-节点替换为一个3-节点，将要插入的键保存在其中即可。由于整棵树的节点并未发生变化，所以这个插入操作并没有引起高度变化，如果原本树是平衡的，那么插入后也能保持平衡

2）向3-节点中插入新键

整棵树只包含一个3-节点（情况一）
整棵树包含多个节点
- 3-节点的父节点为2-节点（情况二）
- 3-节点的父节点为3-节点（情况三）

情况一：先临时将新键存入该节点中，使之成为一个4-节点。然后将这个4-节点转换成一棵由3个2-节点组成的2-3树：其中一个节点(根)含有中键，一个节点含有3个键中的最小者(左子节点)，一个节点含有3个键中的最大者(右子节点)。很容易看出插入后的树依然是平衡的

情况二：先构造一个临时的4-节点并将其分解，但此时不会像情况一一样为中键创建一个新节点，而是将其移动至原来的父节点中。可以将这次转换看成将原3-节点的一条链接替换为新父节点中的原中键左右两边的两条链接，并分别指向两个新的2-节点。插入后树仍是有序的，并且是完美平衡的

情况三：和情况二一样，先构造一个临时的4-节点并分解，将它的中键插入到父节点中。但父节点也是一个3-节点，因此再用这个中键构造一个新的临时4-节点，然后在这个节点上进行相同的变换（即分解这个父节点并将它的中键插入到父节点中）。推广到一般情况，这样一直向上不断分解临时的4-节点并将中键插入更高层的父节点，直至遇到一个2-节点并将它替换为一个不需要继续分解的3-节点，或者是到达3-节点的根（这种情况下，按情况一进行处理，将临时的4-节点分解为3个2-节点，使得树高加一，因为变换的是根节点，所以仍然保持树的完美平衡性）

3. 2-3树构造实例

下面是根据字符序列[S,E,A,R,C,H,X,M,P,L]构造一棵2-3树的过程。左边是乱序插入，右边是顺序插入

可以发现，2-3树在最坏情况下（顺序插入）仍然可以保证平衡

每个操作中处理每个节点的时间都不会超过一个很小的常数，并且只会访问一条路径上的节点，所以任何查找或插入的成本都肯定不会超过对数级别。含有10亿个节点的一颗2-3树的高度仅在19到30之间，最多只需要访问30个节点就能够在10亿个键中进行查找和插入操作

红黑树

尽管可以用不同的数据类型表示2-节点和3-节点并写出转换所需的代码，但用这种直白的表示方法实现大多数的操作并不方便，因为需要处理的情况实在太多：需要维护两种不同类型的节点，将被查找的键和节点中的每个键进行比较，将链接和其它信息从一种节点复制到另一种节点，将节点从一种数据类型转换到另一种数据类型，等等。实现这些不仅需要大量代码，而且它们产生的额外开销可能会使算法比标准的二插查找树更慢。平衡二叉树的初衷是为了消除最坏情况，但我们希望这种保障所需的代码能够越少越好，因此有了红黑树

红黑树背后的基本思想是：用标准的二插查找树（完全由2-节点构成）和一些额外的信息（替换3-节点）来表示2-3树。将红黑树中的链接分为2种类型：

红链接：红链接将两个2-节点连接起来构成一个3-节点
黑链接：2-3树中的普通链接

将2-3树中的3-节点表示为由一条左斜的红链接相连的两个2-节点（优点是，无需修改就可以直接使用标准二插查找树的get方法）

红黑树是满足下列条件的二叉查找树：

红链接均为左链接
没有任何一个节点同时和两个红链接相连
该树是完美”黑色“平衡的，即任意空链接到根节点的路径上的黑链接数量相同

如果将一棵红黑树中的红链接画平，那么所有的空链接到根节点的距离都将是相同的。如果将由红链接相连的节点合并，得到的就是一棵2-3树。相反，如果将一棵2-3树中的3-节点画作由红色左链接相连的两个2-节点，那么不会存在能够和两条红链接相连的节点，且树必然是完美黑色平衡的

算法题总结

Sun, 24 May 2026 00:00:00 +0000

题目来源：《剑指offer》、leetcode、lintcode、hihocoder、《王道程序员求职宝典》

一	二	三	四	五	六	七	八	九	十
数组	字符串	链表	树	栈和队列	数学	图	设计	海量数据	C/C++基础

一.数组
- 二分查找
  - Leetcode35：查找插入位置（二分查找 easy）
  - 《剑指offer》面试题11：旋转数组的最小数字（二分查找）
  - Leetcode33：旋转数组中查找数字（二分查找 medium）
  - Leetcode81：旋转数组中查找数字II（二分查找 medium）
  - 《剑指offer》面试题53(题目一)：有序数组中查找数字的范围（二分查找）
  - 《剑指offer》面试题53(题目二)：缺失的数字（二分查找）
  - 《剑指offer》面试题53(题目三)：数组中数值和下标相等的元素（二分查找）
  - Leetcode162：查找数组中任一峰值的下标（二分查找 medium）
  - Leetcode4：两个排序数组的中值（二分查找 hard）
- 其它查找
  - Leetcode41：缺失的第一个正数（交换 hard）
  - Leetcode287：寻找数组中重复的数（二分查找 链表 medium）
  - Leetcode268：0~n中缺失的数字（位运算 easy）
  - Leetcode136：只出现1次的数字（位运算 easy）
  - 《剑指offer》面试题56(题目一)：数组中只出现1次的2个数（位运算）
  - 《剑指offer》面试题56(题目二)：数组中唯一只出现1次的数字（位运算）
  - 《剑指offer》面试题41：数据流的中位数（堆）
  - 《剑指offer》面试题57(题目一)：和为s的两个数字（双指针）
  - 《剑指offer》面试题57(题目二)：和为s的连续正数序列（双指针）
  - Leetcode217：判断数组是否包含重复元素（哈希表 easy）
  - Leetcode1：两数之和（哈希表 easy）
  - Leetcode15：三数之和（排序 双指针 medium）
  - Leetcode18：四数之和（排序 双指针 medium）
  - Leetcode454：四数之和II（哈希表 medium）
  - 《剑指offer》面试题39：数组中出现次数超过一半的数字（partition）
  - 《剑指offer》面试题40：数组中最小的k个数（partition 海量数据）
  - Leetcode347：出现频率最高的k个数字（medium）
  - Leetcode350：两个数组的交集II（easy）
- 数组操作
  - Leetcode26：删除排序数组中的重复项（双指针 easy）
  - Leetcode27：删除数组中值为val的元素（双指针 easy）
  - Leetcode189：旋转数组（easy）
  - Leetcode283：将数组中的零移到尾部（easy）
- 子数组与连续子数组
  - 《剑指offer》面试题42：连续子数组的最大和（动态规划）
  - Leetcode152：连续子数组的最大积（动态规划 medium）
  - Leetcode128：最长连续序列（哈希表 hard）
  - Leetcode300：最长升序子序列（动态规划 medium）
  - Leetcode334：数组的三元升序子序列（medium）
- 排列组合
  - 《剑指offer》面试题38(相关题一)：正方体顶点上放数字（全排列）
  - 《剑指offer》面试题38(相关题二)：八皇后（全排列）
  - Leetcode52：N皇后II（全排列 hard）
  - Leetcode51：N皇后（全排列 hard）
  - Leetcode31：下一个排列（排列 medium）
  - Leetcode60：第K个排列（排列 medium）
  - Leetcode46：不含重复元素数组的全排列（全排列 medium）
  - Leetcode47：含重复元素数组的全排列（全排列 medium）
  - Leetcode77：1~n中所有k个数的组合（组合 medium）
  - Leetcode78：不含重复元素集合的所有子集（组合 medium）
  - Leetcode90：含重复元素集合的所有子集（组合 medium）
  - Leetcode39：和为target的数字组合（组合 medium）
  - Leetcode40：和为target的数字组合II（组合 medium）
- 排序
  - 《剑指offer》面试题21：调整数组顺序使奇数位于偶数前面（partition)
  - 《剑指offer》面试题61：扑克牌中的顺子
  - Leetcode75：颜色分类（medium）
  - Leetcode179：将一组数拼接成最大数字（medium）
  - Leetcode88：合并两个有序数组（归并 easy）
  - 《剑指offer》面试题51：数组中的逆序对（归并）
  - Leetcode315：计算右侧小于当前元素的个数（归并 BST hard）
  - Leetcode324：摆动排序（medium）
  - Leetcode384：打乱数组（Fisher–Yates shuffle洗牌算法 medium）
- 场景
  - Leetcode134：加油站（贪心 medium）
  - Leetcode121：买卖股票的最佳时机（easy）
  - Leetcode122：买卖股票的最佳时机II（贪心 easy）
  - Leetcode123：买卖股票的最佳时机III（动态规划 hard）
  - Leetcode188：买卖股票的最佳时机IV（动态规划 hard）
  - Leetcode198：打家劫舍（动态规划 easy）
  - Leetcode213：打家劫舍II（动态规划 medium）
  - Leetcode337：打家劫舍III（动态规划 medium）
  - Leetcode322：找钱（动态规划 medium）
  - 拼多多内推笔试：装载货物的最少货车数量（贪心）
- 二维数组
  - 《剑指offer》面试题4：二维数组中的查找
  - Leetcode378：有序矩阵中第K小的元素（优先队列 二分查找 medium）
  - 《剑指offer》面试题29：顺时针打印矩阵
  - Leetcode48：90度旋转图片（medium）
  - 《剑指offer》面试题66：构建乘积数组
  - Leetcode73：矩阵置零（medium）
  - Leetcode289：细胞自动机的下一个状态（位运算 medium）

二.字符串
- 字符串与数字
  - 《剑指offer》面试题20：判断字符串是否表示一个数值（鲁棒性）
  - 《剑指offer》面试题67：把字符串转换成整数（鲁棒性）
- 字符查找
  - 《剑指offer》面试题50(题目一)：字符串中第一个只出现一次的字符（哈希表）
  - 《剑指offer》面试题50(题目二)：字符流中第一个只出现一次的字符（哈希表）
- 翻转
  - 《剑指offer》面试题58(题目一)：翻转单词顺序
  - 《剑指offer》面试题58(题目二)：左旋转字符串
  - Leetcode344：翻转字符串（双指针 easy）
- 排列组合
  - 《剑指offer》面试题38：字符串的排列（排列）
  - 《剑指offer》面试题38(扩展)：求字符的所有组合（组合）
- 删除替换
  - 《剑指offer》面试题5：替换空格
  - Leetcode71：简化路径（medium）
- 异位词
  - Leetcode49：字母异位词分组（排序 哈希表 medium）
  - Leetcode242：有效的字母异位词（排序 哈希表 easy）
- 单词查找
  - 《剑指offer》面试题12：单词搜索（DFS）
  - Leetcode212：单词搜索II（Trie DFS hard）
- 字符串转换
  - Leetcode91：数字字符串解码（动态规划 medium）
  - Leetcode127：单词阶梯（BFS medium）
  - Lintcode119：单词转换的最少次数（动态规划 medium）
- 子串与子序列
  - Leetcode28：子串查找（KMP easy）
  - Leetcode3：不含重复字符的最长子串（滑动窗口 哈希表 medium）
  - Leetcode395：至少有K个重复字符的最长子串（二分法 哈希表 medium）
  - Leetcode76：最小覆盖子串（滑动窗口 哈希表 hard）
  - Leetcode30：所有单词相连的子串（哈希表 hard）
  - Leetcode5：最长回文子串（动态规划 medium）
  - Leetcode125：判断字符串是否是回文串（双指针 easy）
- 字符串拆分
  - Leetcode131：分割回文串（动态规划 DFS medium）
  - Leetcode139：单词拆分I（动态规划 medium）
  - Leetcode140：单词拆分II（动态规划 hard）
- 字符串匹配
  - Leetcode10：正则表达式匹配（动态规划 hard）
  - Leetcode44：通配符匹配（动态规划 hard）
- 最长公共问题
  - Lintcode77：两个字符串的最长公共子序列（动态规划 medium）
  - Lintcode79：两个字符串的最长公共子串（动态规划 medium）
  - Leetcode14：多个字符串的最长公共前缀（扫描 分治 二分查找 Trie easy）

三.链表
- 遍历
  - 《剑指offer》面试题6：从尾到头打印链表（栈）
  - Leetcode234：回文链表（栈 easy）
  - 《剑指offer》面试题22：链表中倒数第k个节点（双指针）
  - Leetcode19：删除链表倒数第n个节点（双指针 鲁棒性 medium）
  - 《剑指offer》面试题22(相关题)：链表的中间节点（双指针）
  - Leetcode141：判断链表是否有环（双指针 easy）
  - 《剑指offer》面试题23：链表中环的入口节点（双指针）
- 节点删除
  - 《剑指offer》面试题18(题目一)：删除链表中的节点
  - Leetcode203：删除链表中等于给定值的所有节点（鲁棒性 easy）
  - Leetcode83：删除有序链表中的重复节点（easy）
  - 《剑指offer》面试题18(题目二)：删除有序链表中的重复节点II（鲁棒性 medium）
  - 《剑指offer》面试题62：圆圈中最后剩下的数
  - 腾讯面试题：实现双链表节点删除函数（鲁棒性）
- 单链表处理
  - 《剑指offer》面试题24：反转链表（栈）
  - 《剑指offer》面试题35：复杂链表的复制
  - Leetcode61：旋转链表（medium）
  - Leetcode24：成对交换链表的节点（鲁棒性 medium）
  - Leetcode25：K个一组翻转链表（鲁棒性 hard）
  - Leetcode143：重排链表（medium）
  - Leetcode148：链表节点排序（分治归并 medium）
  - Leetcode328：将链表偶数位置的节点移至尾部（medium）
- 多链表处理
  - Leetcode2：两数相加（数学 medium）
  - 《剑指offer》面试题25：合并两个有序链表
  - Leetcode23：合并k个有序链表（多路归并 堆 分治 hard）
  - 《剑指offer》面试题52：两个链表的第一个公共节点（双指针）

四.树
- 遍历
  - 《剑指offer》面试题7：重建二叉树（前序 中序）
  - 《剑指offer》面试题8：中序遍历的下一个节点（中序）
  - 《剑指offer》面试题26：树的子结构（前序）
  - 《剑指offer》面试题37：序列化二叉树（前序）
  - Leetcode94：输出二叉树的中序遍历序列（中序 递归 迭代 medium）
  - Leetcode98：判断一棵二叉树是否是BST（BST 中序 medium）
  - 《剑指offer》面试题33：BST的后序遍历序列（BST 后序）
  - 《剑指offer》面试题36：BST转双链表（BST 中序 双链表）
  - Leetcode108：有序数组转BST（BST 分治 easy）
  - Leetcode109：单链表转BST（BST 中序 单链表 medium）
  - 《剑指offer》面试题54：BST第k小的节点（BST 中序）
  - Leetcode116：填充同一层的兄弟节点（BFS 前序 medium）
  - 《剑指offer》面试题32(题目一)：按层不分行输出二叉树（BFS）
  - 《剑指offer》面试题32(题目二)：按层分行输出二叉树（BFS）
  - 《剑指offer》面试题32(题目三)：之字形打印二叉树（BFS 栈）
- 对称二叉树
  - 《剑指offer》面试题27：二叉树的镜像（递归 迭代）
  - 《剑指offer》面试题28：对称的二叉树（递归 迭代）
- 路径
  - 《剑指offer》面试题34：二叉树中和为某一值的路径（回溯）
  - Leetcode124：二叉树的最大路径和（动态规划 后序 hard）
  - Leetcode863：二叉树中与target距离为K的结点（DFS(前序) BFS medium）
- 深度
  - 《剑指offer》面试题55(题目一)：二叉树的深度（递归）
  - 《剑指offer》面试题55(题目二)：平衡二叉树AVL（后序）
- 公共祖先
  - 《剑指offer》面试题68：两个节点的最低公共祖先

五.栈和队列
- 设计
  - 《剑指offer》面试题9：用两个栈实现队列（栈 队列）
  - 《剑指offer》面试题9(相关题)：用两个队列实现栈（栈 队列）
  - 《剑指offer》面试题30：包含min函数的栈（栈）
  - 《剑指offer》面试题59(题目二)：包含max函数的队列（队列）
- 其它
  - 《剑指offer》面试题31：栈的压入弹出序列（栈）
  - Leetcode20：有效的括号（栈 easy）
  - Leetcode32：最长有效括号（栈 hard）
  - 《剑指offer》面试题59(题目一)：滑动窗口的最大值（队列）

六.数学
- 斐波那契数列
  - 《剑指offer》面试题10(题目一)：斐波那契数列（动态规划）
  - 《剑指offer》面试题10(题目二)：跳台阶（动态规划）
  - 《剑指offer》面试题10(题目三)：变态跳台阶（动态规划）
  - 《剑指offer》面试题10(题目四)：矩形覆盖（动态规划）
- 特殊
  - 《剑指offer》面试题49：丑数
  - Leetcode36：有效数独（哈希表 medium）
  - Leetcode204：计数质数（easy）
  - Leetcode279：完美平方数（动态规划 medium）
- 进制
  - 《剑指offer》面试题15：二进制中1的个数（位运算）
  - Leetcode7：反转整数（鲁棒性 easy）
  - Leetcode43：字符串相乘（鲁棒性 medium）
  - Leetcode66：数组表示的数字加1（easy）
  - Leetcode171：Excel表列序号（26进制转10进制）（easy）
  - Leetcode190：颠倒二进制位（位运算 easy）
- 倍数约数
  - Leetcode412：Fizz Buzz（easy）
- 次方与小数
  - 《剑指offer》面试题16：数值的整数次方（位运算 鲁棒性）
  - Leetcode69：求x的平方根（二分查找 鲁棒性 easy）
  - Leetcode166：求分数的值（鲁棒性 medium）
  - Leetcode326：3的幂（easy）
- 找规律
  - 《剑指offer》面试题43：整数1~n中1出现的次数
  - Leetcode38：报数（字符串 easy）
  - Leetcode172：阶乘后的零（鲁棒性 easy）
- 条件限制
  - 《剑指offer》面试题64：求1~n的和
  - 《剑指offer》面试题65：不用加减乘除做加法（位运算）
  - Leetcode29：不用乘除取模实现整数除法（位运算 medium）
- 表达式求值
  - Leetcode150：逆波兰表达式求值（栈 medium）
  - Leetcode227：基础的计算器（medium）
- 几何
  - Leetcode11：盛最多水的容器（双指针 medium）
  - Leetcode42：接雨水（hard）
  - Leetcode55：合并区间（medium）
  - Leetcode84：柱状图中最大的矩形（栈 hard）
  - Leetcode149：直线上最多的点数（哈希 hard）
  - Leetcode218：天际线问题（hard）

七.图
- 遍历
  - 《剑指offer》面试题13：机器人的运动范围（DFS）
  - Leetcode62：左上角到右下角的路径数（DFS 动态规划 medium）
  - Leetcode63：左上角到右下角的路径数II（DFS 动态规划 medium ）
  - Leetcode64：左上角到右下角的最短路径（DFS 动态规划 medium ）
  - Leetcode130：被包围的区域（DFS medium）
  - Leetcode200：岛屿的数量（DFS easy）
  - Leetcode695：岛屿的最大面积（DFS easy）
  - Leetcode329：矩阵中的最长递增路径（DFS 动态规划 hard）
  - Leetcode55：跳步游戏（贪心 medium）
  - Leetcode45：跳步游戏II（动态规划 BFS hard）
- 拓扑排序
  - Leetcode207：课程安排（BFS DFS medium）
  - Leetcode210：课程安排II（BFS DFS medium）
- 最短路径
  - hihoCoder1081：Dijkstra算法（dijkstra Lv.2）
- 最小生成树
  - hihoCoder1097：连通所有城市的最短道路（prim Lv.2）

八.设计
- Leetcode146：LRU缓存机制（哈希表 链表 hard）
- Leetcode208：实现Trie树(前缀树)（Trie 设计 medium）
- Leetcode341：扁平化嵌套列表迭代器（栈 medium）
- Leetcode380：实现O(1)的插入删除与随机获取（哈希表 medium）

九.海量数据
- 公共部分
  - 《王道程序员求职宝典》：两个文件共同的url（hash 分治）
- 频率最高
  - 《王道程序员求职宝典》：按频率排序多个文件中的query记录（hash 分治）
  - 《王道程序员求职宝典》：找出文件中频率最高的100个词（Top K hash 分治）
  - 《王道程序员求职宝典》：海量日志中提取访问百度次数最多的IP（Top K hash 分治）
- 中位数
  - BAT面试经典题：100亿个整数的中位数（二分查找 分桶）
- 位图
  - 《王道程序员求职宝典》：实现位图（位图）
  - 《王道程序员求职宝典》：统计不同号码的个数（位图）
  - 《王道程序员求职宝典》：查找某个数是否在40亿个数当中（位图）
  - 《王道程序员求职宝典》：2.5亿整数中只出现一次的整数（位图）
- 其它
  - 《王道程序员求职宝典》：布隆过滤器
  - 《王道程序员求职宝典》：倒排索引法

十.C/C++基础
- C库函数
- 结构体与联合
  - 实现一个函数确定主机字节序
  - 实现计算结构体成员偏移量的宏
- 动态内存管理
  - 手写实现智能指针

数组中重复的数字

OJ链接

图

Sun, 24 May 2026 00:00:00 +0000

图可以用G=(V,E)来表示，每个图都包括一个顶点集合V和一个边集合E，顶点总数记为|V|，边总数记为|E|

稀疏图：边数较少的图
密集图：边数较多的图
完全图：包含所有可能边的图
带权图：边上标有权的图
邻接点：一条边所连的两个顶点
简单路径：路径上不包含重复顶点的图
回路：将某个顶点连接到本身，且长度大于等于3的路径
无环图：不带回路的图

图的表示

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

邻接矩阵
邻接表

1.邻接矩阵

使用一个二维矩阵来表示图:

(i,j)=1，表示顶点i到顶点j之间有一条边（非带权图）
(i,j)=n，表示顶点i到顶点j之间有一条权重为n的边（带权图）

使用邻接矩阵的空间代价总是O(|V|^2)

2.邻接表

邻接表使用一个顶点指针数组来表示：

数组的元素i表示顶点i的指针，它是一个链表的头结点
链表其余的顶点表示与顶点i之间存在边的顶点

邻接表的空间代价与图中边的数目和顶点的数目均有关系。每个顶点要占据一个数组元素的位置，且每条边必须出现在其中某个顶点的边链表中

图的遍历

DFS(深度优先遍历)

DFS会递归地访问它的所有未被访问的相邻顶点：

先访问顶点v，把所有与v相关联的边存入栈中；
弹出栈顶元素，栈顶元素代表的边所关联的另一个顶点就是要访问的下一个元素k；
对k重复对v的操作；
重复，直至栈中所有元素都被处理完毕

DFS的执行过程将产生一棵DFS(深度优先搜索)树：

整个DFS的过程如下：

相关题目：

Leetcode：695.Max Area of Island

BFS(广度优先遍历)

使用一个队列。对于每个顶点，在访问其它顶点前，检查当前节点所有邻接点。和树的广度优先遍历类似

BFS执行过程将产生一棵BFS(广度优先搜索)树：

整个BFS的过程如下：

拓扑排序

(DAG)有向无环图可以描述这样一种场景：有一组任务，任务的执行顺序之间具有依赖性，一些任务必须在另一些任务完成之后才开始执行，如下图：

在这种场景下，任务之间的依赖关系不能出现环，否则任何一个都无法开始执行。将一个(DAG)有向无环图中所有顶点在不违反先决条件规定的基础上排成线性序列的过程就是拓扑排序

有2种方法实现拓扑排序：

基于DFS的方法(递归)：当访问某个顶点时，不对这个顶点进行任何处理。当递归返回到这个顶点时，打印这个顶点。这将产生一个逆序的拓扑排序。对其进行一次反序操作就可以得到一个拓扑排序的序列。序列从哪个顶点开始并不重要，只要所有顶点最终都能被访问到
基于BFS的方法(迭代)：首先访问所有的边，计算指向每个顶点的边数(即计算每个顶点的先决条件数目)。将所有没有先决条件的顶点放入队列，然后开始处理队列。当从顶点中删除一个顶点时，把它打印出来，同时将其所有相邻顶点的先决条件计数减1。当某个相邻顶点的计数为 0时，就将其放入队列。如果还有顶点未被打印，而队列已经为空，则图中必然包含回路

最小生成树

最小生成树(MST)是一个包括图G所有顶点及其部分边的图，包括的边是G的子集，满足下列条件：

这个子集中所有边的权之和为所有子集中最小的
子集中的边能保证图是连通的

下面是一个最小生成树的例子：

如果上图中使用边(D,F)代替(C,F)，可得到另一个最小生成树，即最小生成树可能有多个

最小生成树适合解决如下问题：怎样使连接电路板上一系列接头所需焊接的线路最短，或者怎样使得在几个城市之间建立电话网所需的线路最短

Prim算法

原理：从图中任意一个节点N开始，初始化，MST为N。选出与N相关联的边中权最小的一条边，设其连接顶点N与另一个顶点M。把顶点M和边(N,M)加入MST中。接下来，选出与顶点N或顶点M相关联的边中权最小的一条边，设其连接另一个新顶点，将这条边和新顶点添加到MST中。反复进行这样的处理，每一步都选出一条边来扩展MST，这条边是连接当前已在MST中的某个顶点与一个不在MST中的顶点的所有边中代价最小的

证明Prim算法能生成MST：反证法。设图G=(V,E)不能通过Prim算法生成最小生成树。根据Prim算法中各顶点加入MST的顺序，依次定义图G中各顶点为v0,v1,...,v(n-1)。令ei代表边(vx,vi)，其中x<i且i>=1，令ej为Prim算法添加的序号最小的那条(第一条)出现以下情况的边：加入ej后的边集不能被扩展而构成图G的一个MST。换句话说，ej是Prim算法发生错误的第一条边。设T为“真正的”MST。令vp为边ej所关联的顶点，即ej=（vp,vj）
因为T是一个树结构，所以T中将存在一条连接vp和vj的路径，且此路径中一定存在某条边e'连接vu和vw，其中u<j，w>=j。因为ej不是T的一部分，所以把ej加入到T会构成一个回路。又因为Prim算法不能生成一个MST，所以e'的权比ej的权更小。这种情况如下图。但是，Prim算法应选择可能的最小权边，它一定会选择e'，而不是ej。这与Prim算法选错了边ej的假设相矛盾。因此，Prim算法一定是正确的

相关题目：

hihoCoder：1097.最小生成树一·Prim算法