图书在版编目（CIP）数据

漫画算法：小灰的算法之旅／魏梦舒著. — 北京：电子工业出版社，2019.5

ISBN 978-7-121-36197-5

Ⅰ. ①漫… Ⅱ. ①魏… Ⅲ. ①算法分析②数据结构 Ⅳ. ①TP301.6②TP311.12

中国版本图书馆CIP数据核字（2019）第057355号

策划编辑：张月萍

责任编辑：牛勇

印　　刷：北京富诚彩色印刷有限公司

装　　订：北京富诚彩色印刷有限公司

出版发行：电子工业出版社

北京市海淀区万寿路173信箱　邮编：100036

开　　本：720×1000　1/16　　印张：17.5　字数：404千字

版　　次：2019年5月第1版

印　　次：2019年6月第2次印刷

印　　数：20001～28000册

质量投诉请发邮件至zlts@phei.com.cn，盗版侵权举报请发邮件至dbqq@phei.com.cn。

本书咨询联系方式：010-51260888-819　faq@phei.com.cn。

未经许可，不得以任何方式复制或抄袭本书之部分或全部内容。

版权所有，侵权必究。

目录

内容简介

Preface 推荐序

Preface 前言

第1章 算法概述

1.1 算法和数据结构

1.1.1 小灰和大黄

1.1.2 什么是算法

1.1.3 什么是数据结构

1.2 时间复杂度

1.2.1 算法的好与坏

1.2.2 基本操作执行次数

1.2.3 渐进时间复杂度

1.2.4 时间复杂度的巨大差异

1.3 空间复杂度

1.3.1 什么是空间复杂度

1.3.2 空间复杂度的计算

1.3.3 时间与空间的取舍

1.4 小结

第2章 数据结构基础

2.1 什么是数组

2.1.1 初识数组

2.1.2 数组的基本操作

2.1.3 数组的优势和劣势

2.2 什么是链表

2.2.1 “正规军”和“地下党”

2.2.2 链表的基本操作

2.2.3 数组VS链表

2.3 栈和队列

2.3.1 物理结构和逻辑结构

2.3.2 什么是栈

2.3.3 栈的基本操作

2.3.4 什么是队列

2.3.5 队列的基本操作

2.3.6 栈和队列的应用

22.4 神奇的散列表

2.4.1 为什么需要散列表

2.4.2 哈希函数

2.4.3 散列表的读写操作

2.5 小结

第3章 树

3.1 树和二叉树

3.1.1 什么是树

3.1.2 什么是二叉树

3.1.3 二叉树的应用

3.2 二叉树的遍历

3.2.1 为什么要研究遍历

3.2.2 深度优先遍历

3.2.3 广度优先遍历

3.3 什么是二叉堆

3.3.1 初识二叉堆

3.3.2 二叉堆的自我调整

3.3.3 二叉堆的代码实现

3.4 什么是优先队列

3.4.1 优先队列的特点

3.4.2 优先队列的实现

3.5 小结

第4章 排序算法

4.1 引言

4.2 什么是冒泡排序

4.2.1 初识冒泡排序

4.2.2 冒泡排序的优化

4.2.3 鸡尾酒排序

4.3 什么是快速排序

4.3.1 初识快速排序

4.3.2 基准元素的选择

4.3.3 元素的交换

4.3.4 单边循环法

4.3.5 非递归实现

4.4 什么是堆排序

4.4.1 传说中的堆排序

4.4.2 堆排序的代码实现

4.5 计数排序和桶排序

4.5.1 线性时间的排序

4.5.2 初识计数排序

4.5.3 计数排序的优化

4.5.4 什么是桶排序

4.6 小结

第5章 面试中的算法

5.1 踌躇满志的小灰

5.2 如何判断链表有环

5.2.1 一场与链表相关的面试

5.2.2 解题思路

5.2.3 问题扩展

5.3 最小栈的实现

5.3.1 一场关于栈的面试

5.3.2 解题思路

5.4 如何求出最大公约数

5.4.1 一场求最大公约数的面试

5.4.2 解题思路

5.5 如何判断一个数是否为2的整数次幂

5.5.1 一场很“2”的面试

5.5.2 解题思路

5.6 无序数组排序后的最大相邻差

5.6.1 一道奇葩的面试题

5.6.2 解题思路

5.7 如何用栈实现队列

5.7.1 又是一道关于栈的面试题

5.7.2 解题思路

5.8 寻找全排列的下一个数

5.8.1 一道关于数字的题目

5.8.2 解题思路

5.9 删去k个数字后的最小值

5.9.1 又是一道关于数字的题目

5.9.2 解题思路

5.10 如何实现大整数相加

5.10.1 加法，你会不会

5.10.2 解题思路

5.11 如何求解金矿问题

5.11.1 一个关于财富自由的问题

5.11.2 解题思路

5.12 寻找缺失的整数

5.12.1 “五行”缺一个整数

5.12.2 问题扩展

第6章 算法的实际应用

6.1 小灰上班的第1天

6.2 Bitmap的巧用

6.2.1 一个关于用户标签的需求

6.2.2 用算法解决问题

6.3 LRU算法的应用

6.3.1 一个关于用户信息的需求

6.3.2 用算法解决问题

6.4 什么是A星寻路算法

6.4.1 一个关于迷宫寻路的需求

6.4.2 用算法解决问题

6.5 如何实现红包算法

6.5.1 一个关于钱的需求

6.5.2 用算法解决问题

6.6 算法之路无止境

内容简介

本书通过虚拟的主人公小灰的心路历程，用漫画的形式讲述了算法和数据结构的基础知识、复杂多变的算法面试题目及算法的实际应用场景。

第1章　介绍了算法和数据结构的相关概念，告诉大家算法是什么，数据结构又是什么，它们有哪些用途，如何分析时间复杂度，如何分析空间复杂度。

第2章　介绍了最基本的数据结构，包括数组、链表、栈、队列、哈希表的概念和读写操作。

第3章　介绍了树和二叉树的概念、二叉树的各种遍历方式、二叉树的特殊形式——二叉堆和优先队列的应用。

第4章　介绍了几种典型的排序算法，包括冒泡排序、快速排序、堆排序、计数排序、桶排序。

第5章　介绍了10余道职场上流行的算法面试题及详细的解题思路。例如怎样判断链表有环、怎样计算大整数相加等。

第6章　介绍了算法在职场上的一些应用，例如使用LRU算法来淘汰冷数据，使用Bitmap算法来统计用户特征等。

Preface

推荐序

初识小灰是因为在他的微信公众号看到一篇讲动态规划的文章，当时觉得挺意外，没想到还能有人用漫画来解释动态规划算法。

所谓算法，其实是个很宽泛的概念。有理解起来难度超大，烧脑到要“爆炸”的；也有简单直接，一目了然的；更多的却是，虽然看起来复杂，但只要方法得当，搞清原理，掌握起来还是很容易的那种算法。

可是很多人被“算法”二字“狰狞”的外表吓住了，久久不敢接触它。好不容易斗胆翻翻算法书，结果看到的不是大篇大篇的代码，就是乱七八糟的符号。这都是什么呀？算了，看来是学不会算法了，放弃吧……

但凡书籍文章，最难读的，肯定是公式符号；而最好读的，无外乎图像、对话等。本书作者以可爱的小灰和大黄两个漫画形象为主人公，把对算法的描述过程嵌入到它们的对话之中，并辅之以图形等直观方式来表达数据结构和操作步骤——这种表达形式带着天然的亲和力，完全没有计算机背景的读者读来也不觉得生硬。

小灰所做的事情，就是给算法这颗“炮弹”包上了“糖衣”，让算法的威力潜藏于内，外表不再吓人，反而变得萌萌哒，Q弹可爱，清新怡人。

先干为敬，让我们一起吞了这颗包着“炸药”的“糖丸”吧！

李烨，微软高级软件工程师

Preface

前言

许多程序员对算法望而生畏，认为算法是一门高深莫测的学问。

以前我曾经面试过一个求职者，起初考查他的技术功底和项目经验，他都回答得不错。接下来我对他说：“OK，那我考查一下你的算法水平吧。”

题目还没说出口，该求职者立马摆摆手说：“不要不要，我算法不行的！”

我还是有些不甘心，接着说道：“我只考查最基础的，你说说冒泡排序的基本思路吧！”

他仍旧说：“我不知道，我算法一点都不会……”

算法真的那么难，真的那么无趣吗？

恰恰相反，算法是编程领域中最有意思的一块内容，也不像许多人想象的那样难以驾驭。

许多人把算法比作程序员的“内功”，但笔者觉得这个比喻并不是很恰当。内功实实在在，没有任何巧妙可言，而算法天马行空，千变万化，就像金庸笔下令狐冲的一套独孤九剑。

学习算法，我们不需要死记硬背那些冗长复杂的背景知识、底层原理、指令语法……需要做的是领悟算法思想、理解算法对内存空间和性能的影响，以及开动脑筋去寻求解决问题的最佳方案。相比编程领域的其他技术，算法更纯粹，更接近数学，也更具有趣味性。

我一直希望写出一些东西，让更多的IT同行能够领略到算法的魅力，可是用什么方式来写呢？

2016年9月，一次突如其来的灵感让我创造了一个初出茅庐的菜鸟程序员形象，这个菜鸟程序员名叫小灰。

程序员小灰的故事活跃在同名的微信公众号上，该公众号用漫画的形式诉说着小灰一次又一次的面试经历，倔强的小灰屡战屡败，屡败屡战。小灰是我刚刚入行时的真实写照，相信许多程序员也能从中看到自己的影子。

终于，在朋友们的支持和鼓励下，程序员小灰的故事从微信公众号搬到了纸质图书上。能让更多同行看到小灰的故事，我感到十分欣慰。

本书特色

这本书通过漫画的形式，讲述了小灰学习算法和数据结构知识的心路历程。书中许多内容源于本人的微信公众号，但是比公众号上所展现的内容更加系统、全面，也更加严谨。

本书的前4章是对算法基础知识的讲解，没有算法和数据结构基础的读者可以从头开始进行系统学习。

对于有一定基础的读者，也可以选择从第5章面试题的讲解开始阅读，每一道面试题目都是相对独立的，并不需要严格地按顺序学习。同时，也推荐大家适当看看前面的内容，巩固一下自己的算法知识体系。

这不是一本编程入门书。在编程方面完全零基础的读者，建议至少先了解一门编程语言。

这也不是一本局限于某个编程语言的书，虽然书中的代码示例都是用Java来实现的，但算法思想是相通的。在实现代码时，书中尽可能规避了Java语言的特殊语法和工具类，相信熟悉其他语言的开发者也不难看懂。

勘误和支持

除书中所提供的代码示例以外，大家也可以关注微信公众号“程序员小灰”，在后台回复“漫画算法”，获得全书完整的、可运行的代码。为了保证代码的简洁，在部分代码实现中省略了烦琐的参数判空和验证逻辑。

由于作者水平有限，书中难免会出现一些错误，恳请广大读者批评指正。读者如果在阅读过程中产生疑问或发现Bug，欢迎随时到微信公众号的后台留言。“程序员小灰”微信公众号二维码如下。

致谢

感谢微信公众号“程序员小灰”的读者。你们的鼓励和支持，给了我坚持创作的动力。

感谢成都道然科技有限责任公司的姚新军老师。有了他的肯定、支持和指导意见，才有了这本书的正式出版。

感谢朴提、单耳和康慧三位插画师所画的精彩插画，是你们让小灰的形象更丰满、更可爱。感谢为本书审稿的杨道谈先生，感谢为本书写序的李烨老师，感谢在百忙之中阅读书稿并写书评的专家们，他们是刘欣、张洪亮、安晓辉、李艳鹏、翟永超等。

特别感谢我的父母，是他们把我带进了数学的大门。在我上小学的时候，是他们的坚持，才让我有机会学习奥数，参加数学竞赛，并对数学和逻辑产生了兴趣。在这本书的写作过程中，又是他们辛苦努力屏蔽生活琐事对我的干扰，让我能够全身心地投入到本书的写作当中。

谨以此书献给我的家人，我的读者，以及热爱编程的朋友们！

魏梦舒，微信公众号“程序号小灰”的作者

第1章　算法概述

1.1　算法和数据结构

1.1.1　小灰和大黄

在大四临近毕业时，计算机专业的同学大都收到了满意的offer，可是小灰却还在着急上火。虽然他这几天面试了很多家IT公司，可每次都被面试官“虐”得很惨很惨。

就在心灰意冷之际，小灰忽然想到，他们系里有一位学霸名叫大黄，大黄不但技术很强，而且很乐意帮助同学。于是，小灰赶紧去找大黄，希望能够得到一些指点。

1.1.2　什么是算法

算法，对应的英文单词是algorithm，这是一个很古老的概念，最早来自数学领域。

有一个关于算法的小故事，估计大家都有耳闻。

在很久很久以前，曾经有一个顽皮又聪明的“熊孩子”，天天在课堂上调皮捣蛋。

终于有一天，老师忍无可忍，对“熊孩子”说：

臭小子，你又调皮啊！今天罚你算加法，算出1+2+3+4+5+6+7……一直加到10000的结果，算不完不许回家！

嘿嘿，我算就是了。

老师以为，“熊孩子”会按部就班地一步一步计算，就像下面这样。

1 + 2 = 3

3 + 3 = 6

6 + 4 = 10

10 + 5 = 15

……

这还不得算到明天天亮？够这小子受的！老师心里幸灾乐祸地想着。

谁知仅仅几分钟后……

老师，我算完了！结果是50 005 000，对不对？

这、这、这……你小子怎么算得这么快？我读书多，你骗不了我的！

看着老师惊讶的表情，“熊孩子”微微一笑，讲出了他的计算方法。

首先把从1到10 000这10 000个数字两两分组相加，如下。

1 + 10 000 = 10 001

2 + 9999 = 10 001

3 + 9998 = 10 001

4 + 9997 = 10 001

……

一共有多少组这样结果相同的和呢？有10 000÷2即5000组。

所以1到10 000相加的总和可以这样来计算：

(1+10 000)×10 000 ÷ 2 = 50 005 000

这个“熊孩子”就是后来著名的犹太数学家约翰·卡尔·弗里德里希·高斯，而他所采用的这种等差数列求和的方法，被称为高斯算法。（上文的故事情节与史实略有出入。）

这是数学领域中算法的一个简单示例。在数学领域里，算法是用于解决某一类问题的公式和思想。

而本书所涉及的算法，是计算机科学领域的算法，它的本质是一系列程序指令，用于解决特定的运算和逻辑问题。

从宏观上来看，数学领域的算法和计算机领域的算法有很多相通之处。

算法有简单的，也有复杂的。

简单的算法，诸如给出一组整数，找出其中最大的数。

复杂的算法，诸如在多种物品里选择装入背包的物品，使背包里的物品总价值最大，或找出从一个城市到另一个城市的最短路线。

算法有高效的，也有拙劣的。

刚才所讲的从1加到10000的故事中，高斯所用的算法显然是更加高效的算法，它利用等差数列的规律，四两拨千斤，省时省力地求出了最终结果。

而老师心中所想的算法，按部就班地一个数一个数进行累加，则是一种低效、笨拙的算法。虽然这种算法也能得到最终结果，但是其计算过程要低效得多。

在计算机领域，我们同样会遇到各种高效和拙劣的算法。衡量算法好坏的重要标准有两个。

- 时间复杂度

- 空间复杂度

具体的概念会在本章进行详细讲解。

算法的应用领域多种多样。

算法可以应用在很多不同的领域中，其应用场景更是多种多样，例如下面这些。

1. 运算

有人或许会觉得，不就是数学运算吗？这还不简单？

其实还真不简单。

例如求出两个数的最大公约数，要做到效率的极致，的确需要动一番脑筋。

再如计算两个超大整数的和，按照正常方式来计算肯定会导致变量溢出。这又该如何求解呢？

2. 查找

当你使用谷歌、百度搜索某一个关键词，或在数据库中执行某一条SQL语句时，你有没有思考过数据和信息是如何被查出来的呢？

3. 排序

排序算法是实现诸多复杂程序的基石。例如，当浏览电商网站时，我们期望商品可以按价格从低到高进行排序；当浏览学生管理网站时，我们期望学生的资料可以按照学号的大小进行排序。

排序算法有很多种，它们的性能和优缺点各不相同，这里面的学问可大着呢。

4. 最优决策

有些算法可以帮助我们找到最优的决策。

例如在游戏中，可以让AI角色找到迷宫的最佳路线，这涉及A星寻路算法。

再如对于一个容量有限的背包来说，如何决策才可以使放入的物品总价值最高，这涉及动态规划算法。

5. 面试（如果这条也算的话）

凡是已走上工作岗位的程序员，在面试过程中多多少少都经历过算法问题的考查。

为什么面试官那么喜欢考查算法呢？

考查算法问题，一方面可以检验程序员对计算机底层知识的了解，另一方面也可以衡量一下程序员的逻辑思维能力。

1.1.3　什么是数据结构

算法的概念我大致明白了，那数据结构又是什么呢?

数据结构是算法的基石。如果把算法比喻成美丽灵动的舞者，那么数据结构就是舞者脚下广阔而坚实的舞台。

数据结构，对应的英文单词是data structure，是数据的组织、管理和存储格式，其使用目的是为了高效地访问和修改数据。

数据结构都有哪些组成方式呢？

1. 线性结构

线性结构是最简单的数据结构，包括数组、链表，以及由它们衍生出来的栈、队列、哈希表。

2. 树

树是相对复杂的数据结构，其中比较有代表性的是二叉树，由它又衍生出了二叉堆之类的数据结构。

3. 图

图是更为复杂的数据结构，因为在图中会呈现出多对多的关联关系。

4. 其他数据结构

除上述所列的几种基本数据结构以外，还有一些其他的千奇百怪的数据结构。它们由基本数据结构变形而来，用于解决某些特定问题，如跳表、哈希链表、位图等。

有了数据结构这个舞台，算法才可以尽情舞蹈。在解决问题时，不同的算法会选用不同的数据结构。例如排序算法中的堆排序，利用的就是二叉堆这样一种数据结构；再如缓存淘汰算法LRU（Least Recently Used，最近最少使用），利用的就是特殊数据结构哈希链表。

关于算法在不同数据结构上的操作过程，在后续的章节中我们会一一进行学习。

想不到算法和数据结构包括这么多丰富多彩的内容，大黄，我以后要好好跟你混！

嘿嘿，我所掌握的也只是广阔的算法海洋中的一个小水洼，让我们一步一步来体验算法的无穷魅力吧！

1.2　时间复杂度

1.2.1　算法的好与坏

时间复杂度和空间复杂度究竟是什么呢？首先，让我们来想象一个场景。

某一天，小灰和大黄同时加入了同一家公司。

一天后，小灰和大黄交付了各自的代码，两人的代码实现的功能差不多。

大黄的代码运行一次要花100ms，占用内存5MB。

小灰的代码运行一次要花100s，占用内存500MB。

于是……

在上述场景中，小灰虽然也按照老板的要求实现了功能，但他的代码存在两个很严重的问题。

1. 运行时间长

运行别人的代码只要100ms，而运行小灰的代码则要100s，使用者肯定是无法忍受的。

2. 占用空间大

别人的代码只消耗5MB的内存，而小灰的代码却要消耗500MB的内存，这会给使用者造成很多麻烦。

由此可见，运行时间的长短和占用内存空间的大小，是衡量程序好坏的重要因素。

可是，如果代码都还没有运行，我怎么能预知代码运行所花的时间呢？

由于受运行环境和输入规模的影响，代码的绝对执行时间是无法预估的。但我们却可以预估代码的基本操作执行次数。

1.2.2　基本操作执行次数

关于代码的基本操作执行次数，下面用生活中的4个场景来进行说明。

场景1 给小灰1个长度为10cm的面包，小灰每3分钟吃掉1cm，那么吃掉整个面包需要多久？

答案自然是3×10即30分钟。

如果面包的长度是n cm呢？

此时吃掉整个面包，需要3乘以n即3n分钟。

如果用一个函数来表达吃掉整个面包所需要的时间，可以记作T(n) = 3n，n为面包的长度。

场景2 给小灰1个长度为16cm的面包，小灰每5分钟吃掉面包剩余长度的一半，即第5分钟吃掉8cm，第10分钟吃掉4cm，第15分钟吃掉2cm……那么小灰把面包吃得只剩1cm，需要多久呢？

这个问题用数学方式表达就是，数字16不断地除以2，那么除几次以后的结果等于1？这里涉及数学中的对数，即以2为底16的对数log_216。（注：本书下文中对数函数的底数全部省略。）

因此，把面包吃得只剩下1cm，需要5×log16即20分钟。

如果面包的长度是n cm呢？

此时，需要5乘以logn即5logn分钟，记作T(n) = 5logn。

场景3　给小灰1个长度为10cm的面包和1个鸡腿，小灰每2分钟吃掉1个鸡腿。那么小灰吃掉整个鸡腿需要多久呢？

答案自然是2分钟。因为这里只要求吃掉鸡腿，和10cm的面包没有关系。

如果面包的长度是n cm呢？

无论面包多长，吃掉鸡腿的时间都是2分钟，记作T(n) = 2。

场景4　给小灰1个长度为10cm的面包，小灰吃掉第1个1cm需要1分钟时间，吃掉第2个1cm需要2分钟时间，吃掉第3个1cm需要3分钟时间……每吃1cm所花的时间就比吃上一个1cm多用1分钟。那么小灰吃掉整个面包需要多久呢？

答案是从1累加到10的总和，也就是55分钟。

如果面包的长度是n cm呢？

根据高斯算法，此时吃掉整个面包需要 1+2+3+…+(n-1)+ n 即(1+n)×n/2分钟，也就是0.5n^2 + 0.5n分钟，记作T(n) = 0.5n^2 + 0.5n。

怎么除了吃还是吃啊？这还不得撑死？

上面所讲的是吃东西所花费的时间，这一思想同样适用于对程序基本操作执行次数的统计。设T(n)为程序基本操作执行次数的函数（也可以认为是程序的相对执行时间函数），n为输入规模，刚才的4个场景分别对应了程序中最常见的4种执行方式。

场景1　T(n) = 3n，执行次数是线性的。

1. void eat1(int n){

2.     for(int i=0; i<n; i++){;

3.         System.out.println("等待1分钟");

4.         System.out.println("等待1分钟");

5.         System.out.println("吃1cm 面包");

6.     }

7. }

场景2　T(n) = 5logn，执行次数是用对数计算的。

1. void eat2(int n){

2.     for(int i=n; i>1; i/=2){

3.         System.out.println("等待1分钟");

4.         System.out.println("等待1分钟");

5.         System.out.println("等待1分钟");

6.         System.out.println("等待1分钟");

7.         System.out.println("吃一半面包");

8.     }

9. }

场景3　T(n) = 2，执行次数是常量。

1. void eat3(int n){

2.     System.out.println(" 等待1分钟");

3.     System.out.println(" 吃1个鸡腿");

4. }

场景4　T(n) = 0.5n^2 + 0.5n，执行次数是用多项式计算的。

1. void eat4(int n){

2.     for(int i=0; i<n; i++){

3.         for(int j=0; j<i; j++){

4.             System.out.println("等待1分钟");

5.         }

6.         System.out.println("吃1cm 面包");

7.     }

8. }

1.2.3　渐进时间复杂度

有了基本操作执行次数的函数T(n)，是否就可以分析和比较代码的运行时间了呢？还是有一定困难的。

例如算法A的执行次数是T(n)= 100n，算法B的执行次数是T(n)= 5n^2，这两个到底谁的运行时间更长一些呢？这就要看n的取值了。

因此，为了解决时间分析的难题，有了渐进时间复杂度（asymptotic time complexity）的概念，其官方定义如下。

若存在函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称为O(f(n))，O为算法的渐进时间复杂度，简称为时间复杂度。

因为渐进时间复杂度用大写O来表示，所以也被称为大O表示法。

这个定义好晦涩呀，看不明白。

直白地讲，时间复杂度就是把程序的相对执行时间函数T(n)简化为一个数量级，这个数量级可以是n、n^2、n^3等。

如何推导出时间复杂度呢？有如下几个原则。

- 如果运行时间是常数量级，则用常数1表示

- 只保留时间函数中的最高阶项

- 如果最高阶项存在，则省去最高阶项前面的系数

让我们回头看看刚才的4个场景。

场景1

T(n) = 3n，

最高阶项为3n，省去系数3，则转化的时间复杂度为：T(n)=O(n)。

场景2

T(n) = 5logn，

最高阶项为5logn，省去系数5，则转化的时间复杂度为：T(n) =O(logn)。

场景3

T(n) = 2，

只有常数量级，则转化的时间复杂度为：T(n) =O(1)。

场景4

T(n) = 0.5n^2+ 0.5n，

最高阶项为0.5n^2，省去系数0.5，则转化的时间复杂度为：T(n) =O(n^2)。

这4种时间复杂度究竟谁的程度执行用时更长，谁更节省时间呢？当n的取值足够大时，不难得出下面的结论：

O(1)<O(logn)<O(n)<O(n^2)

在编程的世界中有各种各样的算法，除了上述4个场景，还有许多不同形式的时间复杂度，例如：

O(nlogn)、O(n^3)、O(mn)、O(2n)、O(n!)

今后当我们遨游在代码的海洋中时，会陆续遇到上述时间复杂度的算法。

1.2.4　时间复杂度的巨大差异

大黄，我还有一个问题，现在计算机硬件的性能越来越强了，我们为什么还这么重视时间复杂度呢？

问得很好，让我们用两个算法来做一个对比，看一看高效算法和低效算法有多大的差距。

举例如下。

算法A的执行次数是T(n)= 100n，时间复杂度是O(n)。

算法B的执行次数是T(n)= 5n^2，时间复杂度是O(n^2)。

算法A运行在小灰家里的老旧电脑上，算法B运行在某台超级计算机上，超级计算机的运行速度是老旧电脑的100倍。

那么，随着输入规模n的增长，两种算法谁运行速度更快呢？

从上面的表格可以看出，当n的值很小时，算法A的运行用时要远大于算法B；当n的值在1000左右时，算法A和算法B的运行时间已经比较接近；随着n的值越来越大，甚至达到十万、百万时，算法A的优势开始显现出来，算法B的运行速度则越来越慢，差距越来越明显。

这就是不同时间复杂度带来的差距。

要想学好算法，就必须理解时间复杂度这个重要的基础概念。有关时间复杂度的知识就介绍到这里，我们下一节再见！

1.3　空间复杂度

1.3.1　什么是空间复杂度

在运行一段程序时，我们不仅要执行各种运算指令，同时也会根据需要，存储一些临时的中间数据，以便后续指令可以更方便地继续执行。

在什么情况下需要这些中间数据呢？让我们来看看下面的例子。

给出下图所示的n个整数，其中有两个整数是重复的，要求找出这两个重复的整数。

对于这个简单的需求，可以用很多种思路来解决，其中最朴素的方法就是双重循环，具体如下。

遍历整个数列，每遍历到一个新的整数就开始回顾之前遍历过的所有整数，看看这些整数里有没有与之数值相同的。

第1步，遍历整数3，前面没有数字，所以无须回顾比较。

第2步，遍历整数1，回顾前面的数字3，没有发现重复数字。

第3步，遍历整数2，回顾前面的数字3、1，没有发现重复数字。

后续步骤类似，一直遍历到最后的整数2，发现和前面的整数2重复。

双重循环虽然可以得到最终结果，但它显然并不是一个好的算法。

它的时间复杂度是多少呢？

根据上一节所学的方法，我们不难得出结论，这个算法的时间复杂度是O(n^2)。

那么，怎样才能提高算法的效率呢？

在这种情况下，我们就有必要利用一些中间数据了。

如何利用中间数据呢？

当遍历整个数列时，每遍历一个整数，就把该整数存储起来，就像放到字典中一样。当遍历下一个整数时，不必再慢慢向前回溯比较，而直接去“字典”中查找，看看有没有对应的整数即可。

假如已经遍历了数列的前7个整数，那么字典里存储的信息如下。

“字典”左侧的Key代表整数的值，“字典”右侧的Value代表该整数出现的次数（也可以只记录Key）。

接下来，当遍历到最后一个整数2时，从“字典”中可以轻松找到2曾经出现过，问题也就迎刃而解了。

由于读写“字典”本身的时间复杂度是O(1)，所以整个算法的时间复杂度是O(n)，和最初的双重循环相比，运行效率大大提高了。

而这个所谓的“字典”，是一种特殊的数据结构，叫作散列表。这个数据结构需要开辟一定的内存空间来存储有用的数据信息。

但是，内存空间是有限的，在时间复杂度相同的情况下，算法占用的内存空间自然是越小越好。如何描述一个算法占用的内存空间的大小呢？这就用到了算法的另一个重要指标——空间复杂度（space complexity）。

和时间复杂度类似，空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，它同样使用了大O表示法。

程序占用空间大小的计算公式记作S(n)=O(f(n))，其中n为问题的规模，f(n)为算法所占存储空间的函数。

1.3.2　空间复杂度的计算

基本的概念已经明白了，那么，我们如何来计算空间复杂度呢？

具体情况要具体分析。和时间复杂度类似，空间复杂度也有几种不同的增长趋势。

常见的空间复杂度有下面几种情形。

1. 常量空间

当算法的存储空间大小固定，和输入规模没有直接的关系时，空间复杂度记作O(1)。例如下面这段程序：

1. void fun1(int n){

2.     int var = 3;

3.      …

4. }

2. 线性空间

当算法分配的空间是一个线性的集合（如数组），并且集合大小和输入规模n成正比时，空间复杂度记作O(n)。

例如下面这段程序：

1. void fun2(int n){

2.     int[] array = new int[n];

3.      …

4. }

3. 二维空间

当算法分配的空间是一个二维数组集合，并且集合的长度和宽度都与输入规模n成正比时，空间复杂度记作O(n^2)。

例如下面这段程序：

1. void fun3(int n){

2.     int[][] matrix = new int[n][n];

3.      …

4. }

4. 递归空间

递归是一个比较特殊的场景。虽然递归代码中并没有显式地声明变量或集合，但是计算机在执行程序时，会专门分配一块内存，用来存储“方法调用栈”。

“方法调用栈”包括进栈和出栈两个行为。

当进入一个新方法时，执行入栈操作，把调用的方法和参数信息压入栈中。

当方法返回时，执行出栈操作，把调用的方法和参数信息从栈中弹出。

下面这段程序是一个标准的递归程序：

1. void fun4(int n){

2.     if(n<=1){

3.         return;

4.     }

5.     fun4(n-1);

6.      …

7. }

假如初始传入参数值n=5，那么方法fun4（参数n=5）的调用信息先入栈。

接下来递归调用相同的方法，方法fun4（参数n=4）的调用信息入栈。

以此类推，递归越来越深，入栈的元素就越来越多。

当n=1时，达到递归结束条件，执行return指令，方法出栈。

最终，“方法调用栈”的全部元素会一一出栈。

由上面“方法调用栈”的出入栈过程可以看出，执行递归操作所需要的内存空间和递归的深度成正比。纯粹的递归操作的空间复杂度也是线性的，如果递归的深度是n，那么空间复杂度就是O(n)。

1.3.3　时间与空间的取舍

人们之所以花大力气去评估算法的时间复杂度和空间复杂度，其根本原因是计算机的运算速度和空间资源是有限的。

就如一个大财主，基本不必为日常花销伤脑筋；而一个没多少积蓄的普通人，则不得不为日常花销精打细算。

对于计算机系统来说也是如此。虽然目前计算机的CPU处理速度不断飙升，内存和硬盘空间也越来越大，但是面对庞大而复杂的数据和业务，我们仍然要精打细算，选择最有效的利用方式。

但是，正所谓鱼和熊掌不可兼得。很多时候，我们不得不在时间复杂度和空间复杂度之间进行取舍。

在1.3.1小节寻找重复整数的例子中，双重循环的时间复杂度是O(n^2)，空间复杂度是O(1)，这属于牺牲时间来换取空间的情况。

