数据结构与算法 on LoveIt

5. 不相交集合

1556824234@qq.com (宋涛) — Sun, 05 Jul 2020 00:00:00 +0000

不相交集合

1. 不相交集合的抽象

在图的最小生成树算法(Kruskal 算法)中我们看到了一个有趣的数据结构，不相交集合(Group ADT)。不相交集合用来对数据进行分组和合并，但不同于Python Set:

4. 图

1556824234@qq.com (宋涛) — Sat, 04 Jul 2020 00:00:00 +0000

图

1. 图的抽象

1.1 图的基本概念

在基础的数据结构中，图应该算的上最复杂的非线性数据结构了，包含了很多专业术语，比如:

顶点，边，权
顶点的度，入度，出度概念比较好理解，就不在此叙述了，我们的重点是如何实现一个图以及图相关的众多算法。

1.2 图的存储

图有两种存储方式:

3. 树

1556824234@qq.com (宋涛) — Fri, 03 Jul 2020 00:00:00 +0000

树

1. 树的抽象

我们都知道树是一种数组组织形式，通过限定树中数据的组织方式，我们可以得到很多树的变种。因此要想学好树，我们就要从最基本的树开始，逐一去了解每种特殊的树的数据组织方式以及他们能提供的操作。

2. 递归

1556824234@qq.com (宋涛) — Thu, 02 Jul 2020 00:00:00 +0000

递归

1. 如何写递归

递归是一种应用非常广泛的算法（或者编程技巧），搞懂递归非常重要。基本上，所有的递归问题都可以用递推公式来表示。要想使用递归解决问题，必需满足三个前提条件:

1. 编程思想

1556824234@qq.com (宋涛) — Wed, 01 Jul 2020 00:00:00 +0000

编程思想

1. 原理

基础的数据结构与算法中，有几块非常难懂，贪心，分治，回溯和动态规划这四个编程思想应该算是"名列前茅"了。本文希望通过详细解答几个经典示例来帮助大家搞懂他们。在进入实战之前，我们先来看看他们的区别。

39 最小生成树

1556824234@qq.com (宋涛) — Wed, 21 Nov 2018 00:00:00 +0000

最小生成树

1. 最小生成树

所谓最小生成树(简称MST)就是在一个无向，有权图G中，找到一颗连接所有顶点的树，并且树包含的边的权重总和最低。最小生成树有两种常见解法:

38 最短路经

1556824234@qq.com (宋涛) — Tue, 20 Nov 2018 00:00:00 +0000

最短路经

1. 最短路径

广度优先算法可以计算连通图中，从一个顶点到另一顶点的最短路径，但前提是图上的每条边的权重相同。那如何计算全重不同的图的最短路径呢？最出名的莫过于 Dijkstra 算法。

37 拓扑排序

1556824234@qq.com (宋涛) — Mon, 19 Nov 2018 00:00:00 +0000

拓扑排序

1. 拓扑排序的背景

拓扑排序是一种排序，假设完成一项任务需要 n 个步骤，这 n 个步骤之间存在依赖关系，拓扑排序就是确定一个满足依赖关系的执行步骤。典型的拓扑排序用于解决如下问题:

36 图的传递闭包

1556824234@qq.com (宋涛) — Sun, 18 Nov 2018 00:00:00 +0000

解决图可达性的传递闭包

1. 场景

通过图上的深度和广度优先搜索算法，我们可以知道顶点 u 到顶点 v 的可达性问题，但是在某些应用中，我们可能希望更高校的回答很多可达性问题。此时对图预计算一个更高效的表示方式是非常值得的，图的传递闭包就是用来解决这个问题。

35 深度和广度优先搜索

1556824234@qq.com (宋涛) — Fri, 16 Nov 2018 00:00:00 +0000

图的深度和广度优先搜索

1. 特性

上一节我们讲解了图的存储和表示，这一节我们来介绍图上的搜索算法。图的搜索方法有很多，最常见的就是深度和广度优先搜索，除此之外还有 A*、IDA* 等启发式搜索算法。因为邻接表更加常用，我们就以邻接表作为图的存储方式来讲解最基础的深度和广度优先算法。

