数据结构与算法复习(持续更新中)

目录

数组

为什么很多编程语言中数组都从0开始编号?

如何实现随机访问

数组和链表的区别

链表

函数调用栈来保存临时变量,为什么函数调用要用“栈”来保存临时变量呢?用其他数据结构不行吗?

什么是栈?

为什么需要栈?

栈实现的复杂度分析

1.数组实现(自动扩容)

2.链表实现

栈的应用

1.栈在函数调用中的应用

2.栈在表达式求值中的应用(比如:34+13*9+44-12/3)

3.栈在括号匹配中的应用(比如:{}{[()]()})

4.如何实现浏览器的前进后退功能?

队列

优化:出队时可以不用搬移数据。如果没有空闲空间了,我们只需要在入队时,再集中触发一次数据的搬移操作。

循环队列,如何判断队空和队满

循环队列解决什么问题

递归

递归需要满足的三个条件

递归代码要警惕堆栈溢出

如何避免出现堆栈溢出

递归代码要警惕重复计算

递归有利有弊

调试递归:

如何将递归改写为非递归代码?

排序

如何分析一个“排序算法”?

排序算法的执行效率

排序算法的内存消耗

排序算法的稳定性

为什么要考察排序算法的稳定性呢?

冒泡排序(Bubble Sort)

第一,冒泡排序是原地排序算法吗?

第二,冒泡排序是稳定的排序算法吗?

第三,冒泡排序的时间复杂度是多少?

有序度

插入排序(Insertion Sort)

第一,插入排序是原地排序算法吗?

第二,插入排序是稳定的排序算法吗?

第三,插入排序的时间复杂度是多少?

选择排序(Selection Sort)

冒泡排序和插入排序的时间复杂度都是O(n2),都是原地排序算法,为什么插入排序要比冒泡排序更受欢迎呢?

特定算法是依赖特定的数据结构的。这几种排序算法,都是基于数组实现的。如果数据存储在链表中,这三种排序算法还能工作吗?如果能,那相应的时间、空间复杂度又是多少呢?

归并排序(Merge Sort)

归并排序的性能分析

快速排序算法(Quicksort)

快排和归并的区别

快速排序的性能分析

O(n)时间复杂度内求无序数组中的第K大元素。

思考题

桶排序(Bucket sort)

桶排序的时间复杂度为什么是O(n)呢?

桶排序看起来很优秀,那它是不是可以替代之前的排序算法呢?

比如说我们有10GB的订单数据,我们希望按订单金额(假设金额都是正整数)进行排序,但是我们的内存有限,只有几百MB,没办法一次性把10GB的数据都加载到内存中。这个时候该怎么办呢?

计数排序(Counting sort)

我们都经历过高考,高考查分数系统你还记得吗?我们查分数的时候,系统会显示我们的成绩以及所在省的排名。如果你所在的省有50万考生,如何通过成绩快速排序得出名次呢?

基数排序(Radix sort)

假设我们有10万个手机号码,希望将这10万个手机号码从小到大排序,你有什么比较快速的排序方法呢?

实际上,有时候要排序的数据并不都是等长的,比如我们排序牛津字典中的英文单词,对于这种不等长的数据,基数排序还适用吗?

思考题

如何选择合适的排序算法?

 为什么归并排序并不常用

如何优化快速排序?

Glibc中的qsort()函数

二分查找

O(logn)惊人的查找速度

关于mid的取值

二分查找应用场景的局限性

如何在1000万个整数中快速查找某个整数?

思考题

二分查找的变体问题

变体一:查找第一个值等于给定值的元素

变体二:查找最后一个值等于给定值的元素

变体三:查找第一个大于等于给定值的元素

变体四:查找最后一个小于等于给定值的元素

如何快速定位出一个IP地址的归属地?

跳表

用跳表查询到底有多快?

跳表是不是很浪费内存?

高效的动态插入和删除

跳表索引动态更新

为什么Redis要用跳表来实现有序集合,而不是红黑树?

散列表

散列冲突

思考题

散列表碰撞攻击的基本原理

如何设计散列函数?

装载因子过大了怎么办?

如何避免低效地扩容?

如何选择冲突解决方法?

工业级散列表举例分析

如何设计的一个工业级的散列函数?

LRU缓存淘汰算法

为什么散列表和链表经常一块使用?

什么是哈希算法?

数据校验

思考题

哈希算法在分布式系统中的应用

二叉树(Binary Tree)

为什么完全二叉树要求最后一层的子节点都靠左?

二叉树的遍历

二叉查找树(Binary Search Tree)

支持重复数据的二叉查找树

二叉查找树的时间复杂度分析

思考题


主要总结自:王争《数据结构与算法之美

本文主要是为了梳理复习流程及记录部分思考题,供读者参考,查漏补缺。

数组

为什么很多编程语言中数组都从0开始编号?

如何实现随机访问

数组和链表的区别

链表

内存中的堆栈数据结构堆栈不是一个概念,可以说内存中的堆栈是真实存在物理区,数据结构中的堆栈是抽象数据存储结构
内存空间在逻辑上分为三部分:代码区静态数据区动态数据区,动态数据区又分为栈区堆区
代码区:存储方法体的二进制代码。高级调度(作业调度)、中级调度(内存调度)、低级调度(进程调度)控制代码区执行代码的切换。

静态数据区:存储全局变量、静态变量、常量 。系统自动分配和回收。
栈区:存储运行方法的形参、局部变量、返回值。由系统自动分配和回收。
堆区: new 一个对象的引用地址存储在栈区,指向该对象存储在堆区中的真实数据

函数调用栈来保存临时变量,为什么函数调用要用“栈”来保存临时变量呢?用其他数据结构不行吗?

什么是栈?

  1. 后进者先出,先进者后出,这就是典型的结构。
  2. 从栈的操作特性来看,是一种操作受限的线性表,只允许在端插入和删除数据。

为什么需要栈?

  1. 栈是一种操作受限的数据结构,其操作特性用数组和链表均可实现。
  2. 但,任何数据结构都是对特定应用场景的抽象,数组和链表虽然使用起来更加灵活,但却暴露了几乎所有的操作,难免会引发错误操作的风险。
  3. 所以,当某个数据集合只涉及在某端插入和删除数据,且满足后进者先出,先进者后出的操作特性时,我们应该首选栈这种数据结构。

栈实现的复杂度分析

1.数组实现(自动扩容)

时间复杂度分析:根据均摊复杂度的定义,可以得数组实现(自动扩容)符合大多数情况是 O(1) 级别复杂度,个别情况是 O(n)级别复杂度,比如自动扩容时 ,会进行完整数据的拷贝。
空间复杂度分析:在入栈和出栈的过程中,只需要一两个临时变量存储空间,所以 O(1)级别。我们说空间复杂度的时候,是指除了原本的数据存储空间外, 算法运行还需要额外的存储空间。

2.链表实现

时间复杂度分析:压栈和弹栈的时间复杂度均为 O(1) 级别,因为只需更改单个节点的索引即可。
空间复杂度分析:在入栈和出栈的过程中,只需要一两个临时变量存储空间,所以 O(1)级别。

栈的应用

1.栈在函数调用中的应用

操作系统给每个线程分配了一块独立的内存空间,这块内存被组织成 ”这种结构,用来存储函数调用时的临时变量。每进入一个函数,就会将其中的临时变量作为栈帧入栈,当被调用函数执行完成,返回之后,将这个函数对应的栈帧出栈。