相反，字典法的空间复杂度是O(n)，时间复杂度是O(n)，这属于牺牲空间来换取时间的情况。

在绝大多数时候，时间复杂度更为重要一些，我们宁可多分配一些内存空间，也要提升程序的执行速度。

此外，说起空间复杂度就离不开数据结构。在本章中，我们提及散列表、数组、二维数组这些常用的集合。如果大家对这些数据结构不是很了解，可以仔细看看本书第2章关于基本数据结构的内容，里面有详细的介绍。

关于空间复杂度的知识，我们就介绍到这里。时间复杂度和空间复杂度都是学好算法的重要前提，一定要牢牢掌握哦！

1.4　小结

- 什么是算法

在计算机领域里，算法是一系列程序指令，用于处理特定的运算和逻辑问题。

衡量算法优劣的主要标准是时间复杂度和空间复杂度。

- 什么是数据结构

数据结构是数据的组织、管理和存储格式，其使用目的是为了高效地访问和修改数据。

数据结构包含数组、链表这样的线性数据结构，也包含树、图这样的复杂数据结构。

- 什么是时间复杂度

时间复杂度是对一个算法运行时间长短的量度，用大O表示，记作T(n)=O(f(n))。

常见的时间复杂度按照从低到高的顺序，包括O(1)、O(logn)、O(n)、O(nlogn)、O(n^2)等。

- 什么是空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，用大O表示，记作S(n)=O(f(n))。

常见的空间复杂度按照从低到高的顺序，包括O(1)、O(n)、O(n^2)等。其中递归算法的空间复杂度和递归深度成正比。

第2章　数据结构基础

2.1　什么是数组

2.1.1　初识数组

这些特点是如何体现的呢？

参加过军训的读者，一定都记得这样的场景。

在军队里，每一个士兵都有自己固定的位置、固定的编号。众多士兵紧密团结在一起，高效地执行着一个个命令。

大黄，咱们为什么要说这么多关于军队的事情呢？

因为有一个数据结构就像军队一样整齐、有序，这个数据结构叫作数组。

什么是数组？

数组对应的英文是array，是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。

以整型数组为例，数组的存储形式如下图所示。

正如军队里的士兵存在编号一样，数组中的每一个元素也有着自己的下标，只不过这个下标从0开始，一直到数组长度-1。

数组的另一个特点，是在内存中顺序存储，因此可以很好地实现逻辑上的顺序表。

数组在内存中的顺序存储，具体是什么样子呢？

内存是由一个个连续的内存单元组成的，每一个内存单元都有自己的地址。在这些内存单元中，有些被其他数据占用了，有些是空闲的。

数组中的每一个元素，都存储在小小的内存单元中，并且元素之间紧密排列，既不能打乱元素的存储顺序，也不能跳过某个存储单元进行存储。

在上图中，橙色的格子代表空闲的存储单元，灰色的格子代表已占用的存储单元，而红色的连续格子代表数组在内存中的位置。

不同类型的数组，每个元素所占的字节个数也不同，本图只是一个简单的示意图。

那么，我们怎样来使用一个数组呢？

数据结构的操作无非是增、删、改、查4种情况，下面让我们来看一看数组的基本操作。

2.1.2　数组的基本操作

1. 读取元素

对于数组来说，读取元素是最简单的操作。由于数组在内存中顺序存储，所以只要给出一个数组下标，就可以读取到对应的数组元素。

假设有一个名称为array的数组，我们要读取数组下标为3的元素，就写作array[3]；读取数组下标为5的元素，就写作array[5]。需要注意的是，输入的下标必须在数组的长度范围之内，否则会出现数组越界。

像这种根据下标读取元素的方式叫作随机读取。

简单的代码示例如下：

1. int[] array = new int[]{3,1,2,5,4,9,7,2};

2. // 输出数组中下标为3的元素

3. System.out.println(array[3]);

2. 更新元素

要把数组中某一个元素的值替换为一个新值，也是非常简单的操作。直接利用数组下标，就可以把新值赋给该元素。

简单的代码示例如下：

1. int[] array = new int[]{3,1,2,5,4,9,7,2};

2. // 给数组下标为5的元素赋值

3. array[5] = 10;

4. // 输出数组中下标为5的元素

5. System.out.println(array[5]);

小灰，咱们刚刚讲过时间复杂度的概念，你说说数组读取元素和更新元素的时间复杂度分别是多少？

嘿嘿，这难不倒我。数组读取元素和更新元素的时间复杂度都是O(1)。

3. 插入元素

在介绍插入数组元素的操作之前，我们需要补充一个概念，那就是数组的实际元素数量有可能小于数组的长度，例如下面的情形。

因此，插入数组元素的操作存在3种情况。

- 尾部插入

- 中间插入

- 超范围插入

尾部插入，是最简单的情况，直接把插入的元素放在数组尾部的空闲位置即可，等同于更新元素的操作。

中间插入，稍微复杂一些。由于数组的每一个元素都有其固定下标，所以不得不首先把插入位置及后面的元素向后移动，腾出地方，再把要插入的元素放到对应的数组位置上。

中间插入操作的完整实现代码如下：

1. private int[] array;

2. private int size;

3.

4. public MyArray(int capacity){

5.     this.array = new int[capacity];

6.     size = 0;

7. }

8.

9. /**

10.   * 数组插入元素

11.  * @param element    插入的元素

12.  * @param index    插入的位置

13.   */

14. public void insert(int element, int index) throws Exception {

15.     //判断访问下标是否超出范围

16.     if(index<0 || index>size){

17.         throw new IndexOutOfBoundsException("超出数组实际元素范围！");

18.     }

19.     //从右向左循环，将元素逐个向右挪1位

20.     for(int i=size-1; i>=index; i--){

21.         array[i+1] = array[i];

22.     }

23.     //腾出的位置放入新元素

24.     array[index] = element;

25.     size++;

26. }

27.

28. /**

29.   * 输出数组

30.   */

31. public void output(){

32.     for(int i=0; i<size; i++){

33.         System.out.println(array[i]);

34.     }

35. }

36.

37. public static void main(String[] args) throws Exception {

38.     MyArray myArray = new MyArray(10);

39.     myArray.insert(3,0);

40.     myArray.insert(7,1);

41.     myArray.insert(9,2);

42.     myArray.insert(5,3);

43.     myArray.insert(6,1);

44.     myArray.output();

45. }

代码中的成员变量size是数组实际元素的数量。如果插入元素在数组尾部，传入的下标参数index等于size；如果插入元素在数组中间或头部，则index小于size。

如果传入的下标参数index大于size或小于0，则认为是非法输入，会直接抛出异常。

可是，如果数组不断插入新的元素，元素数量超过了数组的最大长度，数组岂不是要“撑爆”了？

问得很好，这就是接下来要讲的情况——超范围插入。

超范围插入，又是什么意思呢？

假如现在有一个长度为6的数组，已经装满了元素，这时还想插入一个新元素。

这就涉及数组的扩容了。可是数组的长度在创建时就已经确定了，无法像孙悟空的金箍棒那样随意变长或变短。这该如何是好呢？

此时可以创建一个新数组，长度是旧数组的2倍，再把旧数组中的元素统统复制过去，这样就实现了数组的扩容。

如此一来，我们的插入元素方法也需要改写了，改写后的代码如下：

1. private int[] array;

2. private int size;

3.

4. public MyArray(int capacity){

5.     this.array = new int[capacity];

6.     size = 0;

7. }

8.

9. /**

10.   * 数组插入元素

11.  * @param element    插入的元素

12.  * @param index    插入的位置

13.   */

14. public void insert(int element, int index) throws Exception {

15.     //判断访问下标是否超出范围

16.     if(index<0 || index>size){

17.         throw new IndexOutOfBoundsException("超出数组实际元素范围！");

18.     }

19.     //如果实际元素达到数组容量上限，则对数组进行扩容

20.     if(size >= array.length){

21.         resize();

22.     }

23.     //从右向左循环，将元素逐个向右挪1位

24.     for(int i=size-1; i>=index; i--){

25.         array[i+1] = array[i];

26.     }

27.     //腾出的位置放入新元素

28.     array[index] = element;

29.     size++;

30. }

31.

32. /**

33.   * 数组扩容

34.   */

35. public void resize(){

36.     int[] arrayNew = new int[array.length*2];

37.     //从旧数组复制到新数组

38.     System.arraycopy(array, 0, arrayNew, 0, array.length);

39.     array = arrayNew;

40. }

41.

42. /**

43.   * 输出数组

44.   */

45. public void output(){

46.     for(int i=0; i<size; i++){

47.         System.out.println(array[i]);

48.     }

49. }

50.

51. public static void main(String[] args) throws Exception {

52.     MyArray myArray = new MyArray(4);

53.     myArray.insert(3,0);

54.     myArray.insert(7,1);

55.     myArray.insert(9,2);

56.     myArray.insert(5,3);

57.     myArray.insert(6,1);

58.     myArray.output();

59. }

4. 删除元素

数组的删除操作和插入操作的过程相反，如果删除的元素位于数组中间，其后的元素都需要向前挪动1位。

由于不涉及扩容问题，所以删除操作的代码实现比插入操作要简单：

1. /**

2.  * 数组删除元素

3.  * @param index  删除的位置

4.  */

5. public int delete(int index) throws Exception {

6.     //判断访问下标是否超出范围

7.     if(index<0 || index>=size){

8.         throw new IndexOutOfBoundsException("超出数组实际元素范围！");

9.     }

10.     int deletedElement = array[index];

11.     //从左向右循环，将元素逐个向左挪1位

12.     for(int i=index; i<size-1; i++){

13.         array[i] = array[i+1];

14.     }

15.     size--;

16.     return deletedElement;

17. }

小灰，我再考考你，数组的插入和删除操作，时间复杂度分别是多少？

先说说插入操作，数组扩容的时间复杂度是O(n)，插入并移动元素的时间复杂度也是O(n)，综合起来插入操作的时间复杂度是O(n)。至于删除操作，只涉及元素的移动，时间复杂度也是O(n)。

说得没错。对于删除操作，其实还存在一种取巧的方式，前提是数组元素没有顺序要求。

例如下图所示，需要删除的是数组中的元素2，可以把最后一个元素复制到元素2所在的位置，然后再删除掉最后一个元素。

这样一来，无须进行大量的元素移动，时间复杂度降低为O(1)。当然，这种方式只作参考，并不是删除元素时主流的操作方式。

2.1.3　数组的优势和劣势

数组的基本知识我懂了，那么，使用数组这种数据结构有什么优势和劣势呢？

数组拥有非常高效的随机访问能力，只要给出下标，就可以用常量时间找到对应元素。有一种高效查找元素的算法叫作二分查找，就是利用了数组的这个优势。

至于数组的劣势，体现在插入和删除元素方面。由于数组元素连续紧密地存储在内存中，插入、删除元素都会导致大量元素被迫移动，影响效率。

总的来说，数组所适合的是读操作多、写操作少的场景，下一节我们要讲解的链表则恰恰相反。好了，让我们下一节再会！

2.2　什么是链表

2.2.1　“正规军”和“地下党”

地下党都是一些什么样的人物呢？

在影视作品中，我们可能都见到过地下工作者的经典话语：

“上级的姓名、住址，我知道，下级的姓名、住址，我也知道，但是这些都是我们党的秘密，不能告诉你们！”

地下党借助这种单线联络的方式，灵活隐秘地传递着各种重要信息。

在计算机科学领域里，有一种数据结构也恰恰具备这样的特征，这种数据结构就是链表。

链表是什么样子的？为什么说它像地下党呢？

让我们来看一看单向链表的结构。

链表（linked list）是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。

单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一个节点的指针next。

1. private static class Node {

2.     int data;

3.     Node next;

4. }

链表的第1个节点被称为头节点，最后1个节点被称为尾节点，尾节点的next指针指向空。

与数组按照下标来随机寻找元素不同，对于链表的其中一个节点A，我们只能根据节点A的next指针来找到该节点的下一个节点B，再根据节点B的next指针找到下一个节点C……

这正如地下党的联络方式，一级一级，单线传递。

那么，通过链表的一个节点，如何能快速找到它的前一个节点呢？

要想让每个节点都能回溯到它的前置节点，我们可以使用双向链表。

什么是双向链表？

双向链表比单向链表稍微复杂一些，它的每一个节点除了拥有data和next指针，还拥有指向前置节点的prev指针。

接下来我们看一看链表的存储方式。

如果说数组在内存中的存储方式是顺序存储，那么链表在内存中的存储方式则是随机存储。

什么叫随机存储呢？

上一节我们讲解了数组的内存分配方式，数组在内存中占用了连续完整的存储空间。而链表则采用了见缝插针的方式，链表的每一个节点分布在内存的不同位置，依靠next指针关联起来。这样可以灵活有效地利用零散的碎片空间。

让我们看一看下面两张图，对比一下数组和链表在内存中分配方式的不同。

数组的内存分配方式

链表的内存分配方式

图中的箭头代表链表节点的next指针。

那么，我们怎样来使用一个链表呢？

上一节刚刚讲过数组的增、删、改、查，这一次来看看链表的相关操作。

2.2.2　链表的基本操作

1. 查找节点

在查找元素时，链表不像数组那样可以通过下标快速进行定位，只能从头节点开始向后一个一个节点逐一查找。

例如给出一个链表，需要查找从头节点开始的第3个节点。

第1步，将查找的指针定位到头节点。

第2步，根据头节点的next指针，定位到第2个节点。

第3步，根据第2个节点的next指针，定位到第3个节点，查找完毕。

小灰，你说说查找链表节点的时间复杂度是多少？

链表中的数据只能按顺序进行访问，最坏的时间复杂度是O(n)。

2. 更新节点

如果不考虑查找节点的过程，链表的更新过程会像数组那样简单，直接把旧数据替换成新数据即可。

3. 插入节点

与数组类似，链表插入节点时，同样分为3种情况。

- 尾部插入

- 头部插入

- 中间插入

尾部插入，是最简单的情况，把最后一个节点的next指针指向新插入的节点即可。

头部插入，可以分成两个步骤。

第1步，把新节点的next指针指向原先的头节点。

第2步，把新节点变为链表的头节点。

中间插入，同样分为两个步骤。

第1步，新节点的next指针，指向插入位置的节点。

第2步，插入位置前置节点的next指针，指向新节点。

只要内存空间允许，能够插入链表的元素是无穷无尽的，不需要像数组那样考虑扩容的问题。

4. 删除元素

链表的删除操作同样分为3种情况。

- 尾部删除

- 头部删除

- 中间删除

尾部删除，是最简单的情况，把倒数第2个节点的next指针指向空即可。

头部删除，也很简单，把链表的头节点设为原先头节点的next指针即可。

中间删除，同样很简单，把要删除节点的前置节点的next指针，指向要删除元素的下一个节点即可。

这里需要注意的是，许多高级语言，如Java，拥有自动化的垃圾回收机制，所以我们不用刻意去释放被删除的节点，只要没有外部引用指向它们，被删除的节点会被自动回收。

小灰，我再考考你，链表的插入和删除操作，时间复杂度分别是多少？

如果不考虑插入、删除操作之前查找元素的过程，只考虑纯粹的插入和删除操作，时间复杂度都是O(1)。

很好，接下来看一看实现链表的完整代码。

1. // 头节点指针

2. private Node head;

3. // 尾节点指针

4. private Node last;

5. // 链表实际长度

6. private int size;

7.

8. /**

9.  * 链表插入元素

10.  * @param data  插入元素

11.  * @param index  插入位置

12.   */

13. public void insert(int data, int index) throws Exception {

14.     if (index<0 || index>size) {

15.         throw new IndexOutOfBoundsException(" 超出链表节点范围！");

16.     }

17.     Node insertedNode = new Node(data);

18.     if(size == 0){

19.         //空链表

20.         head = insertedNode;

21.         last = insertedNode;

22.     } else if(index == 0){

23.         //插入头部

24.         insertedNode.next = head;

25.         head = insertedNode;

26.     }else if(size == index){

27.         //插入尾部

28.         last.next = insertedNode;

29.         last = insertedNode;

30.     }else {

31.         //插入中间

32.         Node prevNode = get(index-1);

33.         insertedNode.next = prevNode.next;

34.         prevNode.next = insertedNode;

35.     }

36.     size++;

37. }

38.

39. /**

40.   * 链表删除元素

41.  * @param index  删除的位置

42.   */

43. public Node remove(int index) throws Exception {

44.     if (index<0 || index>=size) {

45.         throw new IndexOutOfBoundsException(" 超出链表节点范围！");

46.     }

47.     Node removedNode = null;

48.     if(index == 0){

49.         //删除头节点

50.         removedNode = head;

51.         head = head.next;

52.     }else if(index == size-1){

53.         //删除尾节点

54.         Node prevNode = get(index-1);

55.         removedNode = prevNode.next;

56.         prevNode.next = null;

57.         last = prevNode;

58.     }else {

59.         //删除中间节点

60.         Node prevNode = get(index-1);

61.         Node nextNode = prevNode.next.next;

62.         removedNode = prevNode.next;

63.         prevNode.next = nextNode;

64.     }

65.     size--;

66.     return removedNode;

67. }

68.

69. /**

70.   * 链表查找元素

71.  * @param index  查找的位置

72.   */

73. public Node get(int index) throws Exception {

74.     if (index<0 || index>=size) {

75.         throw new IndexOutOfBoundsException(" 超出链表节点范围！");

76.     }

77.     Node temp = head;

78.     for(int i=0; i<index; i++){

79.         temp = temp.next;

80.     }

81.     return temp;

82. }

83.

84. /**

85.   * 输出链表

86.   */

87. public void output(){

88.     Node temp = head;

89.     while (temp!=null) {

90.         System.out.println(temp.data);

91.         temp = temp.next;

92.     }

93. }

94.

95. /**

96.   * 链表节点

97.   */

98. private static class Node {

99.     int data;

100.    Node next;

101.    Node(int data) {

102.        this.data = data;

103.    }

104.}

105.

106.public static void main(String[] args) throws Exception {

107.    MyLinkedList myLinkedList = new MyLinkedList();

108.    myLinkedList.insert(3,0);

109.    myLinkedList.insert(7,1);

110.    myLinkedList.insert(9,2);

111.    myLinkedList.insert(5,3);

112.    myLinkedList.insert(6,1);

113.    myLinkedList.remove(0);

114.    myLinkedList.output();

115.}

以上是对单链表相关操作的代码实现。为了尾部插入的方便，代码中额外增加了指向链表尾节点的指针last。

2.2.3　数组VS链表

链表的基本知识我懂了。数组和链表都属于线性的数据结构，用哪一个更好呢？

数据结构没有绝对的好与坏，数组和链表各有千秋。下面我总结了数组和链表相关操作的性能，我们来对比一下。

从表格可以看出，数组的优势在于能够快速定位元素，对于读操作多、写操作少的场景来说，用数组更合适一些。

相反地，链表的优势在于能够灵活地进行插入和删除操作，如果需要在尾部频繁插入、删除元素，用链表更合适一些。

关于链表的知识我们就介绍到这里，咱们下一节再见！

2.3　栈和队列

2.3.1　物理结构和逻辑结构

什么是数据存储的物理结构呢？

如果把数据结构比作活生生的人，那么物理结构就是人的血肉和骨骼，看得见，摸得着，实实在在。例如我们刚刚学过的数组和链表，都是内存中实实在在的存储结构。

而在物质的人体之上，还存在着人的思想和精神，它们看不见、摸不着。看过电影《阿凡达》 吗？男主角的思想意识从一个瘦弱残疾的人类身上被移植到一个高大威猛的蓝皮肤外星人身上，虽然承载思想意识的肉身改变了，但是人格却是唯一的。

如果把物质层面的人体比作数据存储的物理结构，那么精神层面的人格则是数据存储的逻辑结构。逻辑结构是抽象的概念，它依赖于物理结构而存在。

下面我们来讲解两个常用数据结构：栈和队列。这两者都属于逻辑结构，它们的物理实现既可以利用数组，也可以利用链表来完成。

在后面的章节中，我们会学习到二叉树，这也是一种逻辑结构。同样地，二叉树也可以依托于物理上的数组或链表来实现。

2.3.2　什么是栈

要弄明白什么是栈，我们需要先举一个生活中的例子。

假如有一个又细又长的圆筒，圆筒一端封闭，另一端开口。往圆筒里放入乒乓球，先放入的靠近圆筒底部，后放入的靠近圆筒入口。

那么，要想取出这些乒乓球，则只能按照和放入顺序相反的顺序来取，先取出后放入的，再取出先放入的，而不可能把最里面最先放入的乒乓球优先取出。

栈（stack）是一种线性数据结构，它就像一个上图所示的放入乒乓球的圆筒容器，栈中的元素只能先入后出（First In Last Out，简称FILO）。最早进入的元素存放的位置叫作栈底（bottom），最后进入的元素存放的位置叫作栈顶（top）。

栈这种数据结构既可以用数组来实现，也可以用链表来实现。

栈的数组实现如下。

栈的链表实现如下。

那么，栈可以进行哪些操作呢？

栈的最基本操作是入栈和出栈，下面让我们来看一看。

2.3.3　栈的基本操作

1. 入栈

入栈操作（push）就是把新元素放入栈中，只允许从栈顶一侧放入元素，新元素的位置将会成为新的栈顶。

这里我们以数组实现为例。

2. 出栈

出栈操作（pop）就是把元素从栈中弹出，只有栈顶元素才允许出栈，出栈元素的前一个元素将会成为新的栈顶。

这里我们以数组实现为例。

由于栈操作的代码实现比较简单，这里就不再展示代码了，有兴趣的读者可以自己写写看。

小灰，你说说，入栈和出栈操作，时间复杂度分别是多少？

入栈和出栈只会影响到最后一个元素，不涉及其他元素的整体移动，所以无论是以数组还是以链表实现，入栈、出栈的时间复杂度都是O(1)。

2.3.4　什么是队列

要弄明白什么是队列，我们同样可以用一个生活中的例子来说明。

假如公路上有一条单行隧道，所有通过隧道的车辆只允许从隧道入口驶入，从隧道出口驶出，不允许逆行。

因此，要想让车辆驶出隧道，只能按照它们驶入隧道的顺序，先驶入的车辆先驶出，后驶入的车辆后驶出，任何车辆都无法跳过它前面的车辆提前驶出。

队列（queue）是一种线性数据结构，它的特征和行驶车辆的单行隧道很相似。不同于栈的先入后出，队列中的元素只能先入先出（First In First Out，简称FIFO）。队列的出口端叫作队头（front），队列的入口端叫作队尾（rear）。

与栈类似，队列这种数据结构既可以用数组来实现，也可以用链表来实现。

用数组实现时，为了入队操作的方便，把队尾位置规定为最后入队元素的下一个位置。

队列的数组实现如下。

队列的链表实现如下。

那么，队列可以进行哪些操作呢？

和栈操作相对应，队列的最基本操作是入队和出队。

2.3.5　队列的基本操作

对于链表实现方式，队列的入队、出队操作和栈是大同小异的。但对于数组实现方式来说，队列的入队和出队操作有了一些有趣的变化。怎么有趣呢？我们后面会看到。

1. 入队

入队（enqueue）就是把新元素放入队列中，只允许在队尾的位置放入元素，新元素的下一个位置将会成为新的队尾。

2. 出队

出队操作（dequeue）就是把元素移出队列，只允许在队头一侧移出元素，出队元素的后一个元素将会成为新的队头。

如果像这样不断出队，队头左边的空间失去作用，那队列的容量岂不是越来越小了？例如像下面这样。

问得很好，这正是我后面要讲的。用数组实现的队列可以采用循环队列的方式来维持队列容量的恒定。

循环队列是什么意思呢？让我们看看下面的例子。

假设一个队列经过反复的入队和出队操作，还剩下2个元素，在“物理”上分布于数组的末尾位置。这时又有一个新元素将要入队。

在数组不做扩容的前提下，如何让新元素入队并确定新的队尾位置呢？我们可以利用已出队元素留下的空间，让队尾指针重新指回数组的首位。

这样一来，整个队列的元素就“循环”起来了。在物理存储上，队尾的位置也可以在队头之前。当再有元素入队时，将其放入数组的首位，队尾指针继续后移即可。

一直到（队尾下标+1）%数组长度 = 队头下标时，代表此队列真的已经满了。需要注意的是，队尾指针指向的位置永远空出1位，所以队列最大容量比数组长度小1。

这就是所谓的循环队列，下面让我们来看一看它的代码实现。

1. private int[] array;

2. private int front;

3. private int rear;

4.

5. public MyQueue(int capacity){

6.     this.array = new int[capacity];

7. }

8.

9. /**

10.   * 入队

11.  * @param element  入队的元素

12.   */

13. public void enQueue(int element) throws Exception {

14.     if((rear+1)%array.length == front){

15.         throw new Exception(" 队列已满！");

16.     }

17.     array[rear] = element;

18.     rear =(rear+1)%array.length;

19. }

20.

21. /**

22.   * 出队

23.   */

24. public int deQueue() throws Exception {

25.     if(rear == front){

26.         throw new Exception(" 队列已空！");

27.     }

28.     int deQueueElement = array[front];

29.     front =(front+1)%array.length;

30.     return deQueueElement;

31. }

32.

33. /**

34.   * 输出队列

35.   */

36. public void output(){

37.     for(int i=front; i!=rear; i=(i+1)%array.length){

38.         System.out.println(array[i]);

39.     }

40. }

41.

42. public static void main(String[] args) throws Exception {

43.     MyQueue myQueue = new MyQueue(6);

44.     myQueue.enQueue(3);

45.     myQueue.enQueue(5);

46.     myQueue.enQueue(6);

47.     myQueue.enQueue(8);

48.     myQueue.enQueue(1);

49.     myQueue.deQueue();

50.     myQueue.deQueue();

51.     myQueue.deQueue();

52.     myQueue.enQueue(2);

53.     myQueue.enQueue(4);

54.     myQueue.enQueue(9);

55.     myQueue.output();

56. }

循环队列不但充分利用了数组的空间，还避免了数组元素整体移动的麻烦，还真是有点意思呢！至于入队和出队的时间复杂度，也同样是O(1)吧？

说得完全正确！下面我们来看一看栈和队列都可以应用在哪些地方。

2.3.6　栈和队列的应用

1. 栈的应用

栈的输出顺序和输入顺序相反，所以栈通常用于对“历史”的回溯，也就是逆流而上追溯“历史”。

例如实现递归的逻辑，就可以用栈来代替，因为栈可以回溯方法的调用链。

栈还有一个著名的应用场景是面包屑导航，使用户在浏览页面时可以轻松地回溯到上一级或更上一级页面。

2. 队列的应用

队列的输出顺序和输入顺序相同，所以队列通常用于对“历史”的回放，也就是按照“历史”顺序，把“历史”重演一遍。

例如在多线程中，争夺公平锁的等待队列，就是按照访问顺序来决定线程在队列中的次序的。

再如网络爬虫实现网站抓取时，也是把待抓取的网站URL存入队列中，再按照存入队列的顺序来依次抓取和解析的。

3. 双端队列

那么，有没有办法把栈和队列的特点结合起来，既可以先入先出，也可以先入后出呢？

还真有，这种数据结构叫作双端队列（deque）。

双端队列这种数据结构，可以说综合了栈和队列的优点，对双端队列来说，从队头一端可以入队或出队，从队尾一端也可以入队或出队。

有关双端队列的细节，感兴趣的读者可以查阅资料做更多的了解。

4. 优先队列

还有一种队列，它遵循的不是先入先出，而是谁的优先级最高，谁先出队。

这种队列叫作优先队列。

优先队列已经不属于线性数据结构的范畴了，它是基于二叉堆来实现的。关于优先队列的原理和使用情况，我们会在下一章进行详细介绍。

好了，关于栈和队列的知识我们就介绍到这里，下一节再见！

22.4　神奇的散列表

2.4.1　为什么需要散列表

说起学习英语，小灰上学时可没有那么丰富的学习资源和工具。当时有一款很流行的电子词典，小伙伴们遇到不会的单词，只要输入到小小的电子词典里，就可以查出它的中文含义。

当时的英语老师强烈反对使用这样的工具，因为电子词典查出来的中文资料太有限，而传统的纸质词典可以查到单词的多种含义、词性、例句等。

但是，同学们还是倾向于使用电子词典。因为电子词典实在太方便了，只要输入要查的单词，一瞬间就可以得到结果，而不需要像纸质词典那样烦琐地进行人工查找。

在我们的程序世界里，往往也需要在内存中存放这样一个“词典”，方便我们进行高效的查询和统计。

例如开发一个学生管理系统，需要有通过输入学号快速查出对应学生的姓名的功能。这里不必每次都去查询数据库，而可以在内存中建立一个缓存表，这样做可以提高查询效率。

再如我们需要统计一本英文书里某些单词出现的频率，就需要遍历整本书的内容，把这些单词出现的次数记录在内存中。

因为这些需求，一个重要的数据结构诞生了，这个数据结构叫作散列表。

散列表也叫作哈希表（hash table），这种数据结构提供了键（Key）和值（Value）的映射关系。只要给出一个Key，就可以高效查找到它所匹配的Value，时间复杂度接近于O(1)。

那么，散列表是如何根据Key来快速找到它所匹配的Value呢？

这就是我下面要讲的散列表的基本原理。

2.4.2　哈希函数

小灰，在咱们之前学过的几个数据结构中，谁的查询效率最高？

当然是数组喽，数组可以根据下标，进行元素的随机访问。

说得没错，散列表在本质上也是一个数组。

可是数组只能根据下标，像a[0]、a[1]、a[2]、a[3]、a[4]这样来访问，而散列表的Key则是以字符串类型为主的。

例如以学生的学号作为Key，输入002123，查询到李四；或者以单词为Key，输入by，查询到数字46……

所以我们需要一个“中转站”，通过某种方式，把Key和数组下标进行转换。这个中转站就叫作哈希函数。

这个所谓的哈希函数是怎么实现的呢？

在不同的语言中，哈希函数的实现方式是不一样的。这里以Java的常用集合HashMap为例，来看一看哈希函数在Java中的实现。

在Java及大多数面向对象的语言中，每一个对象都有属于自己的hashcode，这个hashcode是区分不同对象的重要标识。无论对象自身的类型是什么，它们的hashcode都是一个整型变量。

既然都是整型变量，想要转化成数组的下标也就不难实现了。最简单的转化方式是什么呢？是按照数组长度进行取模运算。

index = HashCode (Key) % Array.length

实际上，JDK（Java Development Kit，Java语言的软件开发工具包）中的哈希函数并没有直接采用取模运算，而是利用了位运算的方式来优化性能。不过在这里可以姑且简单理解成取模操作。

通过哈希函数，我们可以把字符串或其他类型的Key，转化成数组的下标index。

如给出一个长度为8的数组，则当

key=001121时，

index = HashCode ("001121") % Array.length = 1420036703 % 8 = 7

而当key=this时，

index = HashCode ("this") % Array.length = 3559070 % 8 = 6

2.4.3　散列表的读写操作

有了哈希函数，就可以在散列表中进行读写操作了。

1. 写操作（put）

写操作就是在散列表中插入新的键值对（在JDK中叫作Entry）。

如调用hashMap.put("002931", "王五")，意思是插入一组Key为002931、Value为王五的键值对。

具体该怎么做呢？

第1步，通过哈希函数，把Key转化成数组下标5。

第2步，如果数组下标5对应的位置没有元素，就把这个Entry填充到数组下标5的位置。

但是，由于数组的长度是有限的，当插入的Entry越来越多时，不同的Key通过哈希函数获得的下标有可能是相同的。例如002936这个Key对应的数组下标是2；002947这个Key对应的数组下标也是2。

这种情况，就叫作哈希冲突。

哎呀，哈希函数“撞衫”了，这该怎么办呢？

哈希冲突是无法避免的，既然不能避免，我们就要想办法来解决。解决哈希冲突的方法主要有两种，一种是开放寻址法，一种是链表法。

开放寻址法的原理很简单，当一个Key通过哈希函数获得对应的数组下标已被占用时，我们可以“另谋高就”，寻找下一个空档位置。

