漫画算法：小灰的算法之旅

更多电子书资料请搜索「书行天下」：http://www.sxpdf.
com
更多电子书资料请搜索「书行天下」：http://www.sxpdf.com
图书在版编目（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
log216。（注：本书下中底部。）
因此，把面包吃得只剩下1cm，需 5×log16即20分钟。
此，需 5乘以logn即5logn分钟， T(n) = 5logn。

场景3　给灰1个长度为10cm 面包和1个腿，灰每2分钟吃
1个腿。那么灰吃个腿需久呢？
自然 2分钟。因为这里只求吃腿，和10cm 面包没有

关系。
面包长，吃腿间都 2分钟， T(n) = 2。

场景4　给灰1个长度为10cm 面包，灰吃 1个1cm需 1分
钟间，吃 2个1cm需 2分钟间，吃 3个1cm需 3分钟
间……每吃1cm所花间比吃上一个1cm 1分钟。那么灰吃
个面包需久呢？
从1累加 10 总和，也 55分钟。
斯法，此吃个面包需 1+2+3+…+(n-1)+ n 即

(1+n)×n/2 分钟，也 0.5n2 + 0.5n 分钟， T(n) = 0.5n2 +
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分钟");
5. System.out.println("吃1cm 面包");
6. }
7. }
场景2　T(n) = 5logn，执行次对数。
2. for(int i=n; i>1; i/=2){
7. System.out.println("吃一半面包");
8. }
9. }
场景3　T(n) = 2，执行次常量。

3. System.out.println(" 吃1个腿");
4. }
场景4　T(n) = 0.5n 2 + 0.5n，执行次多项式。

2. for(int i=0; i<n; i++){
3. for(int j=0; j<i; j++){
5. }
6. System.out.println("吃1cm 面包");
7. }
8. }
1.2.3　渐进时间复杂度
有了本执行次 T(n)，否可以分和比较代
运行间了呢？还有一困难。
法A 执行次 T(n)= 100n，法B 执行次 T(n)=

5n2，这两个底运行间长一些呢？这 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、n2、n3

等。
推导间度呢？有下几个原则。
如果运行时间是常数量级，则用常数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.5n2+ 0.5n，
最阶项为0.5n2 ，去系 0.5，则化间度为： T(n)

=O(n2)。
这4 间度竟度执行长，节间呢？
当n 取，不难得下面结：
O(1)<O(logn)<O(n)<O(n2)
在编世中有各各法，除了上述4个场景，还有
不同形式间度，：
O(nlogn)、O(n3)、O(mn)、O(2n)、O(n!)
今后当我遨游在代海洋中，会陆续遇上述间度

法。
1.2.4　时间复杂度的巨大差异
大黄，我还有一个问题，现在算机件
能越来越了，我们为什么还这么重时间复杂度呢？
问好，我们两个算来一个对比，
一高效算和低效算有多大。
举下。
法A 执行次 T(n)= 100n，间度 O(n)。
法B 执行次 T(n)= 5n2，间度 O(n2)。
法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(n2)。
么，样能提高算效呢？
在这下，我们有要一些中间数
据了。
中间呢？
当遍历个，每遍历一个，把该存起，
字典中一。当遍历下一个，不必慢慢向前回溯比
较，而去“字典”中找，有没有应即可。
已经遍历了前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)。
下面这段序：

2. int[] array = new int[n];
3. …
4. }
3. 二维空
当法分配间一个二维组集合，并且集合长度和度
都与输模n成正比，间度 O(n2)。
下面这段序：

2. int[][] matrix = new int[n][n];
3. …
4. }
4. 归空
递归一个比较特殊场景。然递归代中并没有式地

变量或集合，在执行序，会专门分配一存，
存 “ 法栈”。
“ 法栈”包括进栈和出栈两个行为。
当进一个新法，执行栈，把法和参息
压栈中。
当法返回，执行栈，把法和参息从栈中

弹。
下面这段序一个标递归序：
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(n2)，间度 O(1)，这于牺牲时间来换取空间情。
反，字典法间度 O(n)，间度 O(n)，这于

牺牲空间来换取时间情。
在绝，间度为重一些，我可分配一
些存间，也升序执行速度。
此，起间度不开结。在本章中，我及
、组、二维组这些集合。果这些结
不很了，可以细本书 2章关于本数据结构，里
面有详细介绍。
关于空间复杂度，我们介绍这里。
时间复杂度和空间复杂度是学好算重要提，一定要