2.栈在表达式求值中的应用(比如:34+13*9+44-12/3

利用两个栈,其中一个用来保存操作数,另一个用来保存运算符。我们从左向右遍历表达式,当遇到数字,我们就直接压入操作数栈;当遇到运算符,就与运算符栈栈顶元素进行比较,若比运算符栈顶元素优先级高,就将当前运算符压入栈,若比运算符栈顶元素的优先级低或者相同,从运算符栈中取出栈顶运算符,从操作数栈顶取出 2 个操作数,然后进行计算,把计算完的结果压入操作数栈,继续比较。

3.栈在括号匹配中的应用(比如:{}{[()]()}

用栈保存为匹配的左括号,从左到右一次扫描字符串,当扫描到左括号时,则将其压入栈中;当扫描到右括号时,从栈顶取出一个左括号,如果能匹配上,则继续扫描剩下的字符串。如果扫描过程中,遇到不能配对的右括号,或者栈中没有数据,则说明为非法格式。当所有的括号都扫描完成之后,如果栈为空,则说明字符串为合法格式;否则,说明未匹配的左括号为非法格式。

4.如何实现浏览器的前进后退功能?

我们使用两个栈 X Y ,我们把首次浏览的页面依次压如栈 X ,当点击后退按钮时,再依次从 X 出栈,并将出栈的数据一次放入 Y栈。当点击前进按钮时,我们依次从 Y 取出数据放入栈 X 中。当 X 没有数据时,说明没有页面可以继续后退浏览了。当 Y栈没有数据,那就说明没有页面可以点击前进浏览了。

队列

优化:出队时可以不用搬移数据。如果没有空闲空间了,我们只需要在入队时,再集中触发一次数据的搬移操作。

// 入队操作,将item放入队尾
 public boolean enqueue(String item) {
 // tail == n表示队列末尾没有空间了
 if (tail == n) {
 // tail ==n && head==0,表示整个队列都占满了
 if (head == 0) return false;
 // 数据搬移
 for (int i = head; i < tail; ++i) {
 items[i-head] = items[i];
 }
 // 搬移完之后重新更新head和tail
 tail -= head;
 head = 0;
 }
 
 items[tail] = item;
 ++tail;
 return true;

循环队列,如何判断队空和队满

队列为空的判断条件仍然是head == tail

队满时,(tail+1)%n=head

循环队列解决什么问题

在数组实现队列的时候,会有数据搬移操作,要想解决数据搬移的问题,我们就需要像环一样的循环队列。

递归

递归需要满足的三个条件

  1. 一个问题的解可以分解为几个子问题的解
  2. 这个问题与分解之后的子问题,除了数据规模不同,求解思路完全一样
  3. 存在递归终止条件

递归代码要警惕堆栈溢出

函数调用会使用来保存临时变量。每调用一个函数,都会将临时变量封装为栈帧压入内存栈,等函数执行完成返回时,才出栈。系统栈或者虚拟机栈空间一般都不大。如果递归求解的数据规模很大调用层次很深一直压入栈,就会有堆栈溢出的风险。

如何避免出现堆栈溢出

我们可以通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度(比如 1000)之后,我们就不继续往下再递归了,直接返回报错。
// 全局变量,表示递归的深度。
int depth = 0;
int f(int n) {
 ++depth;
 if (depth > 1000) throw exception;
 
 if (n == 1) return 1;
 return f(n-1) + 1;
}
但这种做法并不能完全解决问题,因为最大允许的递归深度跟当前线程剩余的栈空间大小有关,事先无法计算。如果实时计算,代码过于复杂,就会影响代码的可读性。所以,如果最大深度比较小,比如 10 50 ,就可以用这种方法,否则这种方法并不是很实用。

递归代码要警惕重复计算

为了避免重复计算,我们可以通过一个数据结构(比如散列表)来保存已经求解过的 f(k) 。当递归调用到 f(k)时,先看下是否已经求解过了。如果是,则直接从散列表中取值返回,不需要重复计算,这样就能避免了。

递归有利有弊

利是递归代码的表达力很强,写起来非常简洁;
而弊就是空间复杂度高、有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题。

调试递归:

  1. 打印日志发现,递归值。
  2. 结合条件断点进行调试。

如何将递归改写为非递归代码?

笼统的讲,所有的递归代码都可以改写为迭代循环的非递归写法。如何做?抽象出递推公式、初始值和边界条件,然后用迭代循环实现。

排序

排序算法时间复杂度是否基于比较
冒泡、插入、选择O(n²)
快排、归并O(nlogn)
桶、计数、基数O(n)×

如何分析一个排序算法

排序算法的执行效率

1. 最好情况、最坏情况、平均情况时间复杂度
我们在分析排序算法的时间复杂度时,要分别给出最好情况、最坏情况、平均情况下的时间复杂度。除此之外,你还要说出最好、最坏时间复杂度对应的要排序的原始数据是什么样的。
为什么要区分这三种时间复杂度呢?
第一,有些排序算法会区分,为了好对比,所以我们最好都做一下区分。
第二,对于要排序的数据,有的接近有序,有的完全无序。有序度不同的数据,对于排序的执行时间肯定是有影响的,我们要知道排序算法在不同数据下的性能表现。
2. 时间复杂度的系数、常数 、低阶
我们知道,时间复杂度反应的是数据规模 n很大的时候的一个增长趋势,所以它表示的时候会忽略系数、常数、低阶。但是实际的软件开发中,我们排序的可能是 10 个、 100 个、 1000 个这样规模很小的数据,所以,在对同一阶时间复杂度的排序算法性能对比的时候,我们就要把系数、常数、低阶也考虑进来。
3. 比较次数和交换(或移动)次数
基于比较的排序算法的执行过程,会涉及两种操作,一种是元素比较大小,另一种是元素交换或移动。所以,如 果我们在分析排序算法的执行效率的时候,应该把比较次数和交换(或移动)次数也考虑进去。

排序算法的内存消耗

我们前面讲过,算法的内存消耗可以通过空间复杂度来衡量,排序算法也不例外。不过,针对排序算法的空间复杂度,我们还引入了一个新的概念,原地排序( Sorted in place )。原地排序算法,就是特指空间复杂度是 O(1) 的排序算法。我们今天讲的三种排序算法,都是原地排序算法。

排序算法的稳定性

仅仅用执行效率和内存消耗来衡量排序算法的好坏是不够的。针对排序算法,我们还有一个重要的度量指标,稳定性。这个概念是说,如果待排序的序列中存在值相等的元素经过排序之后,相等元素之间原有的先后顺序不变

为什么要考察排序算法的稳定性呢?

很多数据结构和算法课程,在讲排序的时候,都是用整数来举例,但在真正软件开发中,我们要排序的往往不是单纯的整数,而是一组对象,我们需要按照对象的某个 key 来排序。
 
比如说,我们现在要给电商交易系统中的 订单 排序。订单有两个属性,一个是下单时间,另一个是订单金额。如果我们现在有 10万条订单数据,我们希望按照金额从小到大对订单数据排序。对于金额相同的订单,我们希望按照下单时间从早到晚有序。对于这样一个排序需求,我们怎么来做呢?
最先想到的方法是:我们先按照金额对订单数据进行排序,然后,再遍历排序之后的订单数据,对于每个金额相同的小区间再按照下单时间排序。这种排序思路理解起来不难,但是实现起来会很复杂。
借助稳定排序算法,这个问题可以非常简洁地解决。解决思路是这样的:我们先按下单时间给订单排序,注意是按照下单时间,不是金额。排序完成之后,我们用稳定排序算法,按照订单金额重新排序。两遍排序之后,我们得到的订单数据就是按照金额从小到大排序金额相同的订单按照下单时间从早到晚排序的。
为什么呢?
稳定排序算法可以保持金额相同的两个对象,在排序之后的前后顺序不变。第一次排序之后,所有的订单按照下单时间从早到晚有序了。在第二次排序中,我们用的是稳定的排序算法,所以经过第二次排序之后,相同金额的订单仍然保持下单时间从早到晚有序。

冒泡排序(Bubble Sort

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。

优化:当某次冒泡操作已经没有数据交换时,说明已经达到完全有序,不用再继续执行后续的冒泡操作。
 

第一,冒泡排序是原地排序算法吗?

冒泡的过程只涉及相邻数据的交换操作,只需要常量级的临时空间,所以它的空间复杂度为 O(1) 一个原地排序算法。

第二,冒泡排序是稳定的排序算法吗?

在冒泡排序中,只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性,当有相邻的两个元素大小相等的时候,我们不做交换,相同大小的数据在排序前后不会改变顺序,所以冒泡排序是稳定的排序算法。

第三,冒泡排序的时间复杂度是多少?

最好情况下,要排序的数据已经是有序的了,我们只需要进行一次冒泡操作,就可以结束了,所以最好情况时间复杂度是 O(n)。而最坏的情况是,要排序的数据刚好是倒序排列的,我们需要进行 n 次冒泡操作,所以最坏情况时间复杂度为 O(n²)

有序度

有序度是数组中具有有序关系元素对个数
有序元素对: a[i] <= a[j], 如果 i < j
对于一个倒序排列的数组,比如 6 5 4 3 2 1 ,有序度是 0 ;对于一个完全有序的数组,比如 1 2 3 4 5 6 ,有序度就是 n*(n-1)/2 ,也就是 15。我们把这种完全有序的数组的有序度叫作满有序度
逆序度 = 满有序度 - 有序度
冒泡排序包含两个操作原子比较交换。每交换一次有序度就加 1 。不管算法怎么改进,交换次数总是确定的,即为逆序度,也就是 n*(n-1)/2– 初始有序度。
此例中就是 15–3=12 ,要进行 12 次交换操作。
// 冒泡排序,a表示数组,n表示数组大小
public void bubbleSort(int[] a, int n) {
 if (n <= 1) return;
 for (int i = 0; i < n; ++i) {
 // 提前退出冒泡循环的标志位
 boolean flag = false;
 for (int j = 0; j < n - i - 1; ++j) {
 if (a[j] > a[j+1]) { // 交换
 int tmp = a[j];
 a[j] = a[j+1];
 a[j+1] = tmp;
 flag = true; // 表示有数据交换 
 }
 }
 if (!flag) break; // 没有数据交换,提前退出
 }
}

插入排序(Insertion Sort

首先,我们将数组中的数据分为两个区间已排序区间和未排序区间。初始已排序区间只有一个元素,就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素,在已排序区间中找到合适的插入位置将其插入,并保证已排序区间数据一直有序。重复这个过程,直到未排序区间中元素为空,算法结束。

如图所示,要排序的数据是 4 5 6 1 3 2 ,其中左侧为已排序区间,右侧是未排序区间
插入排序也包含两种操作,一种是元素的比较,一种是元素的移动。当我们需要将一个数据 a 插入到已排序区间时,需要拿 a与已排序区间的元素依次比较大小,找到合适的插入位置。找到插入点之后,我们还需要将插入点之后的元素顺序往后移动一位,这样才能腾出位置给元素插入。
对于不同的查找插入点方法(从头到尾、从尾到头),元素的比较次数是有区别的。但对于一个给定的初始序列,移动操作的次数总是固定的,就等于逆序度。
// 插入排序,a表示数组,n表示数组大小
public void insertionSort(int[] a, int n) {
 if (n <= 1) return;
 for (int i = 1; i < n; ++i) {
     int value = a[i];
     int j = i - 1;
     // 查找插入的位置
     for (; j >= 0; --j) {
         if (a[j] > value) {
             a[j+1] = a[j]; // 数据移动
         } 
     else {
         break;
     }
 }
 a[j+1] = value; // 插入数据
 }
}

第一,插入排序是原地排序算法吗?

从实现过程可以很明显地看出,插入排序算法的运行并不需要额外的存储空间,所以空间复杂度是 O(1) ,也就是说,这一个原地排序算法。

第二,插入排序是稳定的排序算法吗?

在插入排序中,对于值相同的元素,我们可以选择将后面出现的元素,插入到前面出现元素的后面,这样就可以保持原有的前后顺序不变,所以插入排序稳定的排序算法。

第三,插入排序的时间复杂度是多少?

如果要排序的数据已经是有序的,我们并不需要搬移任何数据。如果我们从尾到头在有序数据组里面查找插入位置,每次只需要比较一个数据就能确定插入的位置。所以这种情况下,最好是时间复杂度为 O(n) 。注意,这里是从尾到头遍历已经有序的数据。
如果数组是倒序的,每次插入都相当于在数组的第一个位置插入新的数据,所以需要移动大量的数据,所以最坏情况时间复杂度为 O(n²)
还记得我们在数组中插入一个数据的平均时间复杂度是多少吗?没错,是 O(n)。所以,对于插入排序来说,每次插入操作都相当于在数组中插入一个数据,循环执行 n 次插入操作,所以平均时间复杂度为 O(n ² )

选择排序(Selection Sort

选择排序算法的实现思路有点类似插入排序,也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素,将其放到已排序区间的末尾
选择排序空间复杂度为 O(1) 一种原地排序算法
选择排序的最好情况时间复杂度、最坏情况和平均情况时间复杂度都为 O(n²)
选择排序是一种不稳定的排序算法。从前面的图中,可以看出来,选择排序每次都要找剩余未排序元素中的最小值,并和前面的元素交换位置,这样破坏了稳定性
比如 5 8 5 2 9 这样一组数据,使用选择排序算法来排序的话,第一次找到最小元素 2 ,与第一个 5 交换位置,那第一个 5 和中间的 5顺序就变了,所以就不稳定了。正是因此,相对于冒泡排序和插入排序,选择排序稍微逊色了。

冒泡排序和插入排序的时间复杂度都是O(n2),都是原地排序算法,为什么插入排序要比冒泡排序更受欢迎呢?

冒泡排序不管怎么优化,元素交换的次数是一个固定值,是原始数据的逆序度。插入排序是同样的,不管怎么优化,元素移动的次数也等于原始数据的逆序度。
但是,从代码实现上来看,冒泡排序的数据交换要比插入排序的数据移动要复杂,冒泡排序需要 3 个赋值操作,而插入排序只需要 1
 
我们把执行一个赋值语句的时间粗略地计为单位时间( unit_time ),然后分别用冒泡排序和插入排序对同一个逆序度是 K 的数组进行排序。用冒泡排序,需要 K次交换操作,每次需要 3 个赋值语句,所以交换操作总耗时就是 3*K 单位时间。而插入排序中数据移动操作只需要 K 个单位时间。
这个只是我们非常理论的分析,为了实验,针对上面的冒泡排序和插入排序的 Java 代码,我写了一个性能对比测试程序,随机生成 10000个数组,每个数组中包含 200 个数据,然后在某机器上分别用冒泡和插入排序算法来排序,冒泡排序算法大约 700ms 才能执行完成,而插入排序只需要 100ms 左右就能搞定!
这三种排序算法,实现代码都非常简单,对于小规模数据的排序,用起来非常高效。但是在大规模数据排序的时候,这个时间复杂度还是稍微有点高, 所以我们更倾向于时间复杂度为 O(nlogn) 的排序算法。

特定算法是依赖特定的数据结构的。这几种排序算法,都是基于数组实现的。如果数据存储在链表中,这三种排序算法还能工作吗?如果能,那相应的时间、空间复杂度又是多少呢?

应该有个前提,是否允许修改链表的节点value值,还是只能改变节点的位置。一般而言,考虑只能改变节点位置
冒泡排序相比于数组实现,比较次数一致,但交换时操作更复杂
插入排序比较次数一致不需要再有后移操作,找到位置后可以直接插入,但排序完毕后可能需要倒置链表
选择排序,比较次数一致交换操作同样比较麻烦
综上,时间复杂度和空间复杂度并无明显变化,若追求极致性能,冒泡排序的时间复杂度系数会变大插入排序系数会减小选择排序无明显变化

归并排序(Merge Sort

归并排序的核心思想还是蛮简单的。如果要排序一个数组,我们先把数组从中间分成前后两部分,然后对前后两部分分别排序,再将排好序的两部分合并在一起,这样整个数组就都有序了。

 

// 归并排序算法, A是数组,n表示数组大小
merge_sort(A, n) {
 merge_sort_c(A, 0, n-1)
}
// 递归调用函数
merge_sort_c(A, p, r) {
 // 递归终止条件
 if p >= r then return
 // 取p到r之间的中间位置q
 q = (p+r) / 2
 // 分治递归
 merge_sort_c(A, p, q)
 merge_sort_c(A, q+1, r)
 // 将A[p...q]和A[q+1...r]合并为A[p...r]
 merge(A[p...r], A[p...q], A[q+1...r])
}

merge(A[p…r], A[p…q], A[q+1…r])这个函数的作用就是,将已经有序的A[p…q]和A[q+1…r]合并成一个有序的数组,并且放入A[p…r]。那这过程具体该如何做呢?

如图所示,我们申请一个临时数组tmp,大小与A[p…r]相同。我们用两个游标i和j,分别指向A[p…q]和A[q+1…r]的第一个元素。比较这两个元素A[i]和A[j],如果A[i]<=A[j],我们就把A[i]放入到临时数组tmp,并且i后移一位,否则将A[j]放入到数组tmp,j后移一位。

继续上述比较过程,直到其中一个子数组中的所有数据都放入临时数组中,再把另一个数组中的数据依次加入到临时数组的末尾,这个时候,临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组tmp中的数据拷贝到原数组A[p…r]中。

merge(A[p...r], A[p...q], A[q+1...r]) {
var i := p,j := q+1,k := 0 //初始化变量i, j, k
var tmp := new array[0...r-p] //申请一个大小跟A[p...r]一样的临时数组
while i<=q AND j<=r do {
if A[i] <= A[j] {
tmp[k++] = A[i++] // i++等于i:=i+1
} else {
tmp[k++] = A[j++]
}
}
//判断哪个子数组中有剩余的数据
var start := i,end := q
if j<=r then start := j, end:=r
//将剩余的数据拷贝到临时数组tmp
while start <= end do {
tmp[k++] = A[start++]
}
//将tmp中的数组拷贝回A[p...r]
for i:=0 to r-p do {
A[p+i] = tmp[i]
}
}

归并排序的性能分析

第一,归并排序是稳定的排序算法吗?
归并排序稳不稳定关键要看merge()函数,也就是两个有序子数组合并成一个有序数组的那部分代码。
在合并的过程中,如果A[p…q]和A[q+1…r]之间有值相同的元素,那我们可以像伪代码中那样,先把A[p…q]中的元素放入tmp数组。这样就保证了值相同的元素,在合并前后的先后顺序不变。所以,归并排序是一个稳定的排序算法。

第二,归并排序的时间复杂度是多少?
归并排序涉及递归,时间复杂度的分析稍微有点复杂。

我们假设对n个元素进行归并排序需要的时间是T(n),那分解成两个子数组排序的时间都是T(n/2)。我们知道,merge()函数合并两个有序子数组的时间复杂度
是O(n)。所以,套用前面的公式,归并排序的时间复杂度的计算公式就是:
T(1) = C;n=1时,只需要常量级的执行时间,所以表示为C。
T(n) = 2*T(n/2) + n;n>1

通过这个公式,如何来求解T(n)呢?还不够直观?那我们再进一步分解一下计算过程。

T(n) = 2*T(n/2) + n
= 2*(2*T(n/4) + n/2) + n = 4*T(n/4) + 2*n
= 4*(2*T(n/8) + n/4) + 2*n = 8*T(n/8) + 3*n
= 8*(2*T(n/16) + n/8) + 3*n = 16*T(n/16) + 4*n
......
= 2^k * T(n/2^k) + k * n

通过这样一步一步分解推导,我们可以得到T(n) = 2^kT(n/2^k)+kn。当T(n/2^k)=T(1)时,也就是n/2^k=1,我们得到k=log2n。我们将k值代入上面的公式,得到T(n)=Cn+nlog2n。如果我们用大O标记法来表示的话,T(n)就等于O(nlogn)。所以归并排序的时间复杂度是O(nlogn)。

从我们的原理分析和伪代码可以看出,归并排序的执行效率与要排序的原始数组的有序程度无关,所以其时间复杂度是非常稳定的,不管是最好情况、最坏情况,还是平均情况,时间复杂度都是O(nlogn)。

第三,归并排序的空间复杂度是多少?

归并排序的时间复杂度任何情况下都是O(nlogn),看起来非常优秀。(待会儿你会发现,即便是快速排序最坏情况下,时间复杂度也是O(n²)。)但是,归并排序并没有像快排那样,应用广泛,这是为什么呢?因为它有一个致命的“弱点”,那就是归并排序不是原地排序算法
这是因为归并排序的合并函数,在合并两个有序数组为一个有序数组时,需要借助额外的存储空间。这一点应该很容易理解。那归并排序的空间复杂度到底是多少呢?是O(n),还是O(nlogn),应该如何分析呢?
如果我们继续按照分析递归时间复杂度的方法,通过递推公式来求解,那整个归并过程需要的空间复杂度就是O(nlogn)。不过,类似分析时间复杂度那样来分析空间复杂度,这个思路对吗?
实际上,递归代码的空间复杂度并不能像时间复杂度那样累加。刚刚我们忘记了最重要的一点,那就是,尽管每次合并操作都需要申请额外的内存空间,但在合并完成之后,临时开辟的内存空间被释放掉了。在任意时刻,CPU只会有一个函数在执行,也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过n个数据的大小,所以空间复杂度是O(n)

快速排序算法(Quicksort)

快排利用的也是分治思想。乍看起来,它有点像归并排序,但是思路其实完全不一样。

快排的思想是这样的:如果要排序数组中下标从p到r之间的一组数据,我们选择p到r之间的任意一个数据作为pivot(分区点)

我们遍历p到r之间的数据,将小于pivot的放到左边,将大于pivot的放到右边,将pivot放到中间。经过这一步骤之后,数组p到r之间的数据就被分成了三个部分,前面p到q-1之间都是小于pivot的,中间是pivot,后面的q+1到r之间是大于pivot的。 

根据分治、递归的处理思想,我们可以用递归排序下标从p到q-1之间的数据和下标从q+1到r之间的数据,直到区间缩小为1,就说明所有的数据都有序了

递推公式:
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1, r)
终止条件:
p >= r

//快速排序,A是数组,n表示数组的大小
quick_sort(A, n) {
quick_sort_c(A, 0, n-1)
}
//快速排序递归函数,p,r为下标
quick_sort_c(A, p, r) {
if p >= r then return
q = partition(A, p, r) //获取分区点
quick_sort_c(A, p, q-1)
quick_sort_c(A, q+1, r)
}

归并排序中有一个merge()合并函数,我们这里有一个partition()分区函数,就是随机选择一个元素作为pivot(一般情况下,可以选择p到r区间的最后一个元素),然后对A[p…r]分区,函数返回pivot的下标。
如果我们不考虑空间消耗的话,partition()分区函数可以写得非常简单。我们申请两个临时数组X和Y,遍历A[p…r],将小于pivot的元素都拷贝到临时数组X,将大于pivot的元素都拷贝到临时数组Y,最后再将数组X和数组Y中数据顺序拷贝到A[p…r]。

但是,如果按照这种思路实现的话,partition()函数就需要很多额外的内存空间,所以快排就不是原地排序算法了。如果我们希望快排是原地排序算法,那它的空间复杂度得是O(1),那partition()分区函数就不能占用太多额外的内存空间,我们就需要在A[p…r]的原地完成分区操作。

partition(A, p, r) {
pivot := A[r]
i := p
for j := p to r-1 do {
if A[j] < pivot {
swap A[i] with A[j]
i := i+1
}
}
swap A[i] with A[r]
return i

这里的处理有点类似选择排序。我们通过游标i把A[p…r-1]分成两部分。A[p…i-1]的元素都是小于pivot的,我们暂且叫它“已处理区间”,A[i…r-1]是“未处理区间”。我们每次都从未处理的区间A[i…r-1]中取一个元素A[j],与pivot对比,如果小于pivot,则将其加入到已处理区间的尾部,也就是A[i]的位置。
数组的插入操作还记得吗?在数组某个位置插入元素,需要搬移数据,非常耗时。当时我们也讲了一种处理技巧,就是交换,在O(1)的时间复杂度内完成插入操作。这里我们也借助这个思想,只需要将A[i]与A[j]交换,就可以在O(1)时间复杂度内将A[j]放到下标为i的位置。

j++;        if(swap) i++;

因为分区的过程涉及交换操作,如果数组中有两个相同的元素,比如序列6,8,7,6,3,5,9,4,在经过第一次分区操作之后,两个6的相对先后顺序就会改变。所以,快速排序并不是一个稳定的排序算法。

快排和归并的区别

可以发现,归并排序的处理过程是由下到上的,先处理子问题,然后再合并。而快排正好相反,它的处理过程是由上到下的,先分区,然后再处理子问题。归并排序虽然是稳定的、时间复杂度为O(nlogn)的排序算法,但是它是非原地排序算法。我们前面讲过,归并之所以是非原地排序算法,主要原因是合并函数无法在原地执行快速排序通过设计巧妙的原地分区函数,可以实现原地排序,解决了归并排序占用太多内存的问题。

快速排序的性能分析

快排也是用递归来实现的。对于递归代码的时间复杂度,我前面总结的公式,这里也还是适用的。如果每次分区操作,都能正好把数组分成大小接近相等的两个小区间,那快排的时间复杂度递推求解公式跟归并是相同的。所以,快排的时间复杂度也是O(nlogn)。

但是,公式成立的前提是每次分区操作,我们选择的pivot都很合适,正好能将大区间对等地一分为二。但实际上这种情况是很难实现的。
我举一个比较极端的例子。如果数组中的数据原来已经是有序的了,比如1,3,5,6,8。如果我们每次选择最后一个元素作为pivot,那每次分区得到的两个区间都是不均等的。我们需要进行大约n次分区操作,才能完成快排的整个过程。每次分区我们平均要扫描大约n/2个元素,这种情况下,快排的时间复杂度就从O(nlogn)退化成了O(n²)

O(n)时间复杂度内求无序数组中的第K大元素。

比如,4,2,5,12,3这样一组数据,第3大元素就是4。
我们选择数组区间A[0…n-1]的最后一个元素A[n-1]作为pivot,对数组A[0…n-1]原地分区,这样数组就分成了三部分,A[0…p-1]、A[p]、A[p+1…n-1]。
如果p+1=K,那A[p]就是要求解的元素;如果K>p+1,说明第K大元素出现在A[p+1…n-1]区间,我们再按照上面的思路递归地在A[p+1…n-1]这个区间内查找。同理,如果K<p+1,那我们就在A[0…p-1]区间查找。

我们再来看,为什么上述解决思路的时间复杂度是O(n)?
第一次分区查找,我们需要对大小为n的数组执行分区操作,需要遍历n个元素。第二次分区查找,我们只需要对大小为n/2的数组执行分区操作,需要遍历n/2个元素。依次类推,分区遍历元素的个数分别为、n/2、n/4、n/8、n/16.……直到区间缩小为1。
如果我们把每次分区遍历的元素个数加起来,就是:n+n/2+n/4+n/8+…+1。这是一个等比数列求和,最后的和等于2n-1。所以,上述解决思路的时间复杂度就为O(n)。

思考题

现在你有10个接口访问日志文件,每个日志文件大小约300MB,每个文件里的日志都是按照时间戳从小到大排序的。你希望将这10个较小的日志文件,合并为1个日志文件,合并之后的日志仍然按照时间戳从小到大排列。如果处理上述排序任务的机器内存只有1GB,你有什么好的解决思路,能“快速”地将这10个日志文件合并吗?

先构建十条io流,分别指向十个文件,每条io流读取对应文件的第一条数据,然后比较时间戳,选择出时间戳最小的那条数据,将其写入一个新的文件,然后指向该时间戳的io流读取下一行数据,然后继续刚才的操作,比较选出最小的时间戳数据,写入新文件,io流读取下一行数据,以此类推,完成文件的合并,这种处理方式,日志文件有n个数据就要比较n次,每次比较选出一条数据来写入,时间复杂度是O(n),空间复杂度是O(1),几乎不占用内存。

桶排序(Bucket sort

核心思想是将要排序的数据分到几个有序的桶里,每个桶里的数据再单独进行排序。桶内排完序之后,再把每个桶里的数据按照顺序依次取出,组成的序列就是有序的了。

桶排序的时间复杂度为什么是O(n)呢?

如果要排序的数据有 n 个,我们把它们均匀地划分到 m 个桶内,每个桶里就有 k=n/m 个元素。每个桶内部使用快速排序,时间复杂度为 O(k * logk) m个桶排序的时间复杂度就是 O(m * k * logk) ,因为 k=n/m ,所以整个桶排序的时间复杂度就是 O(n*log(n/m)) 。当桶的个数 m 接近数据个数 n 时, log(n/m)就是一个非常小的常量,这个时候桶排序的时间复杂度接近 O(n)

桶排序看起来很优秀,那它是不是可以替代之前的排序算法呢?

实际上,桶排序对要排序数据的要求是非常苛刻的。
首先,要排序的数据需要很容易就能划分成 m个桶,并且,桶与桶之间有着天然的大小顺序。这样每个桶内的数据都排序完之后,桶与桶之间的数据不需要再进行排序。
其次,数据在各个桶之间的分布是比较均匀的。如果数据经过桶的划分之后,有些桶里的数据非常多,有些非常少,很不平均,那桶内数据排序的时间复杂度就不是常量级了。在极端情况下,如果数据都被划分到一个桶里,那就退化为 O(nlogn) 的排序算法了。
桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中,数据量比较大,内存有限,无法将数据全部加载到内存中。

比如说我们有10GB的订单数据,我们希望按订单金额(假设金额都是正整数)进行排序,但是我们的内存有限,只有几百MB,没办法一次性把10GB的数据都加载到内存中。这个时候该怎么办呢?

我们可以先扫描一遍文件,看订单金额所处的数据范围。假设经过扫描之后我们得到,订单金额最小 1 元,最大 10万元。我们将所有订单根据金额划分到 100 个桶里,第一个桶我们存储金额在 1 元到 1000 元之内的订单,第二桶存储金额在 1001 元到 2000元之内的订单,以此类推。每一个桶对应一个文件,并且按照金额范围的大小顺序编号命名( 00 01 02…99 )。
理想的情况下,如果订单金额在 1 10 万之间均匀分布,那订单会被均匀划分到 100 个文件中,每个小文件中存储大约 100MB 的订单数据,我们就可以将这100个小文件依次放到内存中,用快排来排序。等所有文件都排好序之后,我们只需要按照文件编号从小到大依次读取每个小文件中的订单数据,并将其写入到一个文件中,那这个文件中存储的就是按照金额从小到大排序的订单数据了。
不过,订单按照金额在 1 元到 10 万元之间并不一定是均匀分布的 ,所以 10GB 订单数据是无法均匀地被划分到 100个文件中的。有可能某个金额区间数据特别多,划分之后对应的文件就会很大,没法一次性读入内存。这又该怎么办呢?
针对这些划分之后还是比较大的文件,我们可以继续划分,比如,订单金额在 1 元到 1000 元之间的比较多,我们就将这个区间继续划分为 10 个小区间, 1元到 100 元, 101 元到 200 元, 201 元到 300 …901 元到 1000 元。如果划分之后, 101 元到 200元之间的订单还是太多,无法一次性读入内存,那就继续再划分,直到所有的文件都能读入内存为止。

计数排序(Counting sort

我们都经历过高考,高考查分数系统你还记得吗?我们查分数的时候,系统会显示我们的成绩以及所在省的排名。如果你所在的省有50万考生,如何通过成绩快速排序得出名次呢?

考生的满分是 900 分,最小是 0 分,这个数据的范围很小,所以我们可以分成 901 个桶,对应分数从 0 分到 900 分。根据考生的成绩,我们将这 50万考生划分到这 901 个桶里。桶内的数据都是分数相同的考生,所以并不需要再进行排序。我们只需要依次扫描每个桶,将桶内的考生依次输出到一个数组中,就实现了 50万考生的排序。因为只涉及扫描遍历操作,所以时间复杂度是 O(n)

计数排序的算法思想跟桶排序非常类似,只是桶的大小粒度不一样。不过,为什么这个排序算法叫计数排序呢?计数的含义来自哪里呢?

假设只有8个考生,分数在0到5分之间。这8个考生的成绩我们放在一个数组A[8]中,它们分别是:2,5,3,0,2,3,0,3。

考生的成绩从0到5分,我们使用大小为6的数组C[6]表示,其中下标对应分数。不过,C[6]内存储的并不是考生,而是对应的考生个数,我们只需要遍历一遍考生分数,就可以得到C[6]的值。

从图中可以看出,分数为3分的考生有3个,小于3分的考生有4个,所以,成绩为3分的考生在排序之后的有序数组R[8]中,会保存下标4,5,6的位置。

 

那我们如何快速计算出,每个分数的考生在有序数组中对应的存储位置呢?

我们对C[6]数组顺序求和,C[6]存储的数据就变成了下面这样子。C[k]里存储小于等于分数k的考生个数。

我们从后到前依次扫描数组A。比如,当扫描到3时,我们可以从数组C中取出下标为3的值7,也就是说,到目前为止,包括自己在内,分数小于等于3的考生有7个,也就是说3是数组R中的第7个元素(也就是数组R中下标为6的位置)。当3放入到数组R中后,小于等于3的元素就只剩下了6个了,所以相应的C[3]要减1,变成6。

以此类推,当我们扫描到第2个分数为3的考生的时候,就会把它放入数组R中的第6个元素的位置(也就是下标为5的位置)。当我们扫描完整个数组A后,数组R内的数据就是按照分数从小到大有序排列的了。

// 计数排序,a是数组,n是数组大小。假设数组中存储的都是非负整数。
public void countingSort(int[] a, int n) {
 if (n <= 1) return;
 // 查找数组中数据的范围
 int max = a[0];
 for (int i = 1; i < n; ++i) {
 if (max < a[i]) {
 max = a[i];
 }
 }
 int[] c = new int[max + 1]; // 申请一个计数数组c,下标大小[0,max]
 for (int i = 0; i <= max; ++i) {
 c[i] = 0;
 }
 // 计算每个元素的个数,放入c中
 for (int i = 0; i < n; ++i) {
 c[a[i]]++;
 }
 // 依次累加
 for (int i = 1; i <= max; ++i) {
 c[i] = c[i-1] + c[i];
 }
 // 临时数组r,存储排序之后的结果
 int[] r = new int[n];
 // 计算排序的关键步骤,有点难理解
 for (int i = n - 1; i >= 0; --i) {
 int index = c[a[i]]-1;
 r[index] = a[i];
 c[a[i]]--;
 }
 // 将结果拷贝给a数组
 for (int i = 0; i < n; ++i) {
 a[i] = r[i];
 }
}

计数排序只能用在数据范围不大的场景中,如果数据范围k要排序的数据n大很多,就不适合用计数排序了。而且,计数排序只能给非负整数排序,如果要排序的数据是其他类型的,要将其在不改变相对大小的情况下,转化为非负整数。比如,如果考生成绩精确到小数后一位,我们就需要将所有的分数都先乘以10,转化成整数,然后再放到9010个桶内。再比如,如果要排序的数据中有负数,数据的范围是[-1000, 1000],那我们就需要先对每个数据都1000,转化成非负整数。

基数排序(Radix sort

假设我们有10万个手机号码,希望将这10万个手机号码从小到大排序,你有什么比较快速的排序方法呢?

快排时间复杂度可以做到O(nlogn),还有更高效的排序算法吗?桶排序、计数排序能派上用场吗?手机号码有11位,范围太大,显然不适合用这两种排序算法。针对这个排序问题,有没有时间复杂度是O(n)的算法呢?这时候就要用到基数排序。

这个问题里有这样的规律:假设要比较两个手机号码a,b的大小,如果在前面几位中,a手机号码已经比b手机号码大了,那后面的几位就不用看了。

那么可以先按照最后一位来排序手机号码,然后,再按照倒数第二位重新排序,以此类推,最后按照第一位重新排序。经过11次排序之后,手机号码就都有序了。

 

注意,这里按照每位来排序的排序算法必须是稳定的,否则这个实现思路就是不正确的。因为如果是非稳定排序算法,那最后一次排序只会考虑最高位的大小顺序,完全不管其他位的大小关系,那么低位的排序完全没有意义了。

根据每一位来排序,我们可以用刚讲过的桶排序或者计数排序,它们的时间复杂度可以做到O(n)。如果要排序的数据有k位,那我们就需要k次桶排序或者计数排序,总的时间复杂度是O(k*n)。当k不大的时候,比如手机号码排序的例子,k最大就是11,所以基数排序的时间复杂度就近似于O(n)。

实际上,有时候要排序的数据并不都是等长的,比如我们排序牛津字典中的英文单词,对于这种不等长的数据,基数排序还适用吗?

实际上,我们可以把所有的单词补齐到相同长度,位数不够的可以在后面补“0”,因为根据ASCII值,所有字母都大于“0”,所以补“0”不会影响到原有的大小顺序。这样就可以继续用基数排序了。

思考题

假设我们现在需要对D,a,F,B,c,A,z这个字符串进行排序,要求将其中所有小写字母都排在大写字母前面,但小写字母内部和大写字母内部不要求有序。比如经过排序之后为a,c,z,D,F,B,A,这个如何来实现呢?如果字符串中存储的不仅有大小写字母,还有数字。要将小写字母的放到前面,大写字母放在最后,数字放在中间,不用排序算法,又该怎么解决呢?

利用桶排序思想,设小写,大写,数字三个桶,遍历一遍,放入桶中,然后再按桶顺序中取出。相当于遍历了两次,复杂度O(n)。

如何选择合适的排序算法?

 

线性排序算法的时间复杂度比较低,但适用场景比较特殊。所以如果要写一个通用的排序函数,不能选择线性排序算法。

如果对小规模数据进行排序,可以选择时间复杂度是O(n²)的算法;如果对大规模数据进行排序,时间复杂度是O(nlogn)的算法更加高效。所以,为了兼顾任意规模数据的排序,一般都会首选时间复杂度是O(nlogn)的排序算法来实现排序函数。

堆排序和快速排序都有比较多的应用,比如Java语言采用堆排序实现排序函数,C语言使用快速排序实现排序函数。

 为什么归并排序并不常用

使用归并排序的情况其实并不多。我们知道,快排最坏情况下的时间复杂度是O(n²),而归并排序可以做到平均情况最坏情况下的时间复杂度都是O(nlogn),从这点上看起来很诱人,那为什么它还是没能得到“宠信”呢?

归并排序并不是原地排序算法空间复杂度是O(n)。所以,粗略点、夸张点讲,如果要排序100MB的数据,除了数据本身占用的内存之外,排序算法还要额外再占用100MB的内存空间,空间耗费就翻倍了。

如何优化快速排序?

为什么最坏情况快速排序的时间复杂度是O(n²)呢?

如果数据原来就是有序的或者接近有序的,每次分区点都选择最后一个数据,那快速排序算法就会变得非常糟糕,时间复杂度就会退化为O(n²)。实际上,这种O(n²)时间复杂度出现的主要原因还是因为我们分区点选的不够合理

最理想的分区点是:被分区点分开的两个分区中,数据的数量差不多。

1.三数取中法

我们从区间的首、尾、中间,分别取出一个数,然后对比大小,取这3个数的中间值作为分区点。这样每间隔某个固定的长度,取数据出来比较,将中间值作为分区点的分区算法,肯定要比单纯取某一个数据更好。但是,如果要排序的数组比较大,那“三数取中”可能就不够了,可能要“五数取中”或者“十数取中”。

2.随机法

随机法就是每次从要排序的区间中,随机选择一个元素作为分区点。这种方法并不能保证每次分区点都选的比较好,但是从概率的角度来看,也不大可能会出现每次分区点都选的很差的情况,所以平均情况下,这样选的分区点是比较好的。时间复杂度退化为最糟糕的O(n²)的情况,出现的可能性不大。

我们知道,快速排序是用递归来实现的,递归要警惕堆栈溢出。为了避免快速排序里,递归过深而堆栈过小,导致堆栈溢出,我们有两种解决办法:

第一种是限制递归深度。一旦递归过深,超过了我们事先设定的阈值,就停止递归。

第二种是通过在模拟实现一个函数调用栈,手动模拟递归压栈、出栈的过程,这样就没有了系统栈大小的限制。

Glibc中的qsort()函数

qsort()优先使用归并排序来排序输入数据,因为归并排序的空间复杂度是O(n),所以对于小数据量的排序,比如1KB、2KB等,归并排序额外需要1KB、2KB的内存空间。现在计算机的内存都很大,很多时候追求的是速度,这是典型的用空间换时间技巧的应用。

但如果数据量太大,如,排序100MB的数据,这个时候再用归并排序就不合适了。所以,要排序的数据量比较大的时候,qsort()会改为用快速排序算法来排序,而qsort()选择分区点的方法就是“三数取中法”。

而前面提到的递归太深会导致堆栈溢出的问题,qsort()是通过自己实现一个堆上的栈,手动模拟递归来解决的。

实际上,qsort()并不仅仅用到了归并排序和快速排序,它还用到了插入排序。在快速排序的过程中,当要排序的区间中,元素的个数小于等于4时,qsort()就退化为插入排序,不再继续用递归来做快速排序,因为前面也讲过,在小规模数据面前,O(n²)时间复杂度的算法并不一定比O(nlogn)的算法执行时间长。

时间复杂度代表的是一个增长趋势,如果画成增长曲线图,你会发现O(n2)比O(nlogn)要陡峭,也就是说增长趋势要更猛一些。但我们前面讲过,在大O复杂度表示法中,我们会省略低阶、系数和常数,也就是说,O(nlogn)在没有省略低阶、系数、常数之前可能是O(knlogn + c),而且k和c有可能还是一个比较大的数。

假设k=1000,c=200,当我们对小规模数据(比如n=100)排序时,n2的值实际上比knlogn+c还要小。

knlogn+c = 1000 * 100 * log100 + 200 远大于10000

n^2 = 100*100 = 10000

所以,对于小规模数据的排序,O(n2)的排序算法并不一定比O(nlogn)排序算法执行的时间长。对于小数据量的排序,我们选择比较简单、不需要递归的插入排序算法。

我们之前讲到的哨兵来简化代码,在qsort()插入排序的算法实现中,也利用了这种编程技巧。虽然哨兵可能只是少做一次判断,但是毕竟排序函数是非常常用、非常基础的函数,性能的优化要做到极致。

堆和堆排序

$Heap$ )的应用场景非常多,最经典的莫过于堆排序了。堆排序是一种原地的、时间复杂度为 $O(n\log n)$ 的排序算法。
平均情况下,它的时间复杂度为 $O(n\log n)$ 。尽管这两种排序算法的时间复杂度都是 $O(n\log n)$ ,甚至堆排序比快速排序的时间复杂度还要稳定,但是,在实际的软件开发中,快速排序的性能要比堆排序好,这是为什么呢?

 

  • 堆是一个完全二叉树;
  • 堆中每一个节点的值都必须大于等于(或小于等于)其子树中每个节点的值。
第一点,完全二叉树要求除了最后一层,其他层的节点个数都是满的,最后一层的节点都靠左排列。
第二点,堆中的每个节点的值必须大于等于(或者小于等于)其子树中每个节点的值。实际上,我们还可以换一种说法,堆中每个节点的值都大于等于(或者小于等于)其左右子节点的值。这两种表述是等价的。
对于每个节点的值都大于等于子树中每个节点值的堆,我们叫作 大顶堆 。对于每个节点的值都小于等于子树中每个节点值的堆,我们叫作 小顶堆

如何实现一个堆?

完全二叉树比较适合用数组来存储。用数组来存储完全二叉树是非常节省存储空间的。因为我们不需要存储左右子节点的指针,单纯地通过数组的下标,就可以找到一个节点的左右子节点和父节点。
 
从图中我们可以看到,数组中下标为  $i$  的节点的左子节点,就是下标为  $i*2$  的节点,右子节点就是下标为  $i*2+1$  的节点,父节点就是下标为  \frac{i}{2}  的节点。

1.往堆中插入一个元素

往堆中插入一个元素后,我们需要继续满足堆的两个特性。

如果我们把新插入的元素放到堆的最后,是不是不符合堆的特性了?于是,我们就需要进行调整,让其重新满足堆的特性,这个过程我们起了一个名字,就叫作堆化( heapify )。

堆化实际上有两种,从下往上和从上往下。这里我先讲从下往上的堆化方法。

堆化非常简单,就是顺着节点所在的路径,向上或者向下,对比,然后交换。
我们可以让新插入的节点与父节点对比大小。如果不满足子节点小于等于父节点的大小关系,我们就互换两个节点。一直重
复这个过程,直到父子节点之间满足刚说的那种大小关系。
public class Heap {
 private int[] a; // 数组,从下标1开始存储数据
 private int n; // 堆可以存储的最大数据个数
 private int count; // 堆中已经存储的数据个数
 public Heap(int capacity) {
 a = new int[capacity + 1];
 n = capacity;
 count = 0;
 }
 public void insert(int data) {
 if (count >= n) return; // 堆满了
 ++count;
 a[count] = data;
 int i = count;
 while (i/2 > 0 && a[i] > a[i/2]) { // 自下往上堆化
 swap(a, i, i/2); // swap()函数作用:交换下标为i和i/2的两个元素
 i = i/2;
 }
 }
 }

2.删除堆顶元素

假设我们构造的是大顶堆,堆顶元素就是最大的元素。当我们删除堆顶元素之后,就需要把第二大的元素放到堆顶,那第二大元素肯定会出现在左右子节点中。
然后我们再迭代地删除第二大节点,以此类推,直到叶子节点被删除。
实际上,我们稍微改变一下思路,就可以解决这个问题。我们把最后一个节点放到堆顶,然后利用同样的父子节点对比方法。对于不满足父子节点大小关系的,互换两个节点,并且重复进行这个过程,直到父子节点之间满足大小关系为止。这就是从上往下的堆化方法。
public void removeMax() {
 if (count == 0) return -1; // 堆中没有数据
 a[1] = a[count];
 --count;
 heapify(a, count, 1);
}
private void heapify(int[] a, int n, int i) { // 自上往下堆化
 while (true) {
 int maxPos = i;
 if (i*2 <= n && a[i] < a[i*2]) maxPos = i*2;
 if (i*2+1 <= n && a[maxPos] < a[i*2+1]) maxPos = i*2+1;
 if (maxPos == i) break;
 swap(a, i, maxPos);
 i = maxPos;
 }
}
一个包含  $n$  个节点的完全二叉树,树的高度不会超过  $\log_{2}n$  。堆化的过程是顺着节点所在路径比较交换的,所以堆化的时间复杂度跟树的高度成正比,也就是  $O(\log n)$  。插入数据和删除堆顶元素的主要逻辑就是堆化,所以,往堆中插入一个元素和删除堆顶元素的时间复杂度都是  $O(\log n)$ 

如何基于堆实现排序?

借助于堆这种数据结构实现的排序算法,就叫作堆排序。这种排序方法的时间复杂度非常稳定,是 $O(n\log n)$ ,并且它还是原地排序算法。如此优秀,它是怎么做到的呢?
1. 建堆
第一种是借助我们前面讲的,在堆中插入一个元素的思路。尽管数组中包含  $n$  个数据,但是我们可以假设,起初堆中只包含一个数据,就是下标为  1  的数据。
然后,我们调用前面讲的插入操作,将下标从 2  到  $n$  的数据依次插入到堆中。这样我们就将包含  $n$  个数据的数组,组织成了堆。
第二种实现思路,跟第一种截然相反,第一种建堆思路的处理过程是从前往后处理数组数据,并且每个数据插入堆中时,都是从下往上堆化。而第二种实现思路,是从后往前处理数组,并且每个数据都是从上往下堆化。
private static void buildHeap(int[] a, int n) {
 for (int i = n/2; i >= 1; --i) {
 heapify(a, n, i);
 }
}
private static void heapify(int[] a, int n, int i) {
 while (true) {
 int maxPos = i;
 if (i*2 <= n && a[i] < a[i*2]) maxPos = i*2;
 if (i*2+1 <= n && a[maxPos] < a[i*2+1]) maxPos = i*2+1;
 if (maxPos == i) break;
 swap(a, i, maxPos);
 i = maxPos;
 }
}
你可能已经发现了,在这段代码中,我们对下标从  \frac{n}{2} 开始到 1  的数据进行堆化,下标是  \frac{n}{2}+1  到 n 的节点是叶子节点,我们不需要堆化。实际上,对于完全二叉树来说,下标从   \frac{n}{2}+1  到 n 的节点都是叶子节点。
 
每个节点堆化的时间复杂度是  $O(\log n)$  ,那  \frac{n}{2}+1  个节点堆化的总时间复杂度是不是就是  $O(\log n)$  呢?这个答案虽然也没错,但是这个值还是不够精确。实际上,堆排序的建堆过程的时间复杂度是  $O(n)$ 
 
因为叶子节点不需要堆化,所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中,需要比较和交换的节点个数,跟这个节点的高度 k 成正比。我们只需要将每个节点的高度求和,得出的就是建堆的时间复杂度。
把公式左右都乘以 2  ,就得到另一个公式  $S2$ 。我们将  $S2$  错位对齐,并且用  $S2$  减去  $S1$ ,可以得到  $S$
因为  $h=\log_{2}n$  ,代入公式  $S$  ,就能得到  $S=O(n)$  ,所以,建堆的时间复杂度就是  $O(n)$ 。
2.排序
建堆结束之后,数组中的数据已经是按照大顶堆的特性来组织的。数组中的第一个元素就是堆顶,也就是最大的元素。我们把它跟最后一个元素交换,那最大元素就放到了下标为 n  的位置。
这个过程有点类似上面讲的“删除堆顶元素”的操作,当堆顶元素移除之后,我们把下标为 n 的元素放到堆顶,然后再通过堆化的方法,将剩下的 n-1 个元素重新构建成堆。堆化完成之后,我们再取堆顶的元素,放到下标是 n-1 的位置,一直重复这个过程,直到最后堆中只剩下标为 1 的一个元素,排序工作就完成了。
// n表示数据的个数,数组a中的数据从下标1到n的位置。
public static void sort(int[] a, int n) {
 buildHeap(a, n);
 int k = n;
 while (k > 1) {
 swap(a, 1, k);
 --k;
 heapify(a, k, 1);
 }
}
整个堆排序的过程,都只需要极个别临时存储空间,所以堆排序是原地排序算法。堆排序包括建堆和排序两个操作,建堆过程的时间复杂度是  $O(n)$  ,排序过程的时间复杂度是  $O(n\log n)$  ,所以,堆排序整体的时间复杂度是  $O(n\log n)$ 
堆排序不是稳定的排序算法,因为在排序的过程,存在将堆的最后一个节点跟堆顶节点互换的操作,所以就有可能改变值相同数据的原始相对顺序。
 
在前面的讲解以及代码中都假设,堆中的数据是从数组下标为 1 的位置开始存储。那如果从 0 开始存储,实际上处理思路是没有任何变化的,唯一变化的,可能就是,代码实现的时候,计算子节点和父节点的下标的公式改变了。
如果节点的下标是  i  ,那左子节点的下标就是  $2*i+1$  ,右子节点的下标就是  $2*i+2$  ,父节点的下标就是  \frac{i-1}{2}
 

在实际开发中,为什么快速排序要比堆排序性能好?

第一点,堆排序数据访问的方式没有快速排序友好。

对于快速排序来说,数据是顺序访问的。而对于堆排序来说,数据是跳着访问的。 比如,堆排序中,最重要的一个操作就是数据的堆化。比如下面这个例子,对堆顶节点进行堆化,会依次访问数组下标是 1,2,4,8 的元素,而不是像快速排序那样,局部顺序访问,所以,这样对CPU缓存是不友好的。

第二点,对于同样的数据,在排序过程中,堆排序算法的数据交换次数要多于快速排序。

我们在讲排序的时候,提过两个概念,有序度和逆序度。对于基于比较的排序算法来说,整个排序过程就是由两个基本的操作组成的,比较和交换(或移动)。
快速排序数据交换的次数不会比逆序度多。
但是堆排序的第一步是建堆,建堆的过程会打乱数据原有的相对先后顺序,导致原数据的有序度降低。比如,对于一组已经有序的数据来说,经过建堆之后,数据反而变得更无序了。
 

堆的应用除了堆排以外,还有如下一些应用:

1. 从大数量级数据中筛选出 top n 条数据; 比如:从几十亿条订单日志中筛选出金额靠前的 1000 条数据
2. 在一些场景中,会根据不同优先级来处理网络请求,此时也可以用到优先队列 ( 用堆实现的数据结构 ) ;比如:网络框架 Volley 就用了 Java 中PriorityBlockingQueue ,当然它是线程安全的
3. 可以用堆来实现多路归并,从而实现有序, leetcode 上也有相关的一题: Merge K Sorted Lists

二分查找

O(logn)惊人的查找速度

我们假设数据大小是n,每次查找后数据都会缩小为原来的一半,也就是会除以2。最坏情况下,直到查找区间被缩小为空,才停止。

可以看出来,这是一个等比数列。其中n/2^k=1时,k的值就是总共缩小的次数。而每一次缩小操作只涉及两个数据的大小比较,所以,经过了k次区间缩小操作,时间复杂度就是O(k)。通过n/2^k=1,我们可以求得k=log2n,所以时间复杂度就是O(logn)。

关于mid的取值

实际上,mid=(low+high)/2这种写法是有问题的。因为如果low和high比较大的话,两者之和就有可能会溢出。改进的方法是将mid的计算方式写成low+(high-low)/2。更进一步,如果要将性能优化到极致的话,我们可以将这里的除以2操作转化成位运算low+((high-low)>>1)。因为相比除法运算来说,计算机处理位运算要快得多。

二分查找应用场景的局限性

第一,二分查找依赖的是顺序表结构,简单点说就是数组。

那二分查找能否依赖其他数据结构呢?比如链表。答案是不可以的,主要原因是二分查找算法需要按照下标随机访问元素。我们在数组和链表那两节讲过,数组按照下标随机访问数据的时间复杂度是O(1),而链表随机访问的时间复杂度是O(n)。所以,如果数据使用链表存储,二分查找的时间复杂就会变得很高。

第二,二分查找针对的是有序数据。

二分查找对这一点的要求比较苛刻,数据必须是有序的。如果数据没有序,我们需要先排序。前面章节里我们讲到,排序的时间复杂度最低是O(nlogn)。所以,如果我们针对的是一组静态的数据,没有频繁地插入、删除,我们可以进行一次排序,多次二分查找。这样排序的成本可被均摊,二分查找的边际成本就会比较低

但是,如果我们的数据集合有频繁的插入和删除操作,要想用二分查找,要么每次插入、删除操作之后保证数据仍然有序,要么在每次二分查找之前都先进行排序。针对这种动态数据集合,无论哪种方法,维护有序的成本都是很高的。

所以,二分查找只能用在插入、删除操作不频繁,一次排序多次查找的场景中。针对动态变化的数据集合,二分查找将不再适用

第三,数据量太小不适合二分查找。

如果要处理的数据量很小,完全没有必要用二分查找,顺序遍历就足够了。比如我们在一个大小为10的数组中查找一个元素,不管用二分查找还是顺序遍历,查找速度都差不多。只有数据量比较大的时候,二分查找的优势才会比较明显。

不过,这里有一个例外。如果数据之间的比较操作非常耗时不管数据量大小,我都推荐使用二分查找。比如,数组中存储的都是长度超过300的字符串,如此长的两个字符串之间比对大小,就会非常耗时。我们需要尽可能地减少比较次数,而比较次数的减少会大大提高性能,这个时候二分查找就比顺序遍历更有优势。

第四,数据量太大也不适合二分查找。

二分查找的底层需要依赖数组这种数据结构,而数组为了支持随机访问的特性,要求内存空间连续,对内存的要求比较苛刻。比如,我们有1GB大小的数据,如果希望用数组来存储,那就需要1GB的连续内存空间。

如何在1000万个整数中快速查找某个整数?

这个问题并不难。我们的内存限制是100MB,每个数据大小是8字节,最简单的办法就是将数据存储在数组中,内存占用差不多是80MB,符合内存的限制。借助今天讲的内容,我们可以先对这1000万数据从小到大排序,然后再利用二分查找算法,就可以快速地查找想要的数据了。

看起来这个问题并不难,很轻松就能解决。实际上,它暗藏了“玄机”。如果你对数据结构和算法有一定了解,知道散列表二叉树这些支持快速查找动态数据结构。你可能会觉得,用散列表和二叉树也可以解决这个问题。实际上是不行的。

虽然大部分情况下,用二分查找可以解决的问题,用散列表、二叉树都可以解决。但是,我们后面会讲,不管是散列表还是二叉树,都会需要比较多的额外的内存空间。如果用散列表或者二叉树来存储这1000万的数据,用100MB的内存肯定是存不下的。而二分查找底层依赖的是数组,除了数据本身之外,不需要额外存储其他信息,是最省内存空间的存储方式,所以刚好能在限定的内存大小下解决这个问题。

思考题

1. 如何编程实现“求一个数的平方根”?要求精确到小数点后6位。

求平方根(根号n)的两种算法——二分法和牛顿迭代

int abs(int i);            处理int类型的取绝对值

double fabs(double i);     处理double类型的取绝对值

float fabsf(float i);      处理float类型的取绝对值

2. 如果数据使用链表存储,二分查找的时间复杂就会变得很高,那查找的时间复杂度究竟是多少呢?

假设链表长度为n,二分查找每次都要找到中间点(计算中忽略奇偶数差异):

第一次查找中间点,需要移动指针n/2次;

第二次,需要移动指针n/4次;

第三次需要移动指针n/8次;

......

以此类推,一直到1次为值

总共指针移动次数(查找次数) = n/2 + n/4 + n/8 + ...+ 1,这显然是个等比数列,根据等比数列求和公式:Sum = n - 1.

最后算法时间复杂度是:O(n-1),忽略常数,记为O(n),时间复杂度和顺序查找时间复杂度相同。

二分查找的变体问题

变体一:查找第一个值等于给定值的元素

public int bsearch(int[] a, int n, int value) {
 int low = 0;
 int high = n - 1;
 while (low <= high) {
 int mid = low + ((high - low) >> 1);
 if (a[mid] >= value) {     /注意这里是>=,因为要找的是第一个val值的下标
 high = mid - 1;
 } else {
 low = mid + 1;
 }
 }
 if (low < n && a[low]==value) return low;
 else return -1;
}
public int bsearch(int[] a, int n, int value) {
 int low = 0;
 int high = n - 1;
 while (low <= high) {
 int mid = low + ((high - low) >> 1);
 if (a[mid] > value) {   大于val
 high = mid - 1;
 } else if (a[mid] < value) {   小于val
 low = mid + 1;
 } else {   等于val
 if ((mid == 0) || (a[mid - 1] != value)) return mid;    /是第一个元素 或 前面的元素不再=val
 else high = mid - 1;    /前面还要=val的值
 }
 }
 return -1;
}

变体二:查找最后一个值等于给定值的元素

public int bsearch(int[] a, int n, int value) {
 int low = 0;
 int high = n - 1;
 while (low <= high) {
 int mid = low + ((high - low) >> 1);
 if (a[mid] > value) {
 high = mid - 1;
 } else if (a[mid] < value) {
 low = mid + 1;
 } else {
 if ((mid == n - 1) || (a[mid + 1] != value)) return mid;
 else low = mid + 1;   /区别在于这时候应该向右搜索
 }
 }
 return -1;
}

变体三:查找第一个大于等于给定值的元素

public int bsearch(int[] a, int n, int value) {
 int low = 0;
 int high = n - 1;
 while (low <= high) {
 int mid = low + ((high - low) >> 1);
 if (a[mid] >= value) {
 if ((mid == 0) || (a[mid - 1] < value)) return mid;   /不用额外判断=val的情况
 else high = mid - 1;
 } else {
 low = mid + 1;
 }
 }
 return -1;
}

变体四:查找最后一个小于等于给定值的元素

public int bsearch7(int[] a, int n, int value) {
 int low = 0;
 int high = n - 1;
 while (low <= high) {
 int mid = low + ((high - low) >> 1);
 if (a[mid] > value) {
 high = mid - 1;
 } else {  
 if ((mid == n - 1) || (a[mid + 1] > value)) return mid;  /这时包含在<=val的情况下
 else low = mid + 1;
 }
 }
 return -1;
}

如何快速定位出一个IP地址的归属地?

如果IP区间与归属地的对应关系不经常更新,我们可以先预处理这12万条数据,让其按照起始IP从小到大排序。如何来排序呢?我们知道,IP地址可以转化为32位的整型数。所以,我们可以将起始地址,按照对应的整型值的大小关系,从小到大进行排序。

然后,这个问题就可以转化为我刚讲的第四种变形问题“在有序数组中,查找最后一个小于等于某个给定值的元素”了。

当我们要查询某个IP归属地时,我们可以先通过二分查找,找到最后一个起始IP小于等于这个IP的IP区间,然后,检查这个IP是否在这个IP区间内,如果在,我们就取出对应的归属地显示;如果不在,就返回未查找到。

 

跳表

对于一个单链表来讲,即便链表中存储的数据是有序的,如果我们要想在其中查找某个数据,也只能从头到尾遍历链表。这样查找效率就会很低,时间复杂度会很高,是O(n)。

那怎么来提高查找效率呢?如果像图中那样,对链表建立一级“索引,查找起来是不是就会更快一些呢?每两个结点提取一个结点到上一级,我们把抽出来的那一级叫作索引或索引层。图中的down表示down指针,指向下一级结点。

 

 

如果我们现在要查找某个结点,比如16。我们可以先在索引层遍历,当遍历到索引层中值为13的结点时,我们发现下一个结点是17,那要查找的结点16肯定就在这两个结点之间。然后我们通过索引层结点的down指针,下降到原始链表这一层,继续遍历。这个时候,我们只需要再遍历2个结点,就可以找到值等于16的这个结点了。这样,原来如果要查找16,需要遍历10个结点,现在只需要遍历7个结点。

从这个例子里,我们看出,加来一层索引之后,查找一个结点需要遍历的结点个数减少了,也就是说查找效率提高了。那如果我们再加一级索引呢?效率会不会提升更多呢?

跟前面建立第一级索引的方式相似,我们在第一级索引的基础之上,每两个结点就抽出一个结点到第二级索引。现在我们再来查找16,只需要遍历6个结点了,需要遍历的结点数量又减少了。

举的例子数据量不大,所以即便加了两级索引,查找效率的提升也并不明显。为了让你能真切地感受索引提升查询效率。我画了一个包含64个结点的链表,按照前面讲的这种思路,建立了五级索引。

用跳表查询到底有多快?

把问题分解一下,先来看这样一个问题,如果链表里有n个结点,会有多少级索引呢?

按照我们刚才讲的,每两个结点会抽出一个结点作为上一级索引的结点,那第一级索引的结点个数大约就是n/2,第二级索引的结点个数大约就是n/4,第三级索引的结点个数大约就是n/8,依次类推,也就是说,第k级索引的结点个数是第k-1级索引的结点个数的1/2,那第k级索引结点的个数就是n/(2^k)

假设索引有h级,最高级的索引有2个结点。通过上面的公式,我们可以得到n/(2^h)=2,从而求得h=log2(n-1)。如果包含原始链表这一层,整个跳表的高度就是log2n。

我们在跳表中查询某个数据的时候,如果每一层都要遍历m个结点,那在跳表中查询一个数据的时间复杂度就是O(m*logn)。

那这个m的值是多少呢?按照前面这种索引结构,我们每一级索引都最多只需要遍历3个结点,也就是说m=3,为什么是3呢?

假设我们要查找的数据是x,在第k级索引中,我们遍历到y结点之后,发现x大于y,小于后面的结点z,所以我们通过y的down指针,从第k级索引下降到第k-1级索引。在第k-1级索引中,y和z之间只有3个结点(包含y和z),所以,我们在K-1级索引中最多只需要遍历3个结点,依次类推,每一级索引都最多只需要遍历3个结点。


 

通过上面的分析,我们得到m=3,所以在跳表中查询任意数据的时间复杂度就是O(logn)。这个查找的时间复杂度跟二分查找是一样的。换句话说,我们其实是基于单链表实现了二分查找,这是空间换时间的设计思路。

跳表是不是很浪费内存?

跳表的空间复杂度分析并不难,假设原始链表大小为n,那第一级索引大约有n/2个结点,第二级索引大约有n/4个结点,以此类推,每上升一级就减少一半,直到剩下2个结点。如果我们把每层索引的结点数写出来,就是一个等比数列。

这几级索引的结点总和就是n/2+n/4+n/8…+8+4+2=n-2。所以,跳表的空间复杂度是O(n)。也就是说,如果将包含n个结点的单链表构造成跳表,我们需要额外再用接近n个结点的存储空间。那我们有没有办法降低索引占用的内存空间呢?

我们前面都是每两个结点抽一个结点到上级索引,如果我们每三个结点或五个结点,抽一个结点到上级索引,是不是就不用那么多索引结点了呢?

通过等比数列求和公式,总的索引结点大约就是n/3+n/9+n/27+…+9+3+1=n/2。尽管空间复杂度还是O(n),但比上面的每两个结点抽一个结点的索引构建方法,要减少了一半的索引结点存储空间。

实际上,在软件开发中,我们不必太在意索引占用的额外空间。在讲数据结构和算法时,我们习惯性地把要处理的数据看成整数,但是在实际的软件开发中,原始链表中存储的有可能是很大的对象,而索引结点只需要存储关键值几个指针,并不需要存储对象,所以当对象比索引结点大很多时,那索引占用的额外空间可以忽略了。

高效的动态插入和删除

跳表这个动态数据结构,不仅支持查找操作,还支持动态的插入、删除操作,而且插入、删除操作的时间复杂度也是O(logn)。

对于纯粹的单链表,需要遍历每个结点,来找到插入的位置。但是,对于跳表来说,我们讲过查找某个结点的的时间复杂度是O(logn),所以这里查找某个数据应该插入的位置,方法也是类似的,时间复杂度也是O(logn)

如果这个结点在索引中也有出现,我们除了要删除原始链表中的结点,还要删除索引中的。因为单链表中的删除操作需要拿到要删除结点的前驱结点,然后通过指针操作完成删除。所以在查找要删除的结点的时候,一定要获取前驱结点。当然,如果我们用的是双向链表,就不需要考虑这个问题了。

跳表索引动态更新

当我们不停地往跳表中插入数据时,如果我们不更新索引,就有可能出现某2个索引结点之间数据非常多的情况。极端情况下,跳表还会退化成单链表

作为一种动态数据结构,我们需要某种手段来维护索引与原始链表大小之间的平衡,也就是说,如果链表中结点多了,索引结点就相应地增加一些,避免复杂度退化,以及查找、插入、删除操作性能下降。

跳表是通过随机函数来维护前面提到的“平衡性”。

当我们往跳表中插入数据的时候,我们可以选择同时将这个数据插入到部分索引层中。如何选择加入哪些索引层呢?

我们通过一个随机函数,来决定将这个结点插入到哪几级索引中,比如随机函数生成了值K,那我们就将这个结点添加到第一级到第K这K级索引中。

随机函数的选择很有讲究,从概率上来讲,能够保证跳表的索引大小和数据大小平衡性,不至于性能过度退化。

为什么Redis要用跳表来实现有序集合,而不是红黑树?

Redis中的有序集合是通过跳表来实现的,严格点讲,其实还用到了散列表。Redis中的有序集合支持的核心操作主要有下面这几个:

  • 插入一个数据;
  • 删除一个数据;
  • 查找一个数据;
  • 按照区间查找数据(比如查找值在[100, 356]之间的数据);
  • 迭代输出有序序列。

其中,插入、删除、查找以及迭代输出有序序列这几个操作,红黑树也可以完成,时间复杂度跟跳表是一样的。但是,按照区间来查找数据这个操作,红黑树的效率没有跳表高。

对于按照区间查找数据这个操作,跳表可以做到O(logn)的时间复杂度定位区间的起点,然后在原始链表中顺序往后遍历就可以了。这样做非常高效。

当然,Redis之所以用跳表来实现有序集合,还有其他原因,比如,跳表更容易代码实现。虽然跳表的实现也不简单,但比起红黑树来说还是好懂、好写多了,而简单就意味着可读性好不容易出错。还有,跳表更加灵活,它可以通过改变索引构建策略,有效平衡执行效率内存消耗

不过,跳表也不能完全替代红黑树。因为红黑树比跳表的出现要早一些,很多编程语言中的Map类型都是通过红黑树来实现的。我们做业务开发的时候,直接拿来用就可以了,不用费劲自己去实现一个红黑树,但是跳表并没有一个现成的实现,所以在开发中,如果你想使用跳表,必须要自己实现。

散列表

散列表时也叫“哈希表”或者“Hash表”,用的是数组支持按照下标随机访问数据的特性,所以散列表其实就是数组的一种扩展.

散列冲突

再好的散列函数也无法避免散列冲突。那究竟该如何解决散列冲突问题呢?我们常用的散列冲突解决方法有两类,开放寻址法(open addressing)和链表法(chaining)。

1.开放寻址法

开放寻址法的核心思想是,如果出现了散列冲突,我们就重新探测一个空闲位置,将其插入。一个比较简单的探测方法是线性探测(Linear Probing)。

当我们往散列表中插入数据时,如果某个数据经过散列函数散列之后,存储位置已经被占用了,我们就从当前位置开始,依次往后查找,看是否有空闲位置,直到找到为止。

在散列表中查找元素的过程有点儿类似插入过程。我们通过散列函数求出要查找元素的键值对应的散列值,然后比较数组中下标为散列值的元素要查找的元素。如果相等,则说明就是我们要找的元素;否则顺序往后依次查找。如果遍历到数组中的空闲位置,还没有找到,就说明要查找的元素并没有在散列表中。

对于使用线性探测法解决冲突的散列表,删除操作不能单纯地把要删除的元素设置为空

在查找的时候,一旦我们通过线性探测方法,找到一个空闲位置,我们就可以认定散列表中不存在这个数据。但是,如果这个空

闲位置是我们后来删除的,就会导致原来的查找算法失效。本来存在的数据,会被认定为不存在。

我们可以将删除的元素,特殊标记为deleted。当线性探测查找的时候,遇到标记为deleted的空间,并不是停下来,而是继续往下探测。

线性探测法其实存在很大问题。当散列表中插入的数据越来越多时,散列冲突发生的可能性就会越来越大空闲位置越来越少线性探测的时间就会越来越久。极端情况下,我们可能需要探测整个散列表,所以最坏情况下的时间复杂度为O(n)。同理,在删除和查找时,也有可能会线性探测整张散列表,才能找到要查找或者删除的数据。

对于开放寻址冲突解决方法,除了线性探测方法之外,还有另外两种比较经典的探测方法,二次探测(Quadratic probing)和双重散列(Double hashing)。

二次探测,跟线性探测很像,线性探测每次探测的步长是1,那它探测的下标序列就是hash(key)+0,hash(key)+1,hash(key)+2……而二次探测探测的步长就变成了原来的“二次方”,也就是说,它探测的下标序列就是hash(key)+0,hash(key)+1^2,hash(key)+2^2……

双重散列,意思就是不仅要使用一个散列函数。我们使用一组散列函数hash1(key),hash2(key),hash3(key)……我们先用第一个散列函数,如果计算得到的存储位置已经被占用再用第二个散列函数,依次类推,直到找到空闲的存储位置。

不管采用哪种探测方法,当散列表中空闲位置不多的时候,散列冲突的概率就会大大提高。为了尽可能保证散列表的操作效率,一般情况下,我们会尽可能保证散列表中有一定比例的空闲槽位。我们用装载因子(load factor)来表示空位的多少

装载因子的计算公式是:

散列表的装载因子 = 填入表中的元素个数 / 散列表的长度

装载因子越大,说明空闲位置越少,冲突越多,散列表的性能会下降。

2.链表法

链表法是一种更加常用的散列冲突解决办法,相比开放寻址法,它要简单很多。我们来看这个图,在散列表中,每个“桶(bucket)”或者“槽(slot)”会对应一条链表,所有散列值相同的元素我们都放到相同槽位对应的链表中。

当插入的时候,我们只需要通过散列函数计算出对应的散列槽位,将其插入到对应链表中即可,所以插入的时间复杂度是O(1)。当查找、删除一个元素时,我们同样通过散列函数计算出对应的槽,然后遍历链表查找或者删除。那查找或删除操作的时间复杂度是多少呢?

实际上,这两个操作的时间复杂度跟链表的长度k成正比,也就是O(k)。对于散列比较均匀的散列函数来说,理论上讲,k=n/m,其中n表示散列中数据的个数,m表示散列表中“槽”的个数。

思考题

1.Word文档中单词拼写检查功能是如何实现的?

常用的英文单词有20万个左右,假设单词的平均长度是10个字母,平均一个单词占用10个字节的内存空间,那20万英文单词大约占2MB的存储空间,就算放大10倍也就是20MB。对于现在的计算机来说,这个大小完全可以放在内存里面。所以我们可以用散列表来存储整个英文单词词典

当用户输入某个英文单词时,我们拿用户输入的单词去散列表中查找。如果查到,则说明拼写正确;如果没有查到,则说明拼写可能有误,给予提示。借助散列表这种数据结构,我们就可以轻松实现快速判断是否存在拼写错误。

2. 假设我们有10万条URL访问日志,如何按照访问次数给URL排序?

遍历 10 万条数据,以 URL 为 key,访问次数为 value,存入散列表,同时记录下访问次数的最大值 K,时间复杂度 O(N)。

如果 K 不是很大,可以使用桶排序,时间复杂度 O(N)。如果 K 非常大(比如大于 10 万),就使用快速排序,复杂度 (NlogN)。

3. 有两个字符串数组,每个数组大约有10万条字符串,如何快速找出两个数组中相同的字符串?

以第一个字符串数组构建散列表,key 为字符串,value 为出现次数。再遍历第二个字符串数组,以字符串为 key 在散列表中查找,如果 value 大于零,说明存在相同字符串。时间复杂度 O(N)。

散列表碰撞攻击的基本原理

极端情况下,有些恶意的攻击者,还有可能通过精心构造的数据,使得所有的数据经过散列函数之后,都散列到同一个槽里。如果我们使用的是基于链表的冲突解决方法,那这个时候,散列表就会退化为链表,查询的时间复杂度就O(1)急剧退化为O(n)

如果散列表中有10万个数据,退化后的散列表查询的效率就下降了10万倍。更直接点说,如果之前运行100次查询只需要0.1秒,那现在就需要1万秒。这样就有可能因为查询操作消耗大量CPU或者线程资源,导致系统无法响应其他请求,从而达到拒绝服务攻击(DoS)的目的。

如何设计散列函数?

首先,散列函数的设计不能太复杂。过于复杂的散列函数,势必会消耗很多计算时间,也就间接的影响到散列表的性能。

其次,散列函数生成的值要尽可能随机并且均匀分布,这样才能避免或者最小化散列冲突,而且即便出现冲突,散列到每个槽里的数据也会比较平均,不会出现某个槽内数据特别多的情况。

两个例子:

第一个例子就是学生运动会的例子,我们通过分析参赛编号的特征,把编号中的后两位作为散列值。我们还可以用类似的散列函数处理手机号码,因为手机号码前几位重复的可能性很大,但是后面几位就比较随机,我们可以取手机号的后四位作为散列值。这种散列函数的设计方法,我们一般叫作“数据分析法”。

第二个例子就是上一节的开篇思考题,如何实现Word拼写检查功能。这里面的散列函数,我们就可以这样设计:将单词中每个字母的ASCII值“进位”相加,然后再跟散列表的大小求余、取模,作为散列值。比如,英文单词nice,我们转化出来的散列值就是下面这样:

hash("nice")=(("n" - "a") * 26*26*26 + ("i" - "a")*26*26 + ("c" - "a")*26+ ("e"-"a")) / 78978

装载因子过大了怎么办?

针对散列表,当装载因子过大时,我们也可以进行动态扩容,重新申请一个更大的散列表,将数据搬移到这个新散列表中。假设每次扩容我们都申请一个原来散列表大小两倍的空间。如果原来散列表的装载因子是0.8,那经过扩容之后,新散列表的装载因子就下降为原来的一半,变成了0.4。

针对数组的扩容,数据搬移操作比较简单。但是,针对散列表的扩容,数据搬移操作要复杂很多。因为散列表的大小变了,数据的存储位置也变了,所以我们需要通过散列函数重新计算每个数据的存储位置

插入一个数据,最好情况下,不需要扩容,最好时间复杂度是O(1)最坏情况下,散列表装载因子过高,启动扩容,我们需要重新申请内存空间,重新计算哈希位置,并且搬移数据,所以时间复杂度是O(n)。用摊还分析法,均摊情况下,时间复杂度接近最好情况,就是O(1)

当散列表的装载因子超过某个阈值时,就需要进行扩容。装载因子阈值需要选择得当。如果太大,会导致冲突过多;如果太小,会导致内存浪费严重。

装载因子阈值的设置要权衡时间、空间复杂度。如果内存空间不紧张,对执行效率要求很高,可以降低负载因子的阈值;相反,如果内存空间紧张,对执行效率要求又不高,可以增加负载因子的值,甚至可以大于1

如何避免低效地扩容?

大部分情况下,动态扩容的散列表插入一个数据都很快,但是在特殊情况下,当装载因子已经到达阈值,需要先进行扩容,再插入数据。这个时候,插入数据就会变得很慢,甚至会无法接受。

举一个极端的例子,如果散列表当前大小为1GB,要想扩容为原来的两倍大小,那就需要对1GB的数据重新计算哈希值,并且从原来的散列表搬移到新的散列表,听起来就很耗时,是不是?

如果我们的业务代码直接服务于用户,尽管大部分情况下,插入一个数据的操作都很快,但是,极个别非常慢的插入操作,也会让用户崩溃。这个时候,“一次性”扩容的机制就不合适了。

为了解决一次性扩容耗时过多的情况,我们可以将扩容操作穿插在插入操作的过程中,分批完成。当装载因子触达阈值之后,我们只申请新空间,但并不将老的数据搬移到新散列表中。

当有新数据要插入时,我们将新数据插入新散列表中,并且从老的散列表中拿出一个数据放入到新散列表。每次插入一个数据到散列表,我们都重复上面的过程。经过多次插入操作之后,老的散列表中的数据就一点一点全部搬移到新散列表中了。这样没有了集中的一次性数据搬移,插入操作就都变得很快了。

通过这样均摊的方法,将一次性扩容的代价,均摊到多次插入操作中,就避免了一次性扩容耗时过多的情况。这种实现方式,任何情况下,插入一个数据的时间复杂度都是O(1)。

如何选择冲突解决方法?

1.开放寻址法

优点:

开放寻址法不像链表法,需要拉很多链表。散列表中的数据都存储在数组中,可以有效地利用CPU缓存加快查询速度。而且,这种方法实现的散列表,序列化起来比较简单。链表法包含指针,序列化起来就没那么容易。

缺点:

用开放寻址法解决冲突的散列表,删除数据的时候比较麻烦,需要特殊标记已经删除掉的数据。而且,在开放寻址法中,所有的数据都存储在一个数组中,比起链表法来说,冲突的代价更高。所以,使用开放寻址法解决冲突的散列表,装载因子上限不能太大。这也导致这种方法比链表法更浪费内存空间

所以,当数据量比较小装载因子小的时候,适合采用开放寻址法。

2.链表法

首先,链表法对内存的利用率比开放寻址法要高。因为链表结点可以在需要的时候再创建,并不需要像开放寻址法那样事先申请好。这一点也是链表优于数组的地方。

链表法比起开放寻址法,对大装载因子容忍度更高。开放寻址法只能适用装载因子小于1的情况。接近1时,就可能会有大量的散列冲突,导致大量的探测、再散列等,性能会下降很多。但是对于链表法来说,只要散列函数的值随机均匀,即便装载因子变成10,也就是链表的长度变长了而已,虽然查找效率有所下降,但是比起顺序查找还是快很多。

链表因为要存储指针,所以对于比较小的对象的存储,是比较消耗内存的,还有可能会让内存的消耗翻倍。而且,因为链表中的结点是零散分布在内存中的,不是连续的,所以CPU缓存是不友好的,这方面对于执行效率也有一定的影响。

当然,如果我们存储的是大对象,也就是说要存储的对象的大小远远大于一个指针的大小(4个字节或者8个字节),那链表中指针的内存消耗在大对象面前就可以忽略了。

实际上,我们对链表法稍加改造,可以实现一个更加高效的散列表。那就是,我们将链表法中的链表改造为其他高效的动态数据结构,比如跳表、红黑树。这样,即便出现散列冲突,极端情况下,所有的数据都散列到同一个桶内,那最终退化成的散列表的查找时间也只不过是O(logn)。这样也就有效避免了前面讲到的散列碰撞攻击。

所以,基于链表的散列冲突处理方法比较适合存储大对象大数据量的散列表,而且,比起开放寻址法,它更加灵活,支持更多的优化策略,比如用红黑树代替链表。

工业级散列表举例分析

1.初始大小 

HashMap默认的初始大小是16,当然这个默认值是可以设置的,如果事先知道大概的数据量有多大,可以通过修改默认初始大小,减少动态扩容的次数,这样会大大提高HashMap的性能。

2.装载因子和动态扩容

最大装载因子默认是0.75,当HashMap中元素个数超过0.75*capacity(capacity表示散列表的容量)的时候,就会启动扩容,每次扩容都会扩容为原来的两倍大小。

3.散列冲突解决方法

HashMap底层采用链表法来解决冲突。即使负载因子和散列函数设计得再合理,也免不了会出现拉链过长的情况,一旦出现拉链过长,则会严重影响HashMap的性能。

于是,在JDK1.8版本中,为了对HashMap做进一步优化,我们引入了红黑树。而当链表长度太长(默认超过8)时,链表就转换为红黑树。我们可以利用红黑树快速增删改查的特点,提高HashMap的性能。当红黑树结点个数少于8个的时候,又会将红黑树转化为链表。因为在数据量较小的情况下,红黑树要维护平衡,比起链表来,性能上的优势并不明显。

4.散列函数

散列函数的设计并不复杂,追求的是简单高效、分布均匀。

如何设计的一个工业级的散列函数?

  • 支持快速的查询插入删除操作;
  • 内存占用合理,不能浪费过多的内存空间;
  • 性能稳定,极端情况下,散列表的性能也不会退化到无法接受的情况。

从这三个方面来考虑设计思路:

  • 设计一个合适的散列函数
  • 定义装载因子阈值,并且设计动态扩容策略
  • 选择合适的散列冲突解决方法

LRU缓存淘汰算法

借助散列表,我们可以把LRU缓存淘汰算法的时间复杂度降低为O(1)。

回顾一下当时我们是如何通过链表实现LRU缓存淘汰算法的。

我们需要维护一个按照访问时间从大到小有序排列的链表结构。因为缓存大小有限,当缓存空间不够,需要淘汰一个数据的时候,我们就直接将链表头部的结点删除

当要缓存某个数据的时候,先在链表中查找这个数据。如果没有找到,则直接将数据放到链表的尾部

如果找到了,我们就把它移动到链表的尾部。因为查找数据需要遍历链表,所以单纯用链表实现的LRU缓存淘汰算法的时间复杂很高,是O(n)。

一个缓存(cache)系统主要包含下面这几个操作:

  • 往缓存中添加一个数据;
  • 从缓存中删除一个数据;
  • 在缓存中查找一个数据。

这三个操作都要涉及“查找”操作,如果单纯地采用链表的话,时间复杂度只能是O(n)。如果我们将散列表和链表两种数据结构组合使用,可以将这三个操作的时间复杂度都降低到O(1)。具体的结构就是下面这个样子:

我们使用双向链表存储数据,链表中的每个结点处理存储数据(data)、前驱指针(prev)、后继指针(next)之外,还新增了一个特殊的字段hnext。这个hnext有什么作用呢?

因为我们的散列表是通过链表法解决散列冲突的,所以每个结点会在两条链中。一个链是刚刚我们提到的双向链表,另一个链是散列表中的拉链。前驱和后继指针是为了将结点串在双向链表中,hnext指针是为了将结点串在散列表的拉链中。

首先,我们来看如何查找一个数据。我们前面讲过,散列表中查找数据的时间复杂度接近O(1),所以通过散列表,我们可以很快地在缓存中找到一个数据。当找到数据之后,我们还需要将它移动到双向链表的尾部

其次,我们来看如何删除一个数据。我们需要找到数据所在的结点,然后将结点删除。借助散列表,我们可以在O(1)时间复杂度里找到要删除的结点。因为我们的链表是双向链表,双向链表可以通过前驱指针O(1)时间复杂度获取前驱结点,所以在双向链表中,删除结点只需要O(1)的时间复杂度。

最后,我们来看如何添加一个数据。添加数据到缓存稍微有点麻烦,我们需要先看这个数据是否已经在缓存中。如果已经在其中,需要将其移动到双向链表的尾部;如果不在其中,还要看缓存有没有满。如果满了,则将双向链表头部的结点删除,然后再将数据放到链表的尾部;如果没有满,就直接将数据放到链表的尾部。

这整个过程涉及的查找操作都可以通过散列表来完成。其他的操作,比如删除头结点、链表尾部插入数据等,都可以在O(1)的时间复杂度内完成。所以,这三个操作的时间复杂度都是O(1)。至此,我们就通过散列表和双向链表的组合使用,实现了一个高效的、支持LRU缓存淘汰算法的缓存系统原型。

为什么散列表和链表经常一块使用?

散列表这种数据结构虽然支持非常高效的数据插入删除查找操作,但是散列表中的数据都是通过散列函数打乱之后无规律存储的。也就说,它无法支持按照某种顺序快速地遍历数据。如果希望按照顺序遍历散列表中的数据,那我们需要将散列表中的数据拷贝到数组中,然后排序,再遍历

因为散列表是动态数据结构,不停地有数据的插入、删除,所以每当我们希望按顺序遍历散列表中的数据的时候,都需要先排序,那效率势必会很低。为了解决这个问题,我们将散列表和链表(或者跳表)结合在一起使用。

什么是哈希算法?

任意长度二进制值串映射为固定长度的二进制值串,这个映射的规则就是哈希算法,而通过原始数据映射之后得到的二进制值串就是哈希值。

  • 从哈希值不能反向推导出原始数据(所以哈希算法也叫单向哈希算法);
  • 对输入数据非常敏感,哪怕原始数据只修改了一个Bit,最后得到的哈希值也大不相同;
  • 散列冲突的概率要很小,对于不同的原始数据,哈希值相同的概率非常小;
  • 哈希算法的执行效率要尽量高效,针对较长的文本,也能快速地计算出哈希值

哈希算法的应用常见有安全加密、唯一标识、数据校验、散列函数、负载均衡、数据分片、分布式存储。

组合数学 鸽巢原理(也叫抽屉原理):如果有10个鸽巢,有11只鸽子,那肯定有1个鸽巢中的鸽子数量多于1个,换句话说就是,肯定有2只鸽子在1个鸽巢内。

数据校验

BT下载的原理是基于P2P协议的。我们从多个机器上并行下载一个2GB的电影,这个电影文件可能会被分割成很多文件块(比如可以分成100块,每块大约20MB)。等所有的文件块都下载完成之后,再组装成一个完整的电影文件就行了。

我们知道,网络传输是不安全的,下载的文件块有可能是被宿主机器恶意修改过的,又或者下载过程中出现了错误,所以下载的文件块可能不是完整的。如果我们没有能力检测这种恶意修改或者文件下载出错,就会导致最终合并后的电影无法观看,甚至导致电脑中毒。现在的问题是,如何来校验文件块的安全、正确、完整呢?

具体的BT协议很复杂,校验方法也有很多,其中的一种思路是:

们通过哈希算法,对100个文件块分别取哈希值,并且保存在种子文件中。哈希算法有一个特点,对数据很敏感。只要文件块的内容有一丁点儿的改变,最后计算出的哈希值就会完全不同。所以,当文件块下载完成之后,我们可以通过相同的哈希算法,对下载好的文件块逐一求哈希值,然后跟种子文件中保存的哈希值比对。如果不同,说明这个文件块不完整或者被篡改了,需要再重新从其他宿主机器上下载这个文件块。

思考题

区块链使用的是哪种哈希算法吗?是为了解决什么问题而使用的呢?

区块链是一块块区块组成的,每个区块分为两部分:区块头和区块体。

区块头保存着 自己区块体 和 上一个区块头 的哈希值。

因为这种链式关系和哈希值的唯一性,只要区块链上任意一个区块被修改过,后面所有区块保存的哈希值就不对了。

区块链使用的是 SHA256 哈希算法,计算哈希值非常耗时,如果要篡改一个区块,就必须重新计算该区块后面所有的区块的哈希值,短时间内几乎不可能做到。

1.安全加密

①常用于加密的哈希算法:

MD5:MD5 Message-Digest Algorithm,MD5消息摘要算法

SHA:Secure Hash Algorithm,安全散列算法

DES:Data Encryption Standard,数据加密标准

AES:Advanced Encryption Standard,高级加密标准

②对用于加密的哈希算法,有两点格外重要,第一点是很难根据哈希值反向推导出原始数据,第二点是散列冲突的概率要小。

③在实际开发中要权衡破解难度和计算时间来决定究竟使用哪种加密算法。

2.唯一标识

通过哈希算法计算出数据的唯一标识,从而用于高效检索数据。

3.数据校验

利用哈希算法对输入数据敏感的特点,可以对数据取哈希值,从而高效校验数据是否被篡改过。

4.散列函数

散列函数中用到的哈希算法更加关注散列后的值能不能平均分布,以及散列函数的执行快慢。

哈希算法在分布式系统中的应用

1.负载均衡

1.1.需求

如何实现一个会话粘滞(session sticky)的负载均衡算法?也就是说,在一次会话中的所有请求都路由到同一个服务器上。

1.2.解决方案

通过哈希算法对客户端IP或会话ID计算哈希值,将取得的哈希值与服务器列表的大小进行取模运算,最终得到的值就是应该被路由到的服务器编号。这样,就可以把同一个IP过来的请求都路由到同一个后端服务器上。

2.数据分片

2.1.如何统计“搜索关键词”出现的次数?

①需求描述

假如我们有1T的日志文件,这里面记录了用户的搜索关键词,我们想要快速统计出每个关键词被搜索的次数,该怎么做呢?

②问题分析

这个问题有两个难点,第一个是搜索量很大,没办法放到一台机器的内存中。第二个是只用一台机器来处理这么巨大的数据,处理时间会很长。

③解决方案

先对数据进行分片,然后采用多台(比如n台)机器进行处理。具体做法:从搜索记录的日志文件中依次读取每个关键词,并通过哈希函数计算该关键词的哈希值,然后跟机器的台数n取模,最终得到值就是该关键词应该被分到的机器编号,这样相同的关键词一定会被分配到同一台机器上,数据分配完成后,由多台机器并行进行统计,最后合并起来就是最终结果。

2.2.如何快速判断图片是否存在图库中?

①需求描述

假设现在我们的图库中有1亿张图片,如何快速判断图片是否在图库中?基本方式是给每个图片去唯一表示(或者信息摘要),然后构建散列表。

②问题分析

很显然,在单台机器上构建散列表示行不通的,因为单台机器的内存有限,而1亿张图片构建散列表远远超过了单台机器的内存上限。

②解决方案

准备n台机器,让每台机器只维护一部分图片对应的散列表。我们每次从图库中读取一个图片,计算唯一标识,然后与机器个数n求余取模,得到的值就对应要分配的机器编号,然后将这个图片的唯一表示和图片路径发往对应的机器构建散列表。

当我们要判断一个图片是否在图库中时,我们通过同样的哈希算法,计算这个图片的唯一表示,然后与机器个数n求余取模。假设得到的值是k,那就去编号为k的机器构建的散列表中查找。

如何估算给1亿张图片构建散列表大约需要多少台机器?

散列表中每个数据单元包含两个信息,哈希值和图片文件的路径。假设我们通过 MD5 来计算哈希值,那长度就是 128 比特,也就是 16 字节。文件路径长度的上限是 256 字节,我们可以假设平均长度是 128 字节。如果我们用链表法来解决冲突,那还需要存储指针,指针只占用 8 字节。所以,散列表中每个数据单元就占用 152 字节(这里只是估算,并不准确)。

假设一台机器的内存大小为 2GB,散列表的装载因子为 0.75,那一台机器可以给大约 1000 万(2GB*0.75/152)张图片构建散列表。所以,如果要对 1 亿张图片构建索引,需要大约十几台机器。在工程中,这种估算还是很重要的,能让我们事先对需要投入的资源、资金有个大概的了解,能更好地评估解决方案的可行性。

实际上,针对这种海量数据的处理问题,我们都可以采用多机分布式处理。借助这种分片的思路,可以突破单机内存、CPU 等资源的限制。

3.分布式存储

3.1.什么是分布式存储?

分布式存储就是将数据存储在多台机器上并提供高效的读取、写入支持。那如何决定将哪个数据放到哪个机器上呢?可以利用数据分片的思想,即通过哈希算法对数据取哈希值,然后对机器个数取模,这个最终值就是应该存储的缓存机器编号。

3.2.遇到的问题是什么?

如果数据持续增多,原来的机器数量已经不能满足需求,就需要增加机器,这时就麻烦了,因为所有的数据都需要重新哈希值进行再次分配。这就相当于缓存中的数据一下子都失效了,所有的数据请求都会穿透缓存,直接去请求数据库。这样就可能发生雪崩效应,压垮数据库。

3.3.解决方案是什么?

①这时,需要一种方法,使得新加入一个机器后,并不需要做大量的数据搬移。那就是在分布式系统中应用非常广泛的一致性哈希算法。

②一致性哈希算法的基本思想是什么呢?为了说清楚这个问题,我们假设有k个机器,数据的哈希值范围是[0-MAX],我们将整个范围划分成m个小区间(m远大于k),每个机器复杂m/k个小区间。当有新机器加入的时候,我们就将某几个小区间的数据,从原来的机器中搬移到新的机器中。这样,既不用全部重新哈希、搬移数据,也保持了各个机器上数据量的均衡。

二叉树(Binary Tree

编号2的二叉树中,叶子节点全都在最底层,除了叶子节点之外,每个节点都有左右两个子节点,这种二叉树就叫作满二叉树。编号3的二叉树中,叶子节点都在最底下两层,最后一层的叶子节点都靠左排列,并且除了最后一层,其他层的节点个数都要达到最大,这种二叉树叫作完全二叉树

想要存储一棵二叉树,我们有两种方法,一种是基于指针或者引用二叉链式存储法,一种是基于数组顺序存储法。

 

如果节点X存储在数组中下标为i的位置,下标为2 * i 的位置存储的就是左子节点,下标为2 * i + 1的位置存储的就是右子节点。反过来,下标为i/2的位置存储就是它的父节点

为什么完全二叉树要求最后一层的子节点都靠左?

非完全二叉树,会浪费比较多的数组存储空间。

如果某棵二叉树是一棵完全二叉树,那用数组存储无疑是最节省内存的一种方式。因为数组的存储方式并不需要像链式存储法那样,要存储额外的左右子节点的指针。

二叉树的遍历

  • 前序遍历是指,对于树中的任意节点来说,先打印这个节点,然后再打印它的左子树,最后打印它的右子树。
  • 中序遍历是指,对于树中的任意节点来说,先打印它的左子树,然后再打印它本身,最后打印它的右子树。
  • 后序遍历是指,对于树中的任意节点来说,先打印它的左子树,然后再打印它的右子树,最后打印这个节点本身。

从图可以看出,每个节点最多会被访问两次,所以遍历操作的时间复杂度,跟节点的个数n成正比,也就是说二叉树遍历的时间复杂度是O(n)。

二叉查找树(Binary Search Tree

二叉查找树要求,在树中的任意一个节点,其左子树中的每个节点的值,都要小于这个节点的值,而右子树节点的值都

这个节点的值。

1.二叉查找树的查找操作

我们先取根节点,如果它等于我们要查找的数据,那就返回。如果要查找的数据比根节点的值小,那就在左子树中递归查找;如果要查找的数据比根节点的值大,那就在右子树中递归查找。

2.二叉查找树的插入操作

如果要插入的数据比节点的数据大,并且节点的右子树为空,就将新数据直接插到右子节点的位置;如果不为空,就再递归遍历右子树,查找插入位置。同理,如果要插入的数据比节点数值小,并且节点的左子树为空,就将新数据插入到左子节点的位置;如果不为空,就再递归遍历左子树,查找插入位置。

3.二叉查找树的删除操作

针对要删除节点的子节点个数的不同,我们需要分三种情况来处理。

第一种情况是,如果要删除的节点没有子节点,我们只需要直接将父节点中,指向要删除节点的指针置为null。比如图中的删除节点55。

第二种情况是,如果要删除的节点只有一个子节点(只有左子节点或者右子节点),我们只需要更新父节点中,指向要删除节点的指针,让它指向要删除节点的子节点就可以了。比如图中的删除节点13。

第三种情况是,如果要删除的节点有两个子节点,这就比较复杂了。我们需要找到这个节点的右子树中的最小节点,把它替换到要删除的节点上。然后再删除掉这个最小节点,因为最小节点肯定没有左子节点(如果有左子结点,那就不是最小节点了),所以,我们可以应用上面两条规则来删除这个最小节点。比如图中的删除节点18。

public void delete(int data) {
 Node p = tree; // p指向要删除的节点,初始化指向根节点
 Node pp = null; // pp记录的是p的父节点
 while (p != null && p.data != data) {
 pp = p;
 if (data > p.data) p = p.right;
 else p = p.left;
 }
 if (p == null) return; // 没有找到
  if (p.left != null && p.right != null) { // 查找右子树中最小节点
 Node minP = p.right;
 Node minPP = p; // minPP表示minP的父节点
 while (minP.left != null) {
 minPP = minP;
 minP = minP.left;
 }
 p.data = minP.data; // 将minP的数据替换到p中
 p = minP; // 下面就变成了删除minP了
 pp = minPP;
 }
 // 删除节点是叶子节点或者仅有一个子节点
 Node child; // p的子节点
 if (p.left != null) child = p.left;
 else if (p.right != null) child = p.right;
 else child = null;
 if (pp == null) tree = child; // 删除的是根节点
 else if (pp.left == p) pp.left = child;
 else pp.right = child;
}

实际上,关于二叉查找树的删除操作,还有个非常简单、取巧的方法,就是单纯将要删除的节点标记为“已删除”,但是并不真正从树中将这个节点去掉。这样原本删除的节点还需要存储在内存中,比较浪费内存空间,但是删除操作就变得简单了很多。而且,这种处理方法也并没有增加插入、查找操作代码实现的难度。

二叉查找树除了支持上面几个操作之外,还有一个重要的特性,就是中序遍历二叉查找树,可以输出有序的数据序列,时间复杂度是O(n),非常高效。因此,二叉查找树也叫作二叉排序树。

支持重复数据的二叉查找树

前面讲二叉查找树的时候,我们默认树中节点存储的都是数字。很多时候,在实际的软件开发中,我们在二叉查找树中存储的,是一个包含很多字段的对象。我们利用对象的某个字段作为键值(key)来构建二叉查找树。我们把对象中的其他字段叫作卫星数据。

前面我们讲的二叉查找树的操作,针对的都是不存在键值相同的情况。那如果存储的两个对象键值相同,这种情况该怎么处理呢?我这里有两种解决方法。

第一种方法:二叉查找树中每一个节点不仅会存储一个数据,因此我们通过链表支持动态扩容的数组等数据结构,把值相同的数据都存储在同一个节点上。

第二种方法:每个节点仍然只存储一个数据。在查找插入位置的过程中,如果碰到一个节点的值,与要插入数据的值相同,我们就将这个要插入的数据放到这个节点的右子树,也就是说,把这个新插入的数据当作大于这个节点的值来处理。

 

当要查找数据的时候,遇到值相同的节点,我们并不停止查找操作,而是继续在右子树中查找,直到遇到叶子节点,才停止。这样就可以把键值等于要查找值的所有节点都找出来。

对于删除操作,我们也需要先查找到每个要删除的节点,然后再按前面讲的删除操作的方法,依次删除。

二叉查找树的时间复杂度分析

实际上,二叉查找树的形态各式各样。比如这个图中,对于同一组数据,我们构造了三种二叉查找树。它们的查找、插入、删除操作的执行效率都是不一样的。

图中第一种二叉查找树,根节点的左右子树极度不平衡,已经退化成了链表,所以查找的时间复杂度就变成了O(n)

最理想的情况,二叉查找树是一棵完全二叉树(或满二叉树)。

不管操作是插入、删除还是查找,时间复杂度其实都跟树的高度成正比,也就是O(height)。既然这样,现在问题就转变成另外一个了,也就是,如何求一棵包含n个节点的完全二叉树的高度

树的高度就等于最大层数减一,为了方便计算,我们转换成层来表示。从图中可以看出,包含n个节点的完全二叉树中,第一层包含1个节点,第二层包含2个节点,第三层包含4个节点,依次类推,下面一层节点个数是上一层的2倍,K包含的节点个数就是2^(K-1)

对于完全二叉树来说,最后一层的节点个数有点儿不遵守上面的规律了。它包含的节点个数在1个到2^(L-1)个之间(我们假设最大层数是L)。如果我们把每一层的节点个数加起来就是总的节点个数n。也就是说,如果节点的个数是n,那么n满足这样一个关系:

n >= 1+2+4+8+...+2^(L-2)+1

n <= 1+2+4+8+...+2^(L-2)+2^(L-1)

借助等比数列的求和公式,我们可以计算出,L的范围是[log2(n+1), log2(n) +1]。完全二叉树的层数小于等于log2(n) +1,也就是说,完全二叉树的高度小于等于log2(n)。

显然,极度不平衡的二叉查找树,它的查找性能肯定不能满足我们的需求。我们需要构建一种不管怎么删除、插入数据,在任何时候,都能保持任意节点左右子树都比较平衡的二叉查找树,即平衡二叉查找树。平衡二叉查找树的高度接近logn,所以插入、删除、查找操作的时间复杂度也比较稳定,是O(logn)

思考题

散列表的插入、删除、查找操作的时间复杂度可以做到常量级的O(1),非常高效。而二叉查找树在比较平衡的情况下,插入、删除、查找操作时间复杂度才是O(logn),相对散列表,好像并没有什么优势,那我们为什么还要用二叉查找树呢?

第一,散列表中的数据是无序存储的,如果要输出有序的数据,需要先进行排序。而对于二叉查找树来说,我们只需要中序遍历,就可以在O(n)的时间复杂度内,输出有序的数据序列。

第二,散列表扩容耗时很多,而且当遇到散列冲突时,性能不稳定,尽管二叉查找树的性能不稳定,但是在工程中,我们最常用的平衡二叉查找树的性能非常稳定,时间复杂度稳定在O(logn)。

第三,笼统地来说,尽管散列表的查找等操作的时间复杂度是常量级的,但因为哈希冲突的存在,这个常量不一定比logn小,所以实际的查找速度可能不一定比O(logn)快。加上哈希函数的耗时,也不一定就比平衡二叉查找树的效率高。

第四,散列表的构造比二叉查找树要复杂,需要考虑的东西很多。比如散列函数的设计、冲突解决办法、扩容、缩容等。平衡二叉查找树只需要考虑平衡性这一个问题,而且这个问题的解决方案比较成熟、固定。

第五,为了避免过多的散列冲突,散列表装载因子不能太大,特别是基于开放寻址法解决冲突的散列表,不然会浪费一定的存储空间。

如何通过编程,求出一棵给定二叉树的确切高度呢?

确定二叉树高度有两种思路:

第一种是深度优先思想的递归,分别求左右子树的高度。当前节点的高度就是左右子树中较大的那个+1

第二种可以采用层次遍历的方式,每一层记录都记录下当前队列的长度,这个是队尾,每一层队头从0开始。然后每遍历一个元素,队头下标+1。直到队头下标等于队尾下标。这个时候表示当前层遍历完成。每一层刚开始遍历的时候,树的高度+1。最后队列为空,就能得到树的高度。

红黑树(不必细抠实现,理解思路应该差不多了)

什么是平衡二叉查找树

平衡二叉树的严格定义是这样的:二叉树中任意一个节点左右子树高度相差不能大于1

完全二叉树、满二叉树其实都是平衡二叉树,但是非完全二叉树也有可能是平衡二叉树。

但是很多平衡二叉查找树其实并没有严格符合上面的定义(树中任意一个节点的左右子树的高度相差不能大于1),比如我们下面要讲的红黑树,它从根节点到各个叶子节点的最长路径有可能比最短路径大一倍

 发明平衡二叉查找树这类数据结构的初衷是,解决普通二叉查找树在频繁的插入、删除等动态更新的情况下,出现时间复杂度退化的问题。

如何定义一棵红黑树

平衡二叉查找树其实有很多,比如,Splay Tree(伸展树)、Treap(树堆)等,但是我们提到平衡二叉查找树,听到的基本都是红黑树。它的出镜率甚至要高于“平衡二叉查找树”这几个字,有时候,我们甚至默认平衡二叉查找树就是红黑树,那我们现在就来看看这个“明星树”。

红黑树的英文是“Red-Black Tree”,简称R-B Tree。它是一种不严格的平衡二叉查找树.

顾名思义,红黑树中的节点,一类被标记为黑色,一类被标记为红色。除此之外,一棵红黑树还需要满足这样几个要求:

  • 根节点黑色的;
  • 每个叶子节点都是黑色空节点(NIL),也就是说,叶子节点不存储数据
  • 任何相邻的节点不能同时为红色,也就是说,红色节点是被黑色节点隔开的;
  • 每个节点,从该节点到达其可达叶子节点所有路径,都包含相同数目黑色节点

这里的第二点要求“叶子节点都是黑色的空节点”,主要是为了简化红黑树的代码实现而设置的.

为什么说红黑树是近似平衡的?

平衡二叉查找树的初衷,是为了解决二叉查找树因为动态更新导致的性能退化问题。所以,平衡的意思可以等价为性能不退化。近似平衡就等价为性能不会退化的太严重。

二叉查找树很多操作的性能都跟树的高度成正比。一棵极其平衡的二叉树(满二叉树或完全二叉树)的高度大约是log2n,所以如果要证明红黑树是近似平衡的,我们只需要分析,红黑树的高度是否比较稳定地趋近log2n就好了。

我们来看,如果我们将红色节点从红黑树中去掉,那单纯包含黑色节点的红黑树的高度是多少呢?

红色节点删除之后,有些节点就没有父节点了,它们会直接拿这些节点的祖父节点(父节点的父节点)作为父节点。所以,之前的二叉树就变成了四叉树。

前面红黑树的定义里有这么一条:从任意节点到可达的叶子节点的每个路径包含相同数目的黑色节点。我们从四叉树中取出某些节点,放到叶节点位置,四叉树就变成了完全二叉树。所以,仅包含黑色节点的四叉树的高度,比包含相同节点个数完全二叉树高度还要小

完全二叉树的高度近似log2n,这里的四叉“黑树”的高度要低于完全二叉树,所以去掉红色节点的“黑树”的高度也不会超过log2n。

我们现在知道只包含黑色节点的黑树的高度,那我们现在把红色节点加回去,高度会变成多少呢?

从上面我画的红黑树的例子和定义看,在红黑树中,红色节点不能相邻,也就是说,有一个红色节点就要至少有一个黑色节点,将它跟其他红色节点隔开。红黑树中包含最多黑色节点的路径不会超过log2n,所以加入红色节点之后,最长路径不会超过2log2n,也就是说,红黑树的高度近似2log2n。

所以,红黑树的高度只比高度平衡的AVL树的高度(log2n)仅仅大了一倍,在性能上,下降得并不多。这样推导出来的结果不够精确,实际上红黑树的性能更好。

为什么在工程中大家都喜欢用红黑树这种平衡二叉查找树?

树堆(Treap)、伸展树(Splay Tree),绝大部分情况下,它们操作的效率都很高,但是也无法避免极端情况下时间复杂度的退化。尽管这种情况出现的概率不大,但是对于单次操作时间非常敏感的场景来说,它们并不适用。

AVL树是一种高度平衡的二叉树,所以查找的效率非常高,但是,有利就有弊,AVL树为了维持这种高度的平衡,就要付出更多的代价。每次插入、删除都要做调整,就比较复杂、耗时。所以,对于有频繁的插入、删除操作的数据集合,使用AVL树的代价就有点高了。

红黑树只是做到了近似平衡,并不是严格的平衡,所以在维护平衡的成本上,要比AVL树要低。

所以,红黑树的插入、删除、查找各种操作性能都比较稳定。对于工程应用来说,要面对各种异常情况,为了支撑这种工业级的应用,我们更倾向于这种性能稳定的平衡二叉查找树。

 

©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页