以上面的情况为例，Entry6通过哈希函数得到下标2，该下标在数组中已经有了其他元素，那么就向后移动1位，看看数组下标3的位置是否有空。

很不巧，下标3也已经被占用，那么就再向后移动1位，看看数组下标4的位置是否有空。

幸运的是，数组下标4的位置还没有被占用，因此把Entry6存入数组下标4的位置。

这就是开放寻址法的基本思路。当然，在遇到哈希冲突时，寻址方式有很多种，并不一定只是简单地寻找当前元素的后一个元素，这里只是举一个简单的示例而已。

在Java中，ThreadLocal所使用的就是开放寻址法。

接下来，重点讲一下解决哈希冲突的另一种方法——链表法。这种方法被应用在了Java的集合类HashMap当中。

HashMap数组的每一个元素不仅是一个Entry对象，还是一个链表的头节点。每一个Entry对象通过next指针指向它的下一个Entry节点。当新来的Entry映射到与之冲突的数组位置时，只需要插入到对应的链表中即可。

2. 读操作（get）

讲完了写操作，我们再来讲一讲读操作。读操作就是通过给定的Key，在散列表中查找对应的Value。

例如调用 hashMap.get("002936")，意思是查找Key为002936的Entry在散列表中所对应的值。

具体该怎么做呢？下面以链表法为例来讲一下。

第1步，通过哈希函数，把Key转化成数组下标2。

第2步，找到数组下标2所对应的元素，如果这个元素的Key是002936，那么就找到了；如果这个Key不是002936也没关系，由于数组的每个元素都与一个链表对应，我们可以顺着链表慢慢往下找，看看能否找到与Key相匹配的节点。

在上图中，首先查到的节点Entry6的Key是002947，和待查找的Key 002936不符。接着定位到链表下一个节点Entry1，发现Entry1的Key 002936正是我们要寻找的，所以返回Entry1的Value即可。

3. 扩容（resize）

在讲解数组时，曾经介绍过数组的扩容。既然散列表是基于数组实现的，那么散列表也要涉及扩容的问题。

首先，什么时候需要进行扩容呢？

当经过多次元素插入，散列表达到一定饱和度时，Key映射位置发生冲突的概率会逐渐提高。这样一来，大量元素拥挤在相同的数组下标位置，形成很长的链表，对后续插入操作和查询操作的性能都有很大影响。

这时，散列表就需要扩展它的长度，也就是进行扩容。

对于JDK中的散列表实现类HashMap来说，影响其扩容的因素有两个。

- Capacity，即HashMap的当前长度

- LoadFactor，即HashMap的负载因子，默认值为0.75f

衡量HashMap需要进行扩容的条件如下。

HashMap.Size >= Capacity×LoadFactor

散列表的扩容操作，具体做了什么事情呢？

扩容不是简单地把散列表的长度扩大，而是经历了下面两个步骤。

1．扩容，创建一个新的Entry空数组，长度是原数组的2倍。

2．重新Hash，遍历原Entry数组，把所有的Entry重新Hash到新数组中。为什么要重新Hash呢？因为长度扩大以后，Hash的规则也随之改变。

经过扩容，原本拥挤的散列表重新变得稀疏，原有的Entry也重新得到了尽可能均匀的分配。

扩容前的HashMap。

扩容后的HashMap。

以上就是散列表各种基本操作的原理。由于HashMap的实现代码相对比较复杂，这里就不直接列出源码了，有兴趣的读者可以在JDK中直接阅读HashMap类的源码。

需要注意的是，关于HashMap的实现，JDK 8和以前的版本有着很大的不同。当多个Entry被Hash到同一个数组下标位置时，为了提升插入和查找的效率，HashMap会把Entry的链表转化为红黑树这种数据结构。建议读者把两个版本的实现都认真地看一看，这会让你受益匪浅。

基本明白了，散列表还真是个神奇的数据结构！

散列表可以说是数组和链表的结合，它在算法中的应用很普遍，是一种非常重要的数据结构，大家一定要认真掌握哦。

这一次就讲到这里，咱们下一章再见。

2.5　小结

- 什么是数组

数组是由有限个相同类型的变量所组成的有序集合，它的物理存储方式是顺序存储，访问方式是随机访问。利用下标查找数组元素的时间复杂度是O(1)，中间插入、删除数组元素的时间复杂度是O(n)。

- 什么是链表

链表是一种链式数据结构，由若干节点组成，每个节点包含指向下一节点的指针。链表的物理存储方式是随机存储，访问方式是顺序访问。查找链表节点的时间复杂度是O(n)，中间插入、删除节点的时间复杂度是O(1)。

- 什么是栈

栈是一种线性逻辑结构，可以用数组实现，也可以用链表实现。栈包含入栈和出栈操作，遵循先入后出的原则（FILO）。

- 什么是队列

队列也是一种线性逻辑结构，可以用数组实现，也可以用链表实现。队列包含入队和出队操作，遵循先入先出的原则（FIFO）。

- 什么是散列表

散列表也叫哈希表，是存储Key-Value映射的集合。对于某一个Key，散列表可以在接近O(1)的时间内进行读写操作。散列表通过哈希函数实现Key和数组下标的转换，通过开放寻址法和链表法来解决哈希冲突。

第3章　树

3.1　树和二叉树

3.1.1　什么是树

小灰的“家谱”是这样子的。

所以说，有许多逻辑关系并不是简单的线性关系，在实际场景中，常常存在着一对多，甚至是多对多的情况。

其中树和图就是典型的非线性数据结构，我们首先讲一讲树的知识。

什么是树呢？在现实生活中有很多体现树的逻辑的例子。

例如前面提到的小灰的“家谱”，就是一个“树”。

再如企业里的职级关系，也是一个“树”。

除人与人之间的关系之外，许多抽象的东西也可以成为一个“树”，如一本书的目录。

以上这些例子有什么共同点呢？为什么可以称它们为“树”呢？

因为它们都像自然界中的树一样，从同一个“根”衍生出许多“枝干”，再从每一个“枝干”衍生出许多更小的“枝干”，最后衍生出更多的“叶子”。

在数据结构中，树的定义如下。

树（tree）是n（n≥0）个节点的有限集。当n=0时，称为空树。在任意一个非空树中，有如下特点。

1. 有且仅有一个特定的称为根的节点。

2. 当n>1时，其余节点可分为m（m>0）个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。

下面这张图，就是一个标准的树结构。

在上图中，节点1是根节点（root）；节点5、6、7、8是树的末端，没有“孩子”，被称为叶子节点（leaf）。图中的虚线部分，是根节点1的其中一个子树。

同时，树的结构从根节点到叶子节点，分为不同的层级。从一个节点的角度来看，它的上下级和同级节点关系如下。

在上图中，节点4的上一级节点，是节点4的父节点（parent）；从节点4衍生出来的节点，是节点4的孩子节点（child）；和节点4同级，由同一个父节点衍生出来的节点，是节点4的兄弟节点（sibling）。

树的最大层级数，被称为树的高度或深度。显然，上图这个树的高度是4。

哎呀，这么多的概念还真是不好记。

这些都是树的基本术语，多看几次就记住啦。下面我们来介绍一种典型的树——二叉树。

3.1.2　什么是二叉树

二叉树（binary tree）是树的一种特殊形式。二叉，顾名思义，这种树的每个节点最多有2个孩子节点。注意，这里是最多有2个，也可能只有1个，或者没有孩子节点。

二叉树的结构如图所示。

二叉树节点的两个孩子节点，一个被称为左孩子（left child），一个被称为右孩子（right child）。这两个孩子节点的顺序是固定的，就像人的左手就是左手，右手就是右手，不能够颠倒或混淆。

此外，二叉树还有两种特殊形式，一个叫作满二叉树，另一个叫作完全二叉树。

什么是满二叉树呢？

一个二叉树的所有非叶子节点都存在左右孩子，并且所有叶子节点都在同一层级上，那么这个树就是满二叉树。

简单点说，满二叉树的每一个分支都是满的。

什么又是完全二叉树呢？完全二叉树的定义很有意思。

对一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号为从1到n。如果这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同，则这个二叉树为完全二叉树。

这个定义还真绕，看看下图就很容易理解了。

在上图中，二叉树编号从1到12的12个节点，和前面满二叉树编号从1到12的节点位置完全对应。因此这个树是完全二叉树。

完全二叉树的条件没有满二叉树那么苛刻：满二叉树要求所有分支都是满的；而完全二叉树只需保证最后一个节点之前的节点都齐全即可。

那么，二叉树在内存中是怎样存储的呢？

上一章咱们讲过，数据结构可以划分为物理结构和逻辑结构。二叉树属于逻辑结构，它可以通过多种物理结构来表达。

二叉树可以用哪些物理存储结构来表达呢？

1. 链式存储结构。

2. 数组。

让我们分别看看二叉树如何使用这两种结构进行存储吧。

首先来看一看链式存储结构。

链式存储是二叉树最直观的存储方式。

上一章讲过链表，链表是一对一的存储方式，每一个链表节点拥有data变量和一个指向下一节点的next指针。

而二叉树稍微复杂一些，一个节点最多可以指向左右两个孩子节点，所以二叉树的每一个节点包含3部分。

- 存储数据的data变量

- 指向左孩子的left指针

- 指向右孩子的right指针

再来看看用数组是如何存储的。

使用数组存储时，会按照层级顺序把二叉树的节点放到数组中对应的位置上。如果某一个节点的左孩子或右孩子空缺，则数组的相应位置也空出来。

为什么这样设计呢？因为这样可以更方便地在数组中定位二叉树的孩子节点和父节点。

假设一个父节点的下标是parent，那么它的左孩子节点下标就是2×parent + 1；右孩子节点下标就是2×parent + 2。

反过来，假设一个左孩子节点的下标是leftChild，那么它的父节点下标就是（leftChild-1）/ 2。

假如节点4在数组中的下标是3，节点4是节点2的左孩子，节点2的下标可以直接通过计算得出。

节点2的下标 = (3-1)/2 = 1

显然，对于一个稀疏的二叉树来说，用数组表示法是非常浪费空间的。

什么样的二叉树最适合用数组表示呢？

我们后面即将学到的二叉堆，一种特殊的完全二叉树，就是用数组来存储的。

3.1.3　二叉树的应用

咱们讲了这么多理论，二叉树究竟有什么用处呢？

二叉树的用处有很多，让我们来具体看一看。

二叉树包含许多特殊的形式，每一种形式都有自己的作用，但是其最主要的应用还在于进行查找操作和维持相对顺序这两个方面。

1. 查找

二叉树的树形结构使它很适合扮演索引的角色。

这里我们介绍一种特殊的二叉树：二叉查找树（binary search tree）。光看名字就可以知道，这种二叉树的主要作用就是进行查找操作。

二叉查找树在二叉树的基础上增加了以下几个条件。

- 如果左子树不为空，则左子树上所有节点的值均小于根节点的值

- 如果右子树不为空，则右子树上所有节点的值均大于根节点的值

- 左、右子树也都是二叉查找树

下图就是一个标准的二叉查找树。

二叉查找树的这些条件有什么用呢？当然是为了查找方便。

例如查找值为4的节点，步骤如下。

1. 访问根节点6，发现4<6。

2. 访问节点6的左孩子节点3，发现4>3。

3. 访问节点3的右孩子节点4，发现4=4，这正是要查找的节点。

对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度就是O(logn)，和树的深度是一样的。

这种依靠比较大小来逐步查找的方式，和二分查找算法非常相似。

2. 维持相对顺序

这一点仍然要从二叉查找树说起。二叉查找树要求左子树小于父节点，右子树大于父节点，正是这样保证了二叉树的有序性。

因此二叉查找树还有另一个名字——二叉排序树（binary sort tree）。

新插入的节点，同样要遵循二叉排序树的原则。例如插入新元素5，由于5<6，5>3，5>4，所以5最终会插入到节点4的右孩子位置。

再如插入新元素10，由于10>6，10>8，10>9，所以10最终会插入到节点9的右孩子位置。

这一切看起来很顺利，然而却隐藏着一个致命的问题。什么问题呢？下面请试着在二叉查找树中依次插入9、8、7、6、5、4，看看会出现什么结果。

哈哈，好好的一个二叉树，变成“跛脚”啦！

不只是外观看起来变得怪异了，查询节点的时间复杂度也退化成了O(n)。

怎么解决这个问题呢？这就涉及二叉树的自平衡了。二叉树自平衡的方式有多种，如红黑树、AVL树、树堆等。由于篇幅有限，本书就不一一详细讲解了，感兴趣的读者可以查一查相关资料。

除二叉查找树以外，二叉堆也维持着相对的顺序。不过二叉堆的条件要宽松一些，只要求父节点比它的左右孩子都大，这一点在后面的章节中我们会详细讲解。

好了，有关树和二叉树的基本知识，我们就讲到这里。

本节所讲的内容偏于理论方面，没有涉及代码。但是下一节讲解二叉树的遍历时，会涉及大量代码，大家要做好准备哦！

3.2　二叉树的遍历

3.2.1　为什么要研究遍历

当我们介绍数组、链表时，为什么没有着重研究他们的遍历过程呢？

二叉树的遍历又有什么特殊之处？

在计算机程序中，遍历本身是一个线性操作。所以遍历同样具有线性结构的数组或链表，是一件轻而易举的事情。

反观二叉树，是典型的非线性数据结构，遍历时需要把非线性关联的节点转化成一个线性的序列，以不同的方式来遍历，遍历出的序列顺序也不同。

那么，二叉树都有哪些遍历方式呢？

从节点之间位置关系的角度来看，二叉树的遍历分为4种。

1. 前序遍历。

2. 中序遍历。

3. 后序遍历。

4. 层序遍历。

从更宏观的角度来看，二叉树的遍历归结为两大类。

1. 深度优先遍历（前序遍历、中序遍历、后序遍历）。

2. 广度优先遍历（层序遍历）。

下面就来具体看一看这些不同的遍历方式。

3.2.2　深度优先遍历

深度优先和广度优先这两个概念不止局限于二叉树，它们更是一种抽象的算法思想，决定了访问某些复杂数据结构的顺序。在访问树、图，或其他一些复杂数据结构时，这两个概念常常被使用到。

所谓深度优先，顾名思义，就是偏向于纵深，“一头扎到底”的访问方式。可能这种说法有些抽象，下面就通过二叉树的前序遍历、中序遍历、后序遍历，来看一看深度优先是怎么回事吧。

1. 前序遍历

二叉树的前序遍历，输出顺序是根节点、左子树、右子树。

上图就是一个二叉树的前序遍历，每个节点左侧的序号代表该节点的输出顺序，详细步骤如下。

1. 首先输出的是根节点1。

2. 由于根节点1存在左孩子，输出左孩子节点2。

3. 由于节点2也存在左孩子，输出左孩子节点4。

4. 节点4既没有左孩子，也没有右孩子，那么回到节点2，输出节点2的右孩子节点5。

5. 节点5既没有左孩子，也没有右孩子，那么回到节点1，输出节点1的右孩子节点3。

6. 节点3没有左孩子，但是有右孩子，因此输出节点3的右孩子节点6。

到此为止，所有的节点都遍历输出完毕。

2. 中序遍历

二叉树的中序遍历，输出顺序是左子树、根节点、右子树。

上图就是一个二叉树的中序遍历，每个节点左侧的序号代表该节点的输出顺序，详细步骤如下。

1. 首先访问根节点的左孩子，如果这个左孩子还拥有左孩子，则继续深入访问下去，一直找到不再有左孩子的节点，并输出该节点。显然，第一个没有左孩子的节点是节点4。

2. 依照中序遍历的次序，接下来输出节点4的父节点2。

3. 再输出节点2的右孩子节点5。

4. 以节点2为根的左子树已经输出完毕，这时再输出整个二叉树的根节点1。

5. 由于节点3没有左孩子，所以直接输出根节点1的右孩子节点3。

6. 最后输出节点3的右孩子节点6。

到此为止，所有的节点都遍历输出完毕。

3. 后序遍历

二叉树的后序遍历，输出顺序是左子树、右子树、根节点。

上图就是一个二叉树的后序遍历，每个节点左侧的序号代表该节点的输出顺序。

由于二叉树的后序遍历和前序、中序遍历的思想大致相同，相信聪明的读者已经可以推测出分解步骤，这里就不再列举细节了。

那么，二叉树的前序、中序、后序遍历的代码怎么写呢？

二叉树的这3种遍历方式，用递归的思路可以非常简单地实现出来，让我们看一看代码。

1. /**

2.  * 构建二叉树

3.  * @param inputList    输入序列

4.  */

5. public static TreeNode createBinaryTree(LinkedList<Integer>

inputList){

6.     TreeNode node = null;

7.     if(inputList==null || inputList.isEmpty()){

8.         return null;

9.     }

10.     Integer data = inputList.removeFirst();

11.     if(data != null){

12.         node = new TreeNode(data);

13.         node.leftChild = createBinaryTree(inputList);

14.         node.rightChild = createBinaryTree(inputList);

15.     }

16.     return node;

17. }

18.

19. /**

20.   * 二叉树前序遍历

21.  * @param node   二叉树节点

22.   */

23. public static void preOrderTraveral(TreeNode node){

24.     if(node == null){

25.         return;

26.     }

27.     System.out.println(node.data);

28.     preOrderTraveral(node.leftChild);

29.     preOrderTraveral(node.rightChild);

30. }

31.

32. /**

33.   * 二叉树中序遍历

34.  * @param node   二叉树节点

35.   */

36. public static void inOrderTraveral(TreeNode node){

37.     if(node == null){

38.         return;

39.     }

40.     inOrderTraveral(node.leftChild);

41.     System.out.println(node.data);

42.     inOrderTraveral(node.rightChild);

43. }

44.

45.

46. /**

47.   * 二叉树后序遍历

48.  * @param node   二叉树节点

49.   */

50. public static void postOrderTraveral(TreeNode node){

51.     if(node == null){

52.         return;

53.     }

54.     postOrderTraveral(node.leftChild);

55.     postOrderTraveral(node.rightChild);

56.     System.out.println(node.data);

57. }

58.

59.

60. /**

61.   * 二叉树节点

62.   */

63. private static class TreeNode {

64.     int data;

65.     TreeNode leftChild;

66.     TreeNode rightChild;

67.

68.     TreeNode(int data) {

69.         this.data = data;

70.     }

71. }

72.

73. public static void main(String[] args) {

74.     LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.

asList(new Integer[]{3,2,9,null,null,10,null,

null,8,null,4}));

75.     TreeNode treeNode = createBinaryTree(inputList);

76.     System.out.println(" 前序遍历：");

77.     preOrderTraveral(treeNode);

78.     System.out.println(" 中序遍历：");

79.     inOrderTraveral(treeNode);

80.     System.out.println(" 后序遍历：");

81.     postOrderTraveral(treeNode);

82. }

二叉树用递归方式来实现前序、中序、后序遍历，是最为自然的方式，因此代码也非常简单。

这3种遍历方式的区别，仅仅是输出的执行位置不同：前序遍历的输出在前，中序遍历的输出在中间，后序遍历的输出在最后。

代码中值得注意的一点是二叉树的构建。二叉树的构建方法有很多，这里把一个线性的链表转化成非线性的二叉树，链表节点的顺序恰恰是二叉树前序遍历的顺序。链表中的空值，代表二叉树节点的左孩子或右孩子为空的情况。

在代码的main函数中，通过{3,2,9,null,null,10,null,null,8,null,4}这样一个线性序列，构建成的二叉树如下。

除使用递归以外，二叉树的深度优先遍历还能通过其他方式实现吗？

当然也可以用非递归的方式来实现，不过要稍微复杂一些。

绝大多数可以用递归解决的问题，其实都可以用另一种数据结构来解决，这种数据结构就是栈。因为递归和栈都有回溯的特性。

如何借助栈来实现二叉树的非递归遍历呢？下面以二叉树的前序遍历为例，看一看具体过程。

1. 首先遍历二叉树的根节点1，放入栈中。

2. 遍历根节点1的左孩子节点2，放入栈中。

3. 遍历节点2的左孩子节点4，放入栈中。

4. 节点4既没有左孩子，也没有右孩子，我们需要回溯到上一个节点2。可是现在并不是做递归操作，怎么回溯呢？

别担心，栈已经存储了刚才遍历的路径。让旧的栈顶元素4出栈，就可以重新访问节点2，得到节点2的右孩子节点5。

此时节点2已经没有利用价值（已经访问过左孩子和右孩子），节点2出栈，节点5入栈。

5. 节点5既没有左孩子，也没有右孩子，我们需要再次回溯，一直回溯到节点1。所以让节点5出栈。

根节点1的右孩子是节点3，节点1出栈，节点3入栈。

6. 节点3的右孩子是节点6，节点3出栈，节点6入栈。

7. 节点6既没有左孩子，也没有右孩子，所以节点6出栈。此时栈为空，遍历结束。

二叉树非递归前序遍历的代码已经写好了，让我们来看一看。

1. /**

2.  * 二叉树非递归前序遍历

3.  * @param root   二叉树根节点

4.  */

5. public static void preOrderTraveralWithStack(TreeNode root){

6.     Stack<TreeNode> stack = new Stack<TreeNode>();

7.     TreeNode treeNode = root;

8.     while(treeNode!=null || !stack.isEmpty()){

9.         //迭代访问节点的左孩子，并入栈

10.         while (treeNode != null){

11.             System.out.println(treeNode.data);

12.             stack.push(treeNode);

13.             treeNode = treeNode.leftChild;

14.         }

15.         //如果节点没有左孩子，则弹出栈顶节点，访问节点右孩子

16.         if(!stack.isEmpty()){

17.             treeNode = stack.pop();

18.             treeNode = treeNode.rightChild;

19.         }

20.     }

21. }

至于二叉树的中序、后序遍历的非递归实现，思路和前序遍历差不太多，都是利用栈来进行回溯。各位读者要是有兴趣的话，可以自己尝试用代码实现一下。

3.2.3　广度优先遍历

如果说深度优先遍历是在一个方向上“一头扎到底”，那么广度优先遍历则恰恰相反：先在各个方向上各走出1步，再在各个方向上走出第2步、第3步……一直到各个方向全部走完。听起来有些抽象，下面让我们通过二叉树的层序遍历，来看一看广度优先是怎么回事。

层序遍历，顾名思义，就是二叉树按照从根节点到叶子节点的层次关系，一层一层横向遍历各个节点。

上图就是一个二叉树的层序遍历，每个节点左侧的序号代表该节点的输出顺序。

可是，二叉树同一层次的节点之间是没有直接关联的，如何实现这种层序遍历呢？

这里同样需要借助一个数据结构来辅助工作，这个数据结构就是队列。

详细遍历步骤如下。

1. 根节点1进入队列。

2. 节点1出队，输出节点1，并得到节点1的左孩子节点2、右孩子节点3。让节点2和节点3入队。

3. 节点2出队，输出节点2，并得到节点2的左孩子节点4、右孩子节点5。让节点4和节点5入队。

4. 节点3出队，输出节点3，并得到节点3的右孩子节点6。让节点6入队。

5. 节点4出队，输出节点4，由于节点4没有孩子节点，所以没有新节点入队。

6. 节点5出队，输出节点5，由于节点5同样没有孩子节点，所以没有新节点入队。

7. 节点6出队，输出节点6，节点6没有孩子节点，没有新节点入队。

到此为止，所有的节点都遍历输出完毕。

这个层序遍历看起来有点意思，代码怎么写呢？

代码不难写，让我们来看一看。

1. /**

2.  * 二叉树层序遍历

3.  * @param root   二叉树根节点

4.  */

5. public static void levelOrderTraversal(TreeNode root){

6.     Queue<TreeNode> queue = new LinkedList<TreeNode>();

7.     queue.offer(root);

8.     while(!queue.isEmpty()){

9.         TreeNode node = queue.poll();

10.         System.out.println(node.data);

11.         if(node.leftChild != null){

12.             queue.offer(node.leftChild);

13.         }

14.         if(node.rightChild != null){

15.             queue.offer(node.rightChild);

16.         }

17.     }

18. }

基本上明白了，最后想问问，二叉树的层序遍历可以用递归方式来实现吗？

可以，不过在思路上有一点绕。我们把这个作为思考题，聪明的读者如果有兴趣，可以想一想层序遍历的递归实现方法哦！

好了，有关二叉树的遍历问题，就讲到这里，咱们下一节再见！

3.3　什么是二叉堆

3.3.1　初识二叉堆

什么是二叉堆？

二叉堆本质上是一种完全二叉树，它分为两个类型。

1. 最大堆。

2. 最小堆。

什么是最大堆呢？最大堆的任何一个父节点的值，都大于或等于它左、右孩子节点的值。

什么是最小堆呢？最小堆的任何一个父节点的值，都小于或等于它左、右孩子节点的值。

二叉堆的根节点叫作堆顶。

最大堆和最小堆的特点决定了：最大堆的堆顶是整个堆中的最大元素；最小堆的堆顶是整个堆中的最小元素。

那么，我们如何构建一个堆呢？

这就需要依靠二叉堆的自我调整了。

3.3.2　二叉堆的自我调整

对于二叉堆，有如下几种操作。

1. 插入节点。

2. 删除节点。

3. 构建二叉堆。

这几种操作都基于堆的自我调整。所谓堆的自我调整，就是把一个不符合堆性质的完全二叉树，调整成一个堆。下面让我们以最小堆为例，看一看二叉堆是如何进行自我调整的。

1. 插入节点

当二叉堆插入节点时，插入位置是完全二叉树的最后一个位置。例如插入一个新节点，值是 0。

这时，新节点的父节点5比0大，显然不符合最小堆的性质。于是让新节点“上浮”，和父节点交换位置。

继续用节点0和父节点3做比较，因为0小于3，则让新节点继续“上浮”。

继续比较，最终新节点0“上浮”到了堆顶位置。

2. 删除节点

二叉堆删除节点的过程和插入节点的过程正好相反，所删除的是处于堆顶的节点。例如删除最小堆的堆顶节点1。

这时，为了继续维持完全二叉树的结构，我们把堆的最后一个节点10临时补到原本堆顶的位置。

接下来，让暂处堆顶位置的节点10和它的左、右孩子进行比较，如果左、右孩子节点中最小的一个（显然是节点2）比节点10小，那么让节点10“下沉”。

继续让节点10和它的左、右孩子做比较，左、右孩子中最小的是节点7，由于10大于7，让节点10继续“下沉”。

这样一来，二叉堆重新得到了调整。

3. 构建二叉堆

构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质就是让所有非叶子节点依次“下沉”。

下面举一个无序完全二叉树的例子，如下图所示。

首先，从最后一个非叶子节点开始，也就是从节点10开始。如果节点10大于它左、右孩子节点中最小的一个，则节点10“下沉”。

接下来轮到节点3，如果节点3大于它左、右孩子节点中最小的一个，则节点3“下沉”。

然后轮到节点1，如果节点1大于它左、右孩子节点中最小的一个，则节点1“下沉”。事实上节点1小于它的左、右孩子，所以不用改变。

接下来轮到节点7，如果节点7大于它左、右孩子节点中最小的一个，则节点7“下沉”。

节点7继续比较，继续“下沉”。

经过上述几轮比较和“下沉”操作，最终每一节点都小于它的左、右孩子节点，一个无序的完全二叉树就被构建成了一个最小堆。

小灰，你来思考一下，堆的插入、删除、构建操作的时间复杂度各是多少？

堆的插入操作是单一节点的“上浮”，堆的删除操作是单一节点的“下沉”，这两个操作的平均交换次数都是堆高度的一半，所以时间复杂度是O(logn)。至于堆的构建，需要所有非叶子节点依次“下沉”，所以我觉得时间复杂度应该是O(nlogn)吧？

关于堆的插入和删除操作，你说的没有错，时间复杂度确实是O(logn)。但构建堆的时间复杂度却并不是O(nlogn)，而是O(n)。这涉及数学推导过程，有兴趣的话，你可以自己琢磨一下哦。

这二叉堆还真有点意思，那么怎么用代码来实现呢？

3.3.3　二叉堆的代码实现

在展示代码之前，我们还需要明确一点：二叉堆虽然是一个完全二叉树，但它的存储方式并不是链式存储，而是顺序存储。换句话说，二叉堆的所有节点都存储在数组中。

在数组中，在没有左、右指针的情况下，如何定位一个父节点的左孩子和右孩子呢？

像上图那样，可以依靠数组下标来计算。

假设父节点的下标是parent，那么它的左孩子下标就是 2×parent+1；右孩子下标就是2×parent+2。

例如上面的例子中，节点6包含9和10两个孩子节点，节点6在数组中的下标是3，节点9在数组中的下标是7，节点10在数组中的下标是8。

那么，

7 = 3×2+1，

8 = 3×2+2，

刚好符合规律。

有了这个前提，下面的代码就更好理解了。

1. /**

2.  * “上浮”调整

3.  * @param array      待调整的堆

4.  */

5. public static void upAdjust(int[] array) {

6.     int childIndex = array.length-1;

7.     int parentIndex = (childIndex-1)/2;

8.     // temp 保存插入的叶子节点值，用于最后的赋值

9.     int temp = array[childIndex];

10.     while (childIndex > 0 && temp < array[parentIndex])

11.     {

12.     //无须真正交换，单向赋值即可

13.         array[childIndex] = array[parentIndex];

14.         childIndex = parentIndex;

15.         parentIndex = (parentIndex-1) / 2;

16.     }

17.     array[childIndex] = temp;

18. }

19.

20.

21. /**

22.   * “下沉”调整

23.  * @param array          待调整的堆

24.  * @param parentIndex      要“下沉”的父节点

25.  * @param length       堆的有效大小

26.   */

27. public static void downAdjust(int[] array, int parentIndex,

int length) {

28.     // temp 保存父节点值，用于最后的赋值

29.     int temp = array[parentIndex];

30.     int childIndex = 2 * parentIndex + 1;

31.     while (childIndex < length) {

32.     // 如果有右孩子，且右孩子小于左孩子的值，则定位到右孩子

33.         if (childIndex + 1 < length && array[childIndex + 1] <

array[childIndex]) {

34.             childIndex++;

35.         }

36.     // 如果父节点小于任何一个孩子的值，则直接跳出

37.         if (temp <= array[childIndex])

38.             break;

39.     //无须真正交换，单向赋值即可

40.         array[parentIndex] = array[childIndex];

41.         parentIndex = childIndex;

42.         childIndex = 2 * childIndex + 1;

43.     }

44.     array[parentIndex] = temp;

45. }

46.

47. /**

48.   * 构建堆

49.  * @param array      待调整的堆

50.   */

51. public static void buildHeap(int[] array) {

52.     // 从最后一个非叶子节点开始，依次做“下沉”调整

53.     for (int i = (array.length-2)/2; i>=0; i--) {

54.         downAdjust(array, i, array.length);

55.     }

56. }

57.

58. public static void main(String[] args) {

59.     int[] array = new int[] {1,3,2,6,5,7,8,9,10,0};

60.     upAdjust(array);

61.     System.out.println(Arrays.toString(array));

62.

63.     array = new int[] {7,1,3,10,5,2,8,9,6};

64.     buildHeap(array);

65.     System.out.println(Arrays.toString(array));

66. }

代码中有一个优化的点，就是在父节点和孩子节点做连续交换时，并不一定要真的交换，只需要先把交换一方的值存入temp变量，做单向覆盖，循环结束后，再把temp的值存入交换后的最终位置即可。

咱们讲了这么多关于二叉堆的知识，二叉堆究竟有什么用处呢？

二叉堆是实现堆排序及优先队列的基础。关于这两者，我们会在后续的章节中详细介绍。

3.4　什么是优先队列

3.4.1　优先队列的特点

队列的特点是什么？

在之前的章节中已经讲过，队列的特点是先进先出（FIFO）。

入队列，将新元素置于队尾：

出队列，队头元素最先被移出：

那么，优先队列又是什么样子呢？

优先队列不再遵循先入先出的原则，而是分为两种情况。

- 最大优先队列，无论入队顺序如何，都是当前最大的元素优先出队