掌握哦！
1.4　小结
什么法
在领里，法一系序令，于特运
和逻辑问题。
量法优劣主标间度和间度。
什么结
结组织、和存式，其为了
地访问和。
结包含组、链这线性结，也包含、图这

结。
什么间度
间度一个法运行间长量度， O ，
T(n)=O(f(n))。
见间度照从低顺序，包括O(1)、O(logn)、
O(n)、O(nlogn)、O(n2) 。
什么间度
间度一个法在运行过中临占存间
量度， O ， S(n)=O(f(n))。
见间度照从低顺序，包括O(1)、O(n)、O(n2)
。其中递归法间度和递归深度成正比。
第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);
44. myArray.output();
45. }
代中成员变量size 组际素量。果素在组尾
部，下标参 index 于size；果素在组中间或部，则
index 于size。
果下标参 index 于size或于0，则为非法输，会

抛异。
可是，如果数组不断插新素，素数
了数组最大度，数组不是要“撑 ”了？
问好，这是接下来要 —— 范围插
范围，又什么意思呢？
现在有一个长度为6 组，已经满了素，这还想一个新

素。
这涉及组扩容了。可组长度在创建已经了，法
孙悟金棒那随意变长或变。这该呢？
此可以创建一个新组，长度组 2 ，把组中素统
统制过去，这现了组扩。
此一，我素法也需了，后代下：

3.
4. public MyArray(int capacity){
6. size = 0;
7. }
8.
9. /**
10. * 组素
11. * @param element 素

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

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

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. */
46. for(int i=0; i<size; i++){

48. }
49. }
50.
52. MyArray myArray = new MyArray(4);
58. myArray.output();
59. }
4. 删元素
组除和过反，果除素位于组中
间，其后素都需向前动1位。
于不涉及扩问题，所以除代现比单：
1. /**
2. * 组除素
3. * @param index 除位置
4. */
5. public int delete(int index) throws Exception {

7. if(index<0 || index>=size){
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. // 链际长度
7.
8. /**
9. * 链素
10. * @param data 素

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) {

46. }
47. Node removedNode = null;

48. if(index == 0){
49. // 除节点
50. removedNode = head;
51. head = head.next;
52. }else if(index == size-1){

53. // 除尾节点
55. removedNode = prevNode.next;
56. prevNode.next = null;

57. last = prevNode;
58. }else {
59. // 除中间节点
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) {

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. */

88. Node temp = head;
89. while (temp!=null) {
90. System.out.println(temp.data);
91. temp = temp.next;
92. }
93. }
94.
95. /**
96. * 链节点
97. */

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);
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。
这是环队，下面我们来一它代
实现。

2. private int front;
3. private int rear;
4.
5. public MyQueue(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. */
37. for(int i=front; i!=rear; i=(i+1)%array.length){

39. }
40. }
41.