34 图的表示

1556824234@qq.com (宋涛) — Thu, 15 Nov 2018 00:00:00 +0000

如何表示一个图

1. 特性

从本节开始，我们将进入图的学习。图是一种比树更复杂的非线性结构，图中有以下一些专用术语:

顶点: 图中的节点被称为顶点
边: 顶点之间存在链接关系，可以有方向，也可以有权重
有向图: 边有方向的图
带权图: 边存在权重的图
度: 顶点包含的边数，在有向图中，度分为出度和入度

出度表示以顶点作为起点的边，该边也称为顶点的输出边
入度表示以顶点作为终点的边，该边也称为顶点的入射边

很显然在表示和存储一个图时，我们需要保存图的顶点，边，以及边的方向和权重。而图的存储有两个常见方法: 邻接矩阵和邻接表

33 动态规划实战

1556824234@qq.com (宋涛) — Mon, 12 Nov 2018 00:00:00 +0000

编程思想之动态规划实战

1. 动态规划总结

上一篇，我们总结了动态规划的使用场景，以及如何利用动态规划去解决问题了，总结了:

一个模型三个特征: 多阶段决策最优解模型，最优子结构，无后效性，重复子问题
状态转移表法
状态转移方程法

并总结对比了四中编程思想之间的区别。这些东西都非常理论，需要慢慢消化。本文是动态规划的实战篇，也是编程思想系列的最后一篇。

32 动态规划理论

1556824234@qq.com (宋涛) — Sun, 11 Nov 2018 00:00:00 +0000

编程思想之动态规划理论

1. 再论动态规划

动态规划比起其三个算法思想更难懂。上一篇文章我们从实践角度介绍了如何利用动态规划解决问题。有了这个基础，接下来我们来解决如下几个问题:

31 初识动态规划

1556824234@qq.com (宋涛) — Sat, 10 Nov 2018 00:00:00 +0000

编程思想之动态规划初识

1. 动态规划

动态规划是几个编程思想中最难的一个，它与回溯密切相关。回溯问题是在一组可能的解中，搜索满足期望的解；采用的方法类似枚举，找出所有解，筛选符合要求的解；而动态规划比较适合用来求解最优问题，比如求最大值、最小值等等。基本上所有的动态规划问题都能用回溯算法解决，但是动态规划能有效避免回溯算法中的重复计算，提高代码执行效率。

30 回溯算法

1556824234@qq.com (宋涛) — Wed, 07 Nov 2018 00:00:00 +0000

编程思想之回溯算法

1. 回溯算法

回溯算法很多时候都应用在“搜索”这类问题上。即在一组可能的解中，搜索满足期望的解。

回溯的处理思想，有点类似枚举搜索。我们枚举所有的解，找到满足期望的解。为了有规律地枚举所有可能的解，避免遗漏和重复，我们把问题求解的过程分为多个阶段。每个阶段，我们都会面对一个岔路口，我们先随意选一条路走，当发现这条路走不通的时候（不符合期望的解），就回退到上一个岔路口，另选一种走法继续走。

29 分治算法

1556824234@qq.com (宋涛) — Mon, 05 Nov 2018 00:00:00 +0000

编程思想之分治算法

1. 分治算法

分治算法（divide and conquer）的核心思想其实就是四个字，分而治之，也就是将原问题划分成 n 个规模较小，并且结构与原问题相似的子问题，递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

28 贪心算法

1556824234@qq.com (宋涛) — Sun, 04 Nov 2018 00:00:00 +0000

编程思想之贪心算法

1. 贪心算法

前面我们讲完了字符串匹配相关的算法，接下来的几章与编程思想有关，包括贪心，分治，回溯和动态规划。它们都非常抽象，但是理解透了可以帮我们解决很多问题。这些算法在一定程度上很相近，因此学习过程中，我们首先要搞清楚它们的适用场景，其次是掌握怎么运用它们去解决问题。今天，我们先来学习贪心算法。

27 AC 自动机