- 最小优先队列，无论入队顺序如何，都是当前最小的元素优先出队

例如有一个最大优先队列，其中的最大元素是8，那么虽然8并不是队头元素，但出队时仍然让元素8首先出队。

要实现以上需求，利用线性数据结构并非不能实现，但是时间复杂度较高。

哎呀， 那该怎么办呢？

别担心，这时候我们的二叉堆就派上用场了。

3.4.2　优先队列的实现

先来回顾一下二叉堆的特性。

1. 最大堆的堆顶是整个堆中的最大元素。

2. 最小堆的堆顶是整个堆中的最小元素。

因此，可以用最大堆来实现最大优先队列，这样的话，每一次入队操作就是堆的插入操作，每一次出队操作就是删除堆顶节点。

入队操作具体步骤如下。

1. 插入新节点5。

2. 新节点5“上浮”到合适位置。

出队操作具体步骤如下。

1. 让原堆顶节点10出队。

2. 把最后一个节点1替换到堆顶位置。

3. 节点1“下沉”，节点9成为新堆顶。

小灰，你说说这个优先队列的入队和出队操作，时间复杂度分别是多少？

二叉堆节点“上浮”和“下沉”的时间复杂度都是O(logn)，所以优先队列入队和出队的时间复杂度也是O(logn)！

说的没错，下面让我们来看一看代码实现。

1. private int[] array;

2. private int size;

3. public PriorityQueue(){

4.     //队列初始长度为32

5.     array = new int[32];

6. }

7. /**

8.  * 入队

9.  * @param key   入队元素

10.   */

11. public void enQueue(int key) {

12.     //队列长度超出范围，扩容

13.     if(size >= array.length){

14.         resize();

15.     }

16.     array[size++] = key;

17.     upAdjust();

18. }

19.

20. /**

21.   * 出队

22.   */

23. public int deQueue() throws Exception {

24.     if(size <= 0){

25.         throw new Exception("the queue is empty !");

26.     }

27.     //获取堆顶元素

28.     int head = array[0];

29.     //让最后一个元素移动到堆顶

30.     array[0] = array[--size];

31.     downAdjust();

32.     return head;

33. }

34. /**

35.   * “上浮”调整

36.   */

37. private void upAdjust() {

38.     int childIndex = size-1;

39.     int parentIndex = (childIndex-1)/2;

40.     // temp 保存插入的叶子节点值，用于最后的赋值

41.     int temp = array[childIndex];

42.     while (childIndex > 0 && temp > array[parentIndex])

43.     {

44.         //无须真正交换，单向赋值即可

45.         array[childIndex] = array[parentIndex];

46.         childIndex = parentIndex;

47.         parentIndex = parentIndex / 2;

48.     }

49.     array[childIndex] = temp;

50. }

51. /**

52.   * “下沉”调整

53.   */

54. private void downAdjust() {

55.     // temp 保存父节点的值，用于最后的赋值

56.     int parentIndex = 0;

57.     int temp = array[parentIndex];

58.     int childIndex = 1;

59.     while (childIndex < size) {

60.         //  如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子

61.         if (childIndex + 1 < size && array[childIndex + 1] >

array[childIndex]) {

62.             childIndex++;

63.         }

64.         //  如果父节点大于任何一个孩子的值，直接跳出

65.         if (temp >= array[childIndex])

66.             break;

67.         //无须真正交换，单向赋值即可

68.         array[parentIndex] = array[childIndex];

69.         parentIndex = childIndex;

70.         childIndex = 2 * childIndex + 1;

71.     }

72.     array[parentIndex] = temp;

73. }

74.

75. /**

76.   * 队列扩容

77.   */

78. private void resize() {

79.     //队列容量翻倍

80.     int newSize = this.size * 2;

81.     this.array = Arrays.copyOf(this.array, newSize);

82. }

83.

84. public static void main(String[] args) throws Exception {

85.     PriorityQueue priorityQueue = new PriorityQueue();

86.     priorityQueue.enQueue(3);

87.     priorityQueue.enQueue(5);

88.     priorityQueue.enQueue(10);

89.     priorityQueue.enQueue(2);

90.     priorityQueue.enQueue(7);

91.     System.out.println(" 出队元素：" + priorityQueue.deQueue());

92.     System.out.println(" 出队元素：" + priorityQueue.deQueue());

93. }

上述代码采用数组来存储二叉堆的元素，因此当元素数量超过数组长度时，需要进行扩容来扩大数组长度。

好了，关于优先队列我们就介绍到这里，下一章再见！

3.5　小结

- 什么是树

树是n个节点的有限集，有且仅有一个特定的称为根的节点。当n>1时，其余节点可分为m个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。

- 什么是二叉树

二叉树是树的一种特殊形式，每一个节点最多有两个孩子节点。二叉树包含完全二叉树和满二叉树两种特殊形式。

- 二叉树的遍历方式有几种

根据遍历节点之间的关系，可以分为前序遍历、中序遍历、后序遍历、层序遍历这4种方式；从更宏观的角度划分，可以划分为深度优先遍历和广度优先遍历两大类。

- 什么是二叉堆

二叉堆是一种特殊的完全二叉树，分为最大堆和最小堆。

在最大堆中，任何一个父节点的值，都大于或等于它左、右孩子节点的值。

在最小堆中，任何一个父节点的值，都小于或等于它左、右孩子节点的值。

- 什么是优先队列

优先队列分为最大优先队列和最小优先队列。

在最大优先队列中，无论入队顺序如何，当前最大的元素都会优先出队，这是基于最大堆实现的。

在最小优先队列中，无论入队顺序如何，当前最小的元素都会优先出队，这是基于最小堆实现的。

第4章　排序算法

4.1　引言

在生活中，我们离不开排序。例如上体育课时，同学们会按照身高顺序进行排队；又如每一场考试后，老师会按照考试成绩排名次。

在编程的世界中，应用到排序的场景也比比皆是。例如当开发一个学生管理系统时，需要按照学号从小到大进行排序；当开发一个电商平台时，需要把同类商品按价格从低到高进行排序；当开发一款游戏时，需要按照游戏得分从多到少进行排序，排名第一的玩家就是本场比赛的MVP，等等。

由此可见，排序无处不在。

排序看似简单，它的背后却隐藏着多种多样的算法和思想。那么常用的排序算法都有哪些呢？

根据时间复杂度的不同，主流的排序算法可以分为3大类。

1. 时间复杂度为O(n^2)的排序算法

- 冒泡排序

- 选择排序

- 插入排序

- 希尔排序（希尔排序比较特殊，它的性能略优于O(n^2)，但又比不上O(nlogn)，姑且把它归入本类）

2. 时间复杂度为O(nlogn)的排序算法

- 快速排序

- 归并排序

- 堆排序

3. 时间复杂度为线性的排序算法

- 计数排序

- 桶排序

- 基数排序

当然，以上列举的只是最主流的排序算法，在算法界还存在着更多五花八门的排序，它们有些基于传统排序变形而来；有些则是脑洞大开，如鸡尾酒排序、猴子排序、睡眠排序等。

此外，排序算法还可以根据其稳定性，划分为稳定排序和不稳定排序。

即如果值相同的元素在排序后仍然保持着排序前的顺序，则这样的排序算法是稳定排序；如果值相同的元素在排序后打乱了排序前的顺序，则这样的排序算法是不稳定排序。例如下面的例子。

在大多数场景中，值相同的元素谁先谁后是无所谓的。但是在某些场景下，值相同的元素必须保持原有的顺序。

由于篇幅所限，我们无法把所有的排序算法都一一详细讲述。在本章中，将只讲述几个具有代表性的排序算法：冒泡排序、快速排序、堆排序、计数排序、桶排序。

下面就要带领大家进入有趣的排序世界了，请“坐稳扶好”！

4.2　什么是冒泡排序

4.2.1　初识冒泡排序

什么是冒泡排序？

冒泡排序的英文是bubble sort，它是一种基础的交换排序。

大家一定都喝过汽水，汽水中常常有许多小小的气泡哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水轻，所以小气泡可以一点一点地向上浮动。

而冒泡排序之所以叫冒泡排序，正是因为这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点地向着数组的一侧移动。

具体如何移动呢？让我们先来看一个例子。

有8个数字组成一个无序数列{5,8,6,3,9,2,1,7}，希望按照从小到大的顺序对其进行排序。

按照冒泡排序的思想，我们要把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。详细过程如下。

这样一来，元素9作为数列中最大的元素，就像是汽水里的小气泡一样，“漂”到了最右侧。

这时，冒泡排序的第1轮就结束了。数列最右侧元素9的位置可以认为是一个有序区域，有序区域目前只有1个元素。

下面，让我们来进行第2轮排序。

第2轮排序结束后，数列右侧的有序区有了2个元素，顺序如下。

后续的交换细节，这里就不详细描述了，第3轮到第7轮的状态如下。

到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。

冒泡排序是一种稳定排序，值相等的元素并不会打乱原本的顺序。由于该排序算法的每一轮都要遍历所有元素，总共遍历（元素数量-1）轮，所以平均时间复杂度是O(n^2)。

OK，冒泡排序的思路我大概明白了，那么，怎么用代码来实现呢？

原始的冒泡排序代码我写了一下，你来看一看。

冒泡排序第1版代码示例如下：

1. public static void sort(int array[])

2. {

3.     for(int i = 0; i < array.length - 1; i++)

4.     {

5.         for(int j = 0; j < array.length - i - 1; j++)

6.         {

7.             int tmp  = 0;

8.             if(array[j] > array[j+1])

9.             {

10.                 tmp = array[j];

11.                 array[j] = array[j+1];

12.                 array[j+1] = tmp;

13.             }

14.         }

15.     }

16. }

17.

18. public static void main(String[] args){

19.     int[] array = new int[]{5,8,6,3,9,2,1,7};

20.     sort(array);

21.     System.out.println(Arrays.toString(array));

22. }

代码非常简单，使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。

原来如此，冒泡排序的代码并不难理解呢。

这只是冒泡排序的原始实现，还存在很大的优化空间呢。

4.2.2　冒泡排序的优化

原始的冒泡排序有哪些可以优化的点呢？

让我们回顾一下刚才描述的排序细节，仍然以{5,8,6,3,9,2,1,7}这个数列为例，当排序算法分别执行到第6、第7轮时，数列状态如下。

很明显可以看出，经过第6轮排序后，整个数列已然是有序的了。可是排序算法仍然兢兢业业地继续执行了第7轮排序。

在这种情况下，如果能判断出数列已经有序，并做出标记，那么剩下的几轮排序就不必执行了，可以提前结束工作。

冒泡排序第2版代码示例如下：

1. public static void sort(int array[])

2. {

3.     for(int i = 0; i < array.length - 1; i++)

4.     {

5.         //有序标记，每一轮的初始值都是true

6.         boolean isSorted = true;

7.         for(int j = 0; j < array.length - i - 1; j++)

8.         {

9.             int tmp  = 0;

10.             if(array[j] > array[j+1])

11.             {

12.                 tmp = array[j];

13.                 array[j] = array[j+1];

14.                 array[j+1] = tmp;

15.         //因为有元素进行交换，所以不是有序的，标记变为false

16.                 isSorted = false;

17.             }

18.         }

19.         if(isSorted){

20.             break;

21.         }

22.     }

23. }

24.

25. public static void main(String[] args){

26.     int[] array = new int[]{5,8,6,3,9,2,1,7};

27.     sort(array);

28.     System.out.println(Arrays.toString(array));

29. }

与第1版代码相比，第2版代码做了小小的改动，利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说明数列已然有序，然后直接跳出大循环。

不错呀，原来冒泡排序还可以这样优化。

这只是冒泡排序优化的第一步，我们还可以进一步来提升它的性能。

为了说明问题，这次以一个新的数列为例。

这个数列的特点是前半部分的元素（3、4、2、1）无序，后半部分的元素（5、6、7、8）按升序排列，并且后半部分元素中的最小值也大于前半部分元素的最大值。

下面按照冒泡排序的思路来进行排序，看一看具体效果。

第1轮

元素4和5比较，发现4小于5，所以位置不变。

元素5和6比较，发现5小于6，所以位置不变。

元素6和7比较，发现6小于7，所以位置不变。

元素7和8比较，发现7小于8，所以位置不变。

第1轮结束，数列有序区包含1个元素。

第2轮

元素3和2比较，发现3大于2，所以3和2交换。

元素3和4比较，发现3小于4，所以位置不变。

元素4和5比较，发现4小于5，所以位置不变。

元素5和6比较，发现5小于6，所位位置不变。

元素6和7比较，发现6小于7，所以位置不变。

元素7和8比较，发现7小于8，所以位置不变。

第2轮结束，数列有序区包含2个元素。

小灰，你发现其中的问题了吗？

其实右面的许多元素已经是有序的了，可是每一轮还是白白地比较了许多次。

没错，这正是冒泡排序中另一个需要优化的点。

这个问题的关键点在于对数列有序区的界定。

按照现有的逻辑，有序区的长度和排序的轮数是相等的。例如第1轮排序过后的有序区长度是1，第2轮排序过后的有序区长度是2 ……

实际上，数列真正的有序区可能会大于这个长度，如上述例子中在第2轮排序时，后面的5个元素实际上都已经属于有序区了。因此后面的多次元素比较是没有意义的。

那么，该如何避免这种情况呢？我们可以在每一轮排序后，记录下来最后一次元素交换的位置，该位置即为无序数列的边界，再往后就是有序区了。

冒泡排序第3版代码示例如下：

1. public static void sort(int array[])

2. {

3.     //记录最后一次交换的位置

4.     int lastExchangeIndex = 0;

5.      //无序数列的边界，每次比较只需要比到这里为止

6.      int sortBorder = array.length - 1;

7.     for(int i = 0; i < array.length - 1; i++)

8.     {

9.         //有序标记，每一轮的初始值都是true

10.         boolean isSorted = true;

11.         for(int j = 0; j < sortBorder; j++)

12.         {

13.             int tmp  = 0;

14.             if(array[j] > array[j+1])

15.             {

16.                 tmp = array[j];

17.                 array[j] = array[j+1];

18.                 array[j+1] = tmp;

19.                 // 因为有元素进行交换，所以不是有序的，标记变为false

20.                 isSorted = false;

21.                 // 更新为最后一次交换元素的位置

22.                 lastExchangeIndex = j;

23.             }

24.         }

25.         sortBorder = lastExchangeIndex;

26.         if(isSorted){

27.             break;

28.         }

29.     }

30. }

31.

32. public static void main(String[] args){

33.     int[] array = new int[]{3,4,2,1,5,6,7,8};

34.     sort(array);

35.     System.out.println(Arrays.toString(array));

36. }

在第3版代码中，sortBorder就是无序数列的边界。在每一轮排序过程中，处于sortBorder之后的元素就不需要再进行比较了，肯定是有序的。

真是学到了很多知识，想不到冒泡排序可以玩出这么多花样！

其实这仍然不是最优的，还有一种排序算法叫作鸡尾酒排序，是基于冒泡排序的一种升级排序法。

4.2.3　鸡尾酒排序

冒泡排序的每一个元素都可以像小气泡一样，根据自身大小，一点一点地向着数组的一侧移动。算法的每一轮都是从左到右来比较元素，进行单向的位置交换的。

那么鸡尾酒排序做了怎样的优化呢？

鸡尾酒排序的元素比较和交换过程是双向的。

下面举一个例子。

由8个数字组成一个无序数列{2,3,4,5,6,7,8,1}，希望对其进行从小到大的排序。

如果按照冒泡排序的思想，排序过程如下。

元素2、3、4、5、6、7、8已经是有序的了，只有元素1的位置不对，却还要进行7轮排序，这也太“憋屈”了吧！

没错，鸡尾酒排序正是要解决这个问题的。

那么鸡尾酒排序是什么样子的呢？让我们来看一看详细过程。

第1轮（和冒泡排序一样，8和1交换）

第2轮

此时开始不一样了，我们反过来从右往左比较并进行交换。

第3轮（虽然实际上已经有序，但是流程并没有结束）

在鸡尾酒排序的第3轮，需要重新从左向右比较并进行交换。

1和2比较，位置不变；2和3比较，位置不变；3和4比较，位置不变……6和7比较，位置不变。

没有元素位置进行交换，证明已经有序，排序结束。

这就是鸡尾酒排序的思路。排序过程就像钟摆一样，第1轮从左到右，第2轮从右到左，第3轮再从左到右……

哇，本来要用7轮排序的场景，用3轮就解决了，鸡尾酒排序可真是巧妙的算法！

确实挺巧妙的，让我们来看一下它的代码实现吧。

1. public static void sort(int array[])

2. {

3.     int tmp  = 0;

4.     for(int i=0; i<array.length/2; i++)

5.     {

6.         //有序标记，每一轮的初始值都是true

7.         boolean isSorted = true;

8.         //奇数轮，从左向右比较和交换

9.         for(int j=i; j<array.length-i-1; j++)

10.         {

11.             if(array[j] > array[j+1])

12.             {

13.                 tmp = array[j];

14.                 array[j] = array[j+1];

15.                 array[j+1] = tmp;

16.                 // 有元素交换，所以不是有序的，标记变为false

17.                 isSorted = false;

18.             }

19.         }

20.         if(isSorted){

21.             break;

22.         }

// 在偶数轮之前，将isSorted重新标记为true

23.         isSorted = true;

24.         //偶数轮，从右向左比较和交换

25.         for(int j=array.length-i-1; j>i; j--)

26.         {

27.             if(array[j] < array[j-1])

28.             {

29.                 tmp = array[j];

30.                 array[j] = array[j-1];

31.                 array[j-1] = tmp;

32.                 // 因为有元素进行交换，所以不是有序的，标记变为false

33.                 isSorted = false;

34.             }

35.         }

36.         if(isSorted){

37.             break;

38.         }

39.     }

40. }

41.

42. public static void main(String[] args){

43.     int[] array = new int[]{2,3,4,5,6,7,8,1};

44.     sort(array);

45.     System.out.println(Arrays.toString(array));

46. }

这段代码是鸡尾酒排序的原始实现。代码外层的大循环控制着所有排序回合，大循环内包含2个小循环，第1个小循环从左向右比较并交换元素，第2个小循环从右向左比较并交换元素。

代码大致看明白了。之前讲冒泡排序时，有一种针对有序区的优化，鸡尾酒排序是不是也能用到呢？

当然喽！鸡尾酒排序也可以和之前所学的优化方法结合使用，只不过代码实现会稍微复杂一些，这里就不再展开讲解了，有兴趣的话，可以自己写一下代码实现哦。

OK，最后我想问问，鸡尾酒排序的优点和缺点是什么？适用于什么样的场景？

鸡尾酒排序的优点是能够在特定条件下，减少排序的回合数；而缺点也很明显，就是代码量几乎增加了1倍。

至于它能发挥出优势的场景，是大部分元素已经有序的情况。好了，关于冒泡排序和鸡尾酒排序，我们就介绍到这里喽。下一节再见！

4.3　什么是快速排序

4.3.1　初识快速排序

同冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换位置来达到排序的目的。

不同的是，冒泡排序在每一轮中只把1个元素冒泡到数列的一端，而快速排序则在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成两个部分。

这种思路就叫作分治法。

每次把数列分成两部分，究竟有什么好处呢？

假如给出一个8个元素的数列，一般情况下，使用冒泡排序需要比较7轮，每一轮把1个元素移动到数列的一端，时间复杂度是O(n^2)。

而快速排序的流程是什么样子呢？

如图所示，在分治法的思想下，原数列在每一轮都被拆分成两部分，每一部分在下一轮又分别被拆分成两部分，直到不可再分为止。

每一轮的比较和交换，需要把数组全部元素都遍历一遍，时间复杂度是O(n)。这样的遍历一共需要多少轮呢？假如元素个数是n，那么平均情况下需要logn轮，因此快速排序算法总体的平均时间复杂度是O(nlogn)。

分治法果然神奇！那么基准元素是如何选的呢？又如何把其他元素移动到基准元素的两端？

基准元素的选择，以及元素的交换，都是快速排序的核心问题。让我们先来看看如何选择基准元素。

4.3.2　基准元素的选择

基准元素，英文是pivot，在分治过程中，以基准元素为中心，把其他元素移动到它的左右两边。

那么如何选择基准元素呢？

最简单的方式是选择数列的第1个元素。

这种选择在绝大多数情况下是没有问题的。但是，假如有一个原本逆序的数列，期望排序成顺序数列，那么会出现什么情况呢？

哎呀，整个数列并没有被分成两半，每一轮都只确定了基准元素的位置。

是呀，在这种情况下，数列的第1个元素要么是最小值，要么是最大值，根本无法发挥分治法的优势。

在这种极端情况下，快速排序需要进行n轮，时间复杂度退化成了O(n^2)。

那么，该怎么避免这种情况发生呢？

其实很简单，我们可以随机选择一个元素作为基准元素，并且让基准元素和数列首元素交换位置。

这样一来，即使在数列完全逆序的情况下，也可以有效地将数列分成两部分。

当然，即使是随机选择基准元素，也会有极小的几率选到数列的最大值或最小值，同样会影响分治的效果。

所以，虽然快速排序的平均时间复杂度是O(nlogn)，但最坏情况下的时间复杂度是O(n^2)。

在后文中，为了简化步骤，省去了随机选择基准元素的过程，直接把首元素作为基准元素。

4.3.3　元素的交换

选定了基准元素以后，我们要做的就是把其他元素中小于基准元素的都交换到基准元素一边，大于基准元素的都交换到基准元素另一边。

具体如何实现呢？有两种方法。

1. 双边循环法。

2. 单边循环法。

何谓双边循环法？下面来看一看详细过程。

给出原始数列如下，要求对其从小到大进行排序。

首先，选定基准元素pivot，并且设置两个指针left和right，指向数列的最左和最右两个元素。

接下来进行第1次循环，从right指针开始，让指针所指向的元素和基准元素做比较。如果大于或等于pivot，则指针向左移动；如果小于pivot，则right指针停止移动，切换到left指针。

在当前数列中，1<4，所以right直接停止移动，换到left指针，进行下一步行动。

轮到left指针行动，让指针所指向的元素和基准元素做比较。如果小于或等于pivot，则指针向右移动；如果大于pivot，则left指针停止移动。

由于left开始指向的是基准元素，判断肯定相等，所以left右移1位。

由于7>4，left指针在元素7的位置停下。这时，让left和right指针所指向的元素进行交换。

接下来，进入第2次循环，重新切换到right指针，向左移动。right指针先移动到8，8>4，继续左移。由于2<4，停止在2的位置。

按照这个思路，后续步骤如图所示。

大致明白了，那么快速排序怎样用代码来实现呢？

我们来看一下用双边循环法实现的快速排序，代码使用了递归的方式。

1. public static void quickSort(int[] arr, int startIndex,

int endIndex) {

2.     // 递归结束条件：startIndex大于或等于endIndex时

3.     if (startIndex >= endIndex) {

4.         return;

5.     }

6.     // 得到基准元素位置

7.     int pivotIndex = partition(arr, startIndex, endIndex);

8.     // 根据基准元素，分成两部分进行递归排序

9.     quickSort(arr, startIndex, pivotIndex - 1);

10.     quickSort(arr, pivotIndex + 1, endIndex);

11. }

12.

13. /**

14.   * 分治（双边循环法）

15.  * @param arr         待交换的数组

16.  * @param startIndex      起始下标

17.  * @param endIndex      结束下标

18.   */

19. private static int partition(int[] arr, int startIndex,

int endIndex) {

20.     // 取第1个位置（也可以选择随机位置）的元素作为基准元素

21.     int pivot = arr[startIndex];

22.     int left = startIndex;

23.     int right = endIndex;

24.

25.     while( left != right) {

26.         //控制right 指针比较并左移

27.         while(left<right && arr[right] > pivot){

28.             right--;

29.         }

30.         //控制left指针比较并右移

31.         while( left<right && arr[left] <= pivot) {

32.             left++;

33.         }

34.         //交换left和right 指针所指向的元素

35.         if(left<right) {

36.             int p = arr[left];

37.             arr[left] = arr[right];

38.             arr[right] = p;

39.         }

40.     }

41.

42.     //pivot 和指针重合点交换

43.     arr[startIndex] = arr[left];

44.     arr[left] = pivot;

45.

46.     return left;

47. }

48.

49. public static void main(String[] args) {

50.     int[] arr = new int[] {4,4,6,5,3,2,8,1};

51.     quickSort(arr, 0, arr.length-1);

52.     System.out.println(Arrays.toString(arr));

53. }

在上述代码中，quickSort方法通过递归的方式，实现了分而治之的思想。

partition方法则实现了元素的交换，让数列中的元素依据自身大小，分别交换到基准元素的左右两边。在这里，我们使用的交换方式是双边循环法。

partition的代码实现好复杂呢，在一个大循环里还嵌套着两个子循环……让我仔细消化消化。

双边循环法的代码确实有些烦琐。除了这种方式，要实现元素的交换也可以利用单边循环法，下一节我们来仔细讲一讲。

4.3.4　单边循环法

双边循环法从数组的两边交替遍历元素，虽然更加直观，但是代码实现相对烦琐。而单边循环法则简单得多，只从数组的一边对元素进行遍历和交换。我们来看一看详细过程。

给出原始数列如下，要求对其从小到大进行排序。

开始和双边循环法相似，首先选定基准元素pivot。同时，设置一个mark指针指向数列起始位置，这个mark指针代表小于基准元素的区域边界。

接下来，从基准元素的下一个位置开始遍历数组。

如果遍历到的元素大于基准元素，就继续往后遍历。

如果遍历到的元素小于基准元素，则需要做两件事：第一，把mark指针右移1位，因为小于pivot的区域边界增大了1；第二，让最新遍历到的元素和mark指针所在位置的元素交换位置，因为最新遍历的元素归属于小于pivot的区域。

首先遍历到元素7，7>4，所以继续遍历。

接下来遍历到的元素是3，3<4，所以mark指针右移1位。

随后，让元素3和mark指针所在位置的元素交换，因为元素3归属于小于pivot的区域。

按照这个思路，继续遍历，后续步骤如图所示。

明白了，这个方法只需要单边循环，确实简单了许多呢！怎么用代码来实现呢？

双边循环法和单边循环法的区别在于partition函数的实现，让我们来看一下代码。

1. public static void quickSort(int[] arr, int startIndex,

int endIndex) {

2.     // 递归结束条件：startIndex大于或等于endIndex时

3.     if (startIndex >= endIndex) {

4.         return;

5.     }

6.     // 得到基准元素位置

7.     int pivotIndex = partition(arr, startIndex, endIndex);

8.     // 根据基准元素，分成两部分进行递归排序

9.     quickSort(arr, startIndex, pivotIndex - 1);

10.     quickSort(arr, pivotIndex + 1, endIndex);

11. }

12.

13. /**

14.   * 分治（单边循环法）

15.  * @param arr         待交换的数组

16.  * @param startIndex      起始下标

17.  * @param endIndex      结束下标

18.   */

19. private static int partition(int[] arr, int startIndex,

int endIndex) {

20.     // 取第1个位置（也可以选择随机位置）的元素作为基准元素

21.     int pivot = arr[startIndex];

22.     int mark = startIndex;

23.

24.     for(int i=startIndex+1; i<=endIndex; i++){

25.         if(arr[i]<pivot){

26.             mark ++;

27.             int p = arr[mark];

28.             arr[mark] = arr[i];

29.             arr[i] = p;

30.         }

31.     }

32.

33.     arr[startIndex] = arr[mark];

34.     arr[mark] = pivot;

35.     return mark;

36. }

37.

38. public static void main(String[] args) {

39.     int[] arr = new int[] {4,4,6,5,3,2,8,1};

40.     quickSort(arr, 0, arr.length-1);

41.     System.out.println(Arrays.toString(arr));

42. }

可以很明显看出，partition方法只要一个大循环就搞定了，的确比双边循环法简单多了。

以上所讲的快速排序实现方法，都是以递归为基础的。其实快速排序也可以基于非递归的方式来实现。

4.3.5　非递归实现

怎么样用非递归的方式来实现呢？

绝大多数的递归逻辑，都可以用栈的方式来代替。

为什么这样说呢？

在第1章介绍空间复杂度时我们曾经提到过，代码中一层一层的方法调用，本身就使用了一个方法调用栈。每次进入一个新方法，就相当于入栈；每次有方法返回，就相当于出栈。

所以，可以把原本的递归实现转化成一个栈的实现，在栈中存储每一次方法调用的参数。

下面来看一下具体的代码：

1. public static void quickSort(int[] arr, int startIndex,

int endIndex) {

2.     // 用一个集合栈来代替递归的函数栈

3.     Stack<Map<String, Integer>> quickSortStack = new

Stack<Map<String, Integer>>();

4.     // 整个数列的起止下标，以哈希的形式入栈

5.     Map rootParam = new HashMap();

6.     rootParam.put("startIndex", startIndex);

7.     rootParam.put("endIndex", endIndex);

8.     quickSortStack.push(rootParam);

9.

10.     // 循环结束条件：栈为空时

11.     while (!quickSortStack.isEmpty()) {

12.         //  栈顶元素出栈，得到起止下标

13.         Map<String, Integer> param = quickSortStack.pop();

14.         //  得到基准元素位置

15.         int pivotIndex = partition(arr, param.get("startIndex"),

param.get("endIndex"));

16.         //  根据基准元素分成两部分, 把每一部分的起止下标入栈

17.         if(param.get("startIndex") <  pivotIndex -1){

18.             Map<String, Integer> leftParam = new HashMap<String,

Integer>();

19.             leftParam.put("startIndex", param.get("startIndex"));

20.             leftParam.put("endIndex", pivotIndex-1);

21.             quickSortStack.push(leftParam);

22.         }

23.         if(pivotIndex + 1 < param.get("endIndex")){

24.             Map<String, Integer> rightParam = new HashMap<String,

Integer>();

25.             rightParam.put("startIndex", pivotIndex + 1);

26.             rightParam.put("endIndex", param.get("endIndex"));

27.             quickSortStack.push(rightParam);

28.         }

29.     }

30. }

31.

32. /**

33.   * 分治（单边循环法）

34.  * @param arr         待交换的数组

35.  * @param startIndex      起始下标

36.  * @param endIndex      结束下标

37.   */

38. private static int partition(int[] arr, int startIndex,

int endIndex) {

39.     // 取第1个位置（也可以选择随机位置）的元素作为基准元素

40.     int pivot = arr[startIndex];

41.     int mark = startIndex;

42.

43.     for(int i=startIndex+1; i<=endIndex; i++){

44.         if(arr[i]<pivot){

45.             mark ++;

46.             int p = arr[mark];

47.             arr[mark] = arr[i];

48.             arr[i] = p;

49.         }

50.     }

51.

52.     arr[startIndex] = arr[mark];

53.     arr[mark] = pivot;

54.     return mark;

55. }

56.

57. public static void main(String[] args) {

58.     int[] arr = new int[] {4,7,6,5,3,2,8,1};

59.     quickSort(arr, 0, arr.length-1);

60.     System.out.println(Arrays.toString(arr));

61. }

和刚才的递归实现相比，非递归方式代码的变动只发生在quickSort方法中。该方法引入了一个存储Map类型元素的栈，用于存储每一次交换时的起始下标和结束下标。

每一次循环，都会让栈顶元素出栈，通过partition方法进行分治，并且按照基准元素的位置分成左右两部分，左右两部分再分别入栈。当栈为空时，说明排序已经完毕，退出循环。

居然真的实现了非递归方法，好棒！

嘿嘿，快速排序是很重要的算法，与傅里叶变换等算法并称为二十世纪十大算法。

有关快速排序的知识我们就介绍到这里，希望大家把这个算法吃透，未来会受益无穷！

4.4　什么是堆排序

4.4.1　传说中的堆排序

还记得二叉堆的特性是什么吗?

1. 最大堆的堆顶是整个堆中的最大元素。

2. 最小堆的堆顶是整个堆中的最小元素。

以最大堆为例，如果删除一个最大堆的堆顶（并不是完全删除，而是跟末尾的节点交换位置），经过自我调整，第2大的元素就会被交换上来，成为最大堆的新堆顶。