43. MyQueue myQueue = new MyQueue(6);
44. myQueue.enQueue(3);
49. myQueue.deQueue();
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. * 二叉中序遍历
35. */
36. public static void inOrderTraveral(TreeNode node){

38. return;
39. }
40. inOrderTraveral(node.leftChild);
42. inOrderTraveral(node.rightChild);
43. }
44.
45.
46. /**
47. * 二叉后序遍历
49. */
50. public static void postOrderTraveral(TreeNode node){
52. return;
53. }
54. postOrderTraveral(node.leftChild);
55. postOrderTraveral(node.rightChild);
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) {
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();

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. * “下沉”

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;
40. array[parentIndex] = array[childIndex];
41. parentIndex = childIndex;

42. childIndex = 2 * childIndex + 1;
43. }
44. array[parentIndex] = temp;
45. }
46.
47. /**
48. * 建
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.
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);
66. }
代中有一个优化点，在父节点和节点连续交，并不一
真交，只需先把交一存 temp变量，单向，循环结
后，把temp 存交后最终位置即可。
咱们了这么多关于二叉堆，二叉堆竟有什
么处呢？
二叉堆是实现堆排序及优先队列基。关于这两者，
我们会在后续章节中详细介绍。
3.4　什么是优先队列
3.4.1　优先队列的特点
队特点什么？
在之前章节中已经过，队特点先进先出（FIFO）。

入列，新元素置于：
出列，元素最先移出：
那么，优先队又什么呢？
优先队不遵循先先原则，而分为两情。
最大优先队列，无论入队顺序如何，都是当前最大的元素优先出队
最小优先队列，无论入队顺序如何，都是当前最小的元素优先出队
有一个最优先队，其中最素 8，那么然8并不队
素，队仍然素8 先队。
现以上需求，线性结并非不能现，间度较
。
哎呀，该么办呢？
，这时我们二叉堆上场了。
3.4.2　优先队列的实现
先回顾一下二叉特性。
1. 最的是整个中的最元素。
因此，可以最现最优先队，这，每一次队

，每一次队除顶节点。
入队操作具步下。
1. 新节点5。
2. 新节点5“上浮” 合适位置。
出队操作具步下。
1. 原顶节点10 队。
2. 把最后一个节点1替顶位置。
3. 节点1“下沉”，节点9成为新顶。
小，你这个优队队和出队操作，时间复
二叉堆节 “上 ”和“下 ” 时间复杂度是
O(logn)，以优队队和出队时间复杂度也是 O(logn)！
，下面我们来一代实现。

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. {

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() {

56. int parentIndex = 0;

58. int childIndex = 1;
59. while (childIndex < size) {

61. if (childIndex + 1 < size && array[childIndex + 1] >
62. childIndex++;
63. }
64. // 果父节点于一个，
65. if (temp >= array[childIndex])

66. break;


71. }

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.
85. PriorityQueue priorityQueue = new PriorityQueue();
86. priorityQueue.enQueue(3);
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(n2)的算法
泡序
选择序
序
序（序比较特殊，性能优于O(n2)，又比不上
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(n2)。
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);
22. }
代非单，双循环进行序。部循环控制所有回合，部

循环现每一泡，先进行素比较，进行素交。
来如此，排代不难呢。
这只是排始实现，还存在大优空间
呢。
4.2.2　冒泡排序的优化
原泡序有哪些可以优化点呢？
我回顾一下刚才述序细节，仍然以{5,8,6,3,9,2,1,7}这个
为，当序法分执行 6、 7 ，状态下。
很可以，经过 6 序后，个已然有序了。可

序法仍然业业地继续执行了 7 序。
在这情下，果能已经有序，并标，那么剩下
几序不必执行了，可以前结工。
2. {
4. {
5. //有序标，每一都 true
6. boolean isSorted = true;
7. for(int j = 0; j < array.length - i - 1; j++)
8. {
9. int tmp = 0;
11. {
12. tmp = array[j];
15. //因为有素进行交，所以不有序，标变为false
16. isSorted = false;

17. }
18. }
19. if(isSorted){
20. break;
21. }
22. }
23. }
24.
26. int[] array = new int[]{5,8,6,3,9,2,1,7};
27. sort(array);
29. }
与 1版代比， 2版代了动，变量isSorted

为标。果在本序中，素有交，则序；果没有
素交，则已然有序，然后循环。
不呀，来排还可以这样优。
这只是排优第一步，我们还可以进一步来
提它能。
为了问题，这次以一个新为。
这个特点前半部分素（3、4、2、1）序，后半部分

素（5、6、7、8）升序，并且后半部分素中最也于前半部
分素最。
下面照泡序思进行序，一具果。
第1
素4和5比较，发现4 于5，所以位置不变。
1 结，有序区包含1个素。
第2
素3和2比较，发现3 于2，所以3和2交。
素5和6比较，发现5 于6，所位位置不变。
2 结，有序区包含2个素。
小，你现其中问题了吗？
其实面多素已经是有了，可是每一
还是白白地比了多次。
，这正是排中另一个需要优。
这个问题关键点在于有序区。
照现有逻辑，有序区长度和序。 1

序过后有序区长度 1， 2 序过后有序区长度 2 ……
际上，真正有序区可能会于这个长度，上述中在 2

序，后面 5个素际上都已经于有序区了。因此后面次
素比较没有意义。
那么，该避这情呢？我可以在每一序后，录下最

后一次素交位置，该位置即为序边，往后有序区
了。
2. {
3. // 录最后一次交位置
4. int lastExchangeIndex = 0;
5. // 序边，每次比较只需比这里为止
6. int sortBorder = array.length - 1;
8. {

11. for(int j = 0; j < sortBorder; j++)
12. {
13. int tmp = 0;

15. {
16. tmp = array[j];


19. // 因为有素进行交，所以不有序，标变为false
21. // 新为最后一次交素位置
22. lastExchangeIndex = j;
23. }
24. }
25. sortBorder = lastExchangeIndex;

26. if(isSorted){
27. break;
28. }
29. }
30. }
31.
33. int[] array = new int[]{3,4,2,1,5,6,7,8};

34. sort(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 决了，鸡
排可是巧妙算！
实挺巧妙，我们来一下它代实现吧。
2. {
3. int tmp = 0;
4. for(int i=0; i<array.length/2; i++)

5. {

8. // ，从左向右比较和交
9. for(int j=i; j<array.length-i-1; j++)
10. {
12. {
13. tmp = array[j];


16. // 有素交，所以不有序，标变为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

34. }
35. }
36. if(isSorted){
37. break;
38. }
39. }
40. }
41.
43. int[] array = new int[]{2,3,4,5,6,7,8,1};
44. sort(array);
46. }
这段代尾酒序原现。代循环控制所有序
回合，循环包含2个循环， 1个循环从左向右比较并交素，
2个循环从右向左比较并交素。
代大致明白了。之排时，有一
对有区优，鸡排是不是也能呢？
当喽！鸡排也可以和之学优方结
使，只不代实现会复杂一些，这里不了，

有兴，可以自己一下代实现哦。
OK，最后我问问，鸡排优和缺是什
么？于什么样场景？
鸡排优是能够在定条件下，少排
回数；而缺也明显，是代几乎增加了1 。
至于它能挥出优场景，是大部分元素已经有序

。好了，关于排和鸡排，我们介绍这里喽。
下一节见！
4.3　什么是快速排序
4.3.1　初识快速排序
同泡序一，快速序也于交换排序，通过素之间比较和交
位置达序。
不同，泡序在每一中只把1个素泡一，而快

速在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列
序则
一边，比它小的元素移动到数列的另一边，从而把数列拆解成两个部分。
这思叫分治法。
每次把分成两部分，竟有什么呢？
给一个8个素，一般情下，泡序需比较7

，每一把1个素动一，间度 O(n2)。
而快速序流什么呢？
图所，在分治法思想下，原在每一都拆分成两部分，每
一部分在下一又分拆分成两部分，不可分为止。
每一比较和交，需把组部素都遍历一遍，间度
O(n)。这遍历一需呢？素个 n，那么平均情下
需 logn ，因此快速序法总平均间度 O(nlogn)。
分果奇！么基素是如何呢？又
如何其他素动基素两端？
基素，以及素交换，是排
核问题。我们来如何基素。
4.3.2　基准元素的选择
素，英 pivot，在分治过中，以素为中心，把其
素动左右两边。
那么选择素呢？
最单式选择 1个素。
这选择在绝情下没有问题。，有一个原本逆序

，序成顺序，那么会现什么情呢？
哎呀，整个数有被分成两，每一只
定了基素位置。
是呀，在这下，数第1个素要么是最小
，要么是最大，根本无挥分优。
在这极端下，排需要进行n ，时间复
杂度成了 O(n2)。
那么，该怎么避这情发呢？
其很单，我可以随机选择一个元素作为基准元素，并且
素和素交位置。
这一，即在逆序情下，也可以有地分成两
部分。
当然，即随选择素，也会有几选最
或最，同会影响分治果。
所以，然快速序平均间度 O(nlogn)，最坏情下

间度 O(n2)。
在后中，为了化步，去了随选择素过，把
素为素。
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.
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 数
实现，我们来一下代。
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. * 分治（单边循环法）
18. */