1556824234@qq.com (宋涛) — Sat, 03 Nov 2018 00:00:00 +0000

敏感词过滤

26 Trie 树

1556824234@qq.com (宋涛) — Fri, 02 Nov 2018 00:00:00 +0000

一组字符串的快速匹配

25 字符串匹配之 BM 算法

1556824234@qq.com (宋涛) — Thu, 01 Nov 2018 00:00:00 +0000

最优匹配的 BM 算法

1. BM 算法

本节我们继续介绍另一个高效的字符串匹配算法 BM(Boyer-Moore)。BM 与 KMP 优化思路类似，都是希望尽可能增加发生不匹配时，模式串后移的位数来提高字符串的匹配效率。BM 要想达到更高的匹配效率，必需利用更多的已知信息。

24 字符串匹配之 KMP 算法

1556824234@qq.com (宋涛) — Wed, 31 Oct 2018 00:00:00 +0000

优雅的的 KMP 算法

1. KMP 算法

BM（Boyer-Moore）和 KMP(Knuth-Morris-Pratt) 都是非常高效的字符串匹配算法。BM 比 KMP 更高效，有实验统计 BM 的性能是 KMP 3-4 倍。但是他们都非常复杂难懂。除了专栏，我也非常推荐你看一看阮一峰老师有关 BM 和 KMP 算法的介绍。因为 BM 算法利用到了KMP的算法思想，本节我们就先来介绍 KMP 的实现。

23 字符串匹配之 BF & RK 算法

1556824234@qq.com (宋涛) — Tue, 30 Oct 2018 00:00:00 +0000

粗暴匹配的 BF 与 RK 算法

1. 特性

从本节开始我们将学习字符串匹配算法。字符串匹配算法有很多，大体可以分成两类:

单模式串匹配算法: 一个串跟一个串进行匹配，包括BF，RK，KMP，BM 算法
多字符串匹配算法: 一个串中同时查找多个串，包括 Trie 树和 AC 自动机

本节我们先来学习“最简单粗暴的” BF 和 RK 算法。为了便于描述，对于在字符串A中查找 B，我们将 A 称为主串，B 称为模式串，n=len(A), m=len(B)。

22 堆的应用

1556824234@qq.com (宋涛) — Mon, 29 Oct 2018 00:00:00 +0000

动态 topK

1. 堆的应用

2. 实现

2.1 合并小文件

2.2 高性能定时器

2.3 动态 topK

2.4 动态求中位数

参考:

21 堆

1556824234@qq.com (宋涛) — Sun, 28 Oct 2018 00:00:00 +0000

能找到"最好学生"的堆

1. 特性

堆是一种特殊的二叉树，它满足如下两个属性:

堆是一完全二叉树
堆中每个节点的值都必需大于等于(或小于等于)其子树中每个节点的值，下称为 Heap-Order

完全二叉树被定义为除了最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列。所以完全二叉树具有如下一些特性:

20 递归树

1556824234@qq.com (宋涛) — Sat, 27 Oct 2018 00:00:00 +0000

利用树计算递归函数的时间复杂度

参考:

王争老师专栏-数据结构与算法之美

19 红黑二叉树

1556824234@qq.com (宋涛) — Fri, 26 Oct 2018 00:00:00 +0000

搞不懂的"红黑数"….

参考:

18 二叉查找树与完全二叉树

1556824234@qq.com (宋涛) — Thu, 25 Oct 2018 00:00:00 +0000

有散列表了，为什么还要"一颗树"

1. 特性

2. 实现

2.1 二叉搜索树

我们实现的二叉搜索树将支持:

标准映射操作:

__setitem__
__getitem__
__delitem__

有序映射操作:

find_lt
find_range

基于位置操作

after(p)
before(p)

from collections import MutableMapping
from linked_tree import LinkedBinaryTree


class MapBase(MutableMapping):
    class _Item(object):
        __slots__ = '_key', '_value'

        def __init__(self, k, v):
            self._key = k
            self._value = v

        def __eq__(self, other):
            return self._key == other._key

        def __lt__(self, other):
            return self._key < other._key

        def __gt__(self, other):
            return self._key > other._key