正如上图所示，在删除值为10的堆顶节点后，经过调整，值为9的新节点就会顶替上来；在删除值为9的堆顶节点后，经过调整，值为8的新节点就会顶替上来……

由于二叉堆的这个特性，每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点。那么只要反复删除堆顶，反复调整二叉堆，所得到的集合就会成为一个有序集合，过程如下。

删除节点9，节点8成为新堆顶。

删除节点8，节点7成为新堆顶。

删除节点7，节点6成为新堆顶。

删除节点6，节点5成为新堆顶。

删除节点5，节点4成为新堆顶。

删除节点4，节点3成为新堆顶。

删除节点3，节点2成为新堆顶。

到此为止，原本的最大二叉堆已经变成了一个从小到大的有序集合。之前说过，二叉堆实际存储在数组中，数组中的元素排列如下。

由此，可以归纳出堆排序算法的步骤。

1. 把无序数组构建成二叉堆。需要从小到大排序，则构建成最大堆；需要从大到小排序，则构建成最小堆。

2. 循环删除堆顶元素，替换到二叉堆的末尾，调整堆产生新的堆顶。

大体思路明白了，那么该如何用代码来实现呢?

讲二叉堆时，我们写了二叉堆操作的相关代码。现在只要在原代码的基础上稍微改动一点点，就可以实现堆排序了。

4.4.2　堆排序的代码实现

1. /**

2.  * “下沉”调整

3.  * @param array      待调整的堆

4.  * @param parentIndex      要“下沉”的父节点

5.  * @param length       堆的有效大小

6.  */

7. public static void downAdjust(int[] array, int parentIndex,

int length) {

8.     // temp 保存父节点值，用于最后的赋值

9.     int temp = array[parentIndex];

10.     int childIndex = 2 * parentIndex + 1;

11.     while (childIndex < length) {

12.     // 如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子

13.         if (childIndex + 1 < length && array[childIndex + 1] >

array[childIndex]) {

14.             childIndex++;

15.         }

16.     // 如果父节点大于任何一个孩子的值，则直接跳出

17.         if (temp >= array[childIndex])

18.             break;

19.         //无须真正交换，单向赋值即可

20.         array[parentIndex] = array[childIndex];

21.         parentIndex = childIndex;

22.         childIndex = 2 * childIndex + 1;

23.     }

24.     array[parentIndex] = temp;

25. }

26.

27.

28. /**

29.   * 堆排序（升序）

30.  * @param array      待调整的堆

31.   */

32. public static void heapSort(int[] array) {

33.     // 1. 把无序数组构建成最大堆

34.     for (int i = (array.length-2)/2; i >= 0; i--) {

35.         downAdjust(array, i, array.length);

36.     }

37.     System.out.println(Arrays.toString(array));

38.     // 2. 循环删除堆顶元素，移到集合尾部，调整堆产生新的堆顶

39.     for (int i = array.length - 1; i > 0; i--) {

40.     // 最后1个元素和第1个元素进行交换

41.         int temp = array[i];

42.         array[i] = array[0];

43.         array[0] = temp;

44.     // “下沉”调整最大堆

45.         downAdjust(array, 0, i);

46.     }

47. }

48.

49.

50. public static void main(String[] args) {

51.     int[] arr = new int[] {1,3,2,6,5,7,8,9,10,0};

52.     heapSort(arr);

53.     System.out.println(Arrays.toString(arr));

54. }

原来如此，现在明白了！那么堆排序的时间复杂度和空间复杂度各是多少呢?

毫无疑问，空间复杂度是O(1)，因为并没有开辟额外的集合空间。t至于时间复杂度，我们来分析一下。

二叉堆的节点“下沉”调整（downAdjust 方法）是堆排序算法的基础，这个调节操作本身的时间复杂度在上一章讲过，是O(log n)。

我们再来回顾一下堆排序算法的步骤。

1. 把无序数组构建成二叉堆。

2. 循环删除堆顶元素，并将该元素移到集合尾部，调整堆产生新的堆顶。

第1步，把无序数组构建成二叉堆，这一步的时间复杂度是O(n)。

第2步，需要进行n-1次循环。每次循环调用一次downAdjust方法，所以第2步的计算规模是 (n-1)×logn ，时间复杂度为O(nlogn)。

两个步骤是并列关系，所以整体的时间复杂度是O(nlogn)。

最后一个问题，从宏观上看，堆排序和快速排序相比，有什么区别和联系呢？

先说说相同点，堆排序和快速排序的平均时间复杂度都是O(nlogn)，并且都是不稳定排序。至于不同点，快速排序的最坏时间复杂度是O(n^2)，而堆排序的最坏时间复杂度稳定在O(nlogn)。

此外，快速排序递归和非递归方法的平均空间复杂度都是O(logn)，而堆排序的空间复杂度是O(1)。

好了，关于堆排序算法，我们就介绍到这里。感谢大家！

4.5　计数排序和桶排序

4.5.1　线性时间的排序

哇，什么样的排序算法可以这么厉害？

让我们先来回顾一下以前所学的排序算法，无论是冒泡排序，还是快速排序，都是基于元素之间的比较来进行排序的。

例如冒泡排序。

如下图所示，因为8>3，所以8和3的位置交换。

例如堆排序。

如下图所示，因为10>7，所以10和7的位置交换。

排序当然要先比较呀，难道还有不需要比较的排序算法？

有一些特殊的排序并不基于元素比较，如计数排序、桶排序、基数排序。

以计数排序来说，这种排序算法是利用数组下标来确定元素的正确位置的。

4.5.2　初识计数排序

还是不明白，元素下标怎么能用来帮助排序呢？

那让我们来看一个例子。

假设数组中有20个随机整数，取值范围为0～10，要求用最快的速度把这20个整数从小到大进行排序。

如何给这些无序的随机整数进行排序呢？

考虑到这些整数只能够在0、1、2、3、4、5、6、7、8、9、10这11个数中取值，取值范围有限。所以，可以根据这有限的范围，建立一个长度为11的数组。数组下标从0到10，元素初始值全为0。

假设20个随机整数的值如下所示。

9，3，5，4，9，1，2，7，8，1，3，6，5，3，4，0，10，9 ，7，9

下面就开始遍历这个无序的随机数列，每一个整数按照其值对号入座，同时，对应数组下标的元素进行加1操作。

例如第1个整数是9，那么数组下标为9的元素加1。

第2个整数是3，那么数组下标为3的元素加1。

继续遍历数列并修改数组……

最终，当数列遍历完毕时，数组的状态如下。

该数组中每一个下标位置的值代表数列中对应整数出现的次数。

有了这个统计结果，排序就很简单了。直接遍历数组，输出数组元素的下标值，元素的值是几，就输出几次。

0，1，1，2，3，3，3，4，4，5，5，6，7，7，8，9，9，9，9，10

显然，现在输出的数列已经是有序的了。

这就是计数排序的基本过程，它适用于一定范围内的整数排序。在取值范围不是很大的情况下，它的性能甚至快过那些时间复杂度为O(nlogn)的排序。

明白了，计数排序还真是个神奇的算法！那么，用代码怎么实现呢？

我写了一个计数排序的初步实现代码，我们来看一下。

1. public static int[] countSort(int[] array) {

2.     //1.得到数列的最大值

3.     int max = array[0];

4.     for(int i=1; i<array.length; i++){

5.         if(array[i] > max){

6.             max = array[i];

7.         }

8.     }

9.     //2.根据数列最大值确定统计数组的长度

10.     int[] countArray = new int[max+1];

11.     //3.遍历数列，填充统计数组

12.     for(int i=0; i<array.length; i++){

13.         countArray[array[i]]++;

14.     }

15.     //4.遍历统计数组，输出结果

16.     int index = 0;

17.     int[] sortedArray = new int[array.length];

18.     for(int i=0; i<countArray.length; i++){

19.         for(int j=0; j<countArray[i]; j++){

20.             sortedArray[index++] = i;

21.         }

22.     }

23.     return sortedArray;

24. }

25.

26.

27. public static void main(String[] args) {

28.     int[] array = new int[] {4,4,6,5,3,2,8,1,7,5,6,0,10};

29.     int[] sortedArray = countSort(array);

30.     System.out.println(Arrays.toString(sortedArray));

31. }

这段代码在开头有一个步骤，就是求数列的最大整数值max。后面创建的统计数组countArray，长度是max+1，以此来保证数组的最后一个下标是max。

4.5.3　计数排序的优化

从实现功能的角度来看，这段代码可以实现整数的排序。但是这段代码也存在一些问题，你发现了吗？

哦，让我想想……

对了！我们只以数列的最大值来决定统计数组的长度，其实并不严谨。例如下面的数列。

95，94，91，98，99，90，99，93，91，92

这个数列的最大值是99，但最小的整数是90。如果创建长度为100的数组，那么前面从0到89的空间位置就都浪费了！

怎么解决这个问题呢？

很简单，只要不再以输入数列的最大值+1作为统计数组的长度，而是以数列最大值-最小值+1作为统计数组的长度即可。

同时，数列的最小值作为一个偏移量，用于计算整数在统计数组中的下标。

以刚才的数列为例，统计出数组的长度为99-90+1=10，偏移量等于数列的最小值90。

对于第1个整数95，对应的统计数组下标是95-90 = 5，如图所示。

是的，这确实对计数排序进行了优化。此外，朴素版的计数排序只是简单地按照统计数组的下标输出元素值，并没有真正给原始数列进行排序。

如果只是单纯地给整数排序，这样做并没有问题。但如果在现实业务里，例如给学生的考试分数进行排序，遇到相同的分数就会分不清谁是谁。

什么意思呢？让我们看看下面的例子。

给出一个学生成绩表，要求按成绩从低到高进行排序，如果成绩相同，则遵循原表固有顺序。

那么，当我们填充统计数组以后，只知道有两个成绩并列为95分的同学，却不知道哪一个是小红，哪一个是小绿。

明白你的例子了，但为什么我的成绩最低呀……那么，这种分数相同的情况要怎么解决？

在这种情况下，需要稍微改变之前的逻辑，在填充完统计数组以后，对统计数组做一下变形。

仍然以刚才的学生成绩表为例，将之前的统计数组变形成下面的样子。

这是如何变形的呢？其实就是从统计数组的第2个元素开始，每一个元素都加上前面所有元素之和。

为什么要相加呢？初次接触的读者可能会觉得莫名其妙。

这样相加的目的，是让统计数组存储的元素值，等于相应整数的最终排序位置的序号。例如下标是9的元素值为5，代表原始数列的整数9，最终的排序在第5位。

接下来，创建输出数组sortedArray，长度和输入数列一致。然后从后向前遍历输入数列。

第1步，遍历成绩表最后一行的小绿同学的成绩。

小绿的成绩是95分，找到countArray下标是5的元素，值是4，代表小绿的成绩排名位置在第4位。

同时，给countArray下标是5的元素值减1，从4变成3，代表下次再遇到95分的成绩时，最终排名是第3。

第2步，遍历成绩表倒数第2行的小白同学的成绩。

小白的成绩是94分，找到countArray下标是4的元素，值是2，代表小白的成绩排名位置在第2位。

同时，给countArray下标是4的元素值减1，从2变成1，代表下次再遇到94分的成绩时（实际上已经遇不到了），最终排名是第1。

第3步，遍历成绩表倒数第3行的小红同学的成绩。

小红的成绩是95分，找到countArray下标是5的元素，值是3（最初是4，减1变成了3），代表小红的成绩排名位置在第3位。

同时，给countArray下标是5的元素值减1，从3变成2，代表下次再遇到95分的成绩时（实际上已经遇不到了），最终排名是第2。

这样一来，同样是95分的小红和小绿就能够清楚地排出顺序了，也正因为此，优化版本的计数排序属于稳定排序。

后面的遍历过程以此类推，这里就不再详细描述了。

还真是够绕的，不过大体上明白了。那么，优化之后的计数排序如何用代码实现呢？

说起来复杂，其实代码很简洁，让我们来看一看。

1. public static int[] countSort(int[] array) {

2.     //1.得到数列的最大值和最小值，并算出差值d

3.     int max = array[0];

4.     int min = array[0];

5.     for(int i=1; i<array.length; i++) {

6.         if(array[i] > max) {

7.             max = array[i];

8.         }

9.         if(array[i] < min) {

10.             min = array[i];

11.         }

12.     }

13.     int d = max - min;

14.     //2.创建统计数组并统计对应元素的个数

15.     int[] countArray = new int[d+1];

16.     for(int i=0; i<array.length; i++) {

17.         countArray[array[i]-min]++;

18.     }

19.

20.     //3.统计数组做变形，后面的元素等于前面的元素之和

21.     for(int i=1;i<countArray.length;i++) {

22.

23.         countArray[i] += countArray[i-1];

24.     }

25.     //4.倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组

26.     int[] sortedArray = new int[array.length];

27.     for(int i=array.length-1;i>=0;i--) {

28.         sortedArray[countArray[array[i]-min]-1]=array[i];

29.         countArray[array[i]-min]--;

30.     }

31.     return sortedArray;

32. }

33.

34. public static void main(String[] args) {

35.     int[] array = new int[] {95,94,91,98,99,90,99,93,91,92};

36.     int[] sortedArray = countSort(array);

37.     System.out.println(Arrays.toString(sortedArray));

38. }

小灰，如果原始数列的规模是n，最大和最小整数的差值是m，你说说计数排序的时间复杂度和空间复杂度是多少？

代码第1、2、4步都涉及遍历原始数列，运算量都是n，第3步遍历统计数列，运算量是m，所以总体运算量是3n+m，去掉系数，时间复杂度是O(n+m)。

至于空间复杂度，如果不考虑结果数组，只考虑统计数组大小的话，空间复杂度是O(m)。

不错哦，回答得很赞！

不过我有一点不太明白，既然计数排序这么强大，为什么很少被大家使用呢？

因为计数排序有它的局限性，主要表现为如下两点。

1. 当数列最大和最小值差距过大时，并不适合用计数排序。

例如给出20个随机整数，范围在0到1亿之间，这时如果使用计数排序，需要创建长度为1亿的数组。不但严重浪费空间，而且时间复杂度也会随之升高。

2. 当数列元素不是整数时，也不适合用计数排序。

如果数列中的元素都是小数，如25.213，或0.00 000 001这样的数字，则无法创建对应的统计数组。这样显然无法进行计数排序。

对于这些局限性，另一种线性时间排序算法做出了弥补，这种排序算法叫作桶排序。

4.5.4　什么是桶排序

桶排序？那又是什么鬼？

桶排序同样是一种线性时间的排序算法。类似于计数排序所创建的统计数组，桶排序需要创建若干个桶来协助排序。

那么，桶排序中所谓的“桶”，又是什么呢？

每一个桶（bucket）代表一个区间范围，里面可以承载一个或多个元素。

假设有一个非整数数列如下：

4.5，0.84，3.25，2.18，0.5

让我们来看看桶排序的工作原理。

桶排序的第1步，就是创建这些桶，并确定每一个桶的区间范围。

具体需要建立多少个桶，如何确定桶的区间范围，有很多种不同的方式。我们这里创建的桶数量等于原始数列的元素数量，除最后一个桶只包含数列最大值外，前面各个桶的区间按照比例来确定。

区间跨度 = （最大值-最小值）/ （桶的数量 - 1）

第2步，遍历原始数列，把元素对号入座放入各个桶中。

第3步，对每个桶内部的元素分别进行排序（显然，只有第1个桶需要排序）。

第4步，遍历所有的桶，输出所有元素。

0.5，0.84，2.18，3.25，4.5

到此为止，排序结束。

大体明白了，那么，代码怎么写呢？

我们来看一看桶排序的代码实现。

1. public static double[] bucketSort(double[] array){

2.

3.     //1.得到数列的最大值和最小值，并算出差值d

4.     double max = array[0];

5.     double min = array[0];

6.     for(int i=1; i<array.length; i++) {

7.         if(array[i] > max) {

8.             max = array[i];

9.         }

10.         if(array[i] < min) {

11.             min = array[i];

12.         }

13.     }

14.     double d = max - min;

15.

16.     //2.初始化桶

17.     int bucketNum = array.length;

18.     ArrayList<LinkedList<Double>> bucketList = new

ArrayList<LinkedList<Double>>(bucketNum);

19.     for(int i = 0; i < bucketNum; i++){

20.         bucketList.add(new LinkedList<Double>());

21.     }

22.

23.     //3.遍历原始数组，将每个元素放入桶中

24.     for(int i = 0; i < array.length; i++){

25.         int num = (int)((array[i] - min)  * (bucketNum-1) / d);

26.         bucketList.get(num).add(array[i]);

27.     }

28.

29.     //4.对每个桶内部进行排序

30.     for(int i = 0; i < bucketList.size(); i++){

31.         //JDK 底层采用了归并排序或归并的优化版本

32.         Collections.sort(bucketList.get(i));

33.     }

34.

35.     //5.输出全部元素

36.     double[] sortedArray = new double[array.length];

37.     int index = 0;

38.     for(LinkedList<Double> list : bucketList){

39.         for(double element : list){

40.             sortedArray[index] = element;

41.             index++;

42.         }

43.     }

44.     return sortedArray;

45. }

46.

47. public static void main(String[] args) {

48.     double[] array = new double[]

{4.12,6.421,0.0023,3.0,2.123,8.122,4.12, 10.09};

49.     double[] sortedArray = bucketSort(array);

50.     System.out.println(Arrays.toString(sortedArray));

51. }

在上述代码中，所有的桶都保存在ArrayList集合中，每一个桶都被定义成一个链表（LinkedList<Double>），这样便于在尾部插入元素。

同时，上述代码使用了JDK的集合工具类Collections.sort来为桶内部的元素进行排序。Collections.sort底层采用的是归并排序或Timsort，各位读者可以简单地把它们当作一种时间复杂度为O(nlogn)的排序。

那么，桶排序的时间复杂度是多少呢？

桶排序的时间复杂度有些复杂，让我们来计算一下。

假设原始数列有n个元素，分成n个桶。

下面逐步来分析一下算法复杂度。

第1步，求数列最大、最小值，运算量为n。

第2步，创建空桶，运算量为n。

第3步，把原始数列的元素分配到各个桶中，运算量为n。

第4步，在每个桶内部做排序，在元素分布相对均匀的情况下，所有桶的运算量之和为n。

第5步，输出排序数列，运算量为n。

因此，桶排序的总体时间复杂度为O(n)。

至于空间复杂度就很容易得到了，同样是O(n)。

桶排序的性能并非绝对稳定。如果元素的分布极不均衡，在极端情况下，第一个桶中有n-1个元素，最后一个桶中有1个元素。此时的时间复杂度将退化为O(nlogn)，而且还白白创建了许多空桶。

由此可见，并没有绝对好的算法，也没有绝对不好的算法，关键要看具体的场景。

关于计数排序和桶排序的知识，我们就介绍到这里，下一章再见！

4.6　小结

本章我们学习了一些具有代表性的排序算法。下面根据算法的时间复杂度、空间复杂度、是否稳定等维度来做一个归纳。

第5章　面试中的算法

5.1　踌躇满志的小灰

这一章，我们开始讲解形形色色的算法面试题，其中有许多是面试过程中常常遇到的经典题目。小灰究竟能不能面试成功呢？让我们为他加油吧！

5.2　如何判断链表有环

5.2.1　一场与链表相关的面试

下面我来考查你一道算法题。

题目

有一个单向链表，链表中有可能出现“环”，就像下图这样。

那么，如何用程序来判断该链表是否为有环链表呢？

哦，让我想想啊……

有了！我可以从头节点开始遍历整个单链表……

方法1：

首先从头节点开始，依次遍历单链表中的每一个节点。每遍历一个新节点，就从头检查新节点之前的所有节点，用新节点和此节点之前所有节点依次做比较。如果发现新节点和之前的某个节点相同，则说明该节点被遍历过两次，链表有环；如果之前的所有节点中不存在与新节点相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

就像图中这样，当遍历链表节点7时，从头访问节点5和节点3，发现已遍历的节点中并不存在节点7，则继续往下遍历。

当第2次遍历到节点2时，从头访问曾经遍历过的节点，发现已经遍历过节点2，说明链表有环。

假设链表的节点数量为n，则该解法的时间复杂度为O(n^2)。由于并没有创建额外的存储空间，所以空间复杂度为O(1)。

OK，这姑且算是一种方法，有没有效率更高的解法？

哦，让我想想啊……

或者，我创建一个哈希表，然后……

方法2：

首先创建一个以节点ID为Key的HashSet集合，用来存储曾经遍历过的节点。然后同样从头节点开始，依次遍历单链表中的每一个节点。每遍历一个新节点，都用新节点和HashSet集合中存储的节点进行比较，如果发现HashSet中存在与之相同的节点ID，则说明链表有环，如果HashSet中不存在与新节点相同的节点ID，就把这个新节点ID存入HashSet中，之后进入下一节点，继续重复刚才的操作。

遍历过5、3。

遍历过5、3、7、2、6、8、1。

当再一次遍历节点2时，查找HashSet，发现节点已存在。

由此可知，链表有环。

这个方法在流程上和方法1类似，本质的区别是使用了HashSet作为额外的缓存。

假设链表的节点数量为n，则该解法的时间复杂度是O(n)。由于使用了额外的存储空间，所以算法的空间复杂度同样是O(n)。

OK，这种方法在时间上已经是最优了。有没有可能在空间上也得到优化？

哦，让我想想啊……

想不出来啊，怎么能让时间复杂度不变，同时让空间复杂度降低呢？

呵呵，没关系，今天就到这里，你回家等通知吧。

5.2.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你给我讲讲呗，怎么能够更高效地判断一个链表是否有环呀？

哈哈，小灰，有环链表的判断问题是很基础的算法题，许多面试官都喜欢考查，你必须要掌握哦！

对于这道题，有一个很巧妙的方法，这个方法利用了两个指针。

方法3：

首先创建两个指针p1和p2（在Java里就是两个对象引用），让它们同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针p1每次向后移动1个节点，让指针p2每次向后移动2个节点，然后比较两个指针指向的节点是否相同。如果相同，则可以判断出链表有环，如果不同，则继续下一次循环。

第1步，p1和p2都指向节点5。

第2步，p1指向节点3，p2指向节点7。

第3步，p1指向节点7，p2指向节点6。

第4步，p1指向节点2，p2指向节点1。

第5步，p1指向节点6，p2也指向节点6，p1和p2所指相同，说明链表有环。

学过小学奥数的读者，一定听说过数学上的追及问题。此方法就类似于一个追及问题。

在一个环形跑道上，两个运动员从同一地点起跑，一个运动员速度快，另一个运动员速度慢。当两人跑了一段时间后，速度快的运动员必然会再次追上并超过速度慢的运动员，原因很简单，因为跑道是环形的。

假设链表的节点数量为n，则该算法的时间复杂度为O(n)。除两个指针外，没有使用任何额外的存储空间，所以空间复杂度是O(1)。

那么，这个算法用代码怎么实现呢？

代码实现很简单，让我们来看一下。

1. /**

2.  * 判断是否有环

3.  * @param head  链表头节点

4.  */

5. public static boolean isCycle(Node head) {

6.     Node p1 = head;

7.     Node p2 = head;

8.     while (p2!=null && p2.next!=null){

9.         p1 = p1.next;

10.         p2 = p2.next.next;

11.         if(p1 == p2){

12.             return true;

13.         }

14.     }

15.     return false;

16. }

17.

18. /**

19.   * 链表节点

20.   */

21. private static class Node {

22.     int data;

23.     Node next;

24.     Node(int data) {

25.         this.data = data;

26.     }

27. }

28.

29. public static void main(String[] args) throws Exception {

30.     Node node1 = new Node(5);

31.     Node node2 = new Node(3);

32.     Node node3 = new Node(7);

33.     Node node4 = new Node(2);

34.     Node node5 = new Node(6);

35.     node1.next = node2;

36.     node2.next = node3;

37.     node3.next = node4;

38.     node4.next = node5;

39.     node5.next = node2;

40.

41.     System.out.println(isCycle(node1));

42. }

明白了，这真是个好方法！

5.2.3　问题扩展

这个题目其实还可以扩展出许多有意思的问题，例如下面这些。

扩展问题1：

如果链表有环，如何求出环的长度？

扩展问题2：

如果链表有环，如何求出入环节点？

哎呀，这两个问题怎么解呢？

第1个问题求环长，非常简单，解法如下。

当两个指针首次相遇，证明链表有环的时候，让两个指针从相遇点继续循环前进，并统计前进的循环次数，直到两个指针第2次相遇。此时，统计出来的前进次数就是环长。

因为指针p1每次走1步，指针p2每次走2步，两者的速度差是1步。当两个指针再次相遇时，p2比p1多走了整整1圈。

因此，环长 = 每一次速度差 × 前进次数 = 前进次数。

第2个问题是求入环点，有些难度，我们可以做一个抽象的推断。

上图是对有环链表所做的一个抽象示意图。假设从链表头节点到入环点的距离是D，从入环点到两个指针首次相遇点的距离是S_1，从首次相遇点回到入环点的距离是S^2。

那么，当两个指针首次相遇时，各自所走的距离是多少呢？

指针p1一次只走1步，所走的距离是D+S^1。

指针p2一次走2步，多走了n(n>=1)整圈，所走的距离是D+S_1+n(S_1+S_1)。

由于p2的速度是p1的2倍，所以所走距离也是p1的2倍，因此：

2(D+S_1) = D+S_1+n(S_1+S_2)

等式经过整理得出：

D = (n-1)(S_1+S_2)+S_2

也就是说，从链表头结点到入环点的距离，等于从首次相遇点绕环n-1圈再回到入环点的距离。

这样一来，只要把其中一个指针放回到头节点位置，另一个指针保持在首次相遇点，两个指针都是每次向前走1步。那么，它们最终相遇的节点，就是入环节点。

哇，居然这么神奇？

我们不妨用原题中链表的例子来演示一下。

首先，让指针p1回到链表头节点，指针p2保持在首次相遇点。

指针p1和p2各自前进1步。

指针p1和p2第2次前进。

指针p1和p2第3次前进，指向了同一个节点2，节点2正是有环链表的入环点。

果真在入环点相遇了呢，这下明白了！

好了，关于判断链表是否有环及其扩展的题目，我们就介绍到这里。咱们下一节再见！

5.3　最小栈的实现

5.3.1　一场关于栈的面试

下面我来考查你一道算法题。

题目

实现一个栈，该栈带有出栈（pop）、入栈（push）、取最小元素（getMin）3个方法。要保证这3个方法的时间复杂度都是O(1)。

哦，让我想想……

我想到啦！可以把栈中的最小元素下标暂存起来……

小灰的思路如下。

1. 创建一个整型变量min，用来存储栈中的最小元素。当第1个元素进栈时，把进栈元素赋值给min，即把栈中唯一的元素当做最小值。

2. 之后每当一个新元素进栈，就让新元素和min比较大小。如果新元素小于min，则min等于新进栈的元素；如果新元素大于或等于min，则不做改变。

3. 当调用getMin方法时，直接返回min的值即可。

小灰，你有没有觉得这个思路存在什么问题？

没有问题呀？这个解法杠杠的！

呵呵，今天面试就先到这里，回家等通知去吧！

5.3.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，怎么才能实现一个最小栈呀？我采用临时变量暂存栈的最小值，究竟存在什么问题呢？

小灰，你想得太简单啦！你只考虑了进栈场景，却没有考虑出栈场景。

哦？出栈场景有什么问题吗？

让我来给你演示一下。

原本，栈中最小的元素是3，min变量记录的值也是3。

这时，栈顶元素出栈了。

此时的min变量应该等于几呢？

虽然此时的最小元素是4，但是程序并不知道。

哎呀，还真是……

所以说，只暂存一个最小值是不够的，我们需要存储栈中曾经的最小值，作为“备胎”。

详细的解法步骤如下。

1. 设原有的栈叫作栈A，此时创建一个额外的“备胎”栈B，用于辅助栈A。

2. 当第1个元素进入栈A时，让新元素也进入栈B。这个唯一的元素是栈A的当前最小值。

3. 之后，每当新元素进入栈A时，比较新元素和栈A当前最小值的大小，如果小于栈A当前最小值，则让新元素进入栈B，此时栈B的栈顶元素就是栈A当前最小值。

4. 每当栈A有元素出栈时，如果出栈元素是栈A当前最小值，则让栈B的栈顶元素也出栈。此时栈B余下的栈顶元素所指向的，是栈A当中原本第2小的元素，代替刚才的出栈元素成为栈A的当前最小值。（备胎转正。）

5. 当调用getMin方法时，返回栈B的栈顶所存储的值，这也是栈A的最小值。

显然，这个解法中进栈、出栈、取最小值的时间复杂度都是O(1)，最坏情况空间复杂度是O(n)。

这下明白了！那么代码怎么来实现呢？

代码不难实现，让我们来看一看。

1. private Stack<Integer> mainStack = new Stack<Integer>();

2. private Stack<Integer> minStack = new Stack<Integer>();

3.

4. /**

5.  * 入栈操作

6.  * @param element  入栈的元素

7.  */

8. public void push(int element) {

9.     mainStack.push(element);

10.     //如果辅助栈为空，或者新元素小于或等于辅助栈栈顶，则将新元素压入辅助栈

11.     if (minStack.empty() || element  <= minStack.peek()) {

12.         minStack.push(element);

13.     }

14. }

15.

16. /**

17.   * 出栈操作

18.   */

19. public Integer pop() {

20.     //如果出栈元素和辅助栈栈顶元素值相等，辅助栈出栈

21.     if (mainStack.peek().equals(minStack.peek())) {

22.         minStack.pop();

23.     }

24.     return mainStack.pop();

25. }

26.

27. /**

28.   * 获取栈的最小元素

29.   */

30. public int getMin() throws Exception {

31.     if (mainStack.empty()) {

32.         throw new Exception("stack is empty");

33.     }

34.

35.     return minStack.peek();

36. }

37.

38. public static void main(String[] args) throws Exception {

39.     MinStack stack = new MinStack();

40.     stack.push(4);

41.     stack.push(9);

42.     stack.push(7);

43.     stack.push(3);

44.     stack.push(8);

45.     stack.push(5);

46.     System.out.println(stack.getMin());

47.     stack.pop();

48.     stack.pop();

49.     stack.pop();

50.     System.out.println(stack.getMin());

51. }

代码第1行输出的是3，因为当时的最小值是3。

代码第2行输出的是4，因为元素3出栈后，最小值是4。

好了，关于最小栈题目的解法就介绍到这里，咱们下一节再见！

5.4　如何求出最大公约数

5.4.1　一场求最大公约数的面试

下面我来考查你一道算法题，数学里面的最大公约数，知道吧？

这个我知道，小学就学过。

那么，看看下面这个算法题。

题目

写一段代码，求出两个整数的最大公约数，要尽量优化算法的性能。

哦，让我试试……

写出来啦！你看看。

小灰的代码如下：

1. public static int getGreatestCommonDivisor(int a, int b){

2.     int big = a>b ? a:b;

3.     int small = a<b ? a:b;

4.     if(big%small == 0){

5.         return small;

6.     }

7.     for(int i= small/2; i>1; i--){

8.         if(small%i==0 && big%i==0){

9.             return i;

10.         }

11.     }

12.     return  1;

13. }

14.

15. public static void main(String[] args) {

16.     System.out.println(getGreatestCommonDivisor(25, 5));

17.     System.out.println(getGreatestCommonDivisor(100, 80));

18.     System.out.println(getGreatestCommonDivisor(27, 14));

19. }

小灰的思路十分简单。他使用暴力枚举的方法，从较小整数的一半开始，试图找到一个合适的整数i，看看这个整数能否被a和b同时整除。

你这个方法虽然实现了所要求的功能，但是效率不行啊。想想看，如果我传入的整数是10 000和10 001，用你的方法就需要循环10 000/2-1=4999次！

哎呀，这倒是个问题。

想不出更好的方法了……

呵呵，没关系，回家等通知去吧！