int endIndex) {
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.
39. int[] arr = new int[] {4,4,6,5,3,2,8,1};

42. }
可以很，partition 法只一个循环了，比双
边循环法单了。
以上排实现方，是以归为基
。其实排也可以基于非递归方来实现。
4.3.5　非递归实现
么样非归方来实现呢？
绝大多数归，可以栈方来代替。
为什么这呢？
在 1章介绍间度我曾经过，代中一一法
，本了一个法栈。每次进一个新法，当于栈；
每次有法返回，当于栈。
所以，可以把原本递归现化成一个栈现，在栈中存每一次

法参。
下面一下具代：
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. * 分治（单边循环法）

37. */
int endIndex) {

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.

58. int[] arr = new int[] {4,7,6,5,3,2,8,1};
61. }
和刚才递归现比，非递归式代变动只发在quickSort
法中。该法引了一个存 Map类素栈，于存每一次交
起下标和结下标。
每一次循环，都会栈顶素栈，通过partition 法进行分治，并

且照素位置分成左右两部分，左右两部分分栈。当栈为
，序已经毕，退循环。
实现了非归方，好棒！
嘿嘿，排是重要算，与里变换等算
为二十世纪十大算法。
有关排我们介绍这里，望大家
这个算吃，未来会受无穷！
4.4　什么是堆排序
4.4.1　传说中的堆排序
还得二叉特性什么吗?
以最为，果除一个最顶（并不除，而