class TreeMap(LinkedBinaryTree, MapBase):
    class Position(LinkedBinaryTree.Position):
        def key(self):
            return self.element()._key

        def value(self):
            return self.element()._value

    def _subtree_search(self, p, k):
        """
        :param p:
        :param k:
        :return: 在子树中搜索值为 k 的节点，未搜索到返回最后搜索路经的最终位置
        """
        p_value = p.key()
        if p_value == k:
            return p
        elif p_value > k:
            if self.left(p):
                return self._subtree_search(self.left(p), k)
        else:
            if self.right(p):
                return self._subtree_search(self.right(p), k)
        return p

    def _subtree_first_position(self, p):
        """
        :return: 返回子树迭代时，第一个位置节点
        """
        walk = p
        while self.left(walk):
            walk = self.left(walk)
        return walk

    def _subtree_last_position(self, p):
        """
        :param p:
        :return: 返回子树迭代时，最后一个位置节点
        """
        walk = p
        while self.right(walk):
            walk = self.right(walk)
        return walk

    ################# 引导方法 #######################
    def first(self):
        """
        :return: 返回树迭代序列的第一个节点
        """
        return self._subtree_first_position(self.root()) if len(self) > 0 else None

    def last(self):
        """
        :return: 返回树迭代序列的最后一个节点
        """
        return self._subtree_last_position(self.root()) if len(self) > 0 else None

    def before(self, p):
        """
        :param p:
        :return: 返回迭代序列中位于 p 之前的，最大节点
        """
        self._validate(p)
        if self.left(p):
            return self._subtree_last_position(self.left(p))
        else:
            walk = p
            ancestor = self.parent(walk)
            while ancestor and self.left(ancestor) is walk:
                walk = ancestor
                ancestor = self.parent(ancestor)
            return ancestor

    def after(self, p):
        """
        :param p:
        :return: 返回迭代序列中位于 p 之后的，最小节点
        """
        self._validate(p)
        if self.right(p):
            self._subtree_first_position(self.right(p))
        else:
            walk = p
            ancestor = self.parent(walk)
            while ancestor and self.right(ancestor) is walk:
                walk = ancestor
                ancestor = self.parent(ancestor)
            return ancestor

    def find_position(self, k):
        """
        :param k:
        :return: 查找值等于 k 的位置节点
        """
        if self.is_empty():
            return None
        else:
            p = self._subtree_search(self.root(), k)
            # avl 平衡树的钩子函数
            self._rebalance_access(p)
            return p

    ####################### 有序映射 ######################

    def find_min(self):
        """
        :return: 查找树中的最小值
        """
        if self.is_empty():
            return None
        else:
            p = self.first()
            return p.key(), p.value()

    def find_ge(self, k):
        """
        :param k:
        :return: 查找大于等于 k 的最小节点
        """
        p = self.find_position(k)
        if p and p.key() < k:
            p = self.after(p)
        return p.key(), p.value() if p else None, None

    def find_range(self, start, stop):
        """
        :param start:
        :param stop:
        :return: 查找值位于 start <= k < stop 的节点
        """
        if not self.is_empty():
            if start is None:
                p = self.first()
            else:
                p = self.find_position(start)
                if p and p.key() < start:
                    p = self.after(p)
            while p and (stop is None or p.key() < stop):
                yield p.key(), p.value()
                p = self.after(p)

    ########################### 增删改查节点操作 ################

    def __getitem__(self, item):
        """
        :param item:
        :return: 查找 item 映射的值  
        """
        if not self.is_empty():
            p = self.find_position(item)
            self._rebalance_access(p)
            if p.key() == item:
                return p.value()
        raise KeyError('Key Error:' + repr(item))

    def __setitem__(self, key, value):
        """
        :param key:
        :param value:
        :return: 设置键 key 的值为 value
        """
        if self.is_empty():
            leaf = self._add_root(self._Item(key, value))
        else:
            p = self.find_position(key)
            if p.key() == key:
                p.element()._value = value
                self._rebalance_access(p)
                return
            else:
                item = self._Item(key, value)
                if p.key() < key:
                    leaf = self._add_right(p, item)
                else:
                    leaf = self._add_left(p, item)
        self._rebalance_insert(leaf)

    def __iter__(self):
        """
        :return: 产生键的一个迭代
        """
        p = self.first()
        while p:
            yield p.key()
            p = self.after(p)

    def delete(self, p):
        """
        :param p:
        :return: 删除位置节点 p
        """
        self._validate(p)
        if self.left(p) and self.right(p):
            r = self._subtree_last_position(self.left(p))
            self._replace(p, r.element())
            p = r
        parent = self.parent(p)
        self._delete(p)
        self._rebalance_delete(parent)

    def __delitem__(self, key):
        """
        :param key:
        :return: 删除键 key
        """
        if not self.is_empty():
            p = self._subtree_search(self.root(), key)
            if p.key() == key:
                self.delete(p)
                return
            self._rebalance_access(p)
        raise KeyError('Key Error: ' + repr(key))

    ################### 平衡二叉树的钩子函数 ###############
    def _rebalance_delete(self, p):
        pass

    def _rebalance_insert(self, p):
        pass

    def _rebalance_access(self, p):
        pass