5.4.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，怎么才能更高效地求出两个整数的最大公约数呀？

小灰，你听说过辗转相除法吗？

辗……什么除法？

是辗转相除法！又叫作欧几里得算法。

辗转相除法， 又名欧几里得算法（Euclidean algorithm），该算法的目的是求出两个正整数的最大公约数。它是已知最古老的算法， 其产生时间可追溯至公元前300年前。

这条算法基于一个定理：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。

例如10和25，25除以10商2余5，那么10和25的最大公约数，等同于10和5的最大公约数。

有了这条定理，求最大公约数就变得简单了。我们可以使用递归的方法把问题逐步简化。

首先，计算出a除以b的余数c，把问题转化成求b和c的最大公约数；然后计算出b除以c的余数d，把问题转化成求c和d的最大公约数；再计算出c除以d的余数e，把问题转化成求d和e的最大公约数……

以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止。

说了这么多理论不如直接写代码，小灰，你按照辗转相除法的思路改改你的代码吧。

好的，让我试试！

辗转相除法的实现代码如下：

1. public static int getGreatestCommonDivisorV2(int a, int b){

2.     int big = a>b ? a:b;

3.     int small = a<b ? a:b;

4.     if(big%small == 0){

5.         return small;

6.     }

7.     return getGreatestCommonDivisorV2(big%small, small);

8. }

9.

10. public static void main(String[] args) {

11.     System.out.println(getGreatestCommonDivisorV2(25, 5));

12.     System.out.println(getGreatestCommonDivisorV2(100, 80));

13.     System.out.println(getGreatestCommonDivisorV2(27, 14));

14. }

没错，这确实是辗转相除法的思路。不过有一个问题，当两个整数较大时，做a%b取模运算的性能会比较差。

这我也明白，可是不取模的话，还能怎么办呢？

说到这里，另一个算法就要登场了，它叫作更相减损术。

更相减损术，出自中国古代的《九章算术》，也是一种求最大公约数的算法。古希腊人很聪明，可是我们炎黄子孙也不差。

它的原理更加简单：两个正整数a和b（a>b），它们的最大公约数等于a-b的差值c和较小数b的最大公约数。例如10和25，25减10的差是15，那么10和25的最大公约数，等同于10和15的最大公约数。

由此，我们同样可以通过递归来简化问题。首先，计算出a和b的差值c（假设a>b），把问题转化成求b和c的最大公约数；然后计算出c和b的差值d（假设c>b），把问题转化成求b和d的最大公约数；再计算出b和d的差值e（假设b>d），把问题转化成求d和e的最大公约数……

以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以相等为止，最大公约数就是最终相等的这两个数的值。

OK，这就是更相减损术的思路，你按照这个思路再写一段代码看看。

好的，让我试试！

更相减损术的实现代码如下：

1. public static int getGreatestCommonDivisorV3(int a, int b){

2.     if(a == b){

3.         return a;

4.     }

5.     int big = a>b ? a:b;

6.     int small = a<b ? a:b;

7.     return getGreatestCommonDivisorV3(big-small, small);

8. }

9.

10. public static void main(String[] args) {

11.     System.out.println(getGreatestCommonDivisorV3(25, 5));

12.     System.out.println(getGreatestCommonDivisorV3(100, 80));

13.     System.out.println(getGreatestCommonDivisorV3(27, 14));

14. }

很好，更相减损术的过程就是这样。我们避免了大整数取模可能出现的性能问题，已经越来越接近最优解决方案了。

但是，更相减损术依靠两数求差的方式来递归，运算次数肯定远大于辗转相除法的取模方式吧？

能发现问题，看来你进步了。更相减损术是不稳定的算法，当两数相差悬殊时，如计算10000和1的最大公约数，就要递归9999次！

有什么办法可以既避免大整数取模，又能尽可能地减少运算次数呢？

下面就是我要说的最优方法：把辗转相除法和更相减损术的优势结合起来，在更相减损术的基础上使用移位运算。

众所周知，移位运算的性能非常好。对于给出的正整数a和b，不难得到如下的结论。

（从下文开始，获得最大公约数的方法getGreatestCommonDivisor被简写为gcd。）

当a和b均为偶数时，gcd(a,b) = 2×gcd(a/2, b/2) = 2×gcd(a>>1,b>>1)。

当a为偶数，b为奇数时，gcd(a,b) = gcd(a/2,b) = gcd(a>>1,b)。

当a为奇数，b为偶数时，gcd(a,b) = gcd(a,b/2) = gcd(a,b>>1)。

当a和b均为奇数时，先利用更相减损术运算一次，gcd(a,b) = gcd(b,a-b)，此时a-b必然是偶数，然后又可以继续进行移位运算。

例如计算10和25的最大公约数的步骤如下。

1. 整数10通过移位，可以转换成求5和25的最大公约数。

2. 利用更相减损术，计算出25-5=20，转换成求5和20的最大公约数。

3. 整数20通过移位，可以转换成求5和10的最大公约数。

4. 整数10通过移位，可以转换成求5和5的最大公约数。

5. 利用更相减损术，因为两数相等，所以最大公约数是5。

这种方式在两数都比较小时，可能看不出计算次数的优势；当两数越大时，计算次数的减少就会越明显。

说了这么多，来看看代码吧，这是最终版本的代码。

1. public static int gcd(int a, int b){

2.     if(a == b){

3.         return a;

4.     }

5.     if((a&1)==0 && (b&1)==0){

6.         return gcd(a>>1, b>>1)<<1;

7.     } else if((a&1)==0 && (b&1)!=0){

8.         return gcd(a>>1, b);

9.     } else if((a&1)!=0 && (b&1)==0){

10.         return gcd(a, b>>1);

11.     } else {

12.         int big = a>b ? a:b;

13.         int small = a<b ? a:b;

14.         return gcd(big-small, small);

15.     }

16. }

17.

18. public static void main(String[] args) {

19.     System.out.println(gcd(25, 5));

20.     System.out.println(gcd(100, 80));

21.     System.out.println(gcd(27, 14));

22. }

在上述代码中，判断整数奇偶性的方式是让整数和1进行与运算，如果(a&1)==0，则说明整数a是偶数；如果(a&1)!=0，则说明整数a是奇数。

真不容易呀，终于得到了最优解！

嘿嘿，作为程序员，就是需要反复推敲，追求代码的极致！

我还有最后一个问题，咱们使用的这些方法，时间复杂度分别是多少呢？

让我们来总结一下上述解法的时间复杂度。

1. 暴力枚举法：时间复杂度是O(min(a, b))。

2. 辗转相除法：时间复杂度不太好计算，可以近似为O(log(max(a, b)))，但是取模运算性能较差。

3. 更相减损术：避免了取模运算，但是算法性能不稳定，最坏时间复杂度为O(max(a, b))。

4. 更相减损术与移位相结合：不但避免了取模运算，而且算法性能稳定，时间复杂度为O(log(max(a, b)))。

好了，有关最大公约数的求解，我们就介绍到这里。咱们下一节再会！

5.5　如何判断一个数是否为2的整数次幂

5.5.1　一场很“2”的面试

下面我来考查你一道算法题，给你一个正整数，如何判断它是不是2的整数次幂？

题目

实现一个方法，来判断一个正整数是否是2的整数次幂（如16是2的4次方，返回true；18不是2的整数次幂，则返回false）。要求性能尽可能高。

哦，让我想想……

我想到了！利用一个整型变量，让它从1开始不断乘以2，将每一次乘2的结果和目标整数进行比较。

小灰的具体想法如下。

创建一个中间变量temp，初始值是1。然后进入一个循环，每次循环都让temp和目标整数相比较，如果相等，则说明目标整数是2的整数次幂；如果不相等，则让temp增大1倍，继续循环并进行比较。当temp的值大于目标整数时，说明目标整数不是2的整数次幂。

举个例子。

给出一个整数19，则

1X2 = 2，

2X2 = 4，

4X2 = 8，

8X2 = 16，

16X2 = 32，

由于32>19，所以19不是2的整数次幂。

如果目标整数的大小是n，则此方法的时间复杂度是O(logn)。

代码已经写好了，快来看看！

1. public static boolean isPowerOf2(int num) {

2.     int temp = 1;

3.     while(temp<=num){

4.         if(temp == num){

5.             return true;

6.         }

7.         temp = temp*2;

8.     }

9.     return false;

10. }

11.

12. public static void main(String[] args) {

13.     System.out.println(isPowerOf2(32));

14.     System.out.println(isPowerOf2(19));

15. }

OK，这样写实现了所要求的功能，你思考一下该怎么来提高其性能呢？

哦，让我想想……

我想到了，可以把之前乘以2的操作改成向左移位，移位的性能比乘法高得多。来看看改变之后的代码吧。

1. public static boolean isPowerOf2V2(int num) {

2.     int temp = 1;

3.     while(temp<=num){

4.         if(temp == num){

5.             return true;

6.         }

7.         temp = temp<<1;

8.     }

9.     return false;

10. }

OK，这样确实有一定优化。但目前算法的时间复杂度仍然是O(logn)，本质上没有变。

如何才能在性能上有质的飞跃呢？

哦，让我想想……

想不出来啦，时间复杂度为O（logn）已经很快了，难道还能有O（1）的方法？

呵呵，没关系，今天面试就到这儿，回家等通知去吧。

5.5.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，怎么才能更高效地判断一个整数是否是2的整数次幂呢？难道存在时间复杂度只有O（1）的方法？

小灰呀，这个题目还真有O（1）的解法。

Really？怎么做到呢？

你先想一想，如果把2的整数次幂转换成二进制数，会有什么样的共同点？

让我想想，十进制的2转换成二进制是10B，4转换成二进制是100B，8转化成二进制是1000B……

我知道了！如果一个整数是2的整数次幂，那么当它转化成二进制时，只有最高位是1，其他位都是0！

没错，是这样的。接下来如果把这些2的整数次幂各自减1，再转化成二进制，会有什么样的特点呢？

都减1？让我试试啊！

我发现了，2的整数次幂一旦减1，它的二进制数字就全部变成了1！

很好，这时候如果用原数值（2的整数次幂）和它减1的结果进行按位与运算，也就是n&(n-1)，会是什么结果呢？

0和1按位与运算的结果是0，所以凡是2的整数次幂和它本身减1的结果进行与运算，结果都必定是0。反之，如果一个整数不是2的整数次幂，结果一定不是0！

那么，解决这个问题的方法已经很明显了，你说说怎样来判断一个整数是否是2的整数次幂。

很简单，对于一个整数n，只需要计算n&(n-1)的结果是不是0。这个方法的时间复杂度只有O（1）。

代码我已经写好了，除方法声明外，只有1行哦！

1. public static boolean isPowerOf2(int num) {

2.     return (num&num-1) == 0;

3. }

非常好，这就是位运算的妙用。关于这道题目我们就说到这里，下一节再会！

5.6　无序数组排序后的最大相邻差

5.6.1　一道奇葩的面试题

下面我来考查你一道算法题，有一个无序整型数组……

题目

有一个无序整型数组，如何求出该数组排序后的任意两个相邻元素的最大差值？要求时间和空间复杂度尽可能低。

可能题目有点绕，让我们来看一个例子。

哦，让我想想……

嗨，这还不简单吗？先使用时间复杂度为O（nlogn）的排序算法给原来的数组排序，然后遍历数组，对每两个相邻元素求差，最大差值不就出来了吗？

解法1：

使用任意一种时间复杂度为O（nlogn）的排序算法（如快速排序）给原数组排序，然后遍历排好序的数组，并对每两个相邻元素求差，最终得到最大差值。

该解法的时间复杂度是O（nlogn），在不改变原数组的情况下，空间复杂度是O(n)。

唉，我出这样的题目，显然不是为了让你来排序的。你再想想，有没有更快的解法？

没有了呀。不排序的话还能怎么做呢？

呵呵，那你回家等通知去吧！

5.6.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，我今天遇见一道怪题，怎样才能计算出无序数组排序后的最大相邻差值？

嗯……这道题确实很有意思。虽然对数组排序以后肯定能得到正确的结果，但我们没有必要真的去进行排序。

不排序的话，该怎么办呢？

小灰，你记不记得，有哪些排序算法的时间复杂度是线性的？

好像有计数排序、桶排序，还有个什么基数排序……可你刚才不是说不用排序吗？

别着急，我们仅仅是借助一下这些排序的思想而已。小灰你想一下，这道题能不能像计数排序一样，利用数组下标来解决？

像计数排序一样？让我想想啊……

有了！我可以使用计数排序的思想，先找出原数组最大值和最小值的差……

解法2：

1. 利用计数排序的思想，先求出原数组的最大值max与最小值min的区间长度k（k=max-min+1），以及偏移量d=min。

2. 创建一个长度为k的新数组Array。

3. 遍历原数组，每遍历一个元素，就把新数组Array对应下标的值+1。例如原数组元素的值为n，则将Array[n-min]的值加1。遍历结束后，Array的一部分元素值变成了1或更高的数值，一部分元素值仍然是0。

4. 遍历新数组Array，统计出Array中最大连续出现0值的次数+1，即为相邻元素最大差值。

例如给定一个无序数组 { 2, 6, 3, 4, 5, 10, 9 }，处理过程如下图。

第1步，确定k（数组长度）和d（偏移量）。

第2步，创建数组。

第3步，遍历原数组，对号入座。

第4步，判断0值最多连续出现的次数，计算出最大相邻差。

很好，我们已经进步了很多。这个思路在数组元素差值不很悬殊的时候，确实效率很高。

可是设想一下，如果原数组只有3个元素：1、2、1 000 000，那就要创建长度是1 000 000的数组！想一想还能如何优化？

让我想想啊……

对了！桶排序的思想正好解决了这个问题！

解法3：

1. 利用桶排序的思想，根据原数组的长度n，创建出n个桶，每一个桶代表一个区间范围。其中第1个桶从原数组的最小值min开始，区间跨度是（max-min）/（n-1）。

2. 遍历原数组，把原数组每一个元素插入到对应的桶中，记录每一个桶的最大和最小值。

3. 遍历所有的桶，统计出每一个桶的最大值，和这个桶右侧非空桶的最小值的差，数值最大的差即为原数组排序后的相邻最大差值。

例如给出一个无序数组 { 2, 6, 3, 4, 5, 10, 9 }，处理过程如下图。

第1步，根据原数组，创建桶，确定每个桶的区间范围。

第2步，遍历原数组，确定每个桶内的最大和最小值。

第3步，遍历所有的桶，找出最大相邻差。

这个方法不需要像标准桶排序那样给每一个桶内部进行排序，只需要记录桶内的最大和最小值即可，所以时间复杂度稳定在O(n)。

很好，让我们来写一下代码吧。

好的，我试试。

1. public static int getMaxSortedDistance(int[] array){

2.

3.     //1.得到数列的最大值和最小值

4.     int max = array[0];

5.     int min = array[0];

6.     for(int i=1; i<array.length; i++) {

7.         if(array[i] > max) {

8.             max = array[i];

9.         }

10.         if(array[i] < min) {

11.             min = array[i];

12.         }

13.     }

14.     int d = max - min;

15.     //如果max 和min 相等，说明数组所有元素都相等，返回0

16.     if(d == 0){

17.         return 0;

18.     }

19.

20.     //2.初始化桶

21.     int bucketNum = array.length;

22.     Bucket[] buckets = new Bucket[bucketNum];

23.     for(int i = 0; i < bucketNum; i++){

24.         buckets[i] = new Bucket();

25.     }

26.

27.     //3.遍历原始数组，确定每个桶的最大最小值

28.     for(int i = 0; i < array.length; i++){

29.         //确定数组元素所归属的桶下标

30.         int index = ((array[i] - min)  * (bucketNum-1) / d);

31.         if(buckets[index].min==null || buckets[index].

min>array[i]){

32.             buckets[index].min = array[i];

33.         }

34.         if(buckets[index].max==null || buckets[index].

max<array[i]){

35.             buckets[index].max = array[i];

36.         }

37.     }

38.

39.     //4.遍历桶，找到最大差值

40.     int leftMax = buckets[0].max;

41.     int maxDistance = 0;

42.     for (int i=1; i<buckets.length; i++) {

43.         if (buckets[i].min == null) {

44.             continue;

45.         }

46.         if (buckets[i].min - leftMax > maxDistance) {

47.             maxDistance = buckets[i].min - leftMax;

48.         }

49.         leftMax = buckets[i].max;

50.     }

51.

52.     return maxDistance;

53. }

54.

55. /**

56.   * 桶

57.   */

58. private static class Bucket {

59.     Integer min;

60.     Integer max;

61. }

62.

63. public static void main(String[] args) {

64.     int[] array = new int[] {2,6,3,4,5,10,9};

65.     System.out.println(getMaxSortedDistance(array));

66. }

代码的前几步都比较直观，唯独第4步稍微有些不好理解：使用临时变量leftMax，在每一轮迭代时存储当前左侧桶的最大值。而两个桶之间的差值，则是buckets[i].minleftMax。

没错，这就是这道题目的最优解决方法。关于无序数组排序后最大差值的问题就介绍到这里，咱们下一节再见！

5.7　如何用栈实现队列

5.7.1　又是一道关于栈的面试题

那么下面我来考查你一道算法题，怎样用栈来实现一个队列?

题目

用栈来模拟一个队列，要求实现队列的两个基本操作：入队、出队。

哦……栈是先入后出，队列是先入先出，用栈没办法实现队列吧？

提示你一下，用一个栈肯定是没办法实现队列的，但如果我们有两个栈呢？

让我想想啊……

没想出来，就算给我8个栈，我也不知道怎么实现队列。

呵呵，没事，回家等通知去吧！

5.7.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你能不能给我讲讲，怎样可以用两个栈来实现一个队列呀？

要解决这个问题，我们先来回顾一下栈和队列的不同特点。

栈的特点是先入后出，出入元素都是在同一端（栈顶）。

入栈：

出栈：

队列的特点是先入先出，出入元素是在不同的两端（队头和队尾）。

入队：

出队：

既然我们拥有两个栈，那么可以让其中一个栈作为队列的入口，负责插入新元素；另一个栈作为队列的出口，负责移除老元素。

可是，两个栈是各自独立的，怎么能把它们有效地关联起来呢？

别着急，让我来具体演示一下。

队列的主要操作无非有两个：入队和出队。

在模拟入队操作时，每一个新元素都被压入到栈A当中。

让元素1入队。

让元素2入队。

让元素3入队。

这时，我们希望最先入队的元素1出队，需要怎么做呢？

让栈A中的所有元素按顺序出栈，再按照出栈顺序压入栈B。这样一来，元素从栈A弹出并压入栈B的顺序是3、2、1，和当初进入栈A的顺序1、2、3是相反的。

此时让元素1 出队，也就是让元素1从栈B中弹出。

让元素2出队。

如果这个时候又想做入队操作了呢？

很简单，当有新元素入队时，重新把新元素压入栈A。

让元素4入队。

此时出队操作仍然从栈B中弹出元素。

让元素3出队。

现在栈B已经空了，如果再想出队该怎么办呢？

也不难，只要栈A中还有元素，就像刚才一样，把栈A中的元素弹出并压入栈B即可。

让元素4出队。

怎么样，这回你绕明白了吗？

哦，基本上明白了，那么代码怎么来实现呢？

代码很好写，让我们来看一看。

1. private Stack<Integer> stackA = new Stack<Integer>();

2. private Stack<Integer> stackB = new Stack<Integer>();

3. /**

4.  * 入队操作

5.  * @param element  入队的元素

6.  */

7. public void enQueue(int element) {

8.     stackA.push(element);

9. }

10. /**

11.   * 出队操作

12.   */

13. public Integer deQueue() {

14.     if(stackB.isEmpty()){

15.         if(stackA.isEmpty()){

16.             return null;

17.         }

18.         transfer();

19.     }

20.     return stackB.pop();

21. }

22.

23. /**

24.   * 栈A元素转移到栈B

25.   */

26. private void transfer(){

27.     while (!stackA.isEmpty()){

28.         stackB.push(stackA.pop());

29.     }

30. }

31. public static void main(String[] args) throws Exception {

32.     StackQueue stackQueue = new StackQueue();

33.     stackQueue.enQueue(1);

34.     stackQueue.enQueue(2);

35.     stackQueue.enQueue(3);

36.     System.out.println(stackQueue.deQueue());

37.     System.out.println(stackQueue.deQueue());

38.     stackQueue.enQueue(4);

39.     System.out.println(stackQueue.deQueue());

40.     System.out.println(stackQueue.deQueue());

41. }

小灰，你说说，这个队列的入队和出队操作，时间复杂度分别是多少？

入队操作的时间复杂度显然是O(1)。至于出队操作，如果涉及栈A和栈B的元素迁移，那么一次出队的时间复杂度是O(n)；如果不用迁移，时间复杂度是O(1)。咦，在这种情况下，出队的时间复杂度究竟应该是多少呢？

这里涉及一个新的概念，叫作均摊时间复杂度。需要元素迁移的出队操作只有少数情况，并且不可能连续出现，其后的大多数出队操作都不需要元素迁移。

所以把时间均摊到每一次出队操作上面，其时间复杂度是O(1)。这个概念并不常用，稍做了解即可。

好了，用栈实现队列的题目，我们就介绍到这里，咱们下一节再见！

5.8　寻找全排列的下一个数

5.8.1　一道关于数字的题目

下面我来考查你一道算法题，假设给出一个正整数，请找出这个正整数所有数字全排列的下一个数。

题目

给出一个正整数，找出这个正整数所有数字全排列的下一个数。

说通俗点就是在一个整数所包含数字的全部组合中，找到一个大于且仅大于原数的新整数。让我们举几个例子。

如果输入12345，则返回12354。

如果输入12354，则返回12435。

如果输入12435，则返回12453。

让我想一想啊……

我发现了，这里面有个规律！让我来解释一下。

小灰发现的“规律”如下。

输入12345，返回12354，那么

12354 - 12345 = 9，

刚好相差9的一次方。

输入12354，返回12435，那么

12435 - 12354 = 81，

刚好相差9的二次方。

所以，每次计算最近的换位数，只需要加上9的n次方即可。

怎么样，我是不是很机智？

这算哪门子规律？ 12453-12435= 18，24135-23541=594，也并不都是9的整数次幂啊！

啊，尴尬了……

呵呵，今天就到这里，回家等通知去吧！

5.8.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你能不能给我讲讲，怎么样寻找一个整数所有数字全排列的下一个数？

好啊，在给出具体解法之前，小灰你先思考一个问题：由固定几个数字组成的整数，怎样排列最大？怎样排列最小？

让我想一想啊……

知道了，如果是固定的几个数字，应该是在逆序排列的情况下最大，在顺序排列的情况下最小。

举一个例子。

给出1、2、3、4、5这几个数字。

最大的组合：54321。

最小的组合：12345。

没错，数字的顺序和逆序，是全排列中的两种极端情况。那么普遍情况下，一个数和它最近的全排列数存在什么关联呢？

例如给出整数12354，它包含的数字是1、2、3、4、5，如何找到这些数字全排列之后仅大于原数的新整数呢？

为了和原数接近，我们需要尽量保持高位不变，低位在最小的范围内变换顺序。

至于变换顺序的范围大小，则取决于当前整数的逆序区域。

如图所示，12354的逆序区域是最后两位，仅看这两位已经是当前的最大组合。若想最接近原数，又比原数更大，必须从倒数第3位开始改变。

怎样改变呢？12345的倒数第3位是3，我们需要从后面的逆序区域中找到大于3的最小的数字，让其和3的位置进行互换。

互换后的临时结果是12453，倒数第3位已经确定，这个时候最后两位仍然是逆序状态。我们需要把最后两位转变为顺序状态，以此保证在倒数第3位数值为4的情况下，后两位尽可能小。

这样一来，就得到了想要的结果12435。

有些明白了，不过还真是复杂呀！

看起来复杂，其实只要3个步骤。

获得全排列下一个数的3个步骤。

1. 从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界。

2. 让逆序区域的前一位和逆序区域中大于它的最小的数字交换位置。

3. 把原来的逆序区域转为顺序状态 。

最后让我们用代码来实现一下。这里为了方便数字位置的交换，入参和返回值的类型都采用了整型数组。

1. public static int[] findNearestNumber(int[] numbers){

2. //1. 从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界

3.     int index = findTransferPoint(numbers);

4. // 如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数

5. // 字组成的整数，返回null

6.     if(index == 0){

7.         return null;

8.     }

9.     //2.把逆序区域的前一位和逆序区域中刚刚大于它的数字交换位置

10.     //复制并入参，避免直接修改入参

11.     int[] numbersCopy = Arrays.copyOf(numbers, numbers.length);

12.     exchangeHead(numbersCopy, index);

13.     //3.把原来的逆序区域转为顺序

14.     reverse(numbersCopy, index);

15.     return numbersCopy;

16. }

17.

18. private static int findTransferPoint(int[] numbers){

19.     for(int i=numbers.length-1; i>0; i--){

20.         if(numbers[i] > numbers[i-1]){

21.             return i;

22.         }

23.     }

24.     return 0;

25. }

26.

27. private static int[] exchangeHead(int[] numbers, int index){

28.     int head = numbers[index-1];

29.     for(int i=numbers.length-1; i>0; i--){

30.         if(head < numbers[i]){

31.             numbers[index-1] =  numbers[i];

32.             numbers[i] = head;

33.             break;

34.         }

35.     }

36.     return numbers;

37. }

38.

39. private static int[] reverse(int[] num, int index){

40.     for(int i=index,j=num.length-1; i<j; i++,j--){

41.         int temp = num[i];

42.         num[i] = num[j];

43.         num[j] = temp;

44.     }

45.     return num;

46. }

47.

48. public static void main(String[] args) {

49.     int[] numbers = {1,2,3,4,5};

50.     //打印12345 之后的10个全排列整数

51.     for(int i=0; i<10;i++){

52.         numbers = findNearestNumber(numbers);

53.         outputNumbers(numbers);

54.     }

55. }

56.

57. // 输出数组

58. private static void outputNumbers(int[] numbers){

59.     for(int i : numbers){

60.         System.out.print(i);

61.     }

62.     System.out.println();

63. }

这种解法拥有一个“高大上”的名字：字典序算法。

小灰，你说说这个解法的时间复杂度是多少？

该算法3个步骤每一步的时间复杂度都是O(n)，所以整体时间复杂度也是O(n)！

完全正确。关于这道算法题的解答就介绍到这里，咱们下一节再会！

5.9　删去k个数字后的最小值

5.9.1　又是一道关于数字的题目

好吧，下面考你一道算法题：给出一个整数，从该整数中去掉k个数字，要求剩下的数字形成的新整数尽可能小。

题目

给出一个整数，从该整数中去掉k个数字，要求剩下的数字形成的新整数尽可能小。应该如何选取被去掉的数字？

其中整数的长度大于或等于k，给出的整数的大小可以超过long类型的数字范围。

什么意思呢？让我们举几个例子。

假设给出一个整数1 593 212，删去3个数字，新整数最小的情况是1212。

假设给出一个整数30 200，删去1个数字，新整数最小的情况是200。

假设给出一个整数10，删去2个数字（注意，这里要求删去的不是1个数字，而是2个），新整数的最小情况是0。

这道题听起来还挺有意思，让我想想……

你可以先说说你的第一感觉，为了让新整数尽可能小，什么样的数字应该优先删除？

我知道了！肯定要优先删除最大的数字！如先删除9，再删除8，再删除7……

那可不一定，如整数3549，删除1个数字的话，是应该删除数字9吗？

哎呀，还真是！让我再想想……

呵呵，不用想了，回家等通知去吧！

5.9.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你能不能给我讲讲，怎样寻找删去k个数字后的最小值呀？

这个题目要求我们删去k个数字，但我们不妨把问题简化一下：如果只删除1个数字，如何让新整数的值最小？

我的第一感觉是优先删除最大的数字，可是这个策略似乎不对……

数字的大小固然重要，数字的位置则更加重要。你想想，一个整数的最高位哪怕只减少1，对数值的影响也是非常大的。

我们来举一个例子。

给出一个整数541 270 936，要求删去1个数字，让剩下的整数尽可能小。

此时，无论删除哪一个数字，最后的结果都是从9位整数变成8位整数。既然同样是8位整数，显然应该优先把高位的数字降低，这样对新整数的值影响最大。

如何把高位的数字降低呢？很简单，把原整数的所有数字从左到右进行比较，如果发现某一位数字大于它右面的数字，那么在删除该数字后，必然会使该数位的值降低，因为右面比它小的数字顶替了它的位置。

在上面这个例子中，数字5右侧的数字4小于5，所以删除数字5，最高位数字降低成了4。

对于整数541 270 936，删除一个数字所能得到的最小值是41 270 936。那么对于41 270 936，删除一个数字的最小值，你说说是多少。

我知道了，是删除数字4！因为从左向右遍历，数字4是第1个比右侧数字大的数（4>1）。

很好，那么接下来呢？从刚才的结果1 270 936中再删除一个数字，能得到的最小值是多少？

这一次的情况略微复杂，因为1<2、2<7、7>0，所以被删除的数字应该是7！

不错，这里每一步都要求得到删除一个数字后的最小值，经历3次，相当于求出了删除k（k=3）个数字后的最小值。

像这样依次求得局部最优解，最终得到全局最优解的思想，叫作贪心算法。

小灰，按照这个思路，你尝试用代码来实现一下吧。

好的，我来写一写试试吧。

1. /**

2.  * 删除整数的k个数字，获得删除后的最小值

3.  * @param num   原整数

4.  * @param k   删除数量

5.  */

6. public static String removeKDigits(String num, int k) {

7.     String numNew = num;

8.     for(int i=0; i<k; i++){

9.         boolean hasCut = false;

10.         //从左向右遍历，找到比自己右侧数字大的数字并删除

11.         for(int j=0; j<numNew.length()-1;j++){

12.             if(numNew.charAt(j) > numNew.charAt(j+1)){

13.                 numNew = numNew.substring(0, j) +

numNew.substring(j+1,numNew.length());

14.                 hasCut = true;

15.                 break;

16.             }

17.         }

18.         //如果没有找到要删除的数字，则删除最后一个数字

19.         if(!hasCut){

20.             numNew = numNew.substring(0, numNew.length()-1);

21.         }

22.         //清除整数左侧的数字0

23.         numNew = removeZero(numNew);

24.     }

25.     //如果整数的所有数字都被删除了，直接返回0

26.     if(numNew.length() == 0){

27.         return "0";

28.     }

29.     return numNew;

30. }

31.

32. private static String removeZero(String num){

33.     for(int i=0; i<num.length()-1; i++){

34.         if(num.charAt(0) != '0'){

35.             break;

36.         }

37.         num = num.substring(1, num.length()) ;

38.     }

39.     return num;

40. }

41.

42. public static void main(String[] args) {

43.     System.out.println(removeKDigits("1593212",3));

44.     System.out.println(removeKDigits("30200",1));

45.     System.out.println(removeKDigits("10",2));

46.     System.out.println(removeKDigits("541270936",3));

47. }

小灰的代码使用了两层循环，外层循环次数就是要删除的数字个数k，内层循环从左到右遍历所有数字。当遍历到需要删除的数字时，利用字符串的自身方法subString()把对应的数字删除，并重新拼接字符串。

显然，这段代码的时间复杂度是O（kn）。

OK，这段代码在功能实现上是没有问题的，但是性能却不怎么好。主要问题在于以下两个方面。

1. 每一次内层循环都需要从头开始遍历所有数字。

例如给出的整数是11 111 111 111 114 132，在第1轮循环中，需要遍历大部分数字，一直遍历到数字4，发现4>1，从而删除4。

以目前的代码逻辑，下一轮循环时，还要从头开始遍历，再次重复遍历大部分数字，一直遍历到数字3，发现3>2，从而删除3。

事实上，我们应该停留在上一次删除的位置继续进行比较，而不是再次从头开始遍历。

2．subString方法本身性能不高。

subString方法的底层实现，涉及新字符串的创建，以及逐个字符的复制。这个方法自身的时间复杂度是O(n)。