末尾节点交位置），经过自我， 2 素会交上，成
为最新顶。
正上图所，在除为10 顶节点后，经过，为9 新节
点会顶替上；在除为9 顶节点后，经过，为8 新节点
会顶替上 ……
于二叉这个特性，每一次除顶，后新顶都
次于顶节点。那么只反除顶，反二叉，所得
集合会成为一个有序集合，过下。
除节点9，节点8成为新顶。
此为止，原本最二叉已经变成了一个从有序集合。之
前过，二叉际存在组中，组中素下。
此，可以归纳序法步。
1. 无数组构二叉。从到，则构最；
从到，则构最。
2. 环删元素，替到二叉的末，整产生新的。
大体明白了，么该如何代来实现呢?
二叉堆时，我们了二叉堆操作关代。现在
只要在代基上改动一，可以实现堆排了。
4.4.2　堆排序的代码实现
1. /**
2. * “下沉”
4. * @param parentIndex “下沉” 父节点

5. * @param length 有
6. */
7. public static void downAdjust(int[] array, int parentIndex,
int length) {

10. int childIndex = 2 * parentIndex + 1;
11. while (childIndex < length) {

13. if (childIndex + 1 < length && array[childIndex + 1] >
14. childIndex++;
15. }
16. // 果父节点于一个，则
17. if (temp >= array[childIndex])
18. break;

23. }
25. }
26.
27.
28. /**
29. * 序（升序）
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. }
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.
51. int[] arr = new int[] {1,3,2,6,5,7,8,9,10,0};
52. heapSort(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(n2)，而堆排最坏时间复杂度定在 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.
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位。
94分成绩（际上已经遇不了），最终名 1。
3步，遍历成绩 3行红同成绩。
红成绩 95分，找 countArray下标 5 素， 3（最

4， 1变成了3），代红成绩名位置在 3位。
95分成绩（际上已经遇不了），最终名 2。
这一，同 95分红和绿能清楚地顺序了，也正因
为此，优化版本序于稳定排序。
后面遍历过以此类推，这里不详细述了。
还是够绕，不大体上明白了。么，优之
后数排如何代实现呢？
起来复杂，其实代简，我们来一。
1. public static int[] countSort(int[] array) {
2. //1.得最和最，并 d

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];
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. }
32. }
33.
35. int[] array = new int[] {95,94,91,98,99,90,99,93,91,92};
36. int[] sortedArray = countSort(array);

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];


8. max = array[i];
9. }

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. }
45. }
46.
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);
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(n2)。于并没有创建

额存间，所以间度为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。
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. */

22. int data;
23. Node next;
24. Node(int data) {
26. }
27. }
28.
30. Node node1 = new Node(5);

35. node1.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，从环点两个针次遇点 S1，从次遇点回环点
S2。
那么，当两个针次遇，各自所呢？
针p1一次只 1步，所 D+S1。
针p2一次 2步，了n(n>=1) 圈，所 D+S1+n(S1+S1)。
于p2 速度 p1 2 ，所以所也 p1 2 ，因此：
2(D+S1) = D+S1+n(S1+S2)
式经过得：
D = (n-1)(S1+S2)+S2
也，从链结点环点，于从次遇点绕环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 即可。
小，你有有这个存在什么问题？
有问题呀？这个杠杠！
呵呵，今天面这里，回家等吧！
唉……
大黄，么能实现一个最小栈呀？我临时变暂
存栈最小，竟存在什么问题呢？
小，你太简啦！你只考虑了进栈场景，却有考
虑出栈场景。
哦？出栈场景有什么问题吗？
我来给你一下。
原本，栈中最素 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.
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.
16. System.out.println(getGreatestCommonDivisor(25, 5));

19. }
灰思十分单。力举法，从较一半开，
图找一个合适 i，这个能否 a和b同除。
你这个方虽实现了要功能，但是效不行啊。
，如果我传整数是10 000和10 001，你方需要环10

000/2-1=4999次！
哎呀，这是个问题。
不出更好方了……
呵呵，关系，回家等吧！
唉……
大黄，么能更高效地出两个整数最大约数
呀？
小，你听辗转相除法吗？
……什么除？
是除！又叫作欧几里算。
辗除法，又名欧几里得法（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){

4. if(big%small == 0){
5. return small;
6. }
7. return getGreatestCommonDivisorV2(big%small, small);

8. }
9.
11. System.out.println(getGreatestCommonDivisorV2(25, 5));
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. }
7. return getGreatestCommonDivisorV3(big-small, small);
8. }
9.

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 最公约。
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 {
14. return gcd(big-small, small);
15. }
16. }
17.