参考:

17 树的存储与遍历

1556824234@qq.com (宋涛) — Wed, 24 Oct 2018 00:00:00 +0000

如何表示和存储一颗树？

1. 特性

树是我们接触的第一种非线性结构，在树中一个"父"元素可以有一个或多个"子"元素，这种组织关系要比一个序列中两个元素之间简单的"前",“后"关系更加复杂。

16 哈希算法

1556824234@qq.com (宋涛) — Tue, 23 Oct 2018 00:00:00 +0000

如何使用使用哈希算法？

1 特性

将任意长度的二进制值串映射为固定长度的二进制值串，这个映射的规则就是哈希算法，而通过原始数据映射之后得到的二进制值串就是哈希值。优秀的哈希算法必需满足如下几点要求:

15 散列表与链表

1556824234@qq.com (宋涛) — Mon, 22 Oct 2018 00:00:00 +0000

“形影不离”的散列表与链表

1. 特性

散列表和链表，经常会被放在一起使用。原因是散列表虽然支持高效的数据插入、删除、查找操作，但是散列后的数据都是无序存储的，无法支持按照某种顺序快速地遍历数据。散列表是动态的数据结构，如果每次按序访问都要拷贝到数组，排序然后在遍历，效率太低了。而支持动态创建的链表刚好能解决散列表的有序遍历问题。

14 散列表

1556824234@qq.com (宋涛) — Sun, 21 Oct 2018 00:00:00 +0000

散列表原理

1. 特性

散列表是数组的一种扩展，利用的是数组支持按照下标随机访问的特性，其由三个核心部分组成:

key: 元素的键
hash func: 散列函数，将键隐射为底层数组的下标
table: 底层的数组

13 跳表

1556824234@qq.com (宋涛) — Sat, 20 Oct 2018 00:00:00 +0000

跳表: 链表上的“二分查找”

1. 特性

跳表是一种动态数据结构，支持快速的插入、删除、查找操作，时间复杂度都是 O(logn)。实现上跳表使用空间换时间的思想，通过构建多级索引来提高查询的效率，实现了基于链表的“二分查找”。

11 映射

1556824234@qq.com (宋涛) — Fri, 19 Oct 2018 00:00:00 +0000

无处不在的映射

1. 映射

前面我们讲解了基于数组和链表最基础的数据结构。在继续下面的内容之前，我们先来说一说映射。因为映射与我们接下来的很多数据结构与算法相关。映射可以看作是搜索或查找的扩展，后面介绍的很多数据结构都是为实现快速的增删改查。因此在继续其他数据结构的介绍之前，我想先介绍一下映射的抽象数据类型以及它的常见几种实现方式。

12 二分查找

1556824234@qq.com (宋涛) — Fri, 19 Oct 2018 00:00:00 +0000