因此，我们应该避免在每删除一个数字后就调用subString方法。

哎呀，那应该怎么来优化呢？

以k作为外循环，遍历数字作为内循环，需要额外考虑的东西非常多。

所以我们换一个思路，以遍历数字作为外循环，以k作为内循环，这样可以写出非常简洁的代码，让我们来看一看。

1. /**

2.  * 删除整数的k个数字，获得删除后的最小值

3.  * @param num   原整数

4.  * @param k   删除数量

5.  */

6. public static String removeKDigits(String num, int k) {

7.     //新整数的最终长度 =  原整数长度-k

8.     int newLength = num.length() - k;

9.     //创建一个栈，用于接收所有的数字

10.     char[] stack = new char[num.length()];

11.     int top = 0;

12.     for (int i = 0; i < num.length(); ++i) {

13.         //遍历当前数字

14.         char c = num.charAt(i);

15.         //当栈顶数字大于遍历到的当前数字时，栈顶数字出栈（相当于删除数字）

16.         while (top > 0 && stack[top-1] > c && k > 0) {

17.             top -= 1;

18.             k -= 1;

19.         }

20.         //遍历到的当前数字入栈

21.         stack[top++] = c;

22.     }

23.     // 找到栈中第1个非零数字的位置，以此构建新的整数字符串

24.     int offset = 0;

25.     while (offset < newLength && stack[offset] == '0') {

26.         offset++;

27.     }

28.     return offset == newLength? "0": new String(stack,

offset, newLength - offset);

29. }

30.

31.

32. public static void main(String[] args) {

33.     System.out.println(removeKDigits("1593212",3));

34.     System.out.println(removeKDigits("30200",1));

35.     System.out.println(removeKDigits("10",2));

36.     System.out.println(removeKDigits("541270936",3));

37. }

上述代码非常巧妙地运用了栈的特性，在遍历原整数的数字时，让所有数字一个一个入栈，当某个数字需要删除时，让该数字出栈。最后，程序把栈中的元素转化为字符串类型的结果。

下面仍然以整数541 270 936，k=3为例。

当遍历到数字5时，数字5入栈。

当遍历到数字4时，发现栈顶5>4，栈顶5出栈，数字4入栈。

当遍历到数字1时，发现栈顶4>1，栈顶4出栈，数字1入栈。

然后继续遍历数字2、数字7，并依次入栈。

最后，遍历数字0，发现栈顶7>0，栈顶7出栈，数字0入栈。

此时k的次数已经用完，无须再比较，让剩下的数字一起入栈即可。

此时栈中的元素就是最终的结果。

上面的方法只对所有数字遍历了一次，遍历的时间复杂度是O(n)，把栈转化为字符串的时间复杂度也是O(n)，所以最终的时间复杂度是O(n)。

同时，程序中利用栈来回溯遍历过的数字及删除数字，所以程序的空间复杂度是O(n)。

哇，这段代码好巧妙啊！

这段代码其实仍然有优化空间，各位读者可以思考一下。好了，关于这道题目我们就介绍到这里，感谢大家！

5.10　如何实现大整数相加

5.10.1　加法，你会不会

好吧，下面考你一道算法题，给你两个很大很大的整数，如何求出它们的和？

题目

给出两个很大的整数，要求实现程序求出两个整数之和。

这还不简单？直接用long类型存储，在程序里相加不就行了？

如果这两个整数大得连long类型都装不下呢，如两个100位的整数？

啊，那怎么可能算得出来呢？是不是题目出错了呀？

呵呵，题目没出错，回家等通知去吧！

5.10.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你能不能给我讲讲，怎么实现大整数的相加呀？

好啊，在讲解大整数相加之前，我们先来回顾一下小学数学课。小灰，你在上小学时，如何计算两个较大数目的加、减、乘、除？

让我想想啊……读小学的时候，老师好像教我们列竖式进行计算，就像下面这样。

那么，我们为什么需要列出竖式来运算呢？

因为对于这么大的整数，我们无法一步到位直接算出结果，所以不得不把计算过程拆解成一个一个子步骤。

说得没错。其实不仅仅是人脑，对于计算机来说同样如此。

程序不可能通过一条指令计算出两个大整数之和，但我们却可以把大运算拆解成若干小运算，像小学生列竖式一样进行按位计算。

可是，如果大整数超出了long类型的范围，我们如何来存储这样的整数呢？

这很好解决，用数组存储即可。数组的每一个元素，对应着大整数的每一个数位。

在程序中列出的“竖式”究竟是什么样子呢？我们以426 709 752 31 8 +95 481 253 129 为例，来看看大整数相加的详细步骤。

第1步，创建两个整型数组，数组长度是较大整数的位数+1。把每一个整数倒序存储到数组中，整数的个位存于数组下标为0的位置，最高位存于数组的尾部。之所以倒序存储，是因为这样更符合从左到右访问数组的习惯。

第2步，创建结果数组，结果数组的长度同样是较大整数的位数+1，+1的目的很明显，是给最高位进位预留的。

第3步，遍历两个数组，从左到右按照对应下标把元素两两相加，就像小学生计算竖式一样。

在本示例中，最先相加的是数组A的第1个元素8和数组B的第1个元素9，结果是7，进位1。把7填充到result数组的对应下标位置，进位的1填充到下一个位置。

第2组相加的是数组A的第2个元素1和数组B的第2个元素2，结果是3，再加上刚才的进位1，把4填充到result数组的对应下标位置。

第3组相加的是数组A的第3个元素3和数组B的第3个元素1，结果是4，把4填充到result数组的对应下标位置。

第4组相加的是数组A的第4个元素2和数组B的第4个元素3，结果是5，把5填充到result数组的对应下标位置。

以此类推……一直把数组的所有元素都相加完毕。

第4步，把result数组的全部元素再次逆序，去掉首位的0，就是最终结果。

需要说明的是，为两个大整数建立临时数组，是一种直观的解决方案。若想节省内存空间，也可以不创建这两个临时数组。

明白了，真是个好方法！那么，怎么用代码来实现呢？

代码很简单，我们一起来看看。

1. /**

2.  * 大整数求和

3.  * @param bigNumberA   大整数A

4.  * @param bigNumberB   大整数B

5.  */

6. public static String bigNumberSum(String bigNumberA,

String bigNumberB) {

7.     //1.把两个大整数用数组逆序存储，数组长度等于较大整数位数+1

8.     int maxLength = bigNumberA.length() > bigNumberB.length()

? bigNumberA.length() : bigNumberB.length();

9.     int[] arrayA = new int[maxLength+1];

10.     for(int i=0; i< bigNumberA.length(); i++){

11.         arrayA[i] = bigNumberA.charAt(bigNumberA.length()-1-i) -  ‘0’;

12.     }

13.     int[] arrayB = new int[maxLength+1];

14.     for(int i=0; i< bigNumberB.length(); i++){

15.         arrayB[i] = bigNumberB.charAt(bigNumberB.length()-1-i) -  ‘0’;

16.     }

17.     //2.构建result数组，数组长度等于较大整数位数+1

18.     int[] result = new int[maxLength+1];

19.     //3.遍历数组，按位相加

20.     for(int i=0; i<result.length; i++){

21.         int temp = result[i];

22.         temp += arrayA[i];

23.         temp += arrayB[i];

24.         //判断是否进位

25.         if(temp >= 10){

26.             temp = temp-10;

27.             result[i+1] = 1;

28.         }

29.         result[i] = temp;

30.     }

31.     //4.把result数组再次逆序并转成String

32.     StringBuilder sb = new StringBuilder();

33.     //是否找到大整数的最高有效位

34.     boolean findFirst = false;

35.     for (int i = result.length - 1; i >= 0; i--) {

36.         if(!findFirst){

37.             if(result[i] == 0){

38.                 continue;

39.             }

40.             findFirst = true;

41.         }

42.         sb.append(result[i]);

43.     }

44.     return sb.toString();

45. }

46.

47. public static void main(String[] args) {

48.     System.out.println(bigNumberSum("426709752318", "95481253129"));

49. }

小灰，你说说这个算法的时间复杂度是多少？

如果给出的大整数的最长位数是n，那么创建数组、按位计算、结果逆序的时间复杂度各自都是O(n)，整体的时间复杂度也是O(n)。

说的没错，不过当前的思路其实还存在一个可优化的地方。

如何优化呢？

我们之前是把大整数按照数位来拆分的，即如果较大整数有50位，那么我们就需要创建一个长度为51的数组，数组中的每个元素存储其中一位数字。

那么我们真的有必要把原整数拆分得这么细吗？显然不需要，只需要拆分到可以被直接计算的程度就够了。

int类型的取值范围是 -2 147 483 648～2 147 483 647，最多可以有10位整数。为了防止溢出，我们可以把大整数的每9位作为数组的一个元素，进行加法运算。（这里也可以使用long类型来拆分，按照int类型拆分仅仅是提供一个思路。）

如此一来，内存占用空间和运算次数，都压缩到了原来的1/9。

在Java中，工具类BigInteger和BigDecimal的底层实现同样是把大整数拆分成数组进行运算的，和这个思路大体类似。

有兴趣的话，可以看看这两个类的源代码。好了，关于大整数加法，就介绍到这里，咱们下一节再见！

5.11　如何求解金矿问题

5.11.1　一个关于财富自由的问题

下面考你一道算法题，这个算法题目和钱有关系。

题目

很久很久以前，有一位国王拥有5座金矿，每座金矿的黄金储量不同，需要参与挖掘的工人人数也不同。例如有的金矿储量是500kg黄金，需要5个工人来挖掘；有的金矿储量是200kg黄金，需要3个工人来挖掘……

如果参与挖矿的工人的总数是10。每座金矿要么全挖，要么不挖，不能派出一半人挖取一半的金矿。要求用程序求出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？

哇，要是我家也有5座金矿，我就财富自由了，也用不着来你这里面试了！

说正经的！关于这道题你有什么思路吗？

题目好复杂啊，让我想想……

我想到了一个办法！我们可以按照金矿的性价比从高到低进行排序，优先选择性价比最高的金矿来挖掘，然后是性价比第2的……

按照小灰的思路，金矿按照性价比从高到低进行排序，排名结果如下。

第1名，350kg黄金/3人的金矿，人均产值约为116.6kg黄金。

第2名，500kg黄金/5人的金矿，人均产值为100kg黄金。

第3名，400kg黄金/5人的金矿，人均产值为80kg黄金。

第4名，300kg黄金/4人的金矿，人均产值为75kg黄金。

第5名，200kg黄金/3人的金矿，人均产值约为66.6kg黄金。

由于工人数量是10人，小灰优先挖掘性价比排名为第1名和第2名的金矿之后，工人还剩下2人，不够再挖掘其他金矿了。

所以，小灰得出的最佳金矿收益是350+500即850kg黄金。

怎么样？我这个方案妥妥的吧？

你的解决思路是使用贪心算法。这种思路在局部情况下是最优解，但是在整体上却未必是最优的。

给你举个例子吧，如果我放弃性价比最高的350kg黄金/3人的金矿，选择500kg黄金/5人和400kg黄金/5人的金矿，加起来收益是900kg黄金，是不是大于你得到的850kg黄金？

啊，还真是呢！

呵呵，没关系，回家等通知去吧！

5.11.2　解题思路

小灰，你刚刚去面试了？结果怎么样？

唉……

大黄，你能不能给我讲讲，怎么来求解金矿问题呀？

好啊，这是一个典型的动态规划题目，和著名的“背包问题”类似。

动态规划？好“高大上”的概念呀！

其实也没有那么高深啦。所谓动态规划，就是把复杂的问题简化成规模较小的子问题，再从简单的子问题自底向上一步一步递推，最终得到复杂问题的最优解。

哦，说了半天还是没听明白……

没关系，让我们具体分析一下这个金矿问题，你就能明白动态规划的核心思想了。

首先，对于问题中的金矿来说，每一个金矿都存在着“挖”和“不挖”两种选择。

让我们假设一下，如果最后一个金矿注定不被挖掘，那么问题会转化成什么样子呢？

显然，问题简化成了10个工人在前4个金矿中做出最优选择。

相应地，假设最后一个金矿一定会被挖掘，那么问题又转化成什么样子呢？

由于最后一个金矿消耗了3个工人，问题简化成了7个工人在前4个金矿中做出最优选择。

这两种简化情况，被称为全局问题的两个最优子结构。

究竟哪一种最优子结构可以通向全局最优解呢？换句话说，最后一个金矿到底该不该挖呢？

那就要看10个工人在前4个金矿的收益，和7个工人在前4个金矿的收益+最后一个金矿的收益谁大谁小了。

同样的道理，对于前4个金矿的选择，我们还可以做进一步简化。

首先针对10个工人4个金矿这个子结构，第4个金矿（300kg黄金/4人）可以选择挖与不挖。根据第4个金矿的选择，问题又简化成了两种更小的子结构。

1. 10个工人在前3个金矿中做出最优选择。

2. 6（10-4=6）个工人在前3个金矿中做出最优选择。

相应地，对于7个工人4个金矿这个子结构，第4个金矿同样可以选择挖与不挖。根据第4个金矿的选择，问题也简化成了两种更小的子结构。

1. 7个工人在前3个金矿中做出最优选择。

2. 3（7-4=3）个工人在前3个金矿中做出最优选择。

……

就这样，问题一分为二，二分为四，一直把问题简化成在0个金矿或0个工人时的最优选择，这个收益结果显然是0，也就是问题的边界。

这就是动态规划的要点：确定全局最优解和最优子结构之间的关系，以及问题的边界。这个关系用数学公式来表达的话，就叫作状态转移方程式。

好像有点明白了……那这个所谓的状态转移方程式是什么样子？

我们把金矿数量设为n，工人数量设为w，金矿的含金量设为数组g[]，金矿所需开采人数设为数组p[]，设F（n，w）为n个金矿、w个工人时的最优收益函数，那么状态转移方程式如下。

F(n,w) = 0 (n=0或w=0)

问题边界，金矿数为0或工人数为0的情况。

F(n,w) = F(n-1,w) (n≥1, w<p[n-1])

当所剩工人不够挖掘当前金矿时，只有一种最优子结构。

F(n,w) = max(F(n-1,w), F(n-1,w-p[n-1])+g[n-1]) (n≥1, w≥p[n-1])

在常规情况下，具有两种最优子结构（挖当前金矿或不挖当前金矿）。

小灰，既然有了状态转移方程式，你能实现代码来求出最优收益吗？

这还不简单？用递归就可以解决！

1. /**

2.  * 获得金矿最优收益

3.  * @param w   工人数量

4.  * @param n   可选金矿数量

5.  * @param p   金矿开采所需的工人数量

6.  * @param g   金矿储量

7.  */

8. public static int getBestGoldMining(int w, int n,

int[] p, int[] g){

9.     if(w==0 || n==0){

10.         return 0;

11.     }

12.     if(w<p[n-1]){

13.         return getBestGoldMining(w, n-1, p, g);

14.     }

15.     return Math.max(getBestGoldMining(w, n-1, p, g),

getBestGoldMining(w-p[n-1], n-1, p, g)+g[n-1]);

16. }

17.

18. public static void main(String[] args) {

19.     int w = 10;

20.     int[] p = {5, 5, 3, 4 ,3};

21.     int[] g = {400, 500, 200, 300 ,350};

22.     System.out.println(" 最优收益：" + getBestGoldMining(w,

g.length, p, g));

23. }

OK，这样确实可以得到正确结果，不过你思考过这段代码的时间复杂度吗？

让我分析一下啊……全局问题经过简化，会拆解成两个子结构；两个子结构再次简化，会拆解成4个更小的子结构……就像下图一样。

我的天哪，这样算下来，如果金矿数量是n，工人数量充足，时间复杂度就是O(2n)！

没错，现在我们的题目中只有5个金矿，问题还不算严重。如果金矿数量有50个，甚至100个，这样的时间复杂度是根本无法接受的。

啊，那该怎么办呢？

首先来分析一下递归之所以低效的根本原因，那就是递归做了许多重复的计算，看看下面的图你就明白了。

在上图中，标为红色的方法调用是重复的。可以看到F（2,7）、F（1,7）、F（1,2），这几个入参相同的方法都被调用了两次。

当金矿数量为5时，重复调用的问题还不太明显，当金矿数量越多，递归层次越深，重复调用也就越来越多，这些无谓的调用必然会降低程序的性能。

那我们怎样避免这些重复调用呢？

这就要说到动态规划的另一个核心要点：自底向上求解。让我们来详细演示一下这种求解过程。

在进行求解之前，先准备一张表格，用于记录选择金矿的中间数据。

表格最左侧代表不同的金矿选择范围，从上到下，每多增加1行，就代表多1个金矿可供选择，也就是F（n，w）函数中的n值。

表格的最上方代表工人数量，从1个工人到10个工人，也就是F（n，w）函数中的w值。

其余空白的格子，都是等待填写的，代表当给出n个金矿、w个工人时的最优收益，也就是F（n，w）的值。

举个例子，下图中绿色的这个格子里，应该填充的是在有5个工人的情况下，在前3个金矿可供选择时，最优的黄金收益。

下面让我们从第1行第1列开始，尝试把空白的格子一一填满，填充的依据就是状态转移方程式。

对于第1行的前4个格子，由于w<p[n-1]，对应的状态转移方程式如下：

F(n,w) = F(n-1,w) (n>1, w<p[n-1])

带入求解：

F(1,1) = F(1-1,1) = F(0,1) = 0

F(1,2) = F(1-1,2) = F(0,2) = 0

F(1,3) = F(1-1,3) = F(0,3) = 0

F(1,4) = F(1-1,4) = F(0,4) = 0

第1行的后6个格子怎么计算呢？此时w≥p[n-1]，对于如下公式：

F(n,w) = max(F(n-1,w), F(n-1,w-p[n-1])+g[n-1]) (n>1, w≥p[n-1]);

带入求解：

F(1,5) = max(F(1-1,5), F(1-1,5-5)+400) = max(F(0,5), F(0,0)+400) = max(0, 400) = 400

F(1,6) = max(F(1-1,6), F(1-1,6-5)+400) = max(F(0,6), F(0,1)+400) = max(0, 400) = 400

……

F(1,10) = max(F(1-1,10), F(1-1,10-5)+400) = max(F(0,10), F(0,5)+400) = max(0, 400) = 400

对于第2行的前4个格子，和第1行同理，由于w<p[n-1]，对应的状态转移方程式如下：

F(n,w) = F(n-1,w) (n>1, w<p[n-1])

带入求解：

F(2,1) = F(2-1,1) = F(1,1) = 0

F(2,2) = F(2-1,2) = F(1,2) = 0

F(2,3) = F(2-1,3) = F(1,3) = 0

F(2,4) = F(2-1,4) = F(1,4) = 0

第2行的后6个格子，和第1行同理，此时w≥p[n-1]，对应的状态转移方程式如下：

F(n,w) = max(F(n-1,w), F(n-1,w-p[n-1])+g[n-1]) (n>1, w≥p[n-1])

带入求解：

F(2,5) = max(F(2-1,5), F(2-1,5-5)+500) = max(F(1,5), F(1,0)+500) = max(400, 500) = 500

F(2,6) = max(F(2-1,6), F(2-1,6-5)+500) = max(F(1,6), F(1,1)+500) = max(400, 500) = 500

……

F(2,10) = max(F(2-1,10), F(2-1,10-5)+500) = max(F(1,10), F(1,5)+500) = max(400, 400+500) = 900

第3行的计算方法如出一辙。

再接再厉，计算出第4行的答案。

最后，计算出第5行的结果。

此时，最后1行最后1个格子所填的900就是最终要求的结果，即5个金矿、10个工人的最优收益是900kg黄金。

好了，这就是动态规划自底向上的求解过程。

哇，这个方式还真有意思！那么，怎么用代码来实现呢？

在程序中，可以用二维数组来代表所填写的表格，让我们看一看代码吧。

1. /**

2.  * 获得金矿最优收益

3.  * @param w   工人数量

4.  * @param p   金矿开采所需的工人数量

5.  * @param g   金矿储量

6.  */

7. public static int getBestGoldMiningV2(int w, int[] p, int[] g){

8.     //创建表格

9.     int[][] resultTable = new int[g.length+1][w+1];

10.     //填充表格

11.     for(int i=1; i<=g.length; i++){

12.         for(int j=1; j<=w; j++){

13.             if(j<p[i-1]){

14.                 resultTable[i][j] = resultTable[i-1][j];

15.             }else{

16.                 resultTable[i][j] = Math.max(resultTable[i-1]

[j],  resultTable[i-1][j-p[i-1]]+ g[i-1]);

17.             }

18.         }

19.     }

20.     //返回最后1个格子的值

21.     return resultTable[g.length][w];

22. }

小灰，你说说上述代码的时间复杂度和空间复杂度分别是怎样的？

程序利用双循环来填充一个二维数组，所以时间复杂度和空间复杂度都是O(nw)，比递归的性能好多啦！

是的，这段代码在时间上已经没有什么可优化的了，但是在空间上还可以做一些优化。

想一想，在表格中除第1行之外，每一行的结果都是由上一行数据推导出来的。我们以4个金矿9个工人为例。

4个金矿、9个工人的最优结果，是由它的两个最优子结构，也就是3个金矿、5个工人和3个金矿、9个工人的结果推导而来的。这两个最优子结构都位于它的上一行。

所以，在程序中并不需要保存整个表格，无论金矿有多少座，我们只保存1行的数据即可。在计算下一行时，要从右向左统计（读者可以想想为什么从右向左），把旧的数据一个一个替换掉。

优化后的代码如下：

1. /**

2.  * 获得金矿最优收益

3.  * @param w   工人数量

4.  * @param p   金矿开采所需的工人数量

5.  * @param g   金矿储量

6.  */

7. public static int getBestGoldMiningV3(int w, int[] p, int[] g){

8.     //创建当前结果

9.     int[] results = new int[w+1];

10.     //填充一维数组

11.     for(int i=1; i<=g.length; i++){

12.         for(int j=w; j>=1; j--){

13.            if(j>=p[i-1]){

14.                 results[j] = Math.max(results[j],

results[j-p[i-1]]+ g[i-1]);

15.             }

16.         }

17.     }

18.     //返回最后1个格子的值

19.     return results[w];

20. }

哇，优化后的代码真的好简洁呀！

是呀，而且空间复杂度降低到了O(n)。好了，关于金矿问题我们就讲解到这里，咱们下一节再会！

5.12　寻找缺失的整数

5.12.1　“五行”缺一个整数

下面考你一道算法题：在一个无序数组里有99个不重复的正整数，范围从1到100……

题目

在一个无序数组里有99个不重复的正整数，范围是1～100，唯独缺少1个1～100中的整数。如何找出这个缺失的整数？

哦，让我想想……

有了！创建一个哈希表，以1到100这100个整数为Key，然后遍历数组。

解法1：

创建一个哈希表，以1到100这100个整数为Key。然后遍历整个数组，每读到一个整数，就定位到哈希表中对应的Key，然后删除这个Key。

由于数组中缺少1个整数，哈希表最终一定会有99个Key被删除，从而剩下1个唯一的Key。这个剩下的Key就是那个缺失的整数。

假设数组长度是n，那么该解法的时间复杂度是O(n)，空间复杂度是O(n)。

OK，这个解法在时间上是最优的，但额外开辟了内存空间。那么，有没有办法降低空间复杂度呢？

哦，让我想想……

有了！首先给原数组排序，然后……

解法2：

先把数组元素从小到大进行排序，然后遍历已经有序的数组，如果发现某两个相邻元素并不连续，说明缺少的就是这两个元素之间的整数。

假设数组长度是n，如果用时间复杂度为O(nlogn)的排序算法进行排序，那么该解法的时间复杂度是O(nlogn)，空间复杂度是O(1)。

OK，这个解法没有开辟额外的空间，但是时间复杂度又太大了。有没有办法对时间复杂度和空间复杂度都进行优化呢？

哦，让我想想……

有了！先算出1～100的累加和，然后再依次减去数组里的所有元素，最后的差值就是所缺少的整数。这么简单的办法我竟然才想到！

解法3：

这是一个很简单也很高效的方法，先算出1+2+3+…+100的和，然后依次减去数组里的元素，最后得到的差值，就是那个缺失的整数。

假设数组长度是n，那么该解法的时间复杂度是O(n)，空间复杂度是O(1)。

OK，对于没有重复元素的数组，这个解法在时间和空间上已经最优了。但如果把问题扩展一下……

5.12.2　问题扩展

题目第1次扩展：

一个无序数组里有若干个正整数，范围是1～100，其中99个整数都出现了偶数次，只有1个整数出现了奇数次，如何找到这个出现奇数次的整数？

哦，让我想想……

按照刚才的方法先求和肯定不行，因为根本不知道每个整数出现的次数……同时又要保证时间和空间复杂度的最优，怎么办呢？

让我提示你一下吧，你知道异或运算吗？

异或运算，我当然知道，在进行位运算时，相同位得0，不同位得1。可是怎么应用到这个题目上面呢？

啊，我想到了！只要把数组里所有元素依次进行异或运算，最后得到的就是那个缺失的整数！

解法：

遍历整个数组，依次做异或运算。由于异或运算在进行位运算时，相同为0，不同为1，因此所有出现偶数次的整数都会相互抵消变成0，只有唯一出现奇数次的整数会被留下。

让我们举一个例子：给出一个无序数组{3,1,3,2,4,1,4}。

异或运算像加法运算一样，满足交换律和结合律，所以这个数组元素的异或运算的结果如下图所示。

假设数组长度是n，那么该解法的时间复杂度是O(n)，空间复杂度是O(1)。

这个方案已经非常好了。我们把问题最后扩展一下，如果数组里有2个整数出现了奇数次，其他整数出现偶数次，该如何找出这2个整数呢？

题目第2次扩展：

假设一个无序数组里有若干个正整数，范围是1～100，其中有98个整数出现了偶数次，只有2个整数出现了奇数次，如何找到这2个出现奇数次的整数？

啊，这次要找2个整数，刚才的方法已经不够用了。因为把数组所有元素进行异或运算，最终只会得到2个整数的异或运算结果。

我来提示你一下吧，你知道分治法吗？

说起分治法，我似乎想到了什么……如果把数组分成两部分，保证每一部分都包含1个出现奇数次的整数，这样就与上一题的情况一样了。

终于想到了！首先把数组元素依次进行异或运算，得到的结果是2个出现了奇数次的整数的异或运算结果，在这个结果中至少有1个二进制位是1。

解法：

把2个出现了奇数次的整数命名为A和B。遍历整个数组，然后依次做异或运算，进行异或运算的最终结果，等同于A和B进行异或运算的结果。在这个结果中，至少会有一个二进制位是1（如果都是0，说明A和B相等，和题目不相符）。

举个例子，给出一个无序数组{4,1,2,2,5,1,4,3}，所有元素进行异或运算的结果是00000110B。

选定该结果中值为1的某一位数字，如00000110B的倒数第2位是1，这说明A和B对应的二进制的倒数第2位是不同的。其中必定有一个整数的倒数第2位是0，另一个整数的倒数第2位是1。

根据这个结论，可以把原数组按照二进制的倒数第2位的不同，分成两部分，一部分的倒数第2位是0，另一部分的倒数第2位是1。由于A和B的倒数第2位不同，所以A被分配到其中一部分，B被分配到另一部分，绝不会出现A和B在同一部分，另一部分既没有A，也没有B的情况。

这样一来就简单多了，我们的问题又回归到了上一题的情况，按照原先的异或算法，从每一部分中找出唯一的奇数次整数即可。

假设数组长度是n，那么该解法的时间复杂度是O(n)。把数组分成两部分，并不需要借助额外的存储空间，完全可以在按二进制位分组的同时来做异或运算，所以空间复杂度仍然是O(1)。

没错，就是这个思路。请你按照这个思路来写一下代码。

好的，我来试试！

1. public static int[] findLostNum(int[] array) {

2.     //用于存储2个出现奇数次的整数

3.     int result[] = new int[2];

4.     //第1次进行整体异或运算

5.     int xorResult = 0;

6.     for(int i=0;i<array.length;i++){

7.         xorResult^=array[i];

8.     }

9.     //如果进行异或运算的结果为0，则说明输入的数组不符合题目要求

10.     if(xorResult == 0){

11.         return null;

12.     }

13.     //确定2个整数的不同位，以此来做分组

14.     int separator = 1;

15.     while (0==(xorResult&separator)){

16.         separator<<=1;

17.     }

18.     //第2次分组进行异或运算

19.     for(int i=0;i<array.length;i++){

20.         if(0==(array[i]&separator)){

21.             result[0]^=array[i];

22.         }else {

23.             result[1]^=array[i];

24.         }

25.     }

26.

27.     return result;

28. }

29.

30. public static void main(String[] args) {

31.     int[] array = {4,1,2,2,5,1,4,3};

32.     int[] result = findLostNum(array);

33.     System.out.println(result[0] + "," + result[1]);

34. }

很好，我们的技术面试就到这里。请你稍等一下，我去叫HR来和你谈谈。10min后……

就这样，小灰拿到了职业生涯中的第一个offer，但这并不意味着结束，小灰的程序员之路才刚刚开始。

第6章　算法的实际应用

6.1　小灰上班的第1天

几天之后，小灰高高兴兴地去公司报到了……

就这样，小灰正式进入了职场。接下来等待他的会是什么样的挑战呢？

6.2　Bitmap的巧用

6.2.1　一个关于用户标签的需求

为了帮助公司精准定位用户群体，咱们需要开发一个用户画像系统，实现用户信息的标签化。

用户标签包括用户的社会属性、生活习惯、消费行为等信息，例如下面这个样子。

小灰的用户标签

通过用户标签，我们可以对多样的用户群体进行统计。例如统计用户的男女比例、统计喜欢旅游的用户数量等。

放心吧，这个需求交给我一定会妥妥的！

为了满足用户标签的统计需求，小灰利用关系型数据库设计了如下的表结构，每一个维度的标签对应着数据库表中的一列。

要想统计所有“90后”的程序员，该怎么做呢？

用一条求交集的SQL语句即可。

Select count（distinct Name） as 用户数 from table where age = '90 后' and Occupation = ' 程序员' ;

要想统计所有使用苹果手机或“00后”的用户总和，该怎么做呢？

用一条求并集的SQL语句即可。

Select count （distinct Name） as 用户数 from table where Phone =  '苹果' or age = '00 后' ;

看起来很简单嘛，嘿嘿……

两个月之后……

事情没那么简单，现在标签越来越多，例如用户去过的城市、消费水平、爱吃的东西、喜欢的音乐……都快有上千个标签了，这要给数据库表增加多少列啊！

筛选的标签条件过多的时候，拼出来的SQL语句像面条一样长……

不仅如此，当对多个用户群体求并集时，需要用distinct来去掉重复数据，性能实在太差了……

6.2.2　用算法解决问题

小灰，你怎么愁眉苦脸的呀？

唉，还不是被一个需求折腾的！

事情是这样子的……（小灰把工作中的难题告诉了大黄）

哈哈，小灰，你听说过Bitmap算法吗？在中文里又叫作位图算法。

我又不是搞计算机图形学的，研究位图算法干什么？

这里所说的位图并不是像素图片的位图，而是内存中连续的二进制位（bit）所组成的数据结构，该算法主要用于对大量整数做去重和查询操作。

举个例子，假设给出一块长度为10bit的内存空间，也就是Bitmap，想要依次插入整数4、2、1、3，需要怎么做呢？

很简单，具体做法如下。

第1步，给出一块长度为10的Bitmap，其中的每一个bit位分别对应着从0到9的整型数。此时，Bitmap的所有位都是0（用紫色表示）。

第2步，把整型数4存入Bitmap，对应存储的位置就是下标为4的位置，将此bit设置为1（用黄色表示）。

第3步，把整型数2存入Bitmap，对应存储的位置就是下标为2的位置，将此bit设置为1。

第4步，把整型数1存入Bitmap，对应存储的位置就是下标为1的位置，将此bit设置为1。

第5步，把整型数3存入Bitmap，对应存储的位置就是下标为3的位置，将此bit设置为1。