19. System.out.println(gcd(25, 5));
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.
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）方？
呵呵，关系，今天面这，回家等吧。
唉……
大黄，么能更高效地断一个整数是否是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)。
唉，我出这样题，显不是为了你来排。你
，有有更？
有了呀。不排还能么呢？
呵呵，你回家等吧！
唉……
大黄，我今天见一题，样能算出无数组
排后最大？
嗯……这题实有。虽对数组排以后肯定能
正结果，但我们有要进行排。
不排，该么办呢？
小，你不，有哪些排算时间复杂度是线
好有数排、桶排，还有个什么基数排 ……可你刚
不是不排吗？
，我们仅仅是助一下这些排而已。小
你一下，这题能不能数排一样，数组下标来决？
数排一样？我啊……
有了！我可以使数排，出数组最大
和最小 ……
法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.得最和最
5. int min = array[0];
8. max = array[i];
9. }
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.
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个栈，我也不么实现队。
呵呵，事，回家等吧！
唉……
大黄，你能不能给我，样可以两个栈来实现一
个队呀？
要决这个问题，我们来回顾一下栈和队不同
栈特点先后，素都在同一（栈顶）。
栈：
栈：
队特点先先，素在不同两（队和队尾）。
队：
队：
然我拥有两个栈，那么可以其中一个栈为队口，新
素；另一个栈为队口，除老素。
可是，两个栈是各自立，么能它们有效地关联起来
呢？
，我来具体一下。
队主非有两个：队和队。
在模拟队，每一个新素都压栈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. }
32. StackQueue stackQueue = new StackQueue();
33. stackQueue.enQueue(1);
36. 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 整数次啊！
啊，了……
呵呵，今天这里，回家等吧！
唉……
大黄，你能不能给我，么样寻一个整数有数
字排下一个数？
好啊，在给出具体之，小你考一个问题：
固定几个数字组成整数，样排最大？样排最小？
我一啊……
了，如果是固定几个数字，应该是在逆序排列