不简单的简单二分查找

1. 特性

二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。

10 工业级的排序算法

1556824234@qq.com (宋涛) — Thu, 18 Oct 2018 00:00:00 +0000

实现一个通用的，高效的工业级排序函数

1. 排序算法对比

前面我们介绍了最常见最经典的几个排序算法，它们有不同的时间复杂度，空间复杂度与使用情景。那么如何用它们实现一个通用的、高效率的排序函数呢？

09 线性排序

1556824234@qq.com (宋涛) — Wed, 17 Oct 2018 00:00:00 +0000

非基于比较的三个排序算法: 桶排序，计数排序，基数排序

1. 线性排序

桶排序、计数排序、基数排序的时间复杂度是线性的，所以我们把这类排序算法叫作线性排序（Linear sort）。之所以能做到线性的时间复杂度，主要原因是，这三个算法是非基于比较的排序算法，都不涉及元素之间的比较操作。

08 基于比较的排序(下)

1556824234@qq.com (宋涛) — Tue, 16 Oct 2018 00:00:00 +0000

基于分治编程思想的归并排序和快速排序

1. 分治

前面讲到的三种排序算法，平均时间复杂度都是 O(n2)，只是适合规模较小的数剧集，接下来要讲的归并排序和快速排序，平均时间复杂度都是 O(nlogn)，它们都用到了分治思想。

07 基于比较的排序(上)

1556824234@qq.com (宋涛) — Sun, 14 Oct 2018 00:00:00 +0000

基于比较的排序算法: 冒泡排序、插入排序和选择排序

1. 排序算法要点

排序算法太多了，因此除了要学习各种算法的原理，代码实现之外；我们还要搞明白如何比较和分析一个排序算法。评价一个算法可以从如下几个方面入手:

06 递归

1556824234@qq.com (宋涛) — Sat, 13 Oct 2018 00:00:00 +0000

递归是一种应用非常广泛的算法（或者编程技巧）。很多数据结构和算法的编码实现都要用到递归，比如 DFS 深度优先搜索、前中后序二叉树遍历等等。所以，搞懂递归非常重要。

05 队列

1556824234@qq.com (宋涛) — Fri, 12 Oct 2018 00:00:00 +0000

先进者先出，这就是典型的"队列"。

1. 特性

我们知道，栈只支持两个基本操作：入栈 push()，出栈 pop()，队列与栈类似基本操作只有两个: 入队 enqueue() 向对尾添加一个数据，出队 dequeue() 从队列头部取出一个数据。

04 栈

1556824234@qq.com (宋涛) — Thu, 11 Oct 2018 00:00:00 +0000

后进者先出，先进者后出，这就是典型的“栈”结构。

1. 特性

栈是一种“操作受限”的线性表，只允许在一端插入和删除数据。主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据和从栈顶删除一个数据。

03 链表

1556824234@qq.com (宋涛) — Wed, 10 Oct 2018 00:00:00 +0000

相比于数组必需使用连续的内存空间，链表通过“指针”将一组零散的内存块串联起来使用，因此更加灵活。

1. 特性

我们知道数组受限于保持数据的连续，插入和删除都需要移动大量的数据，而在链表中插入或者删除一个数据，我们并不需要为了保持内存的连续性而搬移结点，因为链表的存储空间本身就不是连续的。所以，在链表中插入和删除一个数据是非常快速的。

02 数组

1556824234@qq.com (宋涛) — Mon, 08 Oct 2018 00:00:00 +0000

数组和链表应该是数据结构与算法中最基础的数据结构。与链表相比，数组更加简单，所以相比于数组的实现和与之相关的算法，充分认识数组的内在特性反而更加重要。

01 数据结构与算法学习开篇

1556824234@qq.com (宋涛) — Sun, 07 Oct 2018 00:00:00 +0000

数据结构与算法前前后后已经学习了很长时间，从一开始看《数据结构与算法分析:C语言描述》，到后来看 Python 相关实现《Problem Solving with Algorithms and Data Structures using Python》，但是一直感觉不得其法。