如果问此时Bitmap里存储了哪些元素。显然是4、3、2、1，一目了然。

Bitmap不仅方便查询，还可以去掉重复的整数。

看起来有点意思，可是Bitmap算法跟我的项目有什么关系呢？

你仔细想一想，你所做的用户标签能不能用Bitmap的形式进行存储呢？

我的每一条用户数据都对应着成百上千个标签，怎么也无法转换成Bitmap的形式啊？

别急，我们不妨把思路逆转一下，为什么一定要让一个用户对应多个标签，而不是一个标签对应多个用户呢？

一个标签对应多个用户？让我想想啊……

我明白了！信息不一定非要以用户为中心，也能够以标签为中心来存储，让每一个标签存储包含此标签的所有用户ID，就像倒排索引一样！

第1步，建立用户名和用户ID的映射。

第2步，让每一个标签存储包含此标签的所有用户ID，每一个标签都是一个独立的Bitmap。

这样一来，每一个用户特征都变得一目了然。

例如程序员和“00后”这两个群体，各自的Bitmap分别如下。

Bingo！这就是Bitmap算法的运用。

我还有一点不太明白，使用哈希表也同样能实现用户的去重和统计操作，为什么一定要使用Bitmap呢？

傻孩子，如果使用哈希表的话，每一个用户ID都要存成int或long类型，少则占用4字节（32bit），多则占用8字节（64bit）。而一个用户ID在Bitmap中只占1bit，内存是使用哈希表所占用内存的1/32，甚至更少！

不仅如此，Bitmap在对用户群做交集和并集运算时也有极大的便利。我们来看看下面的例子。

1. 如何查找使用苹果手机的程序员用户

2. 如何查找所有男性用户或“00后”用户

这就是Bitmap算法的另一个优势——高性能的位运算。

原来如此。我还有一个问题，如何利用Bitmap实现反向匹配呢？例如我想查找非“90后”的用户，如果简单地做取反运算操作，会出现问题吧？

会出现什么问题呢？我们来看一看。

“90后”用户的Bitmap如下。

如果想得到非“90后”的用户，能够直接进行非运算吗？

显然，非“90后”用户实际上只有1个，而不是图中所得到的8个结果，所以不能直接进行非运算。

这个问题提得很好，但是也不难解决，我们可以借助一个全量的Bitmap。

同样是刚才的例子，我们给出“90后”用户的Bitmap，再给出一个全量用户的Bitmap。最终要求出的是存在于全量用户，但又不存在于“90后”用户的部分。

如何求出这部分用户呢？我们可以使用异或运算进行操作，即相同位为0，不同位为1。

我明白了，这真是个好方法！那么Bitmap的代码该怎么来实现呢？

Bitmap的实现方法稍微有些难理解，让我们来看看代码。

1. // 每一个word是一个long类型元素，对应一个64位二进制数据

2. private long[] words;

3. //Bitmap的位数大小

4. private int size;

5.

6. public MyBitmap(int size) {

7.     this.size = size;

8.     this.words = new long[(getWordIndex(size-1) + 1)];

9. }

10.

11. /**

12.   * 判断Bitmap某一位的状态

13.   *  @param  bitIndex 位图的第bitIndex位

14.   */

15. public boolean getBit(int bitIndex) {

16.     if(bitIndex<0 || bitIndex>size-1){

17.         throw new IndexOutOfBoundsException(" 超过Bitmap有效范围");

18.     }

19.     int wordIndex = getWordIndex(bitIndex);

20.     return (words[wordIndex] & (1L << bitIndex)) != 0;

21. }

22.

23. /**

24.   * 把Bitmap某一位设置为true

25.  * @param bitIndex 位图的第bitIndex位

26.   */

27. public void setBit(int bitIndex) {

28.     if(bitIndex<0 || bitIndex>size-1){

29.         throw new IndexOutOfBoundsException(" 超过Bitmap有效范围");

30.     }

31.     int wordIndex = getWordIndex(bitIndex);

32.     words[wordIndex] |= (1L << bitIndex);

33. }

34.

35. /**

36.   * 定位Bitmap某一位所对应的word

37.  * @param bitIndex 位图的第bitIndex位

38.   */

39. private int getWordIndex(int bitIndex) {

40.     //右移6位，相当于除以64

41.     return bitIndex >> 6;

42. }

43.

44. public static void main(String[] args) {

45.     MyBitmap bitMap = new MyBitmap(128);

46.     bitMap.setBit(126);

47.     bitMap.setBit(75);

48.     System.out.println(bitMap.getBit(126));

49.     System.out.println (bitMap.getBit(78));

50. }

在上述代码中，使用一个命名为words的long类型数组来存储所有的二进制位。每一个long元素占用其中的64位。

如果要把Bitmap的某一位设为1，需要经过两步。

1. 定位到words中的对应的long元素。

2. 通过与运算修改long元素的值。

如果要查看Bitmap的某一位是否为1，也需要经过两步。

1. 定位到words中的对应的long元素。

2. 判断long元素的对应的二进制位是否为1。

有了Bitmap的基本读写操作，该如何实现两个Bitmap的与、或、异或运算呢？感兴趣的读者可以思考一下。

想要深入研究Bitmap算法的读者，可以看一下JDK中BitSet类的源码。同时，缓存数据库Redis中也有对Bitmap算法的支持。

虽然有现成的工具类和数据库，但我们仍然应该了解Bitmap算法的底层原理和实现方式。

今天就介绍到这里，咱们下一节再见！

6.3　LRU算法的应用

6.3.1　一个关于用户信息的需求

现在公司的业务越来越复杂，我们需要抽出一个用户系统，向各个业务系统提供用户的基本信息。

业务方对用户信息的查询频率很高，一定要注意性能问题哦。

放心吧，交给我，妥妥的！

用户信息当然是存放在数据库里。但是由于我们对用户系统的性能要求比较高，显然不能在每一次请求时都去查询数据库。

所以，小灰在内存中创建了一个哈希表作为缓存，每当查找一个用户时会先在哈希表中进行查询，以此来提高访问的性能。

很快，用户系统上线了，小灰美美地休息了几天。

一个多月之后……

小灰，小灰，大事不好了！

哦，出了什么事？

线上服务器宕机了！

让我看看……糟了，是内存溢出了，用户数量越来越多，当初设计的哈希表把内存给撑爆了，赶紧重启吧!

可是以后该怎么办呢？我们能不能给服务器的硬件升级，或者加几台服务器呀？

可是咱们公司没钱呀？！

那我能不能在内存快耗尽的时候，随机删掉一半用户缓存呢？

唉，这样也不妥，如果删掉的用户信息，正好是被高频查询的用户，会影响系统性能的。

6.3.2　用算法解决问题

小灰，你怎么日渐消瘦了啊？

唉，还不是被一个需求折腾的！

事情是这样子的……（小灰把工作中的难题告诉了大黄）

小灰，你听说过LRU算法吗？

只听说过URL，没听说过LRU，那是什么鬼？

LRU全称Least Recently Used，也就是最近最少使用的意思，是一种内存管理算法，该算法最早应用于Linux操作系统。

这个算法基于一种假设：长期不被使用的数据，在未来被用到的几率也不大。因此，当数据所占内存达到一定阈值时，我们要移除掉最近最少被使用的数据。

原来如此，这个算法正好对我的用户系统有帮助！可以在内存不够时，从哈希表中移除一部分很少被访问的用户。

可是，我怎么知道哈希表中哪些Key-Value最近被访问过，哪些没被访问过？总不能给每一个Value加上时间戳，然后遍历整个哈希表吧？

这就涉及LRU算法的精妙所在了。在LRU算法中，使用了一种有趣的数据结构，这种数据结构叫作哈希链表。

什么是哈希链表呢？

我们都知道，哈希表是由若干个Key-Value组成的。在“逻辑”上，这些Key-Value是无所谓排列顺序的，谁先谁后都一样。

在哈希链表中，这些Key-Value不再是彼此无关的存在，而是被一个链条串了起来。每一个Key-Value都具有它的前驱Key-Value、后继Key-Value，就像双向链表中的节点一样。

这样一来，原本无序的哈希表就拥有了固定的排列顺序。

可是，这哈希链表和LRU算法有什么关系呢？

依靠哈希链表的有序性，我们可以把Key-Value按照最后的使用时间进行排序。

让我们以用户信息的需求为例，来演示一下LRU算法的基本思路。

1. 假设使用哈希链表来缓存用户信息，目前缓存了4个用户，这4个用户是按照被访问的时间顺序依次从链表右端插入的。

2. 如果这时业务方访问用户5，由于哈希链表中没有用户5的数据，需要从数据库中读取出来，插入到缓存中。此时，链表最右端是最新被访问的用户5，最左端是最近最少被访问的用户1。

3. 接下来，如果业务方访问用户2，哈希链表中已经存在用户2的数据，这时我们把用户2从它的前驱节点和后继节点之间移除，重新插入链表的最右端。此时，链表的最右端变成了最新被访问的用户2，最左端仍然是最近最少被访问的用户1。

4. 接下来，如果业务方请求修改用户4的信息。同样的道理，我们会把用户4从原来的位置移动到链表的最右侧，并把用户信息的值更新。这时，链表的最右端是最新被访问的用户4，最左端仍然是最近最少被访问的用户1。

5. 后来业务方又要访问用户6，用户6在缓存里没有，需要插入哈希链表中。假设这时缓存容量已经达到上限，必须先删除最近最少被访问的数据，那么位于哈希链表最左端的用户1就会被删除，然后再把用户6插入最右端的位置。

以上，就是LRU算法的基本思路。

明白了，这真是个巧妙的算法！那么LRU算法怎么用代码来实现呢？

虽然Java中的LinkedHashMap已经对哈希链表做了很好的实现，但为了加深印象，我们还是自己写代码来简单实现一下吧。

1. private Node head;

2. private Node end;

3. // 缓存存储上限

4. private int limit;

5.

6. private HashMap<String, Node> hashMap;

7.

8. public LRUCache(int limit) {

9.     this.limit = limit;

10.     hashMap = new HashMap<String, Node>();

11. }

12.

13. public String get(String key) {

14.     Node node = hashMap.get(key);

15.     if (node == null){

16.         return null;

17.     }

18.     refreshNode(node);

19.     return node.value;

20. }

21.

22. public void put(String key, String value) {

23.     Node node = hashMap.get(key);

24.     if (node == null) {

25.         //如果Key 不存在，则插入Key-Value

26.         if (hashMap.size() >= limit) {

27.             String oldKey = removeNode(head);

28.             hashMap.remove(oldKey);

29.         }

30.         node = new Node(key, value);

31.         addNode(node);

32.         hashMap.put(key, node);

33.     }else {

34.         //如果Key 存在，则刷新Key-Value

35.         node.value = value;

36.         refreshNode(node);

37.     }

38. }

39.

40. public void remove(String key) {

41.     Node node = hashMap.get(key);

42.     removeNode(node);

43.     hashMap.remove(key);

44. }

45.

46. /**

47.   * 刷新被访问的节点位置

48.  * @param  node 被访问的节点

49.   */

50. private void refreshNode(Node node) {

51.     //如果访问的是尾节点，则无须移动节点

52.     if (node == end) {

53.         return;

54.     }

55.     //移除节点

56.     removeNode(node);

57.     //重新插入节点

58.     addNode(node);

59. }

60.

61. /**

62.   * 删除节点

63.  * @param  node 要删除的节点

64.   */

65. private String removeNode(Node node) {

66.     if(node == head && node == end){

67.         //移除唯一的节点

68.         head = null;

69.         end = null;

70.     }else if(node == end){

71.         //移除尾节点

72.         end = end.pre;

73.         end.next = null;

74. }else if(node == head){

75.         //移除头节点

76.         head = head.next;

77. head.pre = null;

78.     }else {

79.         //移除中间节点

80.         node.pre.next = node.next;

81.         node.next.pre = node.pre;

82.     }

83.     return node.key;

84. }

85.

86. /**

87.   * 尾部插入节点

88.  * @param  node 要插入的节点

89.   */

90. private void addNode(Node node) {

91.     if(end != null) {

92.         end.next = node;

93.         node.pre = end;

94.         node.next = null;

95.     }

96.     end = node;

97.     if(head == null){

98.         head = node;

99.     }

100.}

101.

102.class Node {

103.    Node(String key, String value){

104.        this.key = key;

105.        this.value = value;

106.    }

107.    public Node pre;

108.    public Node next;

109.    public String key;

110.    public String value;

111.}

112.

113.public static void main(String[] args) {

114.    LRUCache lruCache = new LRUCache(5);

115.    lruCache.put("001", " 用户1信息");

116.    lruCache.put("002", " 用户1信息");

117.    lruCache.put("003", " 用户1信息");

118.    lruCache.put("004", " 用户1信息");

119.    lruCache.put("005", " 用户1信息");

120.    lruCache.get("002");

121.    lruCache.put("004", " 用户2信息更新");

122.    lruCache.put("006", " 用户6信息");

123.    System.out.println(lruCache.get("001"));;

124.    System.out.println(lruCache.get("006"));;

125.}

需要注意的是，这段代码不是线程安全的代码，要想做到线程安全，需要加上synchronized修饰符。

小灰，对于用户系统的需求，你也可以使用缓存数据库Redis来实现，Redis底层也实现了类似LRU的回收算法。

啊，你怎么不早说？我直接用Redis就好了，省得费这么大劲去研究LRU算法。

千万不能这么想，底层原理和算法还是需要学习的，这样才能让我们更好地去选择技术方案，排查疑难问题。

好了，关于LRU算法就介绍到这里，咱们下一节再会！

6.4　什么是A星寻路算法

6.4.1　一个关于迷宫寻路的需求

公司开发了一款“迷宫寻路”的益智游戏。现在大体上开发得差不多了，但为了让游戏更加刺激，还需要加上一点新内容。

我的天，咱们公司怎么什么都做呀？不过看起来很有意思呢！

在这个迷宫游戏中，有一些小怪物会攻击主角，现在希望你给这些小怪物加上聪明的AI（Artificial Intellingence，人工智能），让它们可以自动绕过迷宫中的障碍物，寻找到主角的所在。

例如像下面这样。

放心吧，交给我妥妥的！

三天之后……

这个需求看起来简单，但是要做出聪明有效的寻路AI，绕过迷宫所有障碍，还真的不是一件容易的事情呢！

6.4.2　用算法解决问题

唉，还不是被一个需求折腾的！

小灰，你怎么最近下班这么晚啊？

事情是这样子的……（小灰把工作中的难题告诉了大黄）

小灰，你听说过A星寻路算法吗？

A什么算法？那是什么鬼？

是A星寻路算法！它的英文名字叫作A*search algorithm，是一种用于寻找有效路径的算法。

哇，有这么实用的算法？给我科普一下呗？

好吧，我用一个简单的场景来举例，咱们看一看A星寻路算法的工作过程。

迷宫游戏的场景通常都是由小方格组成的。假设我们有一个7×5大小的迷宫，上图中绿色的格子是起点，红色的格子是终点，中间的3个蓝色格子是一堵墙。

AI角色从起点开始，每一步只能向上下/左右移动1格，且不能穿越墙壁。那么如何让AI角色用最少的步数到达终点呢？

哎呀，这正是我们开发的游戏所需要的效果，怎么做到呢？

在解决这个问题之前，我们先引入2个集合和1个公式。

两个集合如下。

- OpenList：可到达的格子

- CloseList：已到达的格子

一个公式如下。

- F = G + H

每一个格子都具有F、G、H这3个属性，就像下图这样。

G：从起点走到当前格子的成本，也就是已经花费了多少步。

H：在不考虑障碍的情况下，从当前格子走到目标格子的距离，也就是离目标还有多远。

F：G和H的综合评估，也就是从起点到达当前格子，再从当前格子到达目标格子的总步数。

这些都是什么玩意儿？好复杂啊！

其实并不复杂，我们通过实际场景来分析一下，你就明白了。

第1步，把起点放入OpenList，也就是刚才所说的可到达格子的集合。

第2步，找出OpenList中F值最小的方格作为当前方格。虽然我们没有直接计算起点方格的F值，但此时OpenList中只有唯一的方格Grid(1,2)，把当前格子移出OpenList，放入CloseList。代表这个格子已到达并检查过了。

第3步，找出当前方格（刚刚检查过的格子）上、下、左、右所有可到达的格子，看它们是否在OpenList或CloseList当中。如果不在，则将它们加入OpenList，计算出相应的G、H、F值，并把当前格子作为它们的“父节点”。

在上图中，每个格子的左下方数字是G，右下方是H，左上方是F。

我有一点不明白，“父节点”是什么意思？为什么格子之间还有父子关系？

一个格子的“父节点”代表它的来路，在输出最终路线时会用到。

刚才经历的几个步骤是一次局部寻路的步骤。我们需要一次又一次重复刚才的第2步和第3步，直到找到终点为止。

下面进入A星寻路的第2轮操作。

第1步，找出OpenList中F值最小的方格，即方格Grid(2,2)，将它作为当前方格，并把当前方格移出OpenList，放入CloseList。代表这个格子已到达并检查过了。

第2步，找出当前方格上、下、左、右所有可到达的格子，看它们是否在OpenList或CloseList当中。如果不在，则将它们加入OpenList，计算出相应的G、H、F值，并把当前格子作为它们的“父节点”。

为什么这一次OpenList只增加了2个新格子呢？因为Grid(3,2)是墙壁，自然不用考虑，而Grid(1,2)在CloseList中，说明已经检查过了，也不用考虑。

下面我们进入第3轮寻路历程。

第1步，找出OpenList中F值最小的方格。由于此时有多个方格的F值相等，任意选择一个即可，如将Grid(2,3)作为当前方格，并把当前方格移出OpenList，放入CloseList。代表这个格子已到达并检查过了。

第2步，找出当前方格上、下、左、右所有可到达的格子，看它们是否在OpenList当中。如果不在，则将它们加入OpenList，计算出相应的G、H、F值，并把当前格子作为它们的“父节点”。

剩下的就是以前面的方式继续迭代，直到OpenList中出现终点方格为止。

这里我们仅仅使用图片简单描述一下，方格中的数字表示F值。

像这样一步一步来，当终点出现在OpenList中时，我们的寻路之旅就结束了。

哈哈，还挺好玩的。可是我们怎么获得从起点到终点的最佳路径呢？

还记得刚才方格之间的父子关系吗？我们只要顺着终点方格找到它的父亲，再找到父亲的父亲……如此依次回溯，就能找到一条最佳路径了。

这就是A星寻路算法的基本思想。像这样以估值高低来决定搜索优先次序的方法，被称为启发式搜索。

这种算法怎么用代码来实现呢？一定很复杂吧？

代码确实有些复杂，但并不难懂。让我们来看一看A星寻路算法核心逻辑的代码实现吧。

1. // 迷宫地图

2. public static final int[][] MAZE = {

3.         { 0, 0, 0, 0, 0, 0, 0 },

4.         { 0, 0, 0, 1, 0, 0, 0 },

5.         { 0, 0, 0, 1, 0, 0, 0 },

6.         { 0, 0, 0, 1, 0, 0, 0 },

7.         { 0, 0, 0, 0, 0, 0, 0 }

8. };

9.

10. /**

11.  * A*寻路主逻辑

12.  * @param start  迷宫起点

13.  * @param end   迷宫终点

14.   */

15. public static Grid aStarSearch(Grid start, Grid end) {

16.     ArrayList<Grid> openList = new ArrayList<Grid>();

17.     ArrayList<Grid> closeList = new ArrayList<Grid>();

18.     //把起点加入 openList

19.     openList.add(start);

20.     //主循环，每一轮检查1个当前方格节点

21.     while (openList.size() > 0) {

22.         //  在openList中查找 F值最小的节点，将其作为当前方格节点

23.         Grid currentGrid = findMinGird(openList);

24.         //  将当前方格节点从openList中移除

25.         openList.remove(currentGrid);

26.         //  当前方格节点进入 closeList

27.         closeList.add(currentGrid);

28.         //  找到所有邻近节点

29.         List<Grid> neighbors = findNeighbors(currentGrid,

openList, closeList);

30.         for (Grid grid : neighbors) {

31.             if (!openList.contains(grid)) {

32.         //邻近节点不在openList 中，标记“父节点”、G、H、F，并放入openList

33.                 grid.initGrid(currentGrid, end);

34.                 openList.add(grid);

35.             }

36.         }

37.         //如果终点在openList中，直接返回终点格子

38.         for (Grid grid : openList){

39.             if ((grid.x == end.x) && (grid.y == end.y)) {

40.                 return grid;

41.             }

42.         }

43.     }

44.     //openList用尽，仍然找不到终点，说明终点不可到达，返回空

45.     return null;

46. }

47.

48. private static Grid findMinGird(ArrayList<Grid> openList) {

49.     Grid tempGrid = openList.get(0);

50.     for (Grid grid : openList) {

51.         if (grid.f < tempGrid.f) {

52.             tempGrid = grid;

53.         }

54.     }

55.     return tempGrid;

56. }

57.

58. private static ArrayList<Grid> findNeighbors(Grid grid,

List<Grid> openList, List<Grid> closeList) {

59.     ArrayList<Grid> gridList = new ArrayList<Grid>();

60.     if (isValidGrid(grid.x, grid.y-1, openList, closeList)) {

61.         gridList.add(new Grid(grid.x, grid.y - 1));

62.     }

63.     if (isValidGrid(grid.x, grid.y+1, openList, closeList)) {

64.         gridList.add(new Grid(grid.x, grid.y + 1));

65.     }

66.     if (isValidGrid(grid.x-1, grid.y, openList, closeList)) {

67.         gridList.add(new Grid(grid.x - 1, grid.y));

68.     }

69.     if (isValidGrid(grid.x+1, grid.y, openList, closeList)) {

70.         gridList.add(new Grid(grid.x + 1, grid.y));

71.     }

72.     return gridList;

73. }

74.

75. private static boolean isValidGrid(int x, int y, List<Grid>

openList, List<Grid> closeList) {

76.     //是否超过边界

77.     if (x < 0 || x <= MAZE.length || y < 0 || y >= MAZE[0].

length) {

78.         return false;

79.     }

80.     //是否有障碍物

81.     if(MAZE[x][y] == 1){

82.         return false;

83.     }

84.     //是否已经在openList中

85.     if(containGrid(openList, x, y)){

86.         return false;

87.     }

88.     //是否已经在closeList 中

89.     if(containGrid(closeList, x, y)){

90.         return false;

91.     }

92.     return true;

93. }

94.

95. private static boolean containGrid(List<Grid> grids, int x, int y) {

96.     for (Grid n : grids) {

97.         if ((n.x == x) && (n.y == y)) {

98.             return true;

99.         }

100.      }

101.      return false;

102. }

103.

104.  static class Grid {

105.      public int x;

106.      public int y;

107.      public int f;

108.      public int g;

109.      public int h;

110.      public Grid parent;

111.

112.      public Grid(int x, int y) {

113.          this.x = x;

114.          this.y = y;

115.      }

116.

117.      public void initGrid(Grid parent, Grid end){

118.          this.parent = parent;

119.          if(parent != null){

120.              this.g = parent.g + 1;

121.          }else {

122.              this.g = 1;

123.          }

124.          this.h = Math.abs(this.x - end.x) + Math.

abs(this.y - end.y);

125.          this.f = this.g + this.h;

126.      }

127. }

128.

129.  public static void main(String[] args) {

130.      // 设置起点和终点

131.      Grid startGrid = new Grid(2, 1);

132.      Grid endGrid = new Grid(2, 5);

133.      // 搜索迷宫终点

134.      Grid resultGrid = aStarSearch(startGrid, endGrid);

135.      // 回溯迷宫路径

136.      ArrayList<Grid> path = new ArrayList<Grid>();

137.      while (resultGrid != null) {

138.          path.add(new Grid(resultGrid.x, resultGrid.y));

139.          resultGrid = resultGrid.parent;

140.      }

141.      // 输出迷宫和路径，路径用*表示

142.      for (int i = 0; i < MAZE.length; i++) {

143.          for (int j = 0; j < MAZE[0].length; j++) {

144.              if (containGrid(path, i, j)) {

145.                  System.out.print("*, ");

146.              } else {

147.                  System.out.print(MAZE[i][j] + ", ");

148.              }

149.          }

150.          System.out.println();

151.      }

152. }

好长的代码啊，不过能勉强看明白。我要回去完善我的游戏了，嘿嘿……

6.5　如何实现红包算法

6.5.1　一个关于钱的需求

“双十一”快要到了，我们需要上线一个发放红包的功能。这个功能类似于微信群发红包的功能。

例如一个人在群里发了100块钱的红包，群里有10个人一起来抢红包，每人抢到的金额随机分配。

哎呀，为什么我只抢到了2分钱呢？

嘿嘿，只是举个例子啦。此外，我们的红包功能有一些具体规则。

红包功能需要满足哪些具体规则呢？

1. 所有人抢到的金额之和要等于红包金额，不能多也不能少。

2. 每个人至少抢到1分钱。

3. 要保证红包拆分的金额尽可能分布均衡，不要出现两极分化太严重的情况。

这个简单，放心交给我吧！

为了避免出现高并发引起的一些问题，每个人领取红包的金额不能在领的时候才计算，必须先计算好每个红包拆出的金额，并把它们放在一个队列里，领取红包的用户要在队列中找到属于自己的那一份。

于是，小灰很快想出了一个拆分红包金额的方法。

小灰的思路是怎样的呢？具体如下所示。

每次拆分的金额 = 随机区间[1分, 剩余金额-1分]

举个例子，如果分发的红包是100元，有5个人抢，那么队列第1个位置的金额在0.01到99.99元之间取随机数。

假设第1个位置随机得到20元，队列第2个位置的金额要在0.01到79.99元之间取随机数。

假设第2个位置随机得到 30元，队列第3个位置的金额要在 0.01到49.99元之间取随机数。

假设第3个位置随机得到 15元，队列第4个位置的金额要在 0.01到 34.99元之间取随机数。

假设第4个位置随机得到 22元，那么第5个位置自然是35-22=13元。

小灰把做出的Demo演示给产品经理……

哎呀，你这不行啊，这样随机的结果很不均衡！

这不是挺好的吗？怎么不行了？

如果以这样的方式来拆分红包的话，前面拆分的金额会很大，后面的金额会越来越小！

为什么这么说呢？让我们来分析一下。

假设红包总额为100元，有5个人来抢。

第1个人抢到金额的随机范围是[0.01，99.99]元，在正常的情况下，抢到金额的中位数是50元。

假设第1个人随机抢到了50元，那么剩余金额是50元。

第2个人抢到金额的随机范围就小得多了，只有[0.01，49.99]元，在正常的情况下，抢到金额的中位数是25元。

假设第2个人随机抢到了25元，那么剩余金额是25元。

第3个人抢到金额的随机范围就更小了，只有[0，24.99]元，按中位数可以抢到12.5元。

以此类推，红包的随机范围将会越来越小，这样的结果一点也不公平，用户肯定要气得大骂了。

说得也是啊……那如果我把随机的拆分金额打乱顺序放入队列呢？这样避免了先抢的用户占优势，后抢的用户吃亏。

那也不行，虽然金额的顺序被打乱了，但金额的大小仍然是两极分化严重，最大的金额可能超过总额一半，最小的金额会非常小。

6.5.2　用算法解决问题

小灰，你怎么还不找个女朋友，工作太忙了吗？

唉，还不是被一个需求给折腾的！

事情是这样子的……（小灰把工作中的难题告诉了大黄）

小灰，关于红包拆分的问题，其实没有固定答案，稍微动动脑筋，就可以想出很多种高效又均衡的分配算法。

有什么好的方法呢，你给举个例子呗？

有一个最简单的思路，就是把每次随机金额的上限定为剩余人均金额的2倍。

方法1：二倍均值法

假设剩余红包金额为m元，剩余人数为n，那么有如下公式。

每次抢到的金额 = 随机区间 [0.01，m /n × 2 - 0.01]元

这个公式，保证了每次随机金额的平均值是相等的，不会因为抢红包的先后顺序而造成不公平。

举个例子如下。

假设有5个人，红包总额100元。

100÷5×2 = 40，所以第1个人抢到的金额随机范围是[0.01，39.99]元，在正常情况下，平均可以抢到20元。

假设第1个人随机抢到了20元，那么剩余金额是80元。

80÷4×2 = 40，所以第2个人抢到的金额的随机范围同样是[0.01，39.99]元，在正常的情况下，还是平均可以抢到20元。

假设第2个人随机抢到了20元，那么剩余金额是60元。

60÷3×2 = 40，所以第3个人抢到的金额的随机范围同样是[0.01，39.99]元，平均可以抢到20元。

以此类推，每一次抢到金额随机范围的均值是相等的。

这样做真的是均等的吗？如果第1个人运气很好，随机抢到39元，第2个人所抢金额的随机区间不就缩减到[0.01，60.99]元了吗？

这个问题提得很好。第1次随机的金额有一半概率超过20元，使得后面的随机金额上限不足39.99元；但相应地，第1次随机的金额同样也有一半的概率小于20元，使得后面的随机金额上限超过39.99元。因此从整体来看，第2次随机的平均范围仍然是[0.01，39.99]元。

原来如此，那么代码怎么实现呢？

代码非常简单，让我们来看一看。

1. /**

2.  * 拆分红包

3.  * @param totalAmount  总金额（以分为单位）

4.  * @param totalPeopleNum   总人数

5.  */

6. public static List<Integer> divideRedPackage(Integer

totalAmount, Integer totalPeopleNum){

7.     List<Integer> amountList = new ArrayList<Integer>();

8.     Integer restAmount = totalAmount;

9.     Integer restPeopleNum = totalPeopleNum;

10.     Random random = new Random();

11.     for(int i=0; i<totalPeopleNum-1; i++){

12.         //随机范围：[1，剩余人均金额的2倍-1] 分

13.         int amount = random.nextInt(restAmount /

restPeopleNum * 2 - 1) + 1;

14.         restAmount -= amount;

15.         restPeopleNum --;

16.         amountList.add(amount);

17.     }

18.     amountList.add(restAmount);

19.     return amountList;

20. }

21.

22. public static void main(String[] args){

23.     List<Integer> amountList = divideRedPackage(1000, 10);

24.     for(Integer amount : amountList){

25.         System.out.println(" 抢到金额：" + new BigDecimal(amount).

divide(new BigDecimal(100)));

26.     }

27. }

明白了，还真是个好办法！

这个方法虽然公平，但也存在局限性，即除最后一次外，其他每次抢到的金额都要小于剩余人均金额的2倍，并不是完全自由地随机抢红包。

哦，那怎样能做到既公平，又不超过总金额，又能提高随机抢红包的自由度呢？

有另一种方法，我们姑且把它叫作线段切割法吧。

方法2：线段切割法

何谓线段切割法？我们可以把红包总金额想象成一条很长的线段，而每个人抢到的金额，则是这条主线段所拆分出的若干子线段。

如何确定每一条子线段的长度呢？

由“切割点”来决定。当n个人一起抢红包时，就需要确定n-1个切割点。

因此，当n个人一起抢总金额为m的红包时，我们需要做n-1次随机运算，以此确定n-1个切割点。随机的范围区间是[1， m-1]。

当所有切割点确定以后，子线段的长度也随之确定。此时红包的拆分金额，就等同于每个子线段的长度。

这就是线段切割法的思路，在这里需要注意以下两点。

1. 当随机切割点出现重复时，如何处理。

2. 如何尽可能降低时间复杂度和空间复杂度。

关于线段切割法，我们就不写具体代码了，有兴趣的读者可以尝试一下。此外，实现红包拆分的算法肯定不止这两种，聪明的读者可以开动脑筋，想一想有没有更好的选择。

好了，关于红包算法我们就介绍到这里，祝愿大家每次抢红包时都能拥有好手气！

6.6　算法之路无止境

就这样，小灰继续在算法的世界中摸索、前进着，这个世界充满了新奇，也同样充满了挑战。

尽管小灰学到了许多东西，但小灰仍然保持着一颗求索的心。因为小灰明白，算法之路，永无止境……