下最大，在顺序排列下最小。
举一个。
给 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.
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吗？
哎呀，还是！我 ……
呵呵，不了，回家等吧！
唉……
大黄，你能不能给我，样寻 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.
43. System.out.println(removeKDigits("1593212",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.
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.
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 金。
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.
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. /**
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. /**
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.
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。
果问此 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 位

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

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

38. */
39. private int getWordIndex(int bitIndex) {
40. //右 6位，当于除以64

41. return bitIndex >> 6;
42. }
43.

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　一个关于用户信息的需求
现在业务越来越复杂，我们需要出一个系统，向各个业务系统提供
基本。
业务方对查频高，一定要能问题哦。
放吧，交给我，妥妥！
户息当然存在库里。于我户系统性能求比较，然不能在每一次

求都去库。
所以，灰在存中创建了一个哈为缓存，每当找一个户会先在哈中进行，以

此访问性能。
很快，户系统上线了，灰美美地息了几天。
一个月之后……
小，小，大事不好了！
哦，出了什么事？
线上服务器宕机了！
我 ……糟了，是存出了，数越来越多，当设哈表存
给撑了，赶紧重启吧!
可是以后该么办呢？我们能不能给服务器件级，者加几台服务器呀？
可是咱们呀？！
我能不能在存耗时，随机掉一缓存呢？
唉，这样也不妥，如果掉，正好是被高频查，会响系统
能。
小，你么日消了啊？
小，你听 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) {

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) {

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，绕宫有障，还
不是一件容易事呢！
小，你么最近下这么晚啊？
小，你听 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.

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 。
3个人抢金额随范围了，只有 [0，24.99] ，中位可以抢 12.5 。
以此类推，红包随范围会，这结果一点也不公平，户肯气得了。
也是啊…… 如果我随机分额乱顺放队呢？这样了
优，后吃亏。
也不行，虽额顺被乱了，但额大小仍是两极分严重，最大
额可能额一，最小额会非小。
小，你么还不个女朋友，工作太了吗？
唉，还不是被一个需给腾！
小，关于红分问题，其实有固定答案，动动脑筋，可以出多
高效又均衡分算。
有什么好方呢，你给举个例子呗？
有一个最简，是每次随机额上限定为余人均额 2 。
方法1：二倍值法
设剩红包金额为m ，剩人为n，那么有下公式。
每次抢到的金额 = 随机区间 [0.01，m /n × 2 - 0.01]元

这个公式，每次随机金额的平均值是相等的，不会因为抢红包
了先后顺序而造成不公平。
举个下。
设有5个人，红包总额100 。
100÷5×2 = 40，所以 1个人抢金额随范围 [0.01，39.99] ，在正情下，平均可以抢

20元。
80÷4×2 = 40，所以 2个人抢金额随范围同 [0.01，39.99] ，在正情下，还

平均可以抢 20元。
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.
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　算法之路无止境
这，灰继续在法世中索、前进，这个世满了新，也同满了战。
尽灰了东，灰仍然一颗求索心。因为灰，法之，永止

……

漫画算法：小灰的算法之旅

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

漫画算法：小灰的算法之旅

Uploaded by

Copyright:

Available Formats

更多电子书资料请搜索「书行天下」：http://www.sxpdf.

中国版本图书馆CIP 字（2019） 057355号

北京 海淀区万 173 箱 邮编：100036

2章 介绍了最 本 结 ，包括 组、链 、栈、队 、

3章 介绍了 和二叉 概念、二叉 各 遍历 式、二叉

4章 介绍了几 典 序 法，包括 泡 序、快速 序、

5章 介绍了10 道职场上流行 法面 题及详细 题思

6章 介绍了 法在职场上 一些应 ， LRU 法 淘

所 法，其 个很 泛 概念。有 起 难度 ，烧脑

凡书籍 章，最难 ，肯 公式 号；而最 ，

以前我曾经面 过一个求职者，起 考 技 功底和项 经

仍 ：“我不 道，我 法一点都不会……”

终于，在 友 和 励下， 序员 灰 事从微 公众

于有一 者，也可以选择从 5章面 题 开 阅

这不 一本编 门书。在编 面 零 者，建 至

感 成都道然 技有限 公司 新 老 。有了 肯 、

以此书 给我 人，我 者，以及热爱编 友 ！

在心灰意 之际， 灰忽然想 ， 系里有一位 霸名叫

臭小子，你又 啊！今天罚你算加 ，算出

1+2+3+4+5+6+7……一 加 10000 结果，算不完不 回家！

老 以为，“熊 ”会 部 地一步一步 ， 下面这

这还不得 天天亮？ 这 受 ！老 心里幸灾乐 地想

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

先把从1 10 000这10 000个 字两两分组 加， 下。

所以1 10 000 加 总和可以这 ：

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

算法有简 的，也有 杂的。

法， 在 物品里选择 背包 物品， 背包里

刚才所 从1加 10000 事中， 斯所 法 然 加

而老 心中所想 法， 部 地一个 一个 进行累加，则

有人或 会觉得，不 运 吗？这还不 单？

当 歌、 度 索 一个关键 ，或在 库中执行 一

序 法有很 ， 性能和优缺点各不 同，这里面

为什么面 那么喜欢考 法呢？

数据结构是算 基 。如果 算 比喻成美

丽 动 舞者， 么数据结构 是舞者脚下 阔而坚实 舞

结 ， 应 英 单 data structure ， 组织、

线性结 最 单 结 ，包括 组、链 ，以及 衍

有了 结 这个舞台， 法才可以尽情舞 。在 决问题 ，

关于 法在不同 结 上 过 ，在后续 章节中我 会

一个小 ， 我们一步一步来体验算 无穷魅 吧！

一天， 灰和 同 加 了同一 公司。

代 运行一次 花100ms，占 存 5MB。

在上述场景中， 灰 然也 照老板 求 现了功能，

别人的代码 消耗5MB的内 ，而 灰的代码 消耗500MB的内

可是，如果代 还 有运行，我 么能预

对 行时间是无 预估 。但我们却可以预估代 基本操作

这个问题 式 达 ， 字16不 地除以2，那么除几次

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

自然 2分钟。因为这里只 求吃 腿，和10cm 面包没有

面包 长，吃 腿 间都 2分钟， T(n) = 2。

从1累加 10 总和，也 55分钟。

斯 法，此 吃 个面包需 1+2+3+…+(n-1)+ n 即

1. void eat1(int n){

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

1. void eat3(int n){

场景4 T(n) = 0.5n 2 + 0.5n，执行次 多项式 。

1. void eat4(int n){

法A 执行次 T(n)= 100n， 法B 执行次 T(n)=

因此，为了 决 间分 难题，有了 渐进时间复杂度

若 函数f(n)，使 当n 近于无穷 时，T(n)/f(n)的极 值

因为渐进 间 度 O ，所以也 称为 大O表示法。

时间 数T(n)简 为一个数 级，这个数 级可以是n、n2、n3

最 阶项为5logn， 去系 5，则 化 间 度为： T(n)

　　　　　北京海淀区万 173 箱　邮编：100036

2章　介绍了最本结，包括组、链、栈、队、

3章　介绍了和二叉概念、二叉各遍历式、二叉

4章　介绍了几典序法，包括泡序、快速序、

5章　介绍了10 道职场上流行法面题及详细题思

6章　介绍了法在职场上一些应， LRU 法淘

所法，其个很泛概念。有起难度，烧脑

凡书籍章，最难，肯公式号；而最，

以前我曾经面过一个求职者，起考技功底和项经

仍：“我不道，我法一点都不会……”

终于，在友和励下，序员灰事从微公众

于有一者，也可以选择从 5章面题开阅

这不一本编门书。在编面零者，建至

感成都道然技有限公司新老。有了肯、

以此书给我人，我者，以及热爱编友！

在心灰意之际，灰忽然想，系里有一位霸名叫

臭小子，你又啊！今天罚你算加，算出

1+2+3+4+5+6+7……一加 10000 结果，算不完不回家！

老以为，“熊 ”会部地一步一步，下面这

这还不得天天亮？这受！老心里幸灾乐地想

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

先把从1 10 000这10 000个字两两分组加，下。

所以1 10 000 加总和可以这：

算法有简的，也有杂的。

法，在物品里选择背包物品，背包里

刚才所从1加 10000 事中，斯所法然加

而老心中所想法，部地一个一个进行累加，则

有人或会觉得，不运吗？这还不单？

当歌、度索一个关键，或在库中执行一

序法有很，性能和优缺点各不同，这里面

为什么面那么喜欢考法呢？

数据结构是算基。如果算比喻成美

丽动舞者，么数据结构是舞者脚下阔而坚实舞

结，应英单 data structure ，组织、

线性结最单结，包括组、链，以及衍

有了结这个舞台，法才可以尽情舞。在决问题，

关于法在不同结上过，在后续章节中我会

一个小，我们一步一步来体验算无穷魅吧！

一天，灰和同加了同一公司。

代运行一次花100ms，占存 5MB。

在上述场景中，灰然也照老板求现了功能，

别人的代码消耗5MB的内，而灰的代码消耗500MB的内

可是，如果代还有运行，我么能预

对行时间是无预估。但我们却可以预估代基本操作

这个问题式达，字16不地除以2，那么除几次

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

自然 2分钟。因为这里只求吃腿，和10cm 面包没有

面包长，吃腿间都 2分钟， T(n) = 2。

斯法，此吃个面包需 1+2+3+…+(n-1)+ n 即

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

场景4　T(n) = 0.5n 2 + 0.5n，执行次多项式。

法A 执行次 T(n)= 100n，法B 执行次 T(n)=

因此，为了决间分难题，有了渐进时间复杂度

若函数f(n)，使当n 近于无穷时，T(n)/f(n)的极值

因为渐进间度 O ，所以也称为大O表示法。

时间数T(n)简为一个数级，这个数级可以是n、n2、n3

最阶项为5logn，去系 5，则化间度为： T(n)

只有量级，则化间度为： T(n) =O(1)。

最阶项为0.5n2 ，去系 0.5，则化间度为： T(n)

今后当我遨游在代海洋中，会陆续遇上述间度

能越来越了，我们为什么还这么重时间复杂度呢？

一高效算和低效算有多大。

法A 执行次 T(n)= 100n，间度 O(n)。

法B 执行次 T(n)= 5n2，间度 O(n2)。

那么，随输模n 长，两法运行速度快呢？

在运行一段序，我不执行各运令，同也会

于这个单需求，可以很思决，其中最素

遍历个，每遍历一个新开回顾之前遍历过

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

2步，遍历 1，回顾前面字3，没有发现重字。

3步，遍历 2，回顾前面字3、1，没有发现重字。

上一节所法，我不难得结，这个法间

已经遍历了前7个，那么字典里存息下。

“字典”左 Key代，“字典”右 Value代该

下，当遍历最后一个 2 ，从“字典”中可以松找

当法分配间一个线性集合（组），并且集合

递归一个比较特殊场景。然递归代中并没有式地

当法返回，执行栈，把法和参息从栈中

参 n=5，那么法fun4（参 n=5）息

，正所和熊不可得。很，我不得不在间