MikeYan01

NBA Simulator的前世今生

Fri, 23 Jan 2026 00:00:00 GMT

聊聊这些年我设计NBA Simulator的故事。

前言#

作为一个NBA爱好者，小时候我一直梦想有一个模拟工具能时时刻刻模拟NBA比赛，让我能在任何时刻过足比赛瘾。上个月在AI的强力加持下，我终于拥有了一个这样的前端页面，理想初具雏形，以此有感而发记录一下它的前世今生。

1.0版本：计算器上的原型探索#

中学时期我经常拿卡西欧计算器来生成随机数。有一天我突然想到，如果将NBA比赛的每一个回合拆分成若干事件（选择球员，球员投篮，投篮命中，…），再用随机数的生成结果来对应这些事件的结果，就能预测一个回合；由于每个回合会随机消耗一定时间，因此只要预测足够多的回合，就能模拟一场比赛。这个思路延用至今，所有的NBA模拟延伸都是在这个基础上进行两个部分的打磨：事件的拆分以及随机数概率的调整。

彼时我还没有接触计算机编程，并且也没有自动化的工具，因此很多时候就是靠着一台计算器、一张纸和一根笔人力完成了一场比赛的模拟。并且最初的事件拆分也比较原始，事件只考虑了最基本的得分，随机数概率范围也基本只考虑了球员的综合能力。然而即便是这样，一场比赛的人力成本也相当之大，因为我需要用纸笔记录所有回合的得分情况，一晚上常常洋洋洒洒写满两三张草稿纸。现在想起那段时光，尽管模拟工作量巨大，但是它也有效缓解了学业压力，仿佛在意念上摸鱼逃课看了N场球。

2.0版本：编程的最初尝试#

大一接触了面向对象程序设计后，我发现篮球比赛是面向对象编程的完美载体，因为球员、球队、比赛等等都可以抽象为对象和类，并进行相应封装。在假期的时候我开始用C++实现比赛的模拟，然而彼时我对C++的使用并不熟练，代码写得相当冗余，几天洋洋洒洒码了四五千行之后却只实现了一个非常简陋的版本（只能预测比赛结果，并且还因为C++相对复杂的内存管理，时不时遇到内存泄漏或者栈溢出），光是debug就花费了一周。然而自动化带来的提升是显而易见的，原来模拟一场比赛需要1-2天的人力劳动，现在只需要不足5秒。这也使我得以观测大量比赛的模拟结果，并且逐步尝试加入更多的回合事件。抢篮板、助攻、抢断、盖帽、犯规等等事件都是在这个阶段被陆续加入程序中的。

彼时我常常用虎扑App看NBA比赛的文字直播，妙趣横生的解说词让观众相当具有代入感。有一天我意识到，我的模拟程序也完全可以加入这些解说词，这比起模拟结束简单生成一个结果要有趣得多。于是我从许多解说比赛里挑选了一些有意思的解说词，在回合模拟的间隙中通过控制台输出。这个改进也让我的模拟初步拥有了“实况”的感觉。许多解说词甚至保留到了今天的版本里。

3.0版本：日复一日地打磨#

2020年，疫情时代来临，NBA遭受冲击被迫停赛，无球可看的我又掏出了我的模拟程序解闷。经过几年的专业学习，我自然而然地发现了诸多当年代码设计的缺陷，我意识到是时候推倒重构了。由于我当时常在LeetCode上用Java刷题，重构时的语言选择上我也选择了用Java练手。

最初我的重构野心很小，仅仅只是用Java重写一个简练、精致的新版本。Java的语法相比C++会简单一些，再加上更合理的面向对象设计，我很快实现了这个目标。这时我又产生了新的念头 - 既然我能从逐个回合推演一场比赛，为什么我不能从逐场比赛推演一个赛季呢？这瞬间让这个程序更上一层楼 - 从单场比赛的胜者模拟蜕变为赛季冠军模拟。代码上的实现需要的成本也并不高，仅仅只需要找到NBA的赛程安排导出成文件，再根据NBA的赛制规则实现一个季后赛模式即可。这个改动让我立即获得了新的乐趣，因为看到模拟程序生成冠军明显比看到一场普通比赛的胜者更引人入胜。然而赛季模式的引入也开始暴露出我程序的缺陷。此前的单场比赛模拟中，我并没有留意球员数据模拟结果的质量 - 从随机数角度来说，单场比赛样本太小，模拟出怎么样的结果都说得通。然而赛季模式下因为有了足够的样本，我发现许多球员的数据（得分、篮板、助攻等等）都和现实相差甚远，这也让我开始反思代码层面如何调整。尽管NBA官方并没有提供球员的量化能力评价，但我找到了2kratings这个替代品，它能实时获取最新的NBA 2K游戏球员能力值。虽然这个能力值来源于电子游戏，但毕竟也是游戏制作团队基于现实中球员的实时表现进行调整的，具有一定的专业参考性。我根据2kratings的数据打磨了我的程序，特别是在Player类中引入了相当多的球员能力，并且重新改进了各种Utility函数，让球员的各方面能力都可以影响到比赛进程，也大大提升了模拟的真实性。后来，我又发现了Basketball Reference这个神仙网站，它提供了大量的现实比赛结果供我参考。可以说Basketball Reference大大降低了我的调参难度，它提供了真实准确的标尺，我只需要让比赛的模拟结果尽可能接近这个标尺即可。此外，我也通过数学建模改进了许多事件模拟的函数，例如投篮距离和命中率的对应引入了指数函数，回合时间的消耗引入了Sigmoid函数等等。经过了这一系列的调整之后，生成的数据质量显著提升。

我还进一步优化了比赛事件。最大的改进是引入了轮换系统，这个轮换系统会参考现实规律，结合了球员体力、负荷管理、实时手感等等的影响，让球员的总体上场时间更接近真实，也让更多替补球员有了上场发挥的机会。同时，我也尽可能引入了一些小概率事件，例如技术犯规/恶意犯规、伤病、挑战等等，让比赛更加跌宕起伏。比赛的解说词也更生动，增加了球员的反应功能，时不时能看到球员因为作出贡献而庆祝，又或者是犯错而沮丧。

另一个优化是比赛回顾相关的功能。此前的程序里面每把比赛都会生成一个对应的文本文件，单赛季总共1300多局比赛因此对应着1300多个结果文件，我根本不可能全部看完。在这个契机下我产生了做比赛回顾的念头，简要显示每局比赛输出分节比分、实时分差图，列举双方发挥的优异球员等等。这个改进大大提升了我浏览比赛的效率，我在后续的网页版本里复用了这个功能，使得网页更接近现实中体育门户网站赛后回顾比赛的体验。另外我还将单赛季模拟拓展至多赛季模拟，用这种方式预测球队夺冠的概率，进一步评估球队的实力差距。

在经过了前后几年断断续续的打磨之后，这个版本最终被我封存在了https://github.com/MikeYan01/NBA-sim这个库里面。可以说这个版本是承上启下之作，它从一个不成熟的玩具变成了一个相对真实可靠的程序，并且囊括了绝大多数我想要的功能。未来我不会再更新这个代码库，但它对我而言可能是最具纪念意义的一个版本。

4.0版本：AI时代的如虎添翼#

2024年开始，AI agent如雨后春笋般爆发，我的模拟器也在AI加持下实现了再次蜕变，从一个命令行程序变成了一个前端页面。

我的设想是利用AI将Java程序用TypeScript再次重构，加上可视化的网页UI。原本我以为重构对AI agent是小菜一碟，而网页UI才会花费较多精力，没想到重构的时候AI遇到了诸多幺蛾子，UI倒是几乎一步到位就画好了，这还是在我使用了Spec Kit这样的工具，按步骤、阶段为AI规划了重构任务的前提下。最主要的缺陷在于AI agent没有充分理解全部代码，在移植时总是会遗漏一部分原有的代码实现（例如在判断犯规的时候只考虑了防守犯规，没考虑进攻犯规等等），以致于需要反复人工检查校对，估计在现有agent技术下，上下文长度限制还是让AI难以一步到位完成重构。UI部分则令人惊艳，Claude给出的设计简洁美观，尤其是球员赛后数据Box score部分和现实中门户网站的UI设计相差无几；反而是前端界广受赞誉的Gemini 3 Pro设计的UI第一眼没有让我满意。不过总体而言整个移植过程还是比较顺利的，这让我对未来人类和AI共智的合作模式也有了更高的期待。

AI在内容创作上也大大提升了效率。此前我一直希望拓展解说语料库丰富比赛输出，AI不仅帮我拓展了诸多内容，甚至还顺带帮我抽象了相关数据库结构方便后续拓展。此外它还提供了翻译支持，我的前端页面目前支持了中英双语，未来的i18n拓展自然也重构为更灵活的架构。

这个版本目前被我存储在https://github.com/MikeYan01/NBA-Sim-Web这个库里，并且也部署到了https://mikeyan01.github.io/NBA-Sim-Web/页面上。至此，我终于可以随时随地，从任何设备上访问我的模拟程序，观看NBA模拟比赛了。

5.0版本：？#

4.0版本几乎已经是我在中学时代的梦想了 - 随时随地，有一个可视化页面能够访问我的NBA模拟程序，并且能看到真实详尽的比赛解说与球队/球员数据。不过也必须要承认的是现阶段的版本仍然有诸多不足，例如解说词的堆叠有时比较生硬，以及部分复杂的比赛事件暂时还未实现（例如比赛末尾时的犯规战术等等）。更远一步畅想，现在的文字模拟版本在AI时代完全有可能拓展成图形甚至是视频版本，因此这十多年的版本更迭一定不是句号。希望我能一致保持这份初心，拥抱技术，让梦想继续进化。

Animenz钢琴改编主观Top20评测

Wed, 14 Feb 2024 00:00:00 GMT

主观向聊聊个人最喜欢的20首Animenz动漫钢琴改编。

前言#

Animenz (Youtube主页)是近年出名的动漫歌曲改编钢琴家。相对于扎实的演奏水平，他的改编风格更加令人印象深刻，我尤其惊叹于他对于多声部的驾驭能力以及丰富的和谐编排，颇有一种“一个人就是一支乐队”的气势。以下列举出我个人最喜欢的20首Animenz改编作品。

No.20 Avid#

出自动漫《86-不存在的战区-》。

这首改编是近年Animenz的创新之作之一。除了招牌的多手技巧与旋律处理，Animenz着重突出了整首改编的“空灵感” - 这种感觉主要来源于Animenz对于踏板的独到理解。Animenz在多个地方仅仅半踩踏板，让延音保持着和谐的同时，缓慢减弱：

Fitting to the lyrics of 「Avid」(“it calls, it calls”), I let the piano “resonate” its sound a bit more than usual by mostly using half pedal during the performance and releasing the sustain pedal very slowly for longer notes. This creates a very interesting “mixed harmonic”, which slowly clears up by itself until only a very few notes remain. It can be heard in 1<47>, 4<04>, and 5<02>.

No.19 One Last Kiss#

出自动漫《新世纪福音战士》。

宇多田光的这首名作其实并不容易改编 - 原曲中充满了大量节奏强烈的和弦，倘若改编时只知道一味重音砸琴，会使得听感特别嘈杂。用Animenz的话形容便是：

I also had to arrange the voicing on the piano very carefully in order to distinguish the multiple layers of music, because it can be easily “drown” the music if I add too many notes. Especially the many cross rhythms was quite difficult to play, because you have to be very precise or else the rhythms will fall easily apart.

Animenz最终理解的改编主题是”Echo”：

It is hard to believe, but this song actually consists of only two harmonic progression patterns, which is repeating itself over and over again. If I had to use one word to describe the mood of this song, it would be “Echoes”.

可以说这个理解相当精准，Animenz用并不算非常复杂的和弦编排巧妙营造了循环与回响的氛围，听罢之后仍觉得余音绕梁不绝于耳。此外Animenz高超的左右手分奏能力也极好地凸显了各自的节奏感。

No.18 Euterpe#

出自动漫《罪恶王冠》。

先聊几句Animenz和《罪恶王冠》的故事 - 整部《罪恶王冠》中诞生了诸多经典配乐，Animenz本人相当喜欢这些曲目，因此倾注了大量心血进行改编，使得《罪恶王冠》的几首改编作品质量都相当之高。

这首改编是Animenz的早期作品，因此充满了浓厚的古典演奏技法，Animenz对原曲旋律进行了大量的改编，使得改编版本的情感表达极其强烈，但却又并不违背原曲的主题。此外，从第二段开始Animenz引入了演奏技巧，例如三手技巧、大量高速的和弦拆解跑动、三连音八度等等，Animenz认为这些技巧的尝试为他之后几年的其他改编提供了许多灵感：

It is also the first arrangements where I am utilizing the three-hand-technique (starting in 2<32>): the left hand is playing the melody and the bass, while the right hand is playing an accompaniment.
Thinking back, it’s one of the prototypes for my future “orchestral” arrangement style and an important personal milestone.

No.17 悪魔の子#

出自动漫《进击的巨人》。

又是一首左右手交替主旋律 + 三手技巧的经典改编，还原感十足。副歌部分在琶音凸显丝滑的同时，主旋律仍能保持洪亮的听感。而4分钟处的A moment of silence，堪称Animenz原创的神来之笔：

I added an extended “epilogue” in 3<57> to bring the chapter Attack on Titan to a proper closure. The melody is slowing down and seems to almost disappear in 4<29>, reflecting Eren’s fate in Attack on Titan. And at the very end in 4<33>, I played the intro melody again but this time in a major key, to give all the characters of Attack on Titan a proper send-off.

No.16 Only my Railgun#

出自动漫《某科学的超电磁炮》。

这首改编可以说是Animenz的“开山之作”：

Only my Railgun was actually the first arrangement I have ever created, in November 2009 to be exact. I was running an Anime blog, writing anime reviews and sharing my anime piano arrangements, before I decided to create my own YouTube channel 2 months later in January 2010.

尽管因为欠缺演奏技法和改编经验，初版的效果不佳并被Animenz视为失败作品，但在之后的六七年中Animenz也因此有了动力精益求精，终于在2016年他完成了目前为世人所知的这个版本的改编。整首改编对于原曲旋律的还原度相当之高，同时也解决了Animenz在六七年前最困扰的多手演奏问题。借鉴动漫里的设定，这首改编对我而言就像”Level Upper”一样，总能在心情低沉时点亮我的情绪。

No.15 スパークル#

出自动漫《你的名字》。

要理解这首改编必须对《你的名字》这部电影需要有一定的了解。在电影中这首曲子出现于高潮时刻（彗星坠落至地球），因此改编的版本需要有一定的故事性，和电影中这一段的人物情节对应上。Animenz对此的理解是“Connected”：

Since the central topic of the movie was “being connected to each other”, I tried to represent it in the music as well. If you listen closely, you will notice that there are many times, where the “voices” of Taki and Mitsuha are collaborating with each other.

由此便能感受到Animenz编曲的精妙之处了。无论是左右手交替主旋律对应男女主角彼此的呼唤，亦或是原创的长篇幅情感积蓄后的迸发，都令人听后欲罢不能。4分20秒处改编的再现部尤其精髓 —— 一连串和弦之后重新回响起的旋律完全将我再次拉回了电影情节，完美对应了电影中立花泷张开手掌，看到了三叶留下掌心里的“すきだ”的画面，有一种苦尽甘来，雨过天晴的感动。

No.14 Key anime piano medley#

出自Key社的若干动漫，包括《AIR》《Kanon》《Clannad》。

Key社的这几部动漫都是二三十年的经典之作，配乐也都经历了年代考验流传至今。Animenz的组曲改编还原了原曲的精髓，尤其是开场的鸟之诗，在和弦的选取和琶音的搭配上堪称完美，C段部分仿佛让听众看到了一只自由之鸟张开双翼飞上天空。

No.13 aLIEz#

出自动漫《Aldnoah.Zero》。

“核爆神曲”一直以曲风激昂，节奏感强烈闻名，而这对钢琴改编是一个极大挑战。Animenz在改编中提供了一个思路：让左手与右手独立开来，以重复、低沉、快速、规律的左手伴奏模拟原曲中强节奏感的鼓声。尽管左右手的节奏相对独立，但Animenz并没有让多声部顾此失彼，而是通过切分音等技巧，既维持了很强的节奏感，又能时刻突出当前篇章中的主旋律。

这首改编最打动我的地方在于2分54秒开始的右手八度主旋律，几乎总能令我产生鸡皮疙瘩。相较于原曲，Animenz将这段右手的旋律提高了八度，效果却异常地出众 - 在高音之下是持久的，濒临绝望却又坚持不能倒下的壮烈感。

No.12 Call of Silence#

出自动漫《进击的巨人》。

这首改编又是Animenz的在情绪铺垫与累积上的一大经典之作。原曲的时长其实很短（2分50秒左右），因此Animenz在改编大胆将前3分钟都变成了一个引子，用相对平静的节奏完成了对原曲的复奏。然而从3分21秒开始，Animenz插入了急速的音阶进一步堆叠情感，并终于在3分56秒的主旋律再现时达到了重生的巅峰 —— 每次听到这段再现部时我都会被伴奏部分如同钟声一般的洪亮和弦重击所深深震撼。而在5分钟之后的结尾部分，Animenz用回归空灵的编曲完成了重生之后的道别。

No.11 Butter-Fly#

出自动漫《数码宝贝》。

这首曲子原曲是动漫界多年的金曲，但是Animenz改编出了属于自己的特色 —— 前半部分的叙事风格拼接后半部分的摇滚风格。从4分14秒开始的“無限大な夢のあとの”阿卡贝拉变奏更是全曲的点睛之笔，尽管挪去了左手伴奏，但是右手的和弦高亢响亮，仿佛令人听到了和田光司发自肺腑地嘶吼演唱，令人动容。

No.10 One more time, One more chance#

出自电影《秒速五厘米》。

我愿称之为Animenz最具画面还原力的改编作品。2分00秒至2分31秒右手的伴奏堪称神来之笔，闭上眼睛仿佛就能看到片片飘落的樱花花瓣；而4分钟之后的双手琶音交叉，仿佛让人看到了电影结尾电车交汇的场景。当时看完电影的我有一种强烈的钝痛感以及无法言语的苦涩，而Animenz的改编还原了这种体会，在静默中渐行渐远。

No.9 Sincerely#

出自动漫《紫罗兰永恒花园》。

Animenz的这版改编娓娓动人，非常契合《紫罗兰永恒花园》细腻、温柔的情感主题。Animenz在这首改编中引入了大量多声部设计，并且精心设计了数段长时间的伴奏修饰音阶，保证节奏的流动性的同时也能更好地和动漫中的主角薇尔莉特故事呼应 - 不同的声部构造而成的主旋律，更能描绘出薇尔莉特这一段悲喜交加、充满起伏的情感旅程。

同时这首改编发布于京都动画纵火案一周年，因此Animenz无缝衔接了一个长达三分钟原创篇章表达了对京阿尼罹难员工的悼念。这段原创可谓画龙点睛之笔，既在旋律上契合了前五分钟的Sincerely原曲，又仿佛讲述了一个京阿尼浴火重生的故事。用Animenz本人的话来总结便是：

Initially, the music would have ended here, but I wanted to include a more positive message in my tribute. I believe there is still hope and that KyoAni will return one day. The right hand plays the main theme A-C-G-A again but this time it’s a little bit hidden within the chords. The violin tremolo is returning as well and the music is swelling up until it finally unleashes a bright and optimistic F-Major chord. It symbolizes the rebirth of KyoAni, where it slowly rises from the ashes, only to shine brighter, than it ever has.

No.8 βios#

出自动漫《罪恶王冠》。

βios原曲自从当年动漫问世之后就一直以“拔剑神曲”著称，而Animenz的改编完全还原了原曲的风味。在2012年的初版改编中，Animenz就已经完美还原了原曲的激昂摇滚元素；而在2021年的再版改编中，Animenz在初版基础上添加了更多的声部演绎，让整首改编的情感更加丰富饱满，甚至隐隐有一种“悲从中来不可断绝”的感觉。

值得一提的是，初版改编的调号基于的是原曲的c小调，而再版改编的调号则更换为了升f小调，以此和泽野弘之在《罪恶王冠》十周年纪念时发布的升f小调版本同步。（十分有趣的是，Animenz承认这个调号改变让他更容易在KTV演唱这首歌曲。。）本已十分熟悉c小调版本的我在听到升f小调新版时的确有一种耳目一新的感觉。

回到改编本身，Animenz的再版改编相较于初版大幅增加了长度，拥有了长达2分多钟的引子和接近1分钟的后记，结构上更加完整。此外在初版旋律再现的部分中，Animenz用这些年更加精进的多手演奏技巧去贴近原曲的旋律：

Compared to my old “Bios” arrangement from 2012, I realized that my tendency to use three-hand techniques has exponentially risen with every year. With other words, this “Bios” remake is a true paradise for all three-hand technique lovers and I tried to replicate the background instruments of the original song as much as I can. They are most noticeable in the guitar solo in 2<48> and in the chorus 3<55>.
The most difficult part to arrange was definitely the double voice climax in 4<34>. Technically, it’s even a 4-hand technique, because the right hand is playing the main melody and an ornamental figure while the left hand is playing the sub melody and the bass.

No.7 Ninelie#

出自动漫《甲铁城的卡巴内利》。

这首改编和原曲风格迥异，却出人意料地抓耳。原曲中”F#3 C#4 F#4 B3 F#3 B3 C#4 E4”的固定音型(Ostinato)被恰到好处地通过多声部 + 左右手交替主旋律复刻进了改编；而第一次进入副歌时的高八度轻处理比起原曲更增添了一种空灵的奇幻感；结尾部分主旋律再次回归左手的同时，右手转变为了高速的跑动，这一部分双手演绎出了截然不同的风格 - 左手厚重的同时右手轻巧灵动，最后还能完美归一，真有种“尘归尘，土归土”之后的六根清净。

No.6 君の知らない物語#

出自动漫《化物语》。

一直以来Animenz对于Ryo就极为推崇。《君の知らない物語》作为Ryo的经典编曲作品之一，Animenz毫不吝啬对其的赞赏：

Did I also mention that Supercell is one of my favorite J-pop bands of all time? Ryo is seriously amazing for composing all these timeless melodies. I think I have listened to this piece more than a hundred times already, and I still get goosebumps while listening the chorus.

而这首改编也开创了Animenz“交响式编曲”的先河，相比起早期改编作品中更加注重古典式演奏技巧，Animenz开始更多地侧重改编的旋律性，用更多的声部、更丰富的和弦设计、更连贯的篇章来体现音乐的“流动性”(natural flow of music)。这个改编思路对于《君の知らない物語》相当契合，Animenz几乎做到了对原曲的极致还原，每一次我聆听的时候都能感受到旋律的细腻，以及琴声之后充满欢笑又带有遗憾的青春回忆。

No.5 Unravel#

出自动漫《东京食尸鬼》。

这首改编可以说是Animenz最为人们熟知的一首改编，截止2026年中，Youtube上已有超过1亿次播放。作为Animenz的代表作，整首改编基本融合了他能想到的所有高难度演奏技巧，并且以极高的还原度复刻了原曲狂放的旋律，听罢令人酣畅淋漓。

我个人也曾花费相当长的时间练习这首改编，但惭愧的是至今也只能演奏出简化版本。全曲最大难点当属贯穿左手部分的和弦分解伴奏，需要在高速跑动的同时兼顾跨越数个音域的准度；其次就是右手部分的各种主旋律变奏，尤其是需要依靠无名指/小拇指强调高音的部分，十分考验四五指的基本功，甚至是多声部的理解驾驭能力。除此之外，遍布整首改编的各种修饰音、颤音、同音换指等高阶技巧中任意一项都需要演奏者具有极深的演奏基本功。

有趣的是，Animenz本人似乎也在日后回顾这首改编时觉得应该降低一些难度：

In hindsight, if I would arrange this song again, I would use my gained experience from the past five years to make it less frustrating to play, but without losing its musical quality.

No.4 The Everlasting Guilty Crown#

出自动漫《罪恶王冠》。

这首改编完美地还原了原曲背景声部一直循环的Ostinato - Animenz甚至将它塞进了三个声部。除此之外，Animenz调整了编曲中的段落结构，减少了重复的篇章，使得全曲听起来更加一气呵成。从4分55秒开始至结尾的华彩部分更是精华中的精华，融合了诸多技巧，用Animenz本人的描述是：

In this short moment, I was reflecting all the past arrangements I have created, all the struggles I had to go through in order to continue and my constant obsession with perfectionism. So I utilized everything I could think of to make the final chorus count, be it three hand technique, fast right hand runs, or multiple voicing.

初次听完这段华彩部分的我真的有一种想从椅子上坐起的冲动，我知道这段旋律在我脑海中也将成为”everlasting”了！

No.3 グランドエスケープ#

出自动漫《天气之子》。

进入排行榜前三名的改编在我心中都达到了一个新的境界 - 超越了原曲。原曲本身已经十分精彩，然而Animenz的改编却给予了我原曲之外全新的聆听感受。

这首改编几乎始终维持在三或四声部，可以看出经过多年历练后，Animenz对于多声部的理解和掌控能力已至化境。与之对应的自然就是演奏难度的大幅提高 - 演奏者必须有极强的左右手分奏能力和协调能力。

然而真正让我觉得这首改编超越原曲的地方在于最后一分钟，可以说在此之前的三分半是一个大型铺垫，一切都是为了最后一分钟的情感迸发做足准备。对应《天气之子》的剧情而言，原曲这一段配乐发生在剧情高潮之时（男女主角逃离天空祭坛，降落回地面重获自由）；而Animenz的改编用极为高超的编曲将这一段画面生动描绘出来了。用他本人的介绍是：

The climax in 3<42> I really wanted to include that cheerful hand clapping from the original music into the piano, so I used the three hand technique again to let the right hand play the CLAP CLAP CLAP. This is one of the few times, where the left hand is literally going all out and play the most glorious forte fortissimo ever!

诚如其所言，改编的高潮部分充满生机、梦幻，既有重获自由的喜悦，又有对未来生活的向往。此刻我的脑海里只剩下天野阳菜那句经典台词“ねぇ、今から晴れるよ!”，这种雨过天晴的幸福不是通过祈求上天得来的，而是自己拼命换来的，唯有这种幸福才是人类最宝贵的力量。

No.2 カワキヲアメク#

出自动漫《家有女友》。

我在初次听罢这首改编之后惊叹到失语，同时我也庆幸借着这首改编认识了美波这一位才华横溢的歌手。美波的原曲演绎几乎已经是完美的了，她歇斯底里、悲怒交杂的招牌唱腔让这首歌极具感染力，而Animenz不仅将这种感染力带到了钢琴上，甚至还在此基础上进一步丰富了旋律编排，令我真正领会到了“钢琴的怒吼”。

Animenz本人将这首改编视为Unravel的“精神续作”：

It’s hard to explain, but this song feels like a “lost twin” of another song: “unravel” from “Tokyo Ghoul”. The similar chorus melody, the similar chord progression, the similar song structure with the “soft” part at the beginning - the similarities are astonishing.
Before I started to arrange this song, I actually practiced many of my old piano arrangements again in order to re-learn my “old arrangement style” (which focuses a lot on piano technique). And similar to my “unravel” piano arrangement, I am also utilizing many notes from the high register of the piano to create a cold - and lonely - atmosphere. I am pretty sure you can hear many similar sections between these two arrangements.

我个人则认为这首改编的难度甚至在Unravel之上，因为它不仅继承了Unravel之中的诸多难点，对于多声部演绎的要求也要高出不少；尾奏部分更是难度极高，还原了原曲的多种乐器组合演绎。Animenz花了接近其他曲子三倍的时间来改编这部作品，然而这样呕心沥血的改编并不是单纯炫技，正如前文所提他希望用这种方式真正让钢琴“怒吼”起来，以此让观众更好共鸣。他也确实做到了，这首改编是我心目中最为接近“一个人就是一支乐队”的典范。

No.1 My Dearest#

出自动漫《罪恶王冠》。

这首改编无论对于Animenz还是我本人都有极为深刻的意义。

对于Animenz而言，他先后为My Dearest出过两个版本的改编，初版是其早期的经典代表作，用Animenz自己的话形容是“my most ambitious fusion between the world of classic and pop”；而再版则特意选择了YouTube首次投稿十周年纪念日当天发布，在保留了初版的绝大部分风味的情况下润色了部分旋律编排和修饰音处理。两首改编基本可以视为一脉相承的一个整体，Animenz也希望借此传达自己不忘初心的想法，以及对所有人的致谢：

With the 10th anniversary around the corner, I knew exactly which song I would upload: “My Dearest” - the OP song of Guilty Crown. Because back in 2013, when I was having a dark time period in my life, this was the piece that showed me the possible future of Anime piano. It was an experiment, a prototype for a new type of music: By combining classical music elements with Japanese anime music, I have managed to create something new on my own.
Without this piece, “Animenz” wouldn’t be what it is today.

而对于我个人而言，这首改编的意义就更特殊了。这是我接触的第一首动漫歌曲改编，彼时我对整个二次元领域所知甚少，对钢琴曲的理解更是几乎全部局限在古典乐和少数近现代流行乐上，这首改编完全为我打开了新世界的大门。同时如歌名My Dearest所指，这首曲子是献给至爱之人的，我至今也难以忘记向伴侣初次演奏这首曲子时内心的忐忑与悸动。每次练琴时，我都会尽可能用最认真的状态演奏一遍My Dearest，用哈利波特中的那句经典台词来形容这首改编再合适不过了：“After all this time?” “Always.”

回到这首改编本身，我至今仍认为这是Animenz编曲的巅峰，将原曲中原本相对激昂的摇滚元素完美转变为了细腻、婉转的叙事曲风格。尽管在Animenz的一众改编里，从演奏难度而言它不一定是最难的，但它有着无与伦比的旋律美感。即便听了多年之后，每次重新播放之时我仍然像第一次听到时被打动。我尤其倾醉于这首改编中的和弦拆解 - 我第一次领会到这种近似练习曲的演奏技法能带来这样优美的旋律，这在之后很多年内都影响了我的音乐观。

感谢Animenz能为世人奉献这样精彩的作品。

2023年终游戏盘点

Sun, 31 Dec 2023 00:00:00 GMT

2023年的最后一天，回顾今年每一个新玩的游戏🎮

前言#

2023年是游戏业界的大年，不管是全新大作还是冷饭翻炒重制都不乏精彩之作；而今年我恰好又用年终奖升级了PC设备，接触到的游戏面因此比之前更加宽广。以下将按照今年游玩的时间月份顺序，试图用三言两语概括每一个新玩的游戏，也算是纪念这不平凡的一年。

列表#

火焰纹章：结合#

2023开年游玩的第一作。作为上一代风花雪月的忠实玩家，本作我早早预购，到手之后游玩了接近150小时。这一代优缺点都十分明显，战斗方面相比前作有了显著提升，更需要动脑；但剧情人设构造则过于幼稚，远不如前作刻画得细腻。从我个人角度来看，毕竟火焰纹章是一款战棋游戏，战斗策略方面仍然是更贴近游戏核心的部分，而且遇到剧情动画实在乏味之时跳过即可，因此总体来说我还是比较满意本作游玩体验的。

女神异闻录4：黄金版 (P4G)#

P4G今年年初登陆了次世代主机，尽管游戏画面、玩法还是十年前的古早风味，但沉迷程度完全不输P5，在剧情、人物刻画方面甚至还超过了它的后代。我个人而言也更喜欢P4G的故事，相比起P5略显压抑的剧情，P4的色调更加阳光，对于青春的理解和刻画也更加到位。值得一提的是，本作改编的番剧P4A和P4GA也是良心之作，即便是没有玩过游戏的观众也能轻松入坑，这也要归功于P4本身的精彩剧情。

鹅鸭杀#

公司团建时接触的游戏。作为此类游戏新手，我并没有什么游戏体验，扮演鸭的时候基本都被早早识破，而扮演鹅的时候则经常沦为炮灰被人暗杀。我认为此类游戏的乐趣在于如何拿捏人与人之间的信任 - 如何伪装自己骗取他人信任，亦或是在人人自危时赢得他人信任。

女神异闻录4：无敌究极后桥背摔#

P4G的后日谈。优点是添加了大量原创剧情，并且加入了P3的人物共同互动；而缺点是剧情质量不如游戏本体，并且几乎没有动画，演出效果大打折扣。而作为游戏本体核心玩法的格斗也并没有太大亮点，甚至让玩家无法分析出不同人物之间的角色强度。总结来说是一部只适合打折购入的粉丝向作品。

宝可梦：朱#

宝可梦第九世代之作，尽管Game Freak技术力仍然是肉眼可见的二流，但好在相比以前还是有些进步的，经过之前剑盾 + 阿尔宙斯的试水之后渐渐也将开放世界宝可梦玩明白了。总体而言，本作主线剧情演出中规中矩，优化有进步空间但不妨碍玩家正常通关。它的技术力展示似乎并不太配得上千万级销量，但它确实又是有史以来最“开放”“新颖”的宝可梦，单就这一点已经足够让世界上众多宝可梦玩家入坑了。

塞尔达传说：王国之泪#

这一作实在不需要过多介绍，只能说没有拿下年度游戏实在是生不逢时，遇上了博德之门3这样的怪物，但从游戏质量本身来说它绝对还是游戏业界标杆。我个人可以给本作打98分，扣掉的两分里一分是因为switch的性能实在是限制了这一作的上限，另一分是因为我思念米法了。

逆转裁判123：成步堂精选合集#

卡普空的经典冷饭，文字推理类游戏的标杆。制作人巧舟的剧本本身已经足够精彩，基本上每一代的最后一章都能达到一个小高潮，第三代的最后一章《华丽的逆转》更是回收了此前章节的几乎所有伏笔，为整个123合集完美收官。此外，在20年前极为有限的存储容量环境下，制作组用并不丰富的素材、配乐就完成了对剧情人物的生动演绎，诸多动漫、游戏都在后来致敬了逆转裁判里的演出桥段。

剑侠情缘网络版三#

今年短暂入坑了这款堪称国内生命力最旺盛的网游，两周多的时间内体验有好有坏。在我看来这款网游的生命力源泉在于高度粘性的玩家群体，其中有相当一部分玩家保持着高素质，这给予了新玩家融入的可能。以我的个人经历为例，我在一无所知的情况下进入一个副本之后频繁迷路，队长愿意停下来手把手教导我如何跑图，同时安抚其他队友让他们耐心等待，将心比心换成我是队长未必做得到如此耐心。然而与此同时，剑网3依然没有办法挣脱传统网游的束缚：金钱 / 时间二选一提升角色。剑网3的选择是时间，并且还设计了类似赛季的机制，保证老玩家永远有新的奋斗目标，新玩家也有追赶的可能。但这样一来，人物的属性也就高度绑定于在线频率；而为了规避工作室影响，官方也在每周资源获取上施加了诸多限制，这就让人物培养周期变长了很多。我相信对于有着大把时间、不愿氪金的玩家来说这是最好的方案，但对于我这类上线时间有限且不规律的上班族来说就比较痛苦了。

异度神剑3#

JRPG的又一标杆之作，在世界观塑造上独具一帜，对于生命的讨论非常有深度。角色塑造张力十足，中后期不少半小时以上的剧情播片并不令玩家出戏，并且还有诸多精彩反转。然而总体而言游戏节奏还是略显拖沓，特别是战斗中引入卡牌策略机制我并不太喜欢，反馈不够强烈并且非常拖时间。

吸血鬼幸存者#

有意思的刷子游戏，尽管画质十分简陋，但是装备组合、地图设计却异常丰富，让人有玩下去的动力。各种各样的彩蛋、隐藏机关设计也十分令人惊喜。

赛博朋克2077#

发售三年后的2077终于迎来了完全体 - 修好了大多数bug并且推出了往日之影DLC，再结合打折，正是最好的入手时机。完全体的游戏质量绝对是达到三年前玩家们的预期的，无论是剧情人物的塑造、角色培养、战斗操作等等都是业界标杆级别。

生化危机4重制版#

卡普空的另一碗经典冷饭，整款游戏玩下来可以用两个词总结：“舒服”和“良心”。“舒服”体现在游戏的各类细节和交互上，没有一丝一毫多余的设计，制作组很清楚玩家会干什么，想要干什么。而“良心”则体现在重制的力度上，重制版相比起原版并不仅仅是画质的巨大提升，对剧情、人物的塑造也有了更合理的改动，让玩家更有沉浸感。值得一提的是，这款游戏虽然是一个线性通关游戏，但因为巧妙的动态难度设计，玩家即便通关一次之后选择新难度开启二周目，也能获得全新的游戏体验，无论是资源的获取、战斗的方式等等都需要重新规划，这也体现出了制作组制作功力之深。

八方旅人2#

我个人认为这是一款言过其实、游玩体验高开低走的游戏。游戏配乐堪称这款游戏最大的亮点，诸多玩家戏称花了几百元买了一个内置音乐播放器并非浪得虚名。游玩体验上，前期开荒阶段十分精彩，尤其是不同角色日夜的个人技能运用带来了非常高的自由度，隐隐让我联想起了上古卷轴5。然而中期开始随着玩家队伍配置成型，怪物似乎并没有相应的提升，玩家无法感受到足够的挑战性。而且频繁的暗雷遇怪模式也让跑图体验磕磕绊绊，难以让玩家保持投入。此外八个角色之间的互动依然比较有限，这也或多或少影响了玩家的代入感。

幽灵诡计#

巧舟的另一款推理解谜游戏，他的剧本质量水准依然相当之高，无论是穿插的幽默、伏笔和照应以及出色的人物塑造都让人印象深刻。尽管我对这款游戏的美术、操作风格并不那么喜欢，但精彩的剧本依然让我有很强的动力通关。

FC24#

年货游戏，今年不幸丢了FIFA的冠名权，本以为改名是个好的契机让制作组能稍微用心做一些新内容，但很可惜作为单机玩家而言，最终玩到的成品并没有太大改变。不过打折时购入还是差强人意的，偶尔放松踢上一把十分解压。

后记#

No game, no life。希望2024年我能接触到更多精彩的游戏作品，点缀一下乏味的打工生活。

女神异闻录5皇家版游玩心得

Mon, 26 Dec 2022 00:00:00 GMT

Take your heart!

前言#

今年Atlus决定将女神异闻录5：皇家版(Persona5 Royal，以下简称P5R)推向全平台，包括我在内的大批新玩家因此有机会入坑了这部JRPG名作。它不止治好了我这几个月里的电子游戏羊伟，更给予了我诸多思考的机会。近年来电子游戏逐渐快餐化与公式化，能让人驻足思考剧情与设定的游戏并不多见，这也是我在经历了约166小时三周目的游玩之后想分享一些P5R心得的原因。

荣格心理学#

P5R乃至整个P系列的设定都主要建立在荣格心理学理论之上，借此游玩机会我也有幸学习了一些荣格的经典理论。

人格面具#

一个人的人格可以视为若干面具的集合，同一个人在不同的社交场合下会表现出不同的形象（戴上不同的面具），用俗话形容就是“见人说人话，见鬼说鬼话”。这个理论很好理解，多重面具的切换能力对每个人都是必要的，我们需要借此融入形形色色风格迥异的社会场合。在游戏中，主角Joker就能自如地持有并切换多重面具，这一能力让他和不同背景、性格的协作人结交时左右逢源、事半功倍；同时在面对不同的暗影（本质上也属于面具的一种另类衍生）时也能轻松攻其软肋。

然而，人格面具会导致自我与他人的界限变得模糊，随着自我的主体性逐渐消失，个人内心的原始冲动以及欲望都将被面具压抑。这时就需要灵活掌控人格面具，使其不能压抑自我本能。P5R中重要的“人格面具觉醒”设定实际就是一个掌控人格面具的过程，主角团中的所有人都在某个机缘巧合之下被社会迫害，陷入了愤怒的绝境中，此时心中的本我爆发，和人格面具达成了契约之后（我は汝，汝は我），就能真正学会如何掌控面具，在需要摘下面具的时候（象征着遇到逆境）能随时摘下来。这也是为什么所有人第一次人格面具觉醒的时候，一定会有一个撕下自己面具的动画特写。在此之后主角团不会再被面具压抑本能；相反人格面具成为了他们叛逆意志的象征，由此能完全释放自身的反抗力量。

个体无意识 vs 集体无意识#

所谓个体无意识，指的是个体层面所有同“自我意识”不一致或者有矛盾的内容，游戏中的几个殿堂均是由个体无意识演变而来的扭曲欲望空间。值得一题的是，引发这种扭曲的事物本身可能是无害的（例如鸭志田的奥运奖牌，班目的小百合画作），这个设定很有意思，很可能制作组想要强调个体无意识是由一个人的后天经历所影响的。

与个体无意识相对应的是集体无意识。荣格认为：

精神的个人层终结于婴儿最早的记忆，而它的集体层却包含着前婴儿的时期，即祖先生活的残余… 集体无意识是相对于个人无意识而言的，它是人精神的一个构成部分，它是集体的、普遍的、非个人的由各种遗传力量形成的心理倾向或种族记忆。

游戏中的印象空间大致复刻了集体无意识的框架，本质上是所有民众心中的欲望集合而形成的巨大殿堂。印象空间每一层大空间都象征着一种人类美好品德被剥夺（思想、和谐、节制、美德、慈悲、感动、宽容，与人类的七宗罪相呼应）；而集体无意识膨胀形成的圣杯象征着宰制人类欲望的最终产物。在P5R的设定中，伪神通过控制圣杯进而主宰了民众的思想，怪盗团因此不可避免地将悔改对象变成了全社会的民众。令人叹息的是，在游戏中有怪盗团弑神唤醒民众的热血桥段，但现实中或许永远无法有人能真正解放民众的集体意识。

人物群像塑造#

P5R塑造了20多位性格特异的协作人(cooperation，以下简称coop)，有些是主角团患难与共的战友，有些是社会上遇到的志同道合的同志，甚至还有来自精神空间的支援。制作组刻画如此众多的人物时并没有顾此失彼，而是成功塑造了精彩的人物群像。每个coop都有十个等级，绝大多数情况下每个等级都需要一个事件+若干对白推动，但P5R安排的coop关系推进节奏十分舒服，让玩家并不对这200余次事件对话感到厌烦。每个NPC都被塑造的有血有肉，在提升coop的关系时还会解锁独特的能力，这些都增加了玩家推动coop发展的动力。以下聊聊我对几位印象深刻的coop的感触。

摩尔加纳#

本质上是来自天鹅绒房间的引导者，在主线故事中对于主角乃至整个团队也是名副其实的引路人。他无私传授了整个异世界的基础观念、战斗的技巧、秘宝的盗取、人格面具的使用等知识；并且在很长一段时间内还兼任了战斗中的导航以及车夫。作为一只猫，他原本可以只充当一只吉祥物划划水，但最后他对团队的贡献却远远超出了吉祥物所能做到的。

当然摩尔加纳也并不完美，他的性格和心态一直为部分玩家诟病。随着怪盗团的壮大，他的存在感似乎也在慢慢变弱，这让他心态逐渐失衡。然而这样的设定也让摩尔加纳的设定更加真实，因为他是一个尽职的前辈，也是一个有点“狂妄”的前辈；他为团队做出了贡献，因此也会眼红别人取代自己的角色。也正是经历了摩尔加纳的离队，其他团员们真正意识到了摩尔加纳的重要性；而回归后的摩尔加纳也最终排除了心魔重新融入了团队，找到了自己的价值。

新岛真#

很多二次元作品里都有这样一个女角色，有能力有抱负，智商在线，内心强大意志坚定，但偶尔也能体现出反差萌激发男性保护欲，在P5R里这个角色就是新岛真。有趣的是，P5R并不是一开始就让新岛真就以完美的姿态登场，而是作为怪盗团的对立面暗中调查乃至干扰怪盗团。但在经过了诸多波折之后，她终于觉醒了自己的反抗意志，摆脱了成人们的操控，加入怪盗团走上了自己的人生道路。游戏投入了相当多的笔墨刻画了这一流程，足见制作者对这个角色下的苦心，而这样的苦心也收到了回报：在国内外几乎所有的P5R角色人气排行中，新岛真都稳居前三，赢得了诸多玩家的认可。

尽管P5R中主角有10位可以攻略的女性角色，但新岛真似乎是和主角最有CP感的角色，甚至制作组官方也通过游戏彩蛋体现了这种“偏心”，有意将她打造成官配：

唯二和主角假扮男女朋友的角色（另一位是大宅一子）。与大宅的coop发展夹杂了成人世界的戏谑，相比之下与新岛真的这段coop关系却是真挚的日久生情
新岛真在主线剧情中惊慌失措时会抱住主角大腿，其他女角色没有类似待遇
白色情人节当天，选择其他女角色约会结束后主角会将她们送回车站，但新岛真并没有类似的文字提示，当天发生了什么我们不得而知

当然彩蛋归彩蛋，我个人认为新岛真最适合成为主角伴侣的原因实际是职业规划。以主角杰出的人格魅力以及坚定的反抗意志，他在未来很有可能会步入政治/司法系统中，为民众的福祉而奋斗。在白色情人节事件中，所有女性角色都会提到一句“你不是为了自己，总是为了别人去行动”算是为主角的性格做了定性概括，也暗示主角可能未来会从事为别人奉献的事业。而在女角色中，新岛真的未来规划毫无疑问是和这个目标最为接近的，无论她进入律政系统还是司法系统，他们都将会有一个共同奋斗的目标。即便从coop事件中二人相处的日常模式来看，新岛真也没有很明显的性格缺陷，甚至还因为反差萌与主角相处得十分融洽，担当得起“官配”这样的角色。

佐仓双叶#

佐仓双叶算是全游戏除了主角之外对怪盗团最重要的角色。她的黑客技术深不可测，达到了人类巅峰水平。主线剧情中她有三个高光时刻：单人挫败梅吉多、远程调用异世界APP戏耍明智、侵入全日本电视信号发预告信，每一次高光时刻都能帮怪盗团扛过一次足以覆灭的危机，并且没有留下任何痕迹。至于日常窃听+窥屏获取情报，异世界的导航+辅助那都是额外附赠的能力了，在一众coop里她解锁的各项技能无一例外都是实用技能。古有“状诸葛多智而近妖”，双叶大概也算是这样的角色了吧。

大宅一子#

这位coop非常有意思，如果单纯以玩家人气作为标准，主角的十位交往对象中她几乎始终是人气最低的那位。造成这一现象的原因也很好列举，颜值无亮点、年龄大、生活方式不健康、coop技能作用低…然而在完整推完了她的coop后，我却对她充满敬佩。

大宅是废人化事件的间接受害者，她的好友因为查出了关键证据惨遭报复，变成废人；大宅本人也因为相关的新闻报道受到牵连，被迫放弃调查，在领导的威逼下她不得不成为了一名花边新闻专栏记者。事业的压力、好友的遭遇无时不刻摧残着她的精神，可她却连倾诉的对象都没有，只能借酒浇愁，并在酒后对着酒吧老板吐露苦水。幸运的是，在遇到主角之后她又燃起了斗志，勇敢地为怪盗团提供情报，并且顶着上司的压力继续调查废人化事件。在主角因为前科入狱后，也是她找到了主角老家的当事人，提供了一手最能直接推翻前案的证据，帮助主角沉冤昭雪。

虽然大宅在外貌上不那么吸引人，但实际上她为主角提供的帮助相当慷慨。同时她也是相当契合P5R反叛精神的角色，在与主角的交往中，她也渐渐找回了自己的意志，与社会的黑暗战斗。

丸喜拓人#

丸喜拓人是P5R新加入的角色，制作组借这个角色抛出了另一个问题供玩家思考：我们是否应该逃避现实中真实的痛苦，沉迷于虚假的幸福？

本质来说，丸喜在怪盗团干掉伪神之后取而代之，成为了虚拟新世界的掌控者。按丸喜的设定，所有人都能在这个世界中避开痛苦取得幸福，并且为了使主角信服，他还让主角亲眼看到了其他队友沉溺于美好世界中的样子。然而稍想一下便知丸喜画的大饼有着诸多漏洞：如何保证不同人之间的幸福互不冲突？如何保证丸喜能精准定义每个人的幸福？如何保证丸喜日后不改变心愿，从营造幸福变为制造不幸？

于是问题出现了：为什么丸喜这样一个漏洞百出的设定能俘获如此多的玩家，情愿选择丸喜的虚拟世界结局？思考数日后我只能得出结论，有太多类似丸喜这样的人在现实中受过挫折，终于放弃了抗争选择了向命运妥协，而丸喜的这个世界不仅没有“惩罚”这种妥协，甚至还回报以如梦般的幸福，这种诱惑让人无法拒绝。丸喜的所作所为其实也可以认为是在贯彻属于他自己的正义，他或许某种程度上也在用类似怪盗团的方式去影响更多民众的心灵，帮助民众“战胜”命运的不公。只可惜，任何强加于人的正义一定不再是正义了。

看过了丸喜的人生故事，与其说丸喜“可怜之人必有可恨之处”，倒不如说丸喜一生都在懦弱地逃避，哪怕在最开始得到力量失去恋人之时他也没有魄力再将恋人追回来，而是放任恋人去过新的生活。也许从这一刻起，“假作真时真亦假”已经贯彻在了他的身上，他将虚拟的世界当做了真正幸福的归宿，对现实世界也从此一叶障目，只能看到痛苦。

“天下第一”？#

自发售后不管是P5还是P5R，溢美之词均不绝于耳，“天下第一”的名头也喊得十分响亮。不论是发自肺腑还是慕名跟风，能让诸多玩家喊出天下第一并非易事。网络上已经有着诸多评测分析P5系列的优点，本文就不再罗列了。我仅寥寥数语提几条最吸引我游玩两周目的优点：

出色的人物群像塑造，大大提升了主角代入感
令人着迷的背景音乐
丰富的人格面具，不管是全面具100%收藏还是打造出一两只完美的人格面具都充满乐趣

然而，即便有着上述优点我也不认为它能成为“天下第一”。抛开P5R新加入的诸多硬伤的第三学期，单就起家的P5本体而言也不能说是尽善尽美。为了专心营造主题剧情，游戏把支线任务和特色小玩法的优先级排的很低，基本上成为了主线剧情以及COOP关系的附庸设定，演绎也以重复性较高的对白+战斗为主，损失了不少游戏性。此外剧情的节奏推动是有些失衡的，中后期赶工痕迹明显，细节演绎相比前期也有退步。再就是占据玩家大量游玩时间的迷宫解谜部分，比较遗憾的一点在于殿堂迷宫都是线性解谜的，玩家并不能进入迷宫后自由探索、选择解开不同机关的先后顺序，这一点也体现出了制作组在技术力或者开发成本上的局限性。

如果要提一些总结性评语的话，我愿意给予P5两个最：

P5是我接触过最有思想深度的JRPG，对于怪盗团行为的合法性讨论几乎贯穿了全部章节，制作组并不因为他们是主角就安插主角光环随心所欲，而是自始自终强调这是怪盗团“坚持自己的正义”并基于这种正义去行动，无论是在秘密基地的会议桌上、国安局审讯室里、乃至最后和丸喜决战前的摊牌里。怪盗团确实能问心无愧地拯救了世界，但这样的问心无愧并不代表正义，民众也必然不可能完全认同（按照怪ch投票，会无限趋近于50 - 50的分布）。所以P5R这种既能塑造主角形象，又能保持思想深度讨论主角立场的平衡做的非常棒。
P5R也是我游玩过最有代入感的JRPG。许多人流连于P5的世界里，更多是老夫聊发少年狂，又或者是圆了一个学生时代曾经遥不可及的梦想。我们全身心融入主角团身上度过了别样的高中生活，甚至拯救了世界，某种程度上算不算怪盗团也偷走了我们的心呢？

海瑞治安疏

Fri, 15 Apr 2022 00:00:00 GMT

直言天下第一疏

原文#

　　《治安疏》，又称《直言天下第一疏》，是海瑞在嘉靖四十四年（公元1565年）十月所创作的一篇奏疏。这篇奏疏指责朱厚熜迷信道教、妄想长生、错聩误国的过失，指出天下“吏贪将弱”“民不聊生”，都是由于他的“误举”所致。甚至讽刺他的年号“嘉靖”，意味着“家家皆净而无财用”。全文内容如下：

　　户部云南清吏司主事臣海瑞谨奏；为直言天下第一事，以正君道、明臣职，求万世治安事：

　　君者，天下臣民万物之主也。惟其为天下臣民万物之主，责任至重。凡民生利病，一有所不宜，将有所不称其任。是故事君之道宜无不备，而以其责寄臣工，使之尽言焉。臣工尽言，而君道斯称矣。昔之务为容悦，阿谀曲从，致使灾祸隔绝、主上不闻者，无足言矣。

　　过为计者则又曰：“君子危明主，忧治世。”夫世则治矣，以不治忧之；主则明矣，以不明危之：无乃使之反求眩瞀，莫知趋舍矣乎！非通论也。

　　臣受国厚恩矣，请执有犯无隐之义，美曰美，不一毫虚美；过曰过，不一毫讳过。不为悦谀，不暇过计，谨披沥肝胆为陛下言之。

　　汉贾谊陈政事于文帝曰：“进言者皆曰：天下已安已治矣，臣独以为未也。曰安且治者，非愚则谀。”夫文帝，汉贤君也，贾谊非苛责备也。文帝性颇仁柔，慈恕恭俭，虽有爱民之美，优游退逊、尚多怠废之政。不究其弊所不免，概以安且治当之，愚也。不究其才所不能，概以政之安且治颂之，谀也。

　　陛下自视，于汉文帝何如？陛下天资英断，睿识绝人，可为尧、舜，可为禹、汤、文、武，下之如汉宣之厉精，光武之大度，唐太宗之英武无敌，宪宗之志平僭乱，宋仁宗之仁恕，举一节可取者，陛下优为之。即位初年，铲除积弊，焕然与天下更始。举其大概：箴敬一以养心，定冠履以定分，除圣贤土木之象，夺宦官内外之权，元世祖毁不与祀，祀孔子推及所生。天下忻忻，以大有作为仰之。识者谓辅相得人，太平指日可期，非虚语也，高汉文帝远甚。然文帝能充其仁恕之性，节用爱人，吕祖谦称其能尽人之才力，诚是也。一时天下虽未可尽以治安予之，然贯朽粟陈，民物康阜，三代后称贤君焉。

　　陛下则锐精未久，妄念牵之而去矣。反刚明而错用之，谓长生可得，而一意玄修。富有四海不曰民之脂膏在是也，而侈兴土木。二十余年不视朝，纲纪驰矣。数行推广事例，名爵滥矣。二王不相见，人以为薄于父子。以猜疑诽谤戮辱臣下，人以为薄于君臣。乐西苑而不返宫，人以为薄于夫妇。天下吏贪将弱，民不聊生，水旱靡时，盗贼滋炽。自陛下登极初年亦有这，而未甚也。今赋役增常，万方则效。陛下破产礼佛日甚，室如悬罄，十余年来极矣。天下因即陛下改元之号而臆之曰：“嘉靖者言家家皆净而无财用也。”

　　迩者，严嵩罢相，世蕃极刑，差快人意一时称清时焉。然严嵩罢相之后，犹之严嵩未相之先而已，非大清明世界也。不及汉文帝远甚。天下之人不直陛下久矣，内外臣工之所知也。知之，不可谓愚。《诗》云：“衮职有阙，惟仲山甫补之。”今日所赖以弼棐匡救，格非而归之正，诸臣责也。夫圣人岂绝无过举哉？古者设官，亮采惠畴足矣，不必责之以谏。保氏掌谏王恶，不必设也。木绳金砺，圣贤不必言之也，乃修斋建醮，相率进香，天桃天药，相率表贺。建兴宫室，工部极力经营；取香觅宝，户部差求四出。陛下误举，诸臣误顺，无一人为陛下正言焉。都俞吁咈之风，陈善闭邪之义，邈无闻矣；谀之甚也。然愧心馁气，退有后言，以从陛下；昧没本心，以歌颂陛下，欺君之罪何如？

　　夫天下者，陛下之家也，人未有不顾其家者。内外臣工有官守、有言责，皆所以奠陛下之家而磐石之也。一意玄修，是陛下心之惑也。过于苛断，是陛下情之伪也。而谓陛下不顾其家，人情乎？诸臣顾身家以保一官，多以欺败，以赃败，不事事败，有不足以当陛下之心者。其不然者，君心臣心偶不相值也，遂谓陛下为贱薄臣工。诸臣正心之学微，所言或不免己私，或失详审，诚如胡寅扰乱政事之说，有不足以当陛下之心者。其不然者，君意臣意偶不相值也，遂谓陛下为是己拒谏。执陛下一二事不当之形迹，亿陛下千百事之尽然，陷陛下误终不复，诸臣欺君之罪大矣。《记》曰：“上人疑则百姓惑，下难知则君长劳。”今日之谓也。

　　为身家心与惧心合，臣职不明，臣以一二事形迹既为诸臣解之矣。求长生心与惑心合，有辞于臣，君道不正，臣请再为陛下开之。

　　陛下之误多矣，大端在修醮。修醮所以求长生也。自古圣贤止说修身立命，止说顺受其正。盖天地赋予于人而为性命者，此尽之矣。尧、舜、禹、汤、文、武之君，圣之盛也，未能久世不终。下之，亦未见方外士自汉、唐、宋存至今日。使陛下得以访其术者陶仲文，陛下以师呼之，仲文则既死矣。仲文尚不能长生，而陛下独何求之？至谓天赐仙桃药丸，怪妄尤甚。伏羲氏王天下，龙马出河，因则其文以画八卦。禹治水时，神龟负文而列其背，因而第之，以成九畴。河图洛书实有此瑞物，以泄万古不传之秘。天不爱道而显之圣人，借圣人以开示天下，犹之日月星辰之布列，而历数成焉，非虚妄也。宋真宗获天书于乾佑山，孙奭谏曰：“天何言哉？岂有书也？”桃必采而后得，药由人工捣以成者也。兹无因而至，桃药是有足而行耶？天赐之者，有手执而付之耶？陛下玄修多年矣，一无所得。至今日，左右奸人逆陛下玄修妄念，区区桃药之长生，理之所无，而玄修之无益可知矣。

　　陛下又将谓悬刑赏以督率臣下，分理有人，天下无不可治，而玄修无害矣乎？夫人幼而学，既无致君泽民异事之学，壮而行，亦无致君泽民殊用之心。《太甲》曰：“有言逆于汝志，必求诸道，有言逊于汝志，必求诸非道。”言顺者之未必为道也。即近事观：严嵩有一不顺陛下者乎？昔为贪窃，今为逆本。梁材守道守官，陛下以为逆者也，历任有声，官户部者以有守称之。虽近日严嵩抄没、百官有惕心焉，无用于积贿求迁，稍自洗涤。然严嵩罢相之后，犹严嵩未相之前而已。诸臣宁为严嵩之顺，不为梁材之执。今甚者贪求，未甚者挨日。见称于人者，亦廊庙山林交战热中，鹘突依违，苟举故事。洁己格物，任天下重，使社稷灵长终必赖之者，未见其人焉。得非有所牵制其心，未能纯然精白使然乎？陛下欲诸臣惟予行而莫违也，而责之以效忠；付之以翼为明听也，又欲其顺乎玄修土木之娱：是股肱耳目不为腹心卫也，而自为视听持行之用。有臣如仪、衍焉，可以成“得志与民由之”之业，无是理也。

　　陛下诚知玄修无益，臣之改行，民之效尤，天下之安与不安、治与不治由之，幡然悟悔，日视正朝，与宰辅、九卿、侍从、言官讲求天下利害，洗数十年君道之误，置其身于尧、舜、禹、汤、文、武之上，使其臣亦得洗数十年阿君之耻，置其身于皋陶、伊、傅之列，相为后先，明良喜起，都俞吁咈。内之宦官宫妾，外之光禄寺厨役，锦衣卫恩荫，诸衙门带俸，举凡无事而官者亦多矣。上之内仓内库，下之户、工部，光禄寺诸厂，段绢、粮料、珠定、器用、木材诸物，多而积于无用，用之非所宜用，亦多矣。诸臣必有为陛下言者。诸臣言之，陛下行之，此则在陛下一节省间而已。京师之一金，田野之百金也。一节省而国有余用，民有盖藏，不知其几也。而陛下何不为之？

　　官有职掌，先年职守之正、职守之全而未行之。今日职守之废、职守之苟且因循，不认真、不尽法而自以为是。敦本行以端士习，止上纳以清仕途，久任吏将以责成功，练选军士以免召募，驱缁黄游食以归四民，责府州县兼举富教使成礼俗，复屯盐本色以裕边储，均田赋丁差以苏困敝，举天下官之侵渔，将之怯懦，吏之为奸，刑之无少姑息焉。必世之仁，博厚高明悠远之业，诸臣必有陛下言者。诸臣言之，陛下行之，此则在陛下一振作间而已。一振作而诸废具举，百弊铲绝，唐、虞三代之治粲然复兴矣，而陛下何不行之？

　　节省之，振作之，又非有所劳于陛下也。九卿总其纲，百职分其任，抚按科道纠举肃清之于其间，陛下持大纲、稽治要而责成焉。劳于求贤，逸于任用如天运于上，而四时六气各得其序，恭己无为之道也。天地万物为一体，固有之性也。民物熙洽，熏为太和，而陛下性分中自有真乐矣。可以赞天地之化育，则可与天地参。道与天通，命由我立，而陛下性分中自有真寿矣。此理之所有者，可旋至而立有效者也。若夫服食不终之药，遥望轻举，理之所无者也。理之所无，而切切然散爵禄，竦精神，玄修求之，悬思凿想，系风捕影，终其身如斯而已矣，求之其可得乎？

　　夫君道不正，臣职不明，此天下第一事也。于此不言，更复何言？大臣持禄而外为谀，小臣畏罪而面为顺，陛下有不得知而改之行之者，臣每恨焉。是以昧死竭忠，惓惓为陛下言之。一反情易向之间，而天下之治与不治，民物之安与不安决焉，伏惟陛下留神，宗社幸甚，天下幸甚。臣不胜战栗恐惧之至，为此具本亲赍，谨具奏闻。

感想#

　　海瑞上疏前据传已经买好了棺材抬至家中，并且遣散了家人童仆，抱定了必死的决心。嘉靖看后自然大怒，立马将海瑞关入监狱，但最终却因为种种原因没有处决海瑞。这里面包括了嘉靖对自己名声的顾虑、对儿子裕王（即后来的隆庆帝）的考虑、徐阶为首的内阁干涉、甚至是嘉靖自己的良心发现等等。本文不具体展开探讨每一条原因，而是更想从海瑞的角度聊一聊海瑞上疏这件事本身的意义。

　　嘉靖当朝四十余年，这其中大部分时间里朝堂为严党把持，败坏朝纲、祸国殃民。海瑞在地方任职时期就已经看不惯严党对国家的祸害，并与巡视的严党官员鄢懋卿产生了矛盾，还因此吃了弹劾被降调到偏远的兴国县。尽管嘉靖晚年开始打击严党，但却“倒严而不倒严嵩”，令天下人大失所望。更糟的是，百姓的生活并没有随着严党垮台而回归正常，甚至“犹之严嵩未相之先而已”。于是海瑞抓住根本，选择直接向嘉靖帝上疏。海瑞用词诚恳，观点实事求是，他第一次让修道数十年的嘉靖听到了真话；并且海瑞在针砭时弊的同时也提出了一定的建议，实务性强，没有不着边际的废话。此外，海瑞是几乎无党无私的道德标兵，如左传所言“无暇者可以戮人”，嘉靖找不出他上疏的特殊动机，因此只能选择将文章看下去。换作是其他人，嘉靖第一反应可能是此人结党营私、受人指使。

　　很多人会质疑海瑞这样的上疏并不能改变现实，又或者其实海瑞所作所为与历史上的其他谏臣并无二致。这里仍旧要抛出我们最开始探讨的主题 - 海瑞上疏这件事本身的意义。嘉靖一直信奉“云在青天水在瓶”，他指望着大臣们各司其职、各安其位，自己就能坐享其成专心修道了，而这样的必然后果就是“二十余年不视朝，纲纪驰矣”。其他大臣知其弊却不敢提出，海瑞却做到了，他的《治安疏》就是万马齐喑时捅破天的一道霹雳。同时，海瑞上疏的动力还是基于海瑞本人绝对的“忠” - 忠于君主、忠于国家。海瑞本人无党无私，个人家庭生活几乎可以用“一贫如洗”形容，在此前提下海瑞的人生价值便几乎全部奉献了给了君主与国家。我不确定当年海瑞上疏前经历了怎样的内心波动，但他能做出这样的决定已经让四百多年后的我肃然起敬。每个时代都需要一个海瑞，这样的人或许会因为人至察而无徒，但是他们的勇气和信念一定能成为浊世中的最后一抹光亮，照耀他人前行。

日语发音

Sun, 27 Feb 2022 00:00:00 GMT

参考B站梦子老师教程和B站阿飞老师教程入门学习日语，以下是日语基础发音规则部分的学习记录。

简介#

日本文字的组成#

汉字
- 几百年间陆续从中国传入，但部分汉字是日文仿造中文新创造而成的，例如辻(つじ)
- 无论是字形还是字义，中日汉字经过演化后差异的程度不同，有的依然完全相同，也有的差异很大
- 发音上，衍生出了音读和训读
  - 音读：模仿中国古汉语的发音
  - 训读：日文固有发音，借用中文汉字表意
假名
- 由平假名和片假名组成；平假名和片假名一一对应，表意相同，但写法不同
  - 平假名：把假借而来的汉字平易简化，来自汉字草书，书写柔美圆润
  - 片假名：取假借汉字的一部分，多取自偏旁部首，来自汉字楷书，书写刚劲有力
- 大多数场合下使用平假名书写文字，但某些特殊场合一般使用片假名（不局限，有时为了凸显强调也可以刻意将平假名写成片假名形式，可类比英语字母中的单词全大写）
  - 外来语
  - 拟声拟态词
  - 动植物名称
罗马字
- 使用拉丁字母表示日语发音，便于和国际化接轨
- 常见使用范围
  - 招牌广告上的字母
  - 输入法录入文字

声调#

两种基本规则
- 单词第一个音节和第二个音节高低相反
- 一个单词的声调中，只有0处/1处下降这两种情况
两种表记方法
- 数字表记法
  - 在单词后添加⓪①②③④⑤这样的数字标记，表示声调核，即最后一个高读音节（②代表第二个假名是高读，此后全部为低。以此类推）
  - 官方词典多采用此法
- 横线标记法
  - 在假名上标记横线与竖线。横线代表高音，竖线代表下降，竖线之后的音不能高读
  line-tone.png
四种类型
- 平板型：一低二高一直高，助词也高。数字表记用⓪表示。
- 头高型：一高二低一直低，助词也低。数字表记用①表示。
- 中高型：两头低中间高，助词低。数字表记可能是②、③……
- 尾高型：一低二高一直高，助词低。数字表记与单词的长度相等（在此之后还有助词，助词不计入单词长度）

五十音#

总览#

50.png

将日语的所有假名以元音、子音为分类依据进行排列
表的横向为“行”，共有10行；纵向为“段”，共有5段
每行每段包含一个平假名、一个片假名、一个罗马音。三者一一对应
第一行あ行为元音行，日语中一共只有这一行的五个元音；其他行中的假名，都是根据这一段的元音，在元音之前搭配一个辅音拼读而成

あ行#

a.png

i.png

u.png

e.png

o.png

あい(愛)①：爱
え(絵)①：画
あおい(青い)②：蓝色
うお(魚)⓪：鱼

か行#

ka.png

ki.png

ku.png

ke.png

ko.png

いか(烏賊)⓪：鱿鱼
えき(駅)①：车站
いけ(池)②：池塘
かく(書く)①：书写
かお(顔)⓪：脸
あき(秋)①：秋天
あかい(赤い)⓪：红色
いく(行く)⓪：去
かき(柿)⓪：柿子
かかく(価格)⓪：价格

さ行#

sa.png

shi.png

su.png

se.png

so.png

すし(寿司)①②：寿司
さけ(酒)⓪：酒
おかし(お菓子)②：点心
せがい(世界)①：世界
あさ(朝)①：早上
かそく(加速)⓪：加速

た行#

ta.png

chi.png

tsu.png

te.png

to.png

たこ①：章鱼
いと(糸)①：线
て(手)①：手，手掌
とかい(都会)⓪：城市
あつい(暑い)②：热
たつ(立つ)①：站立

な行#

na.png

ni.png

nu.png

ne.png

no.png

いぬ(犬)②：狗
ねこ(猫)①：猫
にく(肉)②：肉
のき(軒)⓪：屋檐
なつ(夏)②：夏天
あに(兄)①：哥哥

は行#

ha.png

hi.png

fu.png

he.png

ho.png

はな(花)②：花
はし(橋)②：桥
ひたい(額)⓪：额头
ほし(星)⓪：星星
へた(下手)②：不擅长
ふさい(夫妻)①②：夫妻

ま行#

ma.png

mi.png

mu.png

me.png

mo.png

まち(街)②：街道
あめ(雨)①：雨
かいもの(買い物)⓪：购物
かみ(髪)②：头发
むすめ(娘)③：女儿
むし(虫)⓪：虫子

や行#

ya.png

yu.png

yo.png

やおや(八百屋)⓪：果蔬店
おかゆ(お粥)⓪：粥
よなか(夜中)⓪：半夜
やすみ(休み)③：休息

ら行#

ra.png

ri.png

ru.png

re.png

ro.png

さくら(桜)⓪：樱花
くすり(薬)⓪：药
かれし(彼氏)①：男朋友
はしる(走る)②：奔跑
ロシア①：俄罗斯

わ行#

wa.png

wo.png

にわ(庭)⓪：院子
わらう(笑う)⓪：笑

浊音/半浊音#

表记方式：浊音在假名上加两点，半浊音在假名上加一个圆圈。

ka -> ga#

kaga.png

かいがい(海外)①：海外
およぐ(泳ぐ)②：游泳
かげ(影)①：影子
いちご(苺)⓪：草莓
かいぎ(会議)①③：会议
かぐ(家具)⓪：家具
かがく(科学)①：科学
げか(外科)⓪：外科

sa -> za#

saza.png

注意“shi”转化后变成了“ji”

みずうみ(湖)③：湖
ちず(地図)①：地图
ふくざつ(複雑)⓪：复杂
じこ(事故)①：事故
かぜ(風邪)⓪：感冒
しじ(指示)①：指示

ta -> da#

tada.png

注意“chi”转化后变成了“ji”，“tsu”转化后变成了“zu”

くだもの(果物)②：水果
ちじむ(縮む)⓪：缩小
ドア①：门
でぐち(出口)①：出口
いだい(偉大)⓪：伟大

寒暄语：

ただいま：我回来了
いただきます：我开动了

ha -> ba, ha -> pa#

bahapa.png

バイク①：摩托车
ながれぼし(流れ星)③：流星
ピアス①：耳钉，耳环
ピアノ⓪：钢琴
パス⓪：pass
ぶた(豚)⓪：猪

拗音/合拗音#

拗音#

起源：模仿中国古代汉语的发音产生
规则：い段假名（除い、ぢ之外）+ 小一号书写的[やゆよ]。片假名也符合这一规律
发音：两个假名视为整体，拼读成一拍。需要特别注意视为整体后单词中高读的音节位置

ao.png

单词示例：

おちゃ(お茶)⓪：茶
ジャズ①：爵士乐
しゅくしゃ(宿舎)②：宿舍
しょくぶつ(植物)②：植物

寒暄语：

おじゃま(邪魔)します：打扰了。通常用于进门，出门可以换成おじゃま(邪魔)しました

合拗音#

起源：明治维新后为了模仿西方外来语的发音而产生。专门用于表记外来语，因此只有片假名无平假名
规则：仍然是辅音假名 + 小一号假名（元音或者yu）书写的合读形式，拼接规则更加随意，没有明显的规律

ex_ao.png

单词示例：

フィルム①：胶卷
プロジェクト②③：项目
チェス①：国际象棋
サファイア②：蓝宝石

特殊音节#

拨音#

写法#

んン Nn / n

nn.png

发音#

拨音发音往往受之后的音节影响。一般而言有三种情况：

[ばぱま]行，发音为”m”
- さんぽ(散歩)
[ただらな]行，发音为”n”
- ほんらい(本来)
- しんねん(新年)
其他行发音为“ng”
- へんか(変化)
- れんあい(恋愛)

如果类比汉语拼音中的鼻音，可以近似为：

あ段转化为ang
い段转化为in
う段转化为un
え段转化为en
お段转化为ong

示例#

单词：

ワイン①：红酒
ふじさん(富士山)①：富士山
げんき(元気)①：元气，精神
プレゼント②：礼物
しゅんかん(瞬間)⓪：瞬间
チャンス①：机会

促音#

写法#

っ/ッ，输入法输入时在前面加”x”
罗马字：双写促音后一个假名的第一个辅音字母
- みっつ(mi ttsu)
- ペット(pe tto)

发音#

促音给人以顿促的感觉，需要在原来连续的两个发音之间插入一段间隙。可以分为两种类型：

[かたぱ]行之前，称为阻塞促音。过程：憋一口气形成阻塞 -> 做好下一个音的口型准备 -> 放开气流疾冲而出
- さっき(sa kki)
- もっと(mo tto)
- いっぱい(i ppai)
さ行之前，称为摩擦促音。基本不停止发音，而是摩擦发出s的音
- まっすぐ(ma ssgu)
- ざっし(za sshi)
- いっさい(i ssai)

示例#

单词：

きって(切手)⓪：邮票
けっこん(結婚)⓪：结婚
ペット①：宠物
チケット①②：门票
こっか(国家)①：国家
せっけん(石けん)⓪：肥皂

寒暄语：

いらっしゃいませ：欢迎光临
行ってきます：我走了
行ってらっしゃい：慢走

长音#

写法#

平假名和片假名分别有不同的标记方式，其中平假名又根据不同段进行了区分：

平假名：

あ段 + あ，例如おかあさん、おばあさん
い段 + い，例如おにいさん、いいえ
う段 + う，例如つうやく
え段 + い（多数情况下），例如せんせい
え段 + え（少数情况下），例如おねえさん、ええと
お段 + う（多数情况下），例如おとうさん、おとうと
お段 + お（少数情况下），例如とおい、おおさか
い段 + や + あ，例如じゃあ
い段 + ゆ + う，例如りゅうがく
い段 + よ + う，例如りょうり

片假名：

加一条横线“ー”，例如スーパー、コーヒー、チャーハン、コンピューター

规律：

长音符号只有第一行的五个元音假名；但是单词中有元音假名时并不一定意味着有长音。需要特别小心判断这个元音和前一个假名是否符合长音组合规则。

发音#

延长前一个音节的发音，发满两个音节的长度。注意不再是念这个假名本身的发音。

示例#

单词：

おいしい(美味しい)⓪③：好吃
はつもおで(初詣)③：初次参拜神社
ごうかく(合格)⓪：合格
すもう(相撲)⓪：相扑
サッカー①：足球
テーブル⓪：桌子
べんきょう(勉強)⓪：勤奋
こきゅう(呼吸)⓪：呼吸
きゅうり(胡瓜)①：黄瓜
ちゅうい(注意)①：注意
ニュース①：新闻
ジャーナリスト④：记者

寒暄语：

おはようございます：早上好
ありがとうございます：谢谢
どういたしましで：不，不用谢
ご馳走様(ちそうさま)でした：我吃好了
さようなら：再见，有永别/分手的意味，或是正式场合的道别

发音特殊规则#

送气音/非送气音#

[かたぱ]这三行的音根据单词中所处位置的不同，发音有两种

位于词头，送气音
- かお(顔)⓪：脸
- たこ①：章鱼
位于词中或词尾，不送气音
- つくえ(机)⓪：桌子
- たつ(立つ)①：站立

注意非送气音只是适度削弱读音气流的强度，但不能完全发成浊音，写法上更不能与浊音假名混淆。依然推荐写什么假名就读对应发音，这样一定不会出错。

浊音/鼻浊音#

が行根据位置不同发音有两种：

位于词头，浊音，发“ga”
- ぐあい(具合)⓪：情形
- ごい(語彙)①：词汇
位于词中或词尾，发浊音或者鼻浊音均可。鼻浊音可以近似理解为”n + ga”的组合，快速连读为nga, ngi等等
- かがく(科学)①：科学
- かげ(影)①：影子

目前鼻浊音主要由日本的播音员、老年人、女性使用，但也有很多年轻人更习惯使用正常的浊音。

发音相同的两组浊音#

[じぢ]分别对应了ji，而[ずづ]分别对应了zu。一般而言使用ji默认代表じ，而使用zu默认代表ず。但也有少数特例，例如つづく(未完待续)
文字录入时，ぢ要打成di，づ要打成du（相当于回归原先的ta -> da转化方式）

日语课文

Sun, 27 Feb 2022 00:00:00 GMT

参考B站梦子老师教程和B站阿飞老师教程入门学习日语，以下是《新版标准日本语》课文的学习记录。

1 小李是中国人#

单词#

国家：

ちゅうごくじん(中国人)④：中国人
にほんじん(日本人)④：日本人
かんこくじん(韓国人)④：韩国人
アメリカ人④：美国人
フランス人④：法国人

城市：

とうきょう(東京)⓪：东京
ペキン(北京)①：北京
しゃんはい(上海)①：上海

学校：

がくせい(学生)⓪：学生
せいと(生徒)①：学生
りゅうがくせい(留学生)③：留学生
けんしゅうせい(研修生)③：进修生
きょうじゅ(教授)⓪：教授
だいがく(大学)⓪：大学

企业：

しゃいん(社員)①：职员
かいしゃいん(会社員)③：公司职员
かちょう(課長)⓪：科长
しゃちょう(社長)⓪：总经理
てんいん(店員)①：店员
きぎょう(企業)①：企业
きかく(企画)①：策划公司
りょこうしゃ(旅行者)②：旅行社

动词：

でむかえ(出迎え)⓪：迎接

人称：

わたし(私)⓪：我
ちち(父)①②：父亲
ひと(人)⓪：人
あのひと(あの人)②：那个人
あなた②：你
くん(君)：称呼年纪相仿，或者年纪比自己小的男性
さん：基本男女都可以使用，但只用于他人的姓名后，不用于自己的姓名后

助词、副词：

どうも①：非常，很
はい①：是，是的
いいえ③：不，不是
ちがいます④：不是，可与“いいえ”连用
あっ：哎，哎呀。一般是吃惊或者有所感触时发出的声音，例如“あっ、すみません”
そうです①：是这样

寒暄语：

こんにちは⑤：你好
こんばんは⑤：晚上好
すみません④：对不起，打扰了（更正式一些的道歉）
ごめんなさい：对不起
初めまして④：初次见面
わかりません⑤：我不知道

人名：

注意大部分日文名声调都是⓪型，当不确定名字发音时首选用这个发音去读；其次是①型

もり(森)⓪：森
はやし(林)⓪：林
おの(小野)⓪：小野
よしだ(吉田)⓪：吉田
たなか(田中)⓪：田中
なかむら(中村)⓪：中村
たろう(太郎)①：太郎
さとう(佐藤)①：佐藤
たかはし(高橋)②：高桥

语法#

(名)は (名)です

可理解为汉语中的“A者，B也”，或者“A是B”。前面的“Aは”是主语部分，注意助词“は”用于提示主题（A是这句的主题），因此要发“わ”的音；后面的“Bです”是谓语，“です”可以当成“是”来理解。
- 私は中国人です
- 李さんは日本人です
- 私は学生です
(名)は (名)ではありません

可理解为汉语中的“A不是B”。“では”在口语中也可以用“じゃ”代替，但书面语等正式场合不能使用
- 私は日本人ではありません
- 私は田中ではありません
(名)は (名)ですか

可理解为汉语中的“A是B吗”。助词“か”放在句尾表示疑问，但注意日语的问句在句尾不使用问号，并且回答时一般只有“はい”和“いいえ”两种回答。
- あなたは佐藤さんですか。はい、佐藤です（如果懒得重复一遍，也可以直接はい、そうです）
- キムさんは中国人ですか。いいえ、中国人ではありません。韓国人です（如果懒得重复一遍，也可以直接いいえ、ちがいます）
- 吉田さんですか。いいえ、ちがいます。小野です。
(名)の(名)

一般情况下“の”相当于汉语“的”的意思。助词“の”连接两个名词，表示前面的名词是后面名词从属的机构、国家和属性。
- 李さんは JC企画の社員です
- 北京旅行者は中国の企業です
- 私は北京大学の学生です

其他：

第二人称的使用

在不知道对方姓名而又必须招呼的时候，才会使用第二人称“あなた”，否则用多了会显得很不礼貌。“君”同理。
省略

あなたは佐藤さんですか。はい、（私は）佐藤です。这边的“私は”就是被省略的部分，因为总是被重复很啰嗦。否定句中同样可以这样省略。
初次见面请多关照的用法

完整向人打招呼以及回复流程：
- 初めましで、李です。どうぞよろしくお願いします。“どうぞ” 一般指代“请”做什么事
- こちらこそ、(どうぞよろしくお願いします)
注意回复时一般不需要重复一遍，只要讲到“こちらこそ”即可，后面往往被省略。

2 这是书#

单词#

地名：

ながしま(長島)⓪：长岛
スワトウ(汕頭)②：汕头
ロンドン①：伦敦

办公用具：

ほん(本)①：书
かばん(かばん)⓪：公文包
ノート⓪：笔记本
えんぴつ(鉛筆)⓪：铅笔
てちょ(手帳)⓪：记事本

生活用品：

かさ(傘)①：伞
くつ(靴)②：鞋子
おみやげ(お土産)⓪：礼物
めいさんひん(名産品)⓪：特产
シルク①：丝绸
ハンカチ⓪：手绢
しんぶん(新聞)⓪：报纸
ざっし(雑誌)⓪：杂志
じしょ(辞書)①：词典
しゃしん(写真)⓪：照片

电器：

カメラ①：照相机
デジカメ⓪：数码照相机
テレビ①：电视
パソコン⓪：个人电脑（注意这个单词来自于personal 和 computer两个单词片假名的前缀合并）
ラジオ①：收音机
でんわ(電話)⓪：电话

家具：

つくえ(机)⓪：桌子
いす(椅子)⓪：椅子
かぎ(鍵)②：钥匙
とけい(時計)⓪：时钟

交通工具：

くるま(車)⓪：车
じてんしゃ(自転車)⓪：自行车

人称：

かた(方)②：（敬称）位、人
かぞく(家族)⓪：家人、家属
はは(母)①：（我）母亲
おかあさん(お母さん)①：母亲

指示代词：

これ⓪：这，这个
この⓪：这，这个（连体，后面接名词）
それ⓪：那，那个
その⓪：那，那个（连体，后接名词）
あれ⓪：那，那个（指代的事物在距离上往往会比それ更远一些）
あの⓪：那，那个（连体，后接名词）
どれ①：哪，哪个
どなた①：哪，哪个（比起どれ更适合面对年龄大、地位高的对象使用）
どの①：哪，哪个（连体，后接名词）
なん(何)①：什么
だれ(誰)①：谁

语法#

これ/それ/あれは (名)です

说话人和听话人相隔一段距离面对面时：
- これ指代离说话人较近的事物
- それ指代离听话人较近的事物
- あれ指代离双方都有些距离的事物
说话人和听话人处于同一位置，并且面向同一方向时：
- これ指代的物体距离最近
- それ指代的物体距离较远
- あれ指代的物体距离更远
- どれ指代的物体距离不明，用于疑问
例句：
- これは本です
- それはかばんです
- あれはテレビです
誰ですか / 何ですか

“誰”用于不知道是什么人，而“何”用于不知道是什么事物
- それは何ですか
- あの人は誰ですか
注意”誰”通常用于对方与自己地位相当，或者比自己地位低。如果是尊长或者地位更高的人，要用“どたな”，例如：どなたさんですか
この/その/あの (名)は (名)のです

修饰名词，表示的位置关系和これ/それ/あれ对应相同
- このカメラはスミスのです
- その自転車は森さんのです
- あのノートは誰のですか
注意，第二个(名)の后面相当于省略了第一个(名)，避免重复一遍
どれ/どの (名) ですか

どれ/どの是在无法用これ/それ/あれ确定事物时，所用的疑问句式。
- 森さんのかばんはどれですか
- 長島さんの傘はどれですか
- 小野さんの机はどの机ですか
注意，这里的どの后面的名词不可以省略

其他：

“方”的使用

一般是一个人的尊称，例如“この方”、“その方”等等，尊称这位、那位，适合指代长辈。
问年龄

最直接的问法就是“何歳”或者“幾つ”(いくつ)，但不适用于直接向年长的人发问。如果要稍微礼貌一些，可以各自加一些修饰语，例如“何歳ですか”或者“お幾つ”
“はい”和“ええ”的区别

二者大部分时候可以互相替代使用，不过“はい”稍微礼貌一些。另外当别人叫到自己名字时，必须用“はい”应答

3 这里是商场#

单词#

地点：

ばしょ(場所)①：场所
デパート②：百货商店
しょくどう(食堂)⓪：食堂
ゆうびんきょく(郵便局)③：邮局
ぎんこう(銀行)⓪：银行
としょかん(図書館)②：图书馆
マンション①：豪华公寓
ホテル①：宾馆
コンビニ⓪：便利店
きっさてん(喫茶店)⓪：咖啡店
びょういん(病院)⓪：医院
ほんや(本屋)①：书店
レストラン①：餐厅
ビル②：大楼、大厦
たてもの(建物)②：大楼，建筑物
トイレ①：厕所
おてあらい(お手洗い)②：洗手间
じむしょ(事務所)②：事务所
うりば(売り場)⓪：柜台、出售处
いりぐち(入口)⓪：入口
うけつけ(受付)⓪：接待处
bargain かいじょう(バーゲン会場)⑤：降价大卖场
エスカレーター④：自动扶梯

服饰：

ふく(服)②：衣服
コート①：风衣、大衣
セーター①：毛衣

地理：

くに(国)⓪：国家
ちず(地図)①：地图

方位：

となり(隣)⓪：旁边
しゅうへん(周辺)⓪：附近，周边
ここ⓪：这里
そこ⓪：那里
あそこ⓪：那里，距离比そこ更远
こちら⓪：这边
そちら⓪：那边
あちら⓪：那边，距离比そちら更远
どこ⓪：哪里
どちら⓪：哪边

日期：

きのう(昨日)①：昨天
きょう(今日)①：今天
あした(明日)②：明天
げつようび(月曜日)③：星期一
かようび(火曜日)②：星期二
すいようび(水曜日)③：星期三
もくようび(木曜日)③：星期四
きんようび(金曜日)③：星期五
どようび(土曜日)②：星期六
にちようび(日曜日)③：星期日

语法#

ここ/そこ/あそこは (名)です

指示场所时，用ここ/そこ/あそこ，表示的位置关系和これ/それ/あれ相同

例句：
- ここはデパートです
- そこは図書館です
- あそこは入り口です
(名) は (场所名)です

表示前一个名字“存在于”某一个场所之中，常用来指示方位
- 食堂はデパート 7階です
- トイレはここです
- 小野さんは事務所です
注意例句第三句中不能和之前学的“AはBです”混淆，即不能翻译成“小野是事务所”，因为这里前为人后为场所不能匹配，所以应当理解为小野在事务所内。日语有多种表示存在的语法，此处是其中一种可能出现的形式。
(名) はどこですか

修饰名词，表示的位置关系和これ/それ/あれ对应相同
- トイレはどこですか。あちらです
- あなたのかばんはどこですか。私のかばんはここです
(名)も (名)です

助词“も”相当于汉语的“也”，注意“も”出现时不会再有“は”
- あなたも中国人ですか。
- ここは JC企画のビルです。あそこも JC企画のビルです
(名)は (名)ですか、(名)ですか、…

答案有多种可能时，而询问其中一种时，可以重复地使用谓语“ですか”
- かばん売り場は一階ですか、二階ですか。　
- 今日は水曜日ですか、木曜日ですか。
(名)はいくらですか

询问某物的价格。
- これはいくらですか。
- この服はいくらですか。

其他：

省略已知部分

例如连续询问多个物品的价格，第一个已经用“これはいくらですか。”开头问过，之后的就可以直接“それは”、“られは”。
礼貌用语

“あちら”相比起“あそこ”会更加礼貌一些。同理“こちら”也比“ここ”更礼貌。另外，“こちら”和“あちら”也可以用来礼貌地指代“这个人/那个人”，“这位/那位”。

同理，疑问句也有这样的用法。例如询问对方来自哪个国家，用“どちら”就比”どこ”礼貌：
- お国はどちらですか
对话的开端

想要和人讲话不一定非要用“すみません”开始，也可以用更口语化的“あのう“
句尾的语气词

如果省略已知部分，以“は”结尾问问题，“は”的声调要适当上提，表示疑问。

类似的还有“ですか”，如果“か”声调上提就表示疑问，如果是下降调就表示附和或者这样啊的意思，例如”そうですか“

4 房间里有桌椅#

单词#

房子：

いま(居間)②：起居室
へや(部屋)②：房间、屋子
にわ(庭)⓪：院子
いえ(家)②：家
かべ(壁)⓪：墙壁

家具：

ほんだな(本棚)①：书架
ベッド①：床
れいぞうこ(冷蔵庫)③：冰箱
スイッチ②：开关
はこ(箱)⓪：盒子、箱子

球类：

サッカーボール⑤：足球
バスケットボール⑥：篮球
バレーボール④：排球

个人用品：

めがね(眼鏡)①：眼镜

人物：

こども(子供)⓪：孩子
おとな(大人)⓪：大人、成年人
きょうだい(兄弟)①：兄弟姐妹
りょうしん(両親)①：父母、双亲
いもうと(妹)④：妹妹
おとこ(男)③：男性
おんな(女)③：女性

方位词：

うえ(上)⓪：（绝对平面的）上面
そと(外)①：外面
なか(中)①：里面、中间
した(下)⓪：（绝对平面的）下面
まえ(前)①：前面
うしろ(後ろ)⓪：后面
ちかく(近く)①：附近
となり(隣)⓪：邻近、附近

地点：

きょうしつ(教室)⓪：教室
かいぎしつ(会議室)③：会议室
としょしつ(図書室)②：图书室
こうえん(公園)⓪：公园
はなや(花屋)②：花店
ばいてん(売店)⓪：小卖部
ちかてつ(地下鉄)⓪：地铁

生活：

ひとりぐらし(一人暮らし)④：一个人住

地名：

よこはま(横浜)⓪：横滨
なごや(名古屋)①：名古屋
おおさか(大阪)⓪：大阪

语法#

あります

あります用于花、草、桌子这种不具有意志的事物，表示这些事物“有”，“存在”。
- 某地有某物：
  
  (场所名)に (物名)があります
  
  (场所名)に何がありますか
  - 部屋に机があります
  - ここに本があります
  - 庭に何がありますが
- 某物在某地：
  
  (物名)は (场所名)にあります
  
  (物名)はどこにありますか
  - 椅子は部屋にあります
  - 本はここにあります
  - 図書館はどこにありますが
注意在实际生活中，疑问句也可以用どこですか替代，因为无论主语是否有意志都能适用。
います

います用于人、动物这种具有意志的事物，表示这些事物“有”，“存在”。
- 某地有某物：
  
  (场所名)に (动物名)がいます
  
  (场所名)に誰がいますか
  - 部屋に猫がいます
  - 公園に子供がいます
  - あそこに誰がいますが
- 某物在某地：
  
  (动物名)は (场所名)にいます
  
  (动物名)はどこにいますか
  - 吉田さんは庭にいます
  - 子供は公園にいます
  - 犬はどこにいますが
注意在实际生活中，疑问句也可以用どこですか替代，因为无论主语是否有意志都能适用。
(名)と(名)

助词と加在两个名词之间表示并列，相当于汉语的“和”
- 時計と眼鏡
- ビールとウィスキー
结合上面学的存在句式：
- 居間にテレビとビデオがあります
- コーラーとケーキは冷蔵庫にあります
方位形容

(名)の(方位)
- 机の上に猫がいます
- 会社の隣に花屋あります
- 猫は箱の中にいます
- 売店は駅の外にあります
ね

当说话人就某事征求听话人的意见时，句尾用“ね”读声调。（听起来会有一些娘，多用于女性）
- この新聞は林さんのですね
- 駅の前に銀行がありますね
疑问句 + も + 否定动词

强调“完全没有“，”什么也没有“
- 教室に誰もいません
- 冷蔵庫に何もありません
- 部屋に誰もいません

Java底层

Sun, 06 Feb 2022 00:00:00 GMT

从更底层的角度了解Java。

集合(Collections)#

Java数组#

所谓数组，是相同数据类型的元素按一定顺序排列的集合。Java中一般来说有三种声明数组的方式：

1
// method1
2
char[] array1 = {'a', 'b', 'c'};
3

4
// method2
5
char[] array2 = new char[]{'a', 'b', 'c'};
6

7
// method3
8
char[] array3 = new char[3];
9
array[0] = 'a';
10
array[1] = 'b';
11
array[2] = 'c';

这三种写法看似有明显的区别，然而经过反编译之后会发现，它们都被转化成了同一种写法。也就是说，这三种写法的实质操作是一样的，并且每一个数组都是按顺序排列在堆内存中，这使得我们可以通过下标的方式来直接访问数组里的元素。

看完一维数组，二维数组基本也弄懂了。在堆内存中，与其说是“二维数组”，倒不如说是“二级数组”，第一维数组更像是索引，指向若干个随机分布的第二维数组起始地址：

2DArray.png

最后如果更加详细地查看每个数组的属性和方法，会发现Object类的方法它基本都有，并且还额外多了一些很有用的属性（例如length）。因此，在Java层面，完全可以把数组当成对象看待。

HashMap#

底层实现#

结构来看源代码中HashMap的实现：

1
transient Node<K,V>[] table;
2
static class Node<K,V> implements Map.Entry<K,V> {
3
    final int hash;
4
    final K key;
5
    V value;
6
    Node<K,V> next;
7
}

可以看到 HashMap 内部存储使用了一个 Node 数组(默认大小是16)，而 Node 类包含一个类型为 Node 的 next 的变量，也就是相当于一个链表。所有根据 hash 值计算的 bucket 一样的 key 会存储到同一个链表里。从jdk 1.8开始，中如果 hash 值相同的 key 数量大于指定值(默认是8)时，会使用红黑树来代替链表，这会将get()方法的性能从O(n)提高到O(logn)。
插入元素在jdk 1.7以及之前，HashMap插入元素到单链表时，采用头插入法，在扩容时需要重新计算哈希值和索引位置，会改变链表中元素原本的顺序，以至于在并发场景下有可能导致链表成环。而从jdk1.8开始，HashMap采用尾插入法，在扩容时会保持链表元素原本的顺序，就不会出现链表成环的问题了。元素插入时，流程图如下：

hashmap-put.png

hash算法#

不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的离散性能。这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

JDK 1.8开始，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用方法一所计算得到的Hash码值总是相同的。

自动扩容机制#

HashMap 内部的 Node 数组默认的大小是16。

假设有100万个元素，那么最好的情况下每个 hash 桶里都有62500个元素，这时get(), put(), remove()等方法效率都会降低。为了解决这个问题，HashMap 提供了自动扩容机制，当元素个数达到数组大小 loadFactor 后会扩大数组的大小，在默认情况下，数组大小为16，loadFactor 为0.75，也就是说当 HashMap 中的元素超过160.75=12时，会把数组大小扩展为216=32，并且计算每个元素在新数组中的位置。

使用2的幂次，有两个主要原因：

方便hash算法中的位运算
扩容后元素均匀分布。元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。在扩充HashMap的时候，不需要重新计算hash。假如table扩容后的长度为n，只需要把n-1和原来的hash值按位与，看结果hash值高位新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引 + oldCap”。由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。

线程安全性#

不安全。考虑以下两个场景：

如果多个线程同时使用put方法添加元素，而且假设正好存在两个 put 的 key 发生了碰撞(根据 hash 值计算的 bucket 一样)，那么根据 HashMap 的实现，这两个 key 会添加到数组的同一个位置，这样最终就会发生其中一个线程的 put 的数据被覆盖。
如果多个线程同时检测到元素个数超过数组大小 * loadFactor ，这样就会发生多个线程同时对 Node 数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给 table，也就是说其他线程的都会丢失，并且各自线程 put 的数据也丢失。最糟糕的是，并发甚至可能导致死循环，因为多线程会导致 HashMap 的 Node 链表形成环形数据结构，Node 的 next 节点永远不为空。

有三种常见解决方式：

Hashtable 源码中是使用 synchronized 来保证线程安全的，当一个线程访问 HashTable 的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。这种方法安全，但是效率很低
SynchronizedMap 同步整个对象，每一次的读写操作都需要加锁，对整个对象加锁会极大降低性能
ConcurrentHashMap，性能比起前两个优越很多
- 基础数据结构与HashMap类似，JDK1.7及以前是数组 + 链表，JDK1.8开始是数组 + 链表 + 红黑树
- JDK 1.7以及之前，ConcurrentHashMap依靠HashEntry[] + Segment[] + ReentrantLock实现了分段锁，也就是将Map分割成了不同的部分，每个Segment对应若干个HashEntry，在执行更新操作时每个Segment使用单独的ReentrantLock。根据默认的并发级别(concurrency level，也就是Segment数组的长度)，Map被分割成16个部分，并且由不同的锁控制。这意味着同时可以有16个写线程操作Map。
  - 进行put操作时，ConcurrentHashMap会尝试自旋获取锁，如果获取失败肯定就有其他线程存在竞争；如果重试的次数达到了 MAX_SCAN_RETRIES 则改为阻塞锁获取，保证能获取成功
- JDK 1.8开始，由于Segment分段锁的诸多缺点（多个分段锁浪费内存空间，实际生产环境中插入新元素竞争同一个锁的概率非常小，GC效率低），ConcurrentHashMap改用了 CAS(Compare And Swap，当且仅当旧预期值和当前内存值相同时，写入新内存值) + synchronized 来保证并发安全性，此外将HashEntry改为了Node，但作用基本相同。
  - 进行put操作时，通过hashCode定位出Node，如果为空就用CAS机制尝试写入，写入失败就自旋保证成功；也有可能通过计算出来的hashCode值是MOVED(-1)，需要扩容；如果这些都不满足，就需要用synchronized锁保证写入数据。
- 允许并发的读操作，JDK 1.7以及之前只需要将 Key 通过 Hash 之后定位到具体的 Segment ，再通过一次 Hash 定位到具体的元素上；JDK 1.8之后也是通过hashCode寻址，看元素具体是在桶上、链表上还是红黑树上决定对应的遍历获取方式。读操作是非常高效的，因为整个过程都不需要加锁，这要归功于volatile关键字，使用它会强制将修改的值立即写入主内存，当线程2进行修改时，会导致线程1的工作内存中缓存变量的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效），这时线程1如果需要读取变量的值时，只能去主存读取最新值。ConcurrentHashMap中，volatile修饰了每个Node的val值以及next指针，使得线程之间具有了可见性
- 如果一个线程在遍历的同时，另一个线程尝试进行修改，ConcurrentHashMap不会抛出ConcurrentModificationException并终止遍历（快速失败）。迭代前，ConcurrentHashMap先复制了原有集合内容，并在拷贝的集合上进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到（安全失败）

ArrayList#

特点#

ArrayList是容量能动态增长的动态数组。

继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能
实现了RandmoAccess接口，提供了随机访问功能，因此可以通过元素的序号快速获取元素对象
实现了Cloneable接口，能被克隆
实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输

底层实现：Object[]数组 + size

elementData，实质是”Object[]类型的数组”，它保存了添加到ArrayList中的元素。我们能通过构造函数来设定它的initialCapacity
size变量，用于记录当前数组的实际长度

扩容机制#

添加新元素时，发现所需的最小minCapacity大于现有elementData的长度，需要调用Arrays.copyOf方法，给elementData赋值一个新的扩容数组。扩容后的newCapacity = oldCapacity + (oldCapacity >> 1)，也就是增长了原来的50%。

LinkedList#

特点#

LinkedList是一个双向链表。

底层实现：两个Node引用 + size

first: 指向链表头元素
last: 指向链表尾元素
size: 链表长度
Node：每个元素内部维护前后指针prev和next，还有值item

LinkedList和ArrayList删除性能对比#

理论而言，ArrayList查找访问快，增删效率低(O(n))；LinkedList查找访问慢，增删效率高(O(1))。实际而言，需要考虑这些场景：

如果操作的元素在List尾部，比如删掉尾元素，那么二者的性能是完全一致的，都是O(1)
对于ArrayList删除来说，耗时的操作在于List中间插入元素后，后续元素需要通过System.arrayCopy()进行复制；而对于LinkedList，需要先循环遍历到目标Node，找到之后通过修改其前后节点的引用将这个Node从链表上移除。因此待删除元素在数组中的位置十分重要，这关系到实际删除的时间是多半花在查找元素还是删除上
由于System.arrayCopy()是原生方法优化不错，因此如果需要复制的元素个数不多，这个复制是非常快的，实战中可能比LinkedList的直接循环还快，这使得ArrayList在某些时候删除元素比LinkedList快

Vector#

Vector和ArrayList的对比#

相同点：

Vector和ArrayList都是动态数组，都支持动态扩容等特性
二者都继承了List类，底层都是通过数组实现的
添加、删除等方法中除了synchronized关键字的使用，具体实现是一致的

主要区别：

Vector是线程安全的（添加、删除等的方法的声明中，有synchronized关键字），支持同步访问；而ArrayList不是
ArrayList在底层数组不够用时，在原来的基础上拓展0.5倍，而Vector拓展1倍

鉴于Vector的加锁特点，单线程的环境中尽量使用ArrayList而不是Vector，否则性能很差。

ArrayDeque#

特点#

提及ArrayDeque前，需要先介绍Java中的Deque接口。Deque的含义是“double ended queue”，即双端队列，它既可以当作栈使用，也可以当作队列使用。Deque的接口函数很多，但基本都是对对容器的两端进行操作，或添加，或删除，或查看。并且需要注意Deque中有两套接口，一套在操作失败时直接抛出异常，另一套则会返回空值。

array-deque-circular.png

ArrayDeque是Deque接口的一种实现，底层依赖于数组，为了满足可以同时在数组两端插入或删除元素的需求，该数组还必须是循环的，即循环数组（circular array），也就是说数组的任何一点都可能被看作起点或者终点。常用的操作中，需要注意以下几点：

插入、删除元素时的下标越界问题
插入元素时的扩容问题，其逻辑是申请一个更大的数组（原数组的两倍），然后将原数组复制过去。过程如下图所示

array-deque-capacity.png

需要注意，ArrayDeque是非线程安全的，当多个线程同时使用的时候，需要程序员手动同步。另外，该容器不允许放入null元素。

实现栈和队列#

Deque 具备普通队列 FIFO 的功能，同时它也具备了 Stack 的 LIFO 功能，并且保留了 push 和 pop 函数，所以基于Deque的ArrayDeque实现可谓是生逢其时，恰到好处。

按照目前Java官方的说法，ArrayDeque经过了充足优化，同时适合实现栈和队列：

Java中有一个栈的类(Stack)，但官方不推荐使用，这是因为Stack继承了Vector类。Vector类是较早Java代码中的遗留产物，因为同步锁等机制性能糟糕。而Stack 和 Vector 本来毫无关系，然而为了复用 Vector 中的方法来实现进栈、出栈等操作，被迫继承了 Vector，这使得 Stack 在基于数组实现上效率受影响。此外由于Stack继承了Vector，导致Stack可以复用Vector中的很多操作，这也使得Stack类设计不严谨
Java中没有队列类Queue，但是有Queue接口，实现时首选ArrayDeque，次选LinkedList。这是由于链表每次插入和删除都涉及到一个节点对象的创建和弃用，非常低效和浪费空间，而动态数组几乎是0花费的(数组扩容拷贝除外)；此外链表不连续，在利用CPU缓存时不如数组方便

Java中的栈、队列创建方法：

1
Deque<Integer> stack = new ArrayDeque<Integer>();
2
Deque<Integer> queue = new ArrayDeque<Integer>();

JVM#

内存模型#

jvm-memory.jpg

JVM的内存结构大概分为：

堆（Heap）：线程共享。所有的对象实例以及数组都要在堆上分配，存放对象实例和数组，也是回收器主要管理的对象
方法区（Method Area）：线程共享。存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
方法栈（JVM Stack）：线程私有。存储局部变量表、操作栈、动态链接、方法出口、对象指针、基本数据类型、对象引用
本地方法栈（Native Method Stack）：线程私有。为虚拟机使用到的Native方法服务。如Java使用C或者C++编写的接口服务时，代码在此区运行
程序计数器（Program Counter Register）：线程私有。它可以看作是当前线程所执行的字节码的行号指示器。指向下一条要执行的指令

类加载机制#

定义#

类加载：虚拟机把编译后的描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可被虚拟机直接使用的Java类型的过程

在Java语言里面，类型的加载、连接和初始化过程都是在程序运行期完成的，从而通过牺牲一些性能开销来换取Java程序的高度灵活性，因为这个时候可以进行一些动态加载、扩展等等。

流程#

类从被加载到虚拟机内存中开始、到卸载出内存为止，整个生命周期包括七个阶段：

加载
- 通过类的全限定名来获取定义此类的二进制字节流
- 将该二进制字节流所代表的静态存储结构转化为方法区的运行时数据结构，数据存储数据结构由虚拟机自行定义
- 在内存中生成一个代表这个类的java.lang.Class对象，它将作为程序访问方法区中的这些类型数据的外部接口
验证（链接第一阶段）
- 确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全，直接决定JVM能否承受恶意代码的攻击
- 文件格式：字节流是否符合Class文件格式的规范、以及是否能被当前版本的虚拟机处理
- 元数据：对类的元数据信息进行语义校验，保证不存在不符合Java语言规范的元数据信息
- 字节码：对类的方法体进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件
- 符号引用：对类自身以外（如常量池中的各种符号引用）的信息进行匹配性校验
准备（链接第二阶段）
- 为类变量（静态变量）分配内存
- 设置类变量初始值：通常情况下零值
解析（链接第三阶段）
- 虚拟机将常量池内的符号引用替换为直接引用
- 符号引用：以一组符号来描述所引用的目标，可以是任何形式的字面量
- 直接引用：可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄
初始化
- 真正执行类中定义的Java代码，根据 Java 程序的设定去初始化类变量和其他资源
使用
- JVM使用代码
卸载（Java虚拟机结束生命周期）
- 执行了System.exit()方法
- 程序正常执行结束
- 程序在执行过程中遇到了异常或错误而异常终止
- 操作系统出现错误而导致Java虚拟机进程终止

双亲委派机制#

JVM提供了三种类加载器将class文件给加载到JVM中去执行：

Bootstrap classLoader：主要负责加载核心的类库(java.lang.*等)，构造ExtClassLoader和APPClassLoader。
Extension classLoader：主要负责加载jre/lib/ext目录下的一些扩展的jar。
Application classLoader：主要负责加载应用程序的主函数类

除此之外，还有自定义的类加载器User classLoader，它们之间的层次关系被称为类加载器的双亲委派模型。该模型要求除了顶层的启动类加载器外，其余的类加载器都应该有自己的父类加载器，而这种父子关系一般通过组合（Composition）关系来实现。

某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回，自己不重复加载；只有父类加载器无法完成此加载任务时，才自己去加载。

使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。无论哪一个类加载器要加载某个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类，这样可以避免产生多个Object类导致混乱。

此外双亲委派模型更加安全，假如有人想替换某个系统级别的类，篡改它的实现。然而双亲委派模型下，这些系统类已经被Bootstrap classLoader加载过了，其他类加载器没有机会再去加载，从一定程度上防止了危险代码的植入。

Synchronized#

synchronized是Java中的关键字，是一种同步锁，常用于多线程编程。它修饰的对象有以下几种：

修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象
修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象
修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象

底层实现#

synchronized是通过monitorenter、monitorexit、ACC_SYNCHRONIZED实现同步的。

monitorenter：每个对象都与一个monitor 相关联。当且仅当拥有所有者时（被拥有），monitor才会被锁定。执行到monitorenter指令的线程，会尝试去获得对应的monitor
- 每个对象维护着一个记录着被锁次数的计数器, 对象未被锁定时，该计数器为0。线程进入monitor（执行monitorenter指令）时，会把计数器设置为1
- 当同一个线程再次获得该对象的锁的时候，计数器再次自增
- 当其他线程想获得该monitor的时候，就会阻塞，直到计数器为0才能成功
monitorexit：monitor的拥有者线程才能执行 monitorexit指令
- 线程执行monitorexit指令，就会让monitor的计数器减一。如果计数器为0，表明该线程不再拥有monitor。其他线程就允许尝试去获得该monitor了
ACC_SYNCHRONIZED：同步方法的常量池中会有一个ACC_SYNCHRONIZED标志
- 当调用一个设置了ACC_SYNCHRONIZED标志的方法，执行线程需要先获得monitor锁，然后开始执行方法，方法执行之后再释放monitor锁，当方法不管是正常return还是抛出异常都会释放对应的monitor锁
- 在此期间，如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住
- 方法执行过程中，发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放

monitor是由ObjectMonitor类来实现的，类中有两个队列 _EntryList和 _WaitSet，它们是用来保存ObjectMonitor对象列表，还有一个_owner指针指向持有ObjectMonitor对象的线程。

当多个线程访问同步代码时，线程会进入_EntryList区
当线程获取对象的monitor后进入 _Owner区并且将 _owner指向获得锁的线程(monitor对象被线程持有)， _count++，其他线程则继续在 _EntryList区等待
若线程调用wait方法，则该线程进入 _WaitSet区等待被唤醒。线程执行完后释放monitor锁并且对ObjectMonitor中的值进行复位

特性#

有序性
- as-if-serial：不管怎么重排序，单线程程序的执行结果都不能被改变
可见性
- happens-before：那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前
- 内存强制刷新
原子性
- 单一线程持有
可重入性
- 每个锁关联一个线程持有者和一个计数器。当计数器为0时表示该锁没有被任何线程持有，那么任何线程都都可能获得该锁而调用相应方法。当一个线程请求成功后，JVM会记下持有锁的线程，并将计数器计为1。此时其他线程请求该锁，则必须等待。而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增。当线程退出一个synchronized方法/块时，计数器会递减，如果计数器为0则释放该锁

对象#

在JVM中，对象在内存中的布局分为3块：对象头、实例数据和对齐填充。

对象头：2个字宽(如果对象是数组则分配3个字宽，多的一个字宽用于存储数组的长度)
- Mark Word：储存对象自身的运行时数据，例如对象的hashCode、GC分代年龄、锁状态标志、线程持有的锁、偏向线程的ID、偏向时间戳等
- 类型指针：标识JVM通过这个指针来确定这个对象是哪个类的实例
实例数据：对象真正的有效信息(程序代码中定义的各种类型的字段内容)
对齐填充：占位符，JVM要求对象的起始地址必须是8个字节的整数倍，而对象头已经是8的整数倍了，如果实例数据没有对齐就需要对齐填充来补全

synchronized使用的锁都放在对象头里，在mark word中会有2个bit作为锁的标志位，用于标示当前对象持有的是什么状态的锁。

锁升级（膨胀）#

锁的状态是通过对象监视器在对象头中的字段来表明的。状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级。四种状态分别是：

无锁状态
偏向锁状态：一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低了获取锁的代价
轻量级锁状态：锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能
重量级锁状态：锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低

没有竞争出现时，默认会使用偏向锁。JVM 会利用 CAS 操作，在对象头上的 Mark Word 部分设置线程 ID，以表示这个对象偏向于当前线程，所以并不涉及真正的互斥锁。这样做的假设是基于在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏向锁可以降低无竞争开销。

如果有另外的线程试图锁定某个已经被偏向过的对象，JVM 就需要撤销（revoke）偏向锁，并切换到轻量级锁实现。轻量级锁依赖 CAS 操作 Mark Word ，修改指针来试图获取锁，并且复制了一份Mark Word叫做Lock Record。如果成功，就使用普通的轻量级锁；否则，进一步升级为重量级锁。

和Lock的区别#

synchronized是关键字，JVM底层已经有对应实现；Lock是一个接口，JDK层面有丰富的API
synchronized会自动释放锁；Lock需要手动释放
synchronized不可中断（如果A不释放，B将一直等下去，不能被中断）；Lock可以中断也可以不中断（如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情）
synchronized支持修饰的范围比较广，有代码块、方法、类等等；Lock只能锁住代码块
synchronized是非公平锁，而Lock可以公平也可以非公平
synchronized不能知道线程是否拿到了锁，而Lock可以通过tryLock的机制实现这个目的

自动装箱/拆箱#

假如有这样两段代码：

1
Integer i3 = 100;
2
Integer i4 = 100;
3
System.out.println(i3 == i4); // true
4

5
Integer i5 = 1000;
6
Integer i6 = 1000;
7
System.out.println(i5 == i6); // false

为何会有上述差异？反编译.class文件，发现编译器实际上把上述代码进行了修改，添加了valueOf方法：

1
Integer i1 = Integer.valueOf(100);
2
Integer i2 = Integer.valueOf(100);
3
System.out.println(i1 == i2); // true
4

5
Integer i3 = Integer.valueOf(1000);
6
Integer i4 = Integer.valueOf(1000);
7
System.out.println(i3 == i4); // false

而valueOf方法的定义中，作者为了避免重复创建对象，对Integer值做了缓存，如果这个值在缓存范围内，直接返回IntegerCache类中缓存好的对象，否则new一个新的对象返回。

那么这个缓存范围是多少？IntegerCache这一内部静态类给出了解答。该类只能在Integer这个类的内部访问，这个类在初始化的时候，会去加载JVM的配置，如果有值，就用配置的值初始化缓存数组，否则就缓存-128到127之间的值。

回到开篇的代码差异。i1和i2赋值时，由于值在-128到-127之间，因此i1和i2指向的是同一个缓存对象；而i3和i4则new了两个不同的对象。

结论：比较两个Integer对象的值时，无论如何声明，一定要使用equals()比较，不能用==，并且注意Java中没有重载操作符这一说。

前文已经提到，JVM把声明的Integer类型变量加上了valueOf()方法。实际上，Java中广泛存在着这种行为。

Java中一共有四类八种基本数据类型，除掉这几种类型，其它的都是对象，也就是引用类型。而JDK1.5后，所有的基本数据类型都被加上了包装类型：

基本类型 -> 包装类型

第一类：整型 byte -> Byte, short -> Short, int -> Integer, long -> Long

第二类：浮点型 float -> Float, double -> Double

第三类：逻辑型 boolean -> Boolean

第四类：字符型 char -> Character

基本类型和包装类型之间可以互相转化：

将int的变量转换成Integer对象，这个过程叫做装箱（boxing）
将Integer对象转换成int类型值，这个过程叫做拆箱（unboxing）

假如我们有如下代码：

1
Integer integer1 = 100;
2
int int1 = integer1;
3

4
Long long1 = 100L;
5
long l1 = long1;
6

7
Boolean boolean1 = true;
8
boolean bool1 = boolean1;

反编译后，会发现代码变成：

1
Integer integer1 = Integer.valueOf(100); // 对int类型的值100装箱
2
int int1 = integer1.intValue(); // 对象类型integer1拆箱
3

4
Long long1 = Long.valueOf(100L); // 对long类型的值100L装箱
5
long l1 = long1.longValue(); // 对象类型l1拆箱
6

7
Boolean boolean1 = Boolean.valueOf(true); // 对int类型的值true装箱
8
boolean bool1 = boolean1.booleanValue(); // 对象类型boolean1拆箱

为什么要使用包装类型？

对象是对现实世界的模拟（一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象）
为泛型提供支持，例如List<Integer> list = new ArrayList<Integer>()这样的写法，因为泛型必须是一个对象
提供了丰富的属性和API，例如Integer.MIN_VALUE，Integer.max(a, b)等等

垃圾回收机制#

实质：垃圾指的是无任何对象引用的对象，垃圾回收指的是清理“垃圾”占用的内存空间。

堆内存分配区域#

新生代（Young Generation）几乎所有新生成的对象首先都是放在年轻代的。新生代内存按照8:1<1的比例分为一个eden区和两个survivor>(Survivor0,Survivor1)区。大部分对象在Eden区中生成。当新对象生成，Eden Space申请失败（因为空间不足等），则会发起一次GC(Scavenge GC)。回收时先将Eden区存活对象复制到一个Survivor0区，然后清空Eden区，当这个Survivor0区也存放满了时，则将Eden区和Survivor0区存活对象复制到另一个Survivor1区，然后清空Eden和这个Survivor0区，此时Survivor0区是空的，然后将Survivor0区和Survivor1区交换，即保持Survivor1区为空，如此往复。当对象在Survivor区躲过一次GC的话，其对象年龄便会加1，如果经历N次垃圾回收仍然存活，就会被移到年老代
老生代（Old Generation）年轻代中经历了N次垃圾回收后仍然存活的对象。此外，大对象一般会被直接分配到老年代。所谓的大对象是指需要大量连续存储空间的对象，最常见的一种大对象就是大数组

Java对象引用#

强引用（Strong Reference）：如Object obj = new Object()，这类引用是Java程序中最普遍的。只要强引用还存在，垃圾收集器就永远不会回收掉被引用的对象。
软引用（Soft Reference）：它用来描述一些可能还有用，但并非必须的对象。在系统内存不够用时，这类引用关联的对象将被垃圾收集器回收。
弱引用（Weak Reference）：它也是用来描述非须对象的，但它的强度比软引用更弱些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。
虚引用（Phantom Reference）：最弱的一种引用关系，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的是希望能在这个对象被收集器回收时收到一个系统通知。

如何判断某个对象是垃圾#

引用计数堆中每个对象都有一个引用计数器。当一个对象被创建并初始化赋值后，该变量计数设置为1。每当有一个地方引用它时，计数器值就加1（a = b， b被引用，则b引用的对象计数+1）。当引用失效时（一个对象的某个引用超过了生命周期（出作用域后）或者被设置为一个新值时），计数器值就减1。任何引用计数为0的对象可以被当作垃圾收集。缺点：难以检测出对象之间的循环引用。同时，引用计数器增加了程序执行的开销
根搜索算法：通过一系列名为“GC Roots”的对象作为起始点，寻找对应的引用节点；找到这些引用节点后，从这些节点开始向下继续寻找它们的引用节点，不断重复这个过程。当标记阶段完成了之后，所有的存活对象都已经被找出来了。其它的那些也是GC根对象不可达的对象，也就是说应用不会再用到它们了。这些就是垃圾对象，回收器将会在接下来的阶段中清除它们。在遍历过程中，垃圾回收器会对内存中的整个对象图进行遍历，它先从GC根对象开始，然后是根对象引用的其它对象，比如实例变量。回收器将访问到的所有对象都标记为存活。

回收垃圾算法#

标记-清除算法标记出所需回收的对象，在标记完成后统一回收掉所有被标记的对象，它的标记过程其实就是前面的根搜索算法中判定垃圾对象的标记过程。一般适用于老生代
- 优点：不需要进行对象的移动，存活对象多的时候很高效
- 缺点：标记清除后会产生大量不连续的内存碎片
标记—整理算法对标记后出的垃圾对象的处理情况有所不同，它不是直接对可回收对象进行清理，而是让所有的对象都向一端移动，然后直接清理掉端边界以外的内存。一般适用于老生代
- 优点：解决碎片问题，并且只需要使用指针碰撞（把指针分界线向未分配内存空间移动一个对象的大小）就能给新对象分配内存
- 缺点：增加了GC的耗时
复制算法将内存按容量分为大小相等的两块，每次只使用其中的一块（对象面），当这一块的内存用完了，就将还存活着的对象复制到另外一块内存上面（空闲面），然后再把已使用过的内存空间一次清理掉。一般适用于新生代
- 优点：标记阶段和复制阶段可以同时进行；内存回收时不用考虑内存碎片的出现
- 缺点：需要一块能容纳下所有存活对象的额外的内存空间，一次性最大分配内存减半

垃圾回收过程细节#

什么时候？
- 新生代GC（Minor GC/Scavenge GC）：发生在新生代的垃圾收集动作。因为Java对象大多都具有朝生夕灭的特性，因此Minor GC非常频繁(不一定等Eden区满了才触发)，一般回收速度也比较快。在新生代中，每次垃圾收集时都会发现有大量对象死去，只有少量存活，因此可选用复制算法来完成收集。
- 老年代GC（Major GC/Full GC）：发生在老年代的垃圾回收动作。Major GC，经常会伴随至少一次Minor GC。由于老年代中的对象生命周期比较长，因此Major GC并不频繁，一般都是升到老年代的对象大于老年代剩余空间时进行，而且其速度一般会比Minor GC慢10倍以上。另外，如果分配了Direct Memory，在老年代中进行Full GC时，会顺便清理掉Direct Memory中的废弃对象。而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须使用标记—清除算法或标记—整理算法来进行回收。
- 新生代采用空闲指针的方式来控制GC触发，指针保持最后一个分配的对象在新生代区间的位置，当有新的对象要分配内存时，用于检查空间是否足够，不够就触发GC。当连续分配对象时，对象会逐渐从Eden到Survivor，最后到老年代。当老年代也满了后，就会报OutOfMemory的异常。注意，如果gc与非gc时间耗时过大，超过了GCTimeRatio的限制，也会引发OutOfMemory异常。
对什么东西？

从root搜索不到，而且经过第一次标记、清理后，仍然没有复活的对象。
做了什么事情？

新生代做的是复制清理、from survivor、to survivor是干啥用的、老年代做的是标记清理、标记清理后碎片要不要整理

Java垃圾回收器种类#

串行垃圾回收器持有应用程序所有的线程进行工作。它为单线程环境设计，只使用一个单独的线程进行垃圾回收，通过冻结所有应用程序线程进行工作
并行垃圾回收器 JVM的默认垃圾回收器，使用多线程进行垃圾回收。当执行垃圾回收的时候它也会冻结所有的应用程序线程。
并发标记扫描垃圾回收器使用多线程扫描堆内存，标记需要清理的实例并且清理被标记过的实例。并发标记垃圾回收器只会在下面两种情况持有应用程序所有线程：
- 当标记的引用对象在Tenured区域
- 在进行垃圾回收的时候，堆内存的数据被并发的改变

STW#

Stop The World，整个Java虚拟机应用线程暂停工作。在标记或者计算的过程中如果还有新对象产生，这个时候就需要STW。暂停工作吧，先把垃圾处理完。

OOM错误种类#

Java heap space#

应用程序尝试添加更多的数据放入堆空间区域，但没有足够的空间供它使用。引起错误的可能原因：

用量/数据量激增
内存泄漏

解决方案：

分配更多的堆
排查是否有内存泄漏

GC overhead limit exceeded#

应用程序已经耗尽了几乎所有的可用内存，并且GC一直未能回收它。引起错误的可能原因：

应用程序花费太多的时间做垃圾收集，清理的时间太少，可能是因为堆太小

解决方案：

分配更多的堆

PermGen space#

永久代的内存区域被耗尽。引起错误的可能原因：

永久区中装入了太多的类或太大的类

解决方案：

增大内存
检查是否存在类加载器泄漏
检查是否设置允许GC从PermGen space卸载类

Unable to create new native thread#

Java应用程序已达到其可以启动线程数的限制。引起错误的可能原因：

Java进程大小已耗尽其内存地址空间
操作系统的虚拟内存已完全耗尽

解决方案：

增加操作系统级别的数量限制来绕过无法创建新的本机线程问题
减少线程创建

JVM性能调优#

原则#

多数的 Java 应用不需要在服务器上进行 GC 优化；多数导致 GC 问题的 Java 应用，都不是因为我们参数设置错误，而是代码问题；在应用上线之前，先考虑将机器的 JVM 参数设置到最优（最适合）；减少创建对象的数量；减少使用全局变量和大对象； GC 优化是到最后不得已才采用的手段；在实际使用中，分析 GC 情况优化代码比优化 GC 参数要多得多。

总体而言，GC的目的是将转移到老年代的对象数量降低到最小；减少 GC 的执行时间。

触发时机#

Heap内存（老年代）持续上涨达到设置的最大内存值
Full GC 次数频繁
GC 停顿时间过长（超过1秒）
应用出现OutOfMemory 等内存异常
应用中有使用本地缓存且占用大量内存空间
系统吞吐量与响应性能不高或下降

一般步骤#

分析GC日志及dump文件，判断是否需要优化，确定瓶颈问题点
确定JVM调优量化目标
确定JVM调优参数（根据历史JVM参数来调整）
依次调优内存、延迟、吞吐量等指标
对比观察调优前后的差异
不断的分析和调整，直到找到合适的JVM参数配置
找到最合适的参数，将这些参数应用到所有服务器，并进行后续跟踪

GC调优#

将新对象预留在新生代，由于 Full GC 的成本远高于 Minor GC，因此尽可能将对象分配在新生代是明智的做法，实际项目中根据 GC 日志分析新生代空间大小分配是否合理，适当通过“-Xmn”命令调节新生代大小，最大限度降低新对象直接进入老年代的情况。
大对象进入老年代，虽然大部分情况下，将对象分配在新生代是合理的。但是对于大对象这种做法却值得商榷，大对象如果首次在新生代分配可能会出现空间不足导致很多年龄不够的小对象被分配的老年代，破坏新生代的对象结构，可能会出现频繁的 full gc。因此，对于大对象，可以设置直接进入老年代（当然短命的大对象对于垃圾回收来说简直就是噩梦）。-XX 可以设置直接进入老年代的对象大小。
合理设置进入老年代对象的年龄，-XX 设置对象进入老年代的年龄大小，减少老年代的内存占用，降低 full gc 发生的频率。
设置稳定的堆大小，堆大小设置有两个参数：-Xms 初始化堆大小，-Xmx 最大堆大小。
注意：如果满足下面的指标，则一般不需要进行 GC 优化： MinorGC 执行时间不到50ms； Minor GC 执行不频繁，约10秒一次； Full GC 执行时间不到1s； Full GC 执行频率不算频繁，不低于10分钟1次。

Full GC内存泄漏排查#

jmap 手动dump出文件进行分析
用jvisualvm等工具监控配置，自动dump
使用Memory Analyzer（MAT）等工具实时查看分析内存使用情况

String类#

String类的对象在声明时，主要生成了两个重要的东西：

private final char value[]，这同时说明Java的String是基于char[]的
private int hash，即String的hashCode

构造函数则是这样写的：

1
public String(String original) {
2
    this.value = original.value;
3
    this.hash = original.hash;
4
}

结合一个例子理解上述的构造过程：

1
String str1 = new String("abc");
2
String str2 = new String("abc");

流程：

JVM会去先检查看一看常量池里有没有”abc”这个对象，如果没有，把”abc”初始化为对象放入常量池，如果有，直接返回常量池内容
处理new关键词，在堆内存中开辟空间，由于hash这个字段是int类型的，成员变量初始化默认值为0
处理构造函数，hash是值类型，直接赋值，数组为引用类型，直接指向常量池中的地址。
str2类似，直接使用常量池中的结果

stringConstruct.png

再看另一段代码：

1
String s1 = "100";
2
String s2 = "100";
3
System.out.println(s1 == s2); // true
4

5
String s3 = new String("100");
6
String s4 = new String("100");
7
System.out.println(s3 == s4); // false

再次出现了差异，并且反编译后发现与代码并没有被修改，与编译器无关。那么问题出在哪？答案是JVM的堆内存使用机制。

在JVM中，堆内存的一部分是常量池，主要的目的是为了避免频繁的创建和销毁对象而影响系统性能，实现了对象的共享。当代码执行到String s1 = "100"时，会先看常量池里有没有字符串刚好是“100”这个对象，如果没有，在常量池里创建初始化该对象，并把引用指向它；当执行到String s2 = "100"时，发现常量池已经有了”100”这个值，于是不会在常量池中创建一个新对象，而是把引用直接指向了原来的”100”对象。而s3和s4的创建就不同了，由于它们是使用new关键字构造的，因此构造时就是明确告诉JVM，要在堆内存开辟一块新内存。

一张图总结上述四个字符串生成时内存的使用情况：

memoryPool.png

结论：比较两个String对象的值时，无论如何声明，一定要使用equals()比较，不能用==，并且注意Java中没有重载操作符这一说。

在引用类型中，”==“是比较两个引用是否指向堆内存里的同一个地址（同一个对象），而equals是一个普通的方法，该方法返回的结果依赖于自身的实现。于是，我们不妨深究一下Java常见类中equals()方法的实现。

如果一个类没有继承其他类，那么它默认继承自Object这个类。而Object类的equals()实现方法很简单，即：判断两个引用是否指向堆内存中的同一块地址（同一个对象）
而Integer类中，首先会判断传入比较的对象是不是Integer类型(obj instanceof Integer)，如果是，才会进行后续的值比较；否则直接返回false。因此，诸如Integer与Long之类的比较，即使值相等，也会直接返回false
String类中的equals()实现略微复杂：
- 先判断两个对象是否指向同一引用，如果是直接返回true
- 判断两个对象是否都是String类型
- 判断字符串底层char数组长度是否一致
- 循环检查数组每一个char字符是否相等

面向对象#

面向对象三大特征：继承、多态、封装

继承：重用父类的代码，一个大类下的诸多小类，如果他们有共同的性质，只需要写一遍即可，不用重复多次（动物 -> 哺乳动物 -> 人）
多态：多个小类同时继承一个大类，调用同一个方法时，运行时会智能匹配到子类的实现，得到不同的结果。需要满足三个条件：
- 要用继承关系
- 要有重写
- 父类引用指向子类对象，也就是向上转型(Animal a = new Cat())，这样既可以使用子类改进拓展的功能，又可以抽取父类的共性
封装：隐藏对象属性和实现细节，仅对外公开指定方法来控制程序中属性的访问和修改。几种修饰符：
- private：访问权限仅限于类的内部，不能被任何外部类访问
- default：任何处于当前包的类、接口等等都可以互相访问
- protected：访问权限仅限于子类，其他类不可以
- public：任何外部包、类都可以访问

所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

Java中使用abstract class定义抽象类。

如果某个类暂时不确定有属性或有具体的形为，建议先声明成接口，因为一个类可以实现多个接口，但只能继承一个类，声明为接口更灵活一些，也使实现类具有更好的扩展性。

重写和重载的区别：

重写：指子类和父类的关系，子类重写了父类的方法，但方法名、参数类型、参数个数必须相同（加上@Override1）
重载：同一个类中，方法的名字相同，但参数个数、参数的类型不同。

这里引申到了一个进阶的问题，即如何比较两个类对象。结论是：

不要自己写方法，或者用==去判断，而是应该重写父类的 equals方法
当我们在实际业务中需要重写（覆盖）equals()方法时，根据规范，我们一定要重写（覆盖）hashCode()方法。

Java反射机制#

什么是Java反射机制？

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。这样子进行类对象的初始化，我们可以理解为“正”。

与之相反，反射 (Reflection) 是 Java 的特征之一，其核心是 JVM 在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

Java 反射主要提供以下功能：
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
- 在运行时调用任意一个对象的方法
具体可以参见这张运行图：

reflection.png
Java反射机制有什么用途？

反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 Bean），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射，运行时动态加载需要加载的对象。

多线程锁#

ReentrantLock#

Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。java.util.concurrent.locks包提供的ReentrantLock用于替代synchronized加锁。

ReentrantLock相比synchronized有几个特点：

必须在代码中去获取锁，用完之后必须释放
比起synchronized更安全，因为可以搭配try…finally代码块，允许用trylock尝试获取锁，即便失败了也不会让程序退出运行或者导致死锁，允许额外的容错处理机会

ReentrantLock 内部有一个抽象类 Sync，继承了 AbstractQueuedSynchronizer。而公平锁的实现就是 FairSync，非公平锁的实现就是 NonFairSync。具体生成锁时，只需要在构造方法中使用一个 boolean 参数即可。默认是非公平锁。

底层实现#

AbstractQueuedSynchronizer

AbstractQueuedSynchronizer （抽象队列同步器，以下简称 AQS）出现在 JDK 1.5 中，是很多同步器的基础框架，比如 ReentrantLock、CountDownLatch 和 Semaphore 等都是基于 AQS 实现的。我们也可以基于 AQS定制出所需要的同步器。

在 AQS 内部，通过维护一个FIFO 队列来管理多线程的排队工作。在公平竞争的情况下，无法获取同步状态的线程将会被封装成一个节点，置于队列尾部。

AQS有两种模式：共享和独享。

独享模式下获取同步状态的流程：

调用 tryAcquire 方法尝试获取同步状态
获取成功，直接返回；获取失败，将线程封装到节点中，并将节点入队
入队节点在 acquireQueued 方法中自旋获取同步状态
若节点的前驱节点是头节点，则再次调用 tryAcquire 尝试获取同步状态
获取成功，当前节点将自己设为头节点并返回
获取失败，可能再次尝试，也可能会被阻塞。这里简单认为会被阻塞。

独享模式下释放同步状态的流程：

调用 tryRelease(arg) 尝试释放同步状态
根据条件判断是否应该唤醒后继线程

共享模式下获取同步状态的流程：

获取共享同步状态
若获取失败，将线程封装到节点中，并将节点入队
如果前驱为头结点，再次尝试获取共享同步状态
获取成功则将自己设为头结点，如果后继节点是共享类型的，则唤醒
若失败，将节点状态设为 SIGNAL，再次尝试。若再次失败，线程进入等待状态

共享模式下释放同步状态的流程：

调用doReleaseShared
如果 head 节点等待状态为 SIGNAL，则将 head 节点状态设为 0，并唤醒后继节点；如果 head 节点等待状态为 0，则将 head 节点状态设为 PROPAGATE，保证唤醒能够正常传播下去

总结：独占模式下，只有一个节点线程可以成功获取同步状态，也只有获取已同步状态节点线程才可以释放同步状态。但在共享模式下，多个共享节点线程可以同时获得同步状态，在一些线程获取同步状态的同时，可能还会有另外一些线程正在释放同步状态。

公平锁

1
static final class FairSync extends Sync {
2
    // 以公平的方式锁
3
    final void lock() {
4
        // 调用AQS框架的逻辑
5
        acquire(1);
6
    }
7
    // AQS acquire 方法会调用tryAcquire这个方法
8
    protected final boolean tryAcquire(int acquires) {
9
        final Thread current = Thread.currentThread();
10
        int c = getState();
11
        if (c == 0) {
12
            if (!hasQueuedPredecessors() &&  compareAndSetState(0, acquires)) {
13
                // 成功获得锁，设置锁的所有者为当前线程
14
                setExclusiveOwnerThread(current);
15
                return true;
16
            }
17
        }
18
        else if (current == getExclusiveOwnerThread()) {
19
            // 可重入锁的逻辑
20
            int nextc = c + acquires;
21
            if (nextc < 0)
22
                throw new Error("Maximum lock count exceeded");
23
            setState(nextc);
24
            return true;
25
        }
26
        return false;
27
    }
28
}

展开收起

公平锁调用的是 AQS 的acquire方法，而AQS 会回调子类的tryAcquire方法。具体逻辑是：

获取 state 变量，如果是 0，说明当前锁没有线程占用, 可以获取
如果当前线程不是锁的占有者，判断 AQS 队列中是否有等待的线程，如果没有，就使用 CAS 尝试获取。如果CAS能修改state = 1，说明锁获取成功，将锁的持有线程修改为当前线程。所谓公平，就体现这一步的“判断 AQS 队列中是否有等待的线程中，对应的函数是hasQueuedPredecessors，避免了新来的线程插队的情况
如果当前线程已经是锁的占有者，允许重入获取锁，同样也是修改state值，不过需要检查是否超出了最大持有锁上限
任何情况下获取锁失败，返回false，AQS会将这个线程放进队列并挂起。

非公平锁

1
static final class NonfairSync extends Sync {
2
    private static final long serialVersionUID = 7316153563782823691L;
3

4
    final void lock() {
5
        // 非公平获得锁，进来直接使用CAS修改，修改成功就是获得锁
6
        if (compareAndSetState(0, 1))
7
            setExclusiveOwnerThread(Thread.currentThread());
8
        else
9
            // acquire 是AQS里面的方法，最终会调用到非公平锁的实现方法tryAcquire
10
            acquire(1);
11
    }
12

13
    protected final boolean tryAcquire(int acquires) {
14
        // 非公平获得锁
15
        return nonfairTryAcquire(acquires);
16
    }
17
}

展开收起

1
abstract static class Sync extends AbstractQueuedSynchronizer {
2
...
3
    final boolean nonfairTryAcquire(int acquires) {
4
      // 当前线程
5
      final Thread current = Thread.currentThread();
6
      // state 状态
7
      int c = getState();
8
      if (c == 0) {
9
          // CAS 修改state 值
10
          if (compareAndSetState(0, acquires)) {
11
              // 成功获得锁，修改锁的所有者线程
12
              setExclusiveOwnerThread(current);
13
              return true;
14
          }
15
      } else if (current == getExclusiveOwnerThread()) {
16
          // 检查锁的所有者是否是当前线程
17
          // 当前线程获得锁，可重入逻辑
18
          int nextc = c + acquires;
19
          if (nextc < 0) // overflow
20
              throw new Error("Maximum lock count exceeded");
21
          setState(nextc);
22
          return true;
23
      }
24
      return false;
25
  }
26
...
27
}

展开收起

非公平锁与公平锁调用的acquire方法是一样的，不同的是tryAcquire部分。

非公平锁进来直接尝试CAS修改state值，如果CAS能修改state = 1，说明锁获取成功，将锁的持有线程修改为当前线程。而如果失败，就会调用AQS的acquire方法，而AQS 会回调子类的tryAcquire方法，里面进一步调用了nonfairTryAcquire这个方法。具体逻辑是：

获取当前线程，当前 state 值
如果 state 值为0 ，直接使用CAS 修改，修改成功代表获得锁，如果成功获得锁，修改锁的所有者线程为当前线程
如果 state 值不为0，检查锁的所有者是否是当前线程，如果是，进入可重入逻辑，修改state，成功获得锁
没有获得锁，返回false

因为非公平锁没有进行队列检查等步骤，相对更快速一些，所以ReentrantLock默认使用了非公平锁。

ReentrantReadWriteLock#

ReentrantLock保证了只有一个线程可以执行临界区代码，但是有些时候，这种保护有点过头，因为其显著降低了并发效率。实际上我们想要的是：允许多个线程同时读，但只要有一个线程在写，其他线程就必须等待。

ReadWriteLock解决了上述问题，它有以下特点：

提高读取效率
只允许一个线程写入
允许多个线程在没有写入时同时读取；
适合读多写少的场景

1
public class Counter {
2
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
3
    private final Lock rlock = rwlock.readLock();
4
    private final Lock wlock = rwlock.writeLock();
5
    private int[] counts = new int[10];
6

7
    public void inc(int index) {
8
        wlock.lock(); // 加写锁
9
        try {
10
            counts[index] += 1;
11
        } finally {
12
            wlock.unlock(); // 释放写锁
13
        }
14
    }
15

16
    public int[] get() {
17
        rlock.lock(); // 加读锁
18
        try {
19
            return Arrays.copyOf(counts, counts.length);
20
        } finally {
21
            rlock.unlock(); // 释放读锁
22
        }
23
    }
24
}

展开收起

StampedLock#

StampedLock和ReadWriteLock相比，改进之处在于：读的过程中也允许获取写锁后写入。

和ReadWriteLock相比，写入的加锁是完全一样的，不同的是读取，先获取一个乐观读锁，并返回版本号。接着进行读取，读取完成后验证版本号，如果在读取过程中没有写入，版本号不变则验证成功；如果在读取过程中有写入，版本号会发生变化，验证将失败。此时，我们再通过获取悲观读锁再次读取。由于写入的概率不高，程序在绝大部分情况下可以通过乐观读锁获取数据，极少数情况下使用悲观读锁获取数据。

总的来说，StampedLock把读锁细分为乐观读和悲观读，能进一步提升并发效率。但这也是有代价的：一是代码更加复杂，二是StampedLock是不可重入锁，不能在一个线程中反复获取同一个StampedLock。此外，StampedLock还提供了更复杂的将悲观读锁升级为写锁的功能，它主要使用在if-then-update的场景：即先读，如果读的数据满足条件，就返回，如果读的数据不满足条件，再尝试写。

线程池#

简介#

线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，主要作用是维护多个线程，等待监督管理者分配可并发执行的任务。

Java中可以直接使用new Thread生成一个新线程，然而这样生成的线程性能差，缺乏管理，功能少。使用线程池可以带来一系列好处：

降低资源消耗：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗
提高响应速度：任务到达时，无需等待线程创建即可立即执行
提高线程的可管理性：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控
提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行

参数#

Java使用ThreadPoolExecutor生成线程池，其构造函数有一些重要参数：

corePoolSize：核心池的大小
maximumPoolSize：线程池最大线程数
poolSize：线程池中当前线程的数量
- 如果poolSize < corePoolSize，新增加一个线程处理新的任务
- 如果poolSize = corePoolSize，新任务会被放入阻塞队列等待
- 如果阻塞队列的容量达到上限，且这时poolSize < maximumPoolSize，新增线程来处理任务
- 如果阻塞队列满了，且poolSize = maximumPoolSize，那么线程池已经达到极限，会根据饱和策略RejectedExecutionHandler拒绝新的任务
keepAliveTime：线程没有任务执行时最多保持多久时间会终止
workQueue：一个阻塞队列，用来存储等待执行的任务。阻塞队列一般有以下几种选择：
- ArrayBlockingQueue
  - 有界队列
  - 加锁保证安全
  - 队列满就阻塞，超时或者队列不满则唤醒被阻塞的出队线程
  - 入队阻塞调用建议使用offer方法，可以及时获取boolean返回值判断是否成功；使用put方法需要考虑阻塞情况，因为出队速度大于入队速度
- LinkedBlockingQueue
  - 无长度上限，需要当心内存溢出
- SynchronousQueue
  - 无缓冲等待队列，是一个不存储元素的阻塞队列，会直接将任务交给消费者，必须等队列中的添加元素被消费后才能继续添加新的元素。
- PriorityBlockingQueue
- DelayedWorkQueue
threadFactory：执行程序创建新线程时使用的工厂
handler：表示当拒绝处理任务时的策略
- AbortPolicy：丢弃任务并抛出RejectedExecutionException异常
- DiscardPolicy：丢弃任务，但是不抛出异常
- DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务，不断重复此过程
- CallerRunsPolicy：由调用线程处理该任务
runState：volatile关键词修饰的线程池运行状态
- RUNNING：线程池接受新任务并执行队列任务中
- SHUTDOWN：不再接受新任务，但是会继续执行等待队列Queued中的任务
- STOP：不再接受新任务，同时也不执行等待队列Queued中的任务，并且会尝试终止正在执行中的任务
- TERMINATED：线程池中所有线程已经停止运行

种类#

Java通过Executors提供几种线程池，底层均是由ThreadPoolExecutor实现的，例如：

newFixedThreadPool
- 定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
- 使用完毕必须手动关闭线程池，否则会一直在内存中存在
newCachedThreadPool
- 可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
- 使用SynchronousQueue
newScheduledThreadPool
- 定长线程池，支持定时及周期性任务执行
- 使用DelayedWorkQueue
newSingleThreadExecutor
- 单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
newWorkStealingPool
- 每个线程池分配一个双端队列(本地队列)用于存放需要执行的任务，当自己的队列没有数据的时候从其它线程池队列中获得一个任务继续执行
- 涉及到并行编程肯定涉及到并发安全的问题，有可能在“偷取”任务过程中A提前抢占了这个任务，那么B的偷取就会失败。大多数实现会尽量避免发生这个问题
- 一般是自己的本地队列采取LIFO(后进先出)，偷取时采用FIFO(先进先出)，一个从头开始执行，一个从尾部开始执行，由于偷取的动作十分快速，会大量降低这种冲突，也是一种优化方式

MySQL

Sat, 05 Feb 2022 00:00:00 GMT

MySQL Notes

MySQL优化#

优化查询效率#

SQL语句层面：

select和join的先后顺序，一般先select后join
使用Explain命令
- 作用：查看一个这些SQL语句的执行计划，查看该SQL语句有没有使用想要的索引，有没有做全表扫描
- 可能统计出的行数和实际不一样。因为MySQL中数据的单位都是页，MySQL又采用了采样统计的方法，采样统计的时候，InnoDB默认会选择N个数据页，统计这些页面上的不同值，得到一个平均值。数据是一直在变的，所以索引的统计信息也是会变的，只是一个估值。另外，优化器走错索引，还可能是因为考虑其他因素，比如回表等等
- 如果发现错误，可以使用analyze table tablename就可以重新统计索引信息；或者force index，强制走正确的索引
使用pt-query-digest，也可以分析慢查询

索引层面：

覆盖索引
- 回表问题：先通过普通索引定位到主键值，再通过聚集索引定位到行记录，性能较扫一遍索引树低很多
- 用于解决回表问题，在一棵索引树上就能获取SQL所需的所有列数据，无需回表
联合索引
- 覆盖索引的一种实现，在两个或更多个列上建立索引
- 优点
  - 联合索引比起单列分别建索引，减少了索引的数量，降低了写开销和磁盘开销
  - 效率高，多列索引能够一次性筛选出想要的数据，避免中间的回表、排序、分页等过程
- 注意调整联合时的顺序，查询语句执行时会从优先从左开始组成索引进行数据匹配（最左前缀原则）
- 可以使用explain语句，查看type字段是index还是ref，判断索引是否达到快速效果
  - index：效率不高，MySQL从索引中的第一个数据查到最后一个，直到找到符合判断的某个索引
  - ref：平常理解的“用索引快速找到数据”，索引字段必须有序
- 不可以无限建立，过多的联合索引还是占据很多空间
```
1
/* 假如索引存在于(col1, col2, col3)，则索引生效于索引会生效于(col1), (col1, col2), 以及(col1, col2, col3) */
2

3
/* 索引生效，触发ref  */
4
SELECT * FROM tbl_name WHERE col1=val1;
5
SELECT * FROM tbl_name WHERE col1=val1 AND col2=val2;
6

7
/* 索引不生效，(col2)和(col2, col3) 不是(col1, col2, col3)的最左前缀，触发index */
8
SELECT * FROM tbl_name WHERE col2=val2;
9
SELECT * FROM tbl_name WHERE col2=val2 AND col3=val3;
```
索引下推
- MySQL 5.6之后的官方优化
- 如果使用了联合索引，在索引遍历过程中，对索引中包含的字段先做判断，直接过滤掉不满足条件的记录，减少回表次数
索引维护
- 索引以数据页的形式存在磁盘上
- 页分裂：插入一条数据需要写数据页，如果数据页满了，且插入位置在中间，那么存储引擎要申请一个新的数据页，把部分数据移动过去。数据插在尾部没有这个问题
- 页合并：删除一条数据，当页的利用率很低之后，就会合并页
- 避免页空洞：页分裂过程会产生“页空洞”，因为两个页都不满（分裂后只用50%），但是占用了两页的磁盘空间，因此不能进行页分裂
根据使用场景，分析普通索引和唯一索引选择的合理性
- 唯一索引上的字段的数据只能是唯一的，而普通索引可以有重复数据
- 唯一索引不能使用change buffer（因为需要进行唯一性检查），普通索引可以使用

表层面：

检查是否满足范式，减少冗余
选择合适的数据类型，比如说int比varchar处理起来更简单，少用NULL因为会增加索引开销

更高级的层面：

修改MySQL配置，例如查询缓存、索引缓冲区这种
硬件优化，分析CPU、硬盘、网络的性能瓶颈等

数据量大#

优化SQL和索引
增加一层缓存，比如Redis或者Memcached
做主从同步
- 一个数据库服务器异步复制到其他服务器上，在复制数据时，一个服务器充当主服务器（master），其余的服务器充当从服务器（slave）。master主服务器发生变化时，变化会实时同步到slave服务器
- 优点：水平拓展数据库的负载能力；数据备份，提升了容错性；读写分离，比如master负责写，slave负责读，避免锁表带来不利影响，同时分担数据访问压力
- 主机器上，主从同步事件会被写到binlog文件中(statement: 操作数据库的SQL语句；row: 每条数据的变化；mixed: statement与row的混合)。slave连接master节点后，master节点会创建一个binlog dump线程，用于发送bin log
- 把slave的线程分成两个线程，一个做binlogs的同步(我们称为I/O线程)，接受主服务器binlog dump进程发来的更新之后，保存在本地的relay log中；另一个做还原现场的工作(我们称为SQL线程)，读取relay log的内容，解析成具体的操作来执行。如此，master端的binlogs能以最小的延时，同步到slave，而slave这边的现场还原工作就可以慢慢来
- 默认情况下主库在执行完客户端提交的事务后会将结果返给给客户端，之后立即开始继续处理其他客户提交操作，并不关心从库是否已经接收并处理（优化：半同步复制，主库线程等待至少一个从库反馈，再进行后续操作）
- 有时主库tps并发较高，产生的DDL数量超过slave一个sql线程所能承受的范围；或slave的一些大型query语句产生了锁等待。这时就会产生主从延迟
  - 对于写了之后立马就要保证可以查到的场景，采用强制读主库的方式，这样就可以保证读到数据
  - 适当降低slave库的数据安全等级，比如说把innodb_flushlog等参数设置为0，提高sql语句执行效率
  - 使用多台slave来分摊读请求，再从这些slave中取一台专用的服务器，只作为备份用，不进行其他任何操作，就能相对最大限度地达到实时的要求
  - 使用比主库更好的硬件作为slave
做垂直拆分，分析模块的耦合度，把一个大的系统拆分成多个小的系统，按照系统业务进行分类，把数据压力分布到不同的数据库上面，即分布式数据库
做水平拆分
- 某个字段为依据（例如uid），按照一定规则（例如取模），将一个库（表）上的数据拆分到多个库（表）上，以降低单库（表）大小
- 拆分后，每个库（表）结构一样，但数据不一样，没有交集

锁#

按加锁范围划分#

简单来说，MySQL中有三种加锁范围不同的锁：

表级锁：开销小，加锁快；锁粒度大；发生锁冲突概率最高，并发度最低
页面锁，开销和加锁时间介于表锁和行锁之间；锁粒度中等
行级锁：开销大，加锁慢；锁粒度小；发生锁冲突概率最低，并发度最高

如果要进一步详细划分：

全局锁
- 对整个数据库实例加锁，使得整个库处于只读状态
- 典型的应用场景是做全库的逻辑备份，全局锁确保没有其他线程对当前数据库做更新，然后再对整个库做备份
表锁
- 有读写两种模式，可以直接LOCK TABLE table1 locktype(read/write)来指定
- 读锁不互斥，写锁互斥
行锁
- 多个事务操作同一行数据时，后来的事务处于阻塞等待状态，但此时他们可以操作其他行数据
- 一般行级锁都是基于索引的，如果一条SQL语句用不到索引是不会使用行级锁的，因为需要请求大量的锁资源，速度慢，内存消耗大；并且需要等待事务完整执行完毕后才能释放
- 行锁可能会引起死锁问题，比如两个不同事务分别持有了一把锁，然后试图加对方的另一把锁，产生死锁
  - 通过 innodb_lock_wait_timeout 来设置超时时间，InnoDB 中默认值是 50s，即第一个被锁住的事务等待超过 50s 才会超时退出，其他事务才能得以执行
  - 通过设置 innodb_deadlock_detect = on，发起死锁检测，发现死锁之后主动回滚死锁链条中的某一个事务，让其他事务得以继续执行
- 热点行问题：若干事务短时间内都要集中更新同一行，每个新来的被堵住的线程，都要判断会不会由于自己的加入导致了死锁，消耗大量CPU
  - 临时关闭若干线程
  - 控制数据库并发度
  - 分治，考虑通过将一行改成逻辑上的多行来减少锁冲突

按模式划分#

MySQL中有两种不同模式的锁：

乐观锁用数据版本（Version）记录机制实现；当读取数据时，将version字段的值一同读出，数据每更新一次，对此version值加1。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的version值进行比对，如果数据库表当前版本号与第一次取出来的version值相等，则予以更新，否则认为是过期数据。注意如果产生了冲突，上层应用可能会多次重试执行，这导致性能降低，因此乐观锁更适合写入较少的场景。
悲观锁悲观锁就是在操作数据时，认为此操作会出现数据冲突，所以在进行每次操作时都要通过获取锁才能进行对相同数据的操作，需要耗费较多的时间。有两种常见的实现方法：
- 共享锁：共享锁又称读锁 (read lock)，多个事务对于同一数据可以共享一把锁。其他用户可以并发读取数据，但任何事务都不能对数据进行修改（获取数据上的排他锁），直到所有共享锁被释放。
- 排他锁：排他锁又称写锁（write lock），若某个事物对某一行加上了排他锁，只能这个事务对其进行读写，在此事务结束之前，其他事务不能对其进行加任何锁，其他进程可以读取，不能进行写操作，需等待其释放

其他类型的锁#

间隙锁：

当我们用范围条件而不是相等条件检索数据，并请求共享或排他锁时，InnoDB会给符合条件的已有数据记录的索引项加锁；对于键值在条件范围内但并不存在的记录，叫做“间隙（GAP)”，InnoDB也会对这个“间隙”加锁，这种锁机制就是所谓的间隙锁。这样做是为了防止幻读，以及利于后续数据恢复

事务#

MySQL并发事务产生的问题#

丢失更新
- 第一类：A事务撤销，把已经提交的B事务的更新数据覆盖了
- 第二类：A事务提交，把已经提交的B事务的更新数据覆盖了
脏读
- 读到未提交更新的数据
不可重复读
- 读到已经提交更新的数据，但一个事务范围内两个相同的查询返回了不同数据
幻读
- 读到另一个事务提交新插入/删除的数据

MySQL事务隔离级别#

以下四种隔离级别按从高到底排序，四种隔离级别的安全性与性能成反比，最安全的性能最差，最不安全的性能最好。

SERIALIZABLE（串行化）一个事务在执行过程中完全看不到其他事务对数据库所做的更新。当两个事务同时操作数据库中相同数据时，如果第一个事务已经在访问该数据，第二个事务只能停下来等待，必须等到第一个事务结束后才能恢复运行。可以解决上述所有并发事务问题。
REPEATABLE READ（可重复读）(MySQL的默认事务隔离级别) 一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，但是不能看到其他事务对已有记录的更新。可以解决除幻读之外所有的并发事务问题。
READ COMMITTED（读已提交数据）当数据库系统使用READ COMMITTED隔离级别时，一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，而且还能看到其他事务已经提交的对已有记录的更新。可以解决第一类丢失更新和脏读问题。
READ UNCOMMITTED（读未提交数据）一个事务在执行过程中可以看到其他事务没有提交的新插入的记录，而且还能看到其他事务没有提交的对已有记录的更新。可以解决第一类丢失更新问题。

MySQL中与事务操作相关的两种日志？#

重做日志(redo log)
- 确保事务的持久性，防止在发生故障的时间点，尚有脏页未写入磁盘，在重启mysql服务的时候，根据redo log进行重做
- 物理格式的日志，记录的是物理数据页面的修改的信息
- 事务开始之后就产生redo log，redo log的落盘并不是随着事务的提交才写入的，而是在事务的执行过程中，便开始写入redo log文件中；对应事务的脏页写入到磁盘之后，redo log的使命也就完成了，其占用的空间就可以被覆盖
回滚日志(undo log)
- 保存了事务发生之前的数据的一个版本，可以用于回滚，同时可以提供多版本并发控制下的读（MVCC）
- 逻辑格式的日志，在执行undo的时候，仅仅是将数据从逻辑上恢复至事务之前的状态，而不是从物理页面上操作实现
- 事务开始之前，将当前是的版本生成undo log；当事务提交之后，undo log并不能立马被删除，而是放入待清理的链表，由purge线程判断是否由其他事务在使用undo段中表的上一个事务之前的版本信息，决定是否可以清理undo log的日志空间
- MySQL 5.6之前，undo文件是保持在共享表空间的，这个共享表空间是不会也不能自动收缩的，所以即便回滚了版本，文件也不会变小。之后的版本支持把undo表空间配制成了独立文件，修复了这一问题

MVCC#

简介#

MVCC（multiversion concurrency control），多版本并发控制，主要是通过在每一行记录中增加2个字段，实现一个版本链：

DB_TRX_ID：6个字节，表示最近一次修改本记录的事务ID
DB_ROLL_PTR：7个字节，回滚指针，指向回滚段中的undo log record，用于找出这个记录的上个修改版本的数据

MVCC与undo log中相关记录配合使用，加上可见性算法，使得各个事务可以在不加锁的情况下能够同时地读取到某行记录上的准确值，提高了并发效率。

不同事务隔离级别下的工作#

MVCC只在REPEATABLE READ和READ COMMITTED两个隔离级别下工作。其他两个隔离级别都和MVCC不兼容，因为READ UNCOMMITTED总是读取最新的数据行，而不是符合当前事务版本的数据行，而SERIALIZABLE会对所有读取到的行都加锁。

对于另两个级别，二者的主要区别是ReadView生成策略不同。ReadView中有个列表来存储系统中当前活跃的读写事务，也就是begin了还未提交的事务，通过这个列表来判断记录的某个版本是否对当前事务可见。最主要的与可见性相关的属性如下：

up_limit_id：当前已经提交的事务号 + 1，事务号 < up_limit_id ，对于当前Read View都是可见的。理解起来就是创建Read View视图的时候，之前已经提交的事务对于该事务肯定是可见的。
low_limit_id：当前最大的事务号 + 1，事务号 >= low_limit_id，对于当前Read View都是不可见的。理解起来就是在创建Read View视图之后创建的事务对于该事务肯定是不可见的。
trx_ids：为活跃事务id列表，即ReadView初始化时当前未提交的事务列表。所以当进行RR读的时候，trx_ids中的事务对于本事务是不可见的（除了自身事务，自身事务对于表的修改对于自己当然是可见的）。理解起来就是创建RV时，将当前活跃事务ID记录下来，后续即使他们提交对于本事务也是不可见的。

对于REPEATABLE READ，只有第一次读的时候会生成ReadView，之后的读都是复用这个ReadView；对于READ COMMITTED，每次查询都会生成一个独立的ReadView。

存储引擎(MySQL)#

InnoDB#

MySQL 5.5之后的默认引擎
使用B+树作为索引结构，表数据文件本身就是索引，叶节点data域保存了完整的数据记录。索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。
索引分为两层，一层是主键索引，按照主键构建一棵B+树，只要建立了主键就会自动加上索引，叶子节点上存放着整张表的行记录数据；另一层是普通索引，叶子结点没有存放行记录的全部数据，只包含了需要的主键值，以及一个标签告诉存储引擎在哪里可以找到这行数据。

MyISAM#

MySQL 5.5之前的默认引擎
使用B+树作为索引结构，叶节点的data域存放的是数据记录的地址。
索引也是两层结构，与InnoDB类似，但是普通索引存储的是行记录的头指针
基本只适合频繁查询（读）的表，因为MyISAM锁是表锁，只有读读之间是并发的，写写之间和读写之间都是串行的，所以写起来慢

两个引擎的主要区别和选择#

InnoDB是聚簇索引，数据文件是和索引绑在一起的，必须要有主键，通过主键索引效率很高，但是辅助索引需要两次查询，先查询到主键，然后再通过主键查询到数据。因此，主键不应该过大，否则其他索引也会很大。而MyISAM是非聚集索引，数据文件是分离的，索引保存的是数据文件的指针，主键索引和辅助索引是独立的
InnoDB支持外键，而MyISAM不支持
InnoDB锁粒度是行锁，而MyISAM是表锁
InnoDB实现了缓冲管理，不仅能缓冲索引也能缓冲数据，并且会自动创建散列索引以加快数据的获取
InnoDB支持事务，MyISAM不支持。对于InnoDB每一条SQL语言都默认封装成事务，自动提交，这样会影响速度，所以最好把多条SQL放在begin和commit之间，组成一个事务
InnoDB不保存表的具体行数，执行select count(*) from table时需要全表扫描。而MyISAM用一个变量保存了整个表的行数
主机宕机后，InnoDB表恢复性更好，MyISAM表易损坏

其他引擎#

MEMORY引擎，提供内存表，不支持事务和外键。显著提高访问数据的速度，可用于缓存会频繁访问的、可以重构的数据、计算结果、统计值、中间结果。

其他问题#

Change Buffer#

当需要更新一个数据页时，如果数据页在内存中就直接更新，而如果这个数据页还没有在内存中的话，在不影响数据一致性的前提下，InnoDB会将这些更新操作缓存在change buffer中，这样就不需要从磁盘中读入这个数据页了。在下次查询需要访问这个数据页的时候，将数据页读入内存，然后执行change buffer中与这个页有关的操作。将change buffer中的操作应用到原数据页，得到最新结果的过程称为merge。除了访问这个数据页会触发merge外，系统有后台线程会定期merge。在数据库正常关闭（shutdown）的过程中，也会执行merge操作。

change buffer适合写多读少的场景（账单、日志…），页面写完后马上被访问的概率很小，对机械硬盘而言性能提升尤其明显。相反，如果更新后来紧接着查询操作，可以考虑关掉 change buffer。

自增ID用尽#

默认情况下，AUTO_INCREMENT ID的最大值是4294967295，如果想再尝试插入一条新数据，ID将不会继续增长，会导致主键冲突。因此如果数据很多时，自增ID应该尽量使用bigint unsigned，范围是 -2^63 到 2^63 - 1

如果创建表没有显示申明主键，InnoDB会自动创建一个不可见的、长度为6字节的row_id，且InnoDB 维护了一个全局的 dictsys.row_id，所有未定义主键的表都共享该row_id，每次插入一条数据，都把全局row_id当成主键id，然后全局row_id加1。虽然row_id在代码实现上使用的是bigint unsigned类型，但因为其实际长度只有6字节，因此row_id超过2^48时就会溢出，存在主键冲突可能。

另外，MySQL 保存了一个全局变量 thread_id_counter，每新建一个连接，就将 thread_id_counter 复制给这个新连接的线程变量。thread_id_counter 定义的大小是 4 个字节，因此达到 2^32 - 1 后，它就会重置为 0，然后继续增加。

数据库理论

Sat, 05 Feb 2022 00:00:00 GMT

数据库理论知识。

关系型数据库#

范式#

设计关系型数据库时，用来参考的设计规范。数据库使用范式，能够使常规的增删改查功能不易出错，并且尽可能的消除了数据库冗余。

下列范式按照从上到下的顺序，严格性逐渐递增：

第一范式1NF
- 数据库表中的每一列都是不能分割的基本数据项
- 同一列中不能有多个值
第二范式2NF
- 首先满足1NF
- 每一个非主键完全依赖于主键（“张三”同学的年龄和性别等字段，不能存储别人的年龄性别，必须是他自己的，因为张三的学号信息就决定了，这行记录归张三所有）
第三范式3NF
- 首先满足2NF
- 消除了非主属性外对于键的传递依赖（对于学生表，主键为学号，主属性为学号，非主属性为姓名、系名和系主任。因为学号 -> 系名，同时系名 -> 系主任，所以存在非主属性系主任对于键学号的传递函数依赖，不符合）
BCNF范式
- 首先满足3NF
- 不存在任何字段对键的传递依赖，相当于消除了主属性对键的传递依赖（学生,老师 -> 课程，学生,课程 -> 老师，而老师 -> 课程，主键一部分被另一部分决定，所以不符合）

连接#

数据库会（尽可能地）只产生满足where子句谓词的笛卡尔积元素来进行优化执行，这个过程就需要指定各种连接方式。内连接：

内连接(join或inner join)：关联过滤出的数据必须满足在左表和右表都符合条件。如果忘记写关联条件，就会出现笛卡尔积的情况

外连接：

左外连接(left outer join)：以左表为基本表，展示所有的左表中的数据，如果在右表中没有匹配的数据便为null
右外连接(right outer join)：以右表为基本表，展示所有的右表中的数据，如果在左表中没有匹配的数据便为null
全连接(full outer join)：全关联是只要其中某个表存在匹配的记录，便会返回行

对于上述连接，常常搭配on子句，即在on子句中指定连接条件，在where子句中出现其它的连接条件，这样的SQL可读性更好。

另外，还有自然连接：

自然连接只取出两张表的笛卡尔乘积中，那些在两个表中都出现的字段上取值相同的结果。两张表中都有的字段，只出现一次（即被合并成一列）。
常常搭配using子句来允许用户指定哪些字段相等

索引#

索引简介与分类#

索引是一种支持从数据表中高效获取数据的数据结构。

稠密/稀疏索引：

稠密索引：每个索引键值都对应有一个索引项
- 更快的定位一条记录
稀疏索引：稀疏索引只为某些搜索码值建立索引记录；在搜索时，找到其最大的搜索码值小于或等于所查找记录的搜索码值的索引项，然后从该记录开始向后顺序查询直到找到为止。
- 所占空间更小，且插入和删除时的维护开销也小。

聚集(聚簇)索引/非聚集(非聚簇)索引：

聚集索引：常说的主键索引，叶子节点就是数据节点，保存当前行的所有数据；索引项的排序方式和表中数据记录排序方式一致
- 一个表只能有一个聚集索引，因为行记录只能按照一个维度进行排序
- 使用场合：1 查询命令的回传结果是以该字段为排序依据 2 查询的结果返回一个区间的值 3 查询的结果返回某值相同的大量结果集
- 降低了insert和update的性能
非聚集索引：叶子节点仍然是索引节点，只不过有指向对应数据块的指针；索引顺序与物理存储顺序不同
- 使用场合：1 查询所获数据量较少 2 某字段中的数据的唯一性比较高
- 必须是稠密索引

索引与主键的区别#

主要区别：

主键用于标识关系型数据库中某行记录唯一性，不允许记录重复，且键值不能为空；索引没有这些限制，数据库里不一定有索引，索引列中的值也可能有重复
数据表中只允许有一个主键，但是可以有多个索引。
使用主键会数据库会自动创建主索引，因此主键本身也是一个特殊的唯一索引；但同时也可以在其他非主键上创建索引

效率比较：主键是唯一索引，聚簇索引（一般是哈希索引，…），因此通常会比较快，而索引实现有多种方式，可能是唯一索引可能是普通索引，性能不能一概而论，要结合具体的使用场景来看（change buffer…）

B+树#

特点#

非叶子节点只进行数据索引，使得B+树非叶子节点容纳关键字的能力大大增加
所有叶子节点之间都有一个链指针，关键字从小到大有序排列
数据记录都存放在叶子节点中，每次数据查询的次数都一样，都是从父节点到叶节点

这样设计的好处是极大增加了每个节点存储的key值数量，降低了B+树的高度。由于索引文件常常存储在磁盘上，索引查找会产生磁盘I/O消耗，由于B+树的高度很低，因此I/O开销很低。

与二叉树/B树的对比#

对比二叉树： 对普通的二叉搜索树来说，构建的过程很容易使得树的两支高度不平衡，进而使得搜索的性能退化；而如果使用AVL或者红黑树等二叉平衡树，维护的代价非常大，因为每次插入更新数据时都要经过多次的旋转操作维持平衡，浪费时间。

对比B树：

B+树的层级更少：相较于B树B+每个非叶子节点存储的关键字数更多，树的层级更少所以查询数据更快；
B+树查询速度更稳定：B+所有关键字数据地址都存在叶子节点上，而B树有些是存在非叶子节点的，所以每次查找的次数都相同所以查询速度要比B树更稳定;
B+树天然具备排序功能：B+树所有的叶子节点数据构成了一个有序链表，在查询大小区间的数据时候更方便，数据紧密性很高，缓存的命中率也会比B树高。
B+树全节点遍历更快：B+树遍历整棵树只需要遍历所有的叶子节点即可，而不需要像B树一样需要对每一层进行遍历，这有利于数据库做全表扫描。

缺点#

如果查询的时候，需要非常频繁地获取到某些离根节点很近的数据，使用B树可能比B+树更高效，因为非叶子节点本身存有关键字数据的结构，可以进一步节省遍历树的时间。

哈希索引#

Hash索引是将索引键通过Hash运算之后，将Hash运算结果的Hash值和所对应的行指针信息存放于一个Hash表中。

优点：搜索效率高，一次定位缺点：

比较进行Hash运算后的值，只能用于等值过滤，不能进行范围查找
数据不按照索引顺序存储，因此也不能用于排序
哈希值可能存在冲突

事务#

简介#

若干个对数据库进行增删改查的SQL语句构成一个事务。事务主要用于处理操作量大，复杂度高的数据，用来维护数据库的完整性。

事务需要满足四个条件（ACID）：

原子性：一个事务中的所有操作，要么全部完成，要么全部不完成。如果事务在执行过程中发生错误，会被回滚到事务开始前的状态
一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏，写入的数据必须完全符合所有的预设规则
隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离有4个不同级别，详见下文。
持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

两阶段锁#

两阶段锁（two-phase locking，2PL）是数据库事务处理时的并发控制方法，用于保证可串行化。这种方法把数据库锁分为两个阶段：

扩张阶段：事务根据需要不断地获取锁，没有锁被释放
收缩阶段：锁被事务陆续释放，没有新的加锁

本质上来说，2PL通过锁的设置保证了在每一组冲突操作中，第一个获得锁的事务一定会排在后来的事务之前执行，从而实现了等价于串行执行。此外，2PL使得事务具有较高的并发度，因为解锁不必发生在事务结尾。

2PL的不足是没有解决死锁的问题，因为它在加锁阶段没有顺序要求。如果两个事务分别申请了A, B锁，接着又申请对方的锁，此时就进入死锁状态。

非关系型数据库#

简介#

在数据量达到一定规模时，由于关系型数据库的系统逻辑非常复杂，会导致诸多问题：

为了维护一致性，常常需要进行加锁等操作，导致其读写速度下滑非常严重
对数据表结构进行调整十分不方便，降低了可维护性
高并发时，磁盘I/O是一个很大的瓶颈

非关系型数据库（NoSQL）是对不同于传统的关系数据库的数据库管理系统的统称，有着以下的特点：

数据以键值对存储，且结构不固定，每一个元组可以有不一样的字段，每个元组可以根据需要增加一些自己的键值对。
不使用 SQL 作为查询语言，一般是基于每个NoSQL数据库具体的数据结构等等自己设计语法来查询

优缺点#

非关系型数据库的出现，多是源于关系型数据库的性能不足，所以优点基本是建立在关系型数据库的缺点上。

读写性能：无需经过 SQL 层的解析，读写性能很高。主要例子有Redis，由于其逻辑简单，而且纯内存操作，使得其性能非常出色，单节点每秒可以处理超过10万次读写操作
简单的扩展：基于键值对，数据没有耦合性，容易扩展。典型例子是 Cassandra，由于其架构是类似于经典的 P2P，所以能通过轻松地添加新的节点来扩展这个集群
存储格式多：支持key-value形式、文档形式、图片形式，而关系型数据库则只支持基础类型
低廉的成本：这是大多数分布式数据库共有的特点，因为主要都是开源软件，没有昂贵的License成本

当然，非关系型数据库也有一些缺点：

不支持 SQL 这样的工业标准，会对用户产生一定的学习和应用迁移成本
支持的特性不够丰富：比如说很多NoSQL数据库都不支持事务

数据库缓存问题与解决#

缓存穿透#

问题：key对应的数据在后端数据库并不存在，比如用一个不存在的用户id获取用户信息，每次针对此key的请求从缓存获取不到，请求都会到数据库，从而导致数据库崩溃

解决：采用BloomFilter，类似于一个基于哈希的集合，用来判断某个元素key是否存在于某个集合中。提前把有数据的key都放到BloomFilter中，每次查询的时候都先去BloomFilter判断，如果没有就直接返回null

缓存击穿#

问题：key对应的数据存在，但在Redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般会从后端数据库加载数据放到缓存，这个并发请求可能会把数据库压垮

解决：在缓存失效的时候，不立即去数据库加载数据，而是就运用互斥锁机制，只有拿到锁的第一个线程去请求数据库，然后插入缓存；其他的线程都等待若干时间后重新尝试从缓存中获取数据

缓存雪崩#

问题：当缓存服务器重启或者大量缓存集中在某一个时间段失效，后端数据库访问量增大导致崩溃

解决：采用服务器集群，提高容错率；或者引入本地缓存，Redis崩了靠本地还能支撑一阵

火焰纹章风花雪月四线心得

Tue, 01 Feb 2022 00:00:00 GMT

翠风，红花，银雪，苍月

背景#

本人于2020年在switch上开始游玩《火焰纹章：风花雪月》(ファイアーエムブレム風花雪月 / Fire Enblem: Three Houses)，这是我初次接触到火焰纹章系列这一经典的回合制策略战棋游戏IP。我对这款游戏极为痴迷，耗费200余小时将全部四条剧情线打通。此文可看作通关后个人对每条线剧情、优缺点的总结分析，也可看作是游玩后意犹未尽的消遣。

本作设定位于三雄鼎立的芙朵拉大陆上，三股势力分别是位于南部的阿德剌斯忒亚帝国，位于北部的法嘉斯神圣王国以及位于东部的雷斯塔诸侯同盟，彼此之间互相制衡。芙朵拉大多数居民都信奉赛罗司教，而大陆正中央区域正是加尔古·玛库大修道院，即赛罗司教中央教会的所在。多年以来教会高高在上，依靠传教以及修道院中武力强大的骑士团维持整块大陆的稳定。同时大修道院中还建有一座著名的士官学校，这所学校历史悠久，为芙朵拉大陆培养了诸多人才。故事开始之时，三个国家未来的领袖，以及来自三个国家的许多贵族、平民学生正要进入学校开始学习。游戏前半部分的学院篇也根据学生们的国籍分为了三个学级：黑鹫、青狮和金鹿。

从本作英文译名Three Houses来看，翻译者强调了“3”这个数字，既代表大陆上的三个国家，又代表了学校中的三个学级。但我认为这个翻译是不准确的，因为赛罗司教会同样是一股重要的势力，虽然其没有成为一个独立的国家，但它对于芙朵拉跨越千年的故事发展起到了决定性作用。从这个角度上看，游戏的日文原名“風花雪月”更加贴切，因为游戏后半部分的章节名字分别以翠风、红花、银雪、苍月进行命名，四个名字分别对应三国与教会中的某一股势力，玩家也将协助这股势力实现一统芙朵拉的伟业。当然制作组以“风花雪月”命名也有其他寓意，按照游戏监督草木原俊行在接受采访时所谈：

…“风花雪月”出自中文成语，指的是风雅的、美丽的景色。我们经过很久才选定这个标题。副标题不只是强调“美丽”，还意味着季节感、时间流逝和生命的无常。我个人认为，“时间”对这款作品来说是很重要的要素。

翠风（金鹿线）#

翠风之章，对应雷斯塔诸侯同盟，同时对应游戏前半部分学院篇的金鹿学级。

金鹿线通关后令人感觉“天朗气清，惠风和畅”，如同春风拂面。这条线是四线中将游戏设定讲述得最为透彻的一条，玩家能彻底了解芙朵拉千年以来的恩怨情仇，同时也能顺藤摸瓜清理反派，不仅端掉了暗黑蠢动者的老巢，甚至还灭了千年前被封印的解放王与十杰大军。这样的结局不能说从此高枕无忧，但至少现有的历史遗留问题得到圆满解决。

同盟盟主库罗德是促成这一局面的重要功臣。库罗德被称为“战略桌上的神鬼军师”，从称谓上就能看出他是一个城府极深，波诡云谲的人物。他的智谋体现在多个方面，包括维护同盟稳定的高超手段、军事指挥上的神出鬼没、以及对芙朵拉历史敏锐精准的剖析。从游戏前半部分学院篇开始，他就对教会的历史、主角的能力展现出了浓厚的兴趣，一直暗中调查真相。金鹿线的后半部分也是他一直保持着这种强烈的探索欲，促成了真相大白的结局。然而，库罗德的出身背景以及他过人的智谋，也让他在与人交流时无法百分百信任对方。五年后库罗德和主角重逢时，他并不相信主角沉睡五年失忆的说辞，并对主角的能力产生了怀疑，借着清除盗贼的名义试探主角是否退步，今后还能否为他所用。尽管随着剧情的发展他逐步对主角敞开心扉吐露了自己的理想，也和主角开始称兄道弟（是否100%真心就见仁见智了），但结合整条线的剧情来看，他始终都必须依赖主角的身份（挂着炎之纹章的军旗）才能施展计划，比起另两位级长几乎无条件对主角的依赖，库罗德的似乎总是有所保留，心中也一直有自己的算盘。

整体而言，金鹿线的基调趋于理性，同盟军有能力独立思考自己为什么而战斗，所有的行动也基于自己的意志。这样的理性让他们谋定而后动，立场上也不囿于支持教会 vs. 反对教会的二元对立中。这个基调主要也源于库罗德的观念，他认为世界的进步源于各种各样的变革，固步自封只也会被思想的洪流冲垮，因此重要的不是站定某一方立场之后一成不变，而是从正反两面各自吸取优点，以此作为变革的前提。在金鹿线进攻帝国梅利赛乌斯要塞时，正是库罗德打破了芙朵拉和帕迈拉人之间的成见，借助了帕迈拉的军队的力量组成跨国联军，进而顺利攻下要塞。这里需要额外补充库罗德的背景：库罗德的母亲是同盟女子，当年远嫁岛芙朵拉大陆以外的敌国帕迈拉，生下了库罗德。混血身份让他无论身处哪个国度都得不到完全的认同，两个民族都因血统不纯而排挤他。长年累月的孤独感催生了他的梦想：他要打碎芙朵拉和外界的隔阂，让所有人不再介意民族、血液与身份而生活在一起。于是他的立场出现了两面性：一方面，他需要借助支持赛罗司教会的名头举起义旗，利于他获得更多支持；另一方面，他的终极理念与教会的教义背道而驰，毕竟芙朵拉的封闭性是由教会长期的思想灌输引起的，芙朵拉人民与异教徒老死不相往来。因此，库罗德并不介意教会在战争结束后是否倒台，即便教会仍然存在，他也会对其进行变革，逐步解放芙朵拉人民的思想。

红花（黑鹫线）#

红花之章，对应阿德剌斯忒亚帝国，同时对应游戏前半部分学院篇的黑鹫学级。由于级长艾黛尔贾特是阿德剌斯忒亚帝国即将继任的皇女，因此此线又被称为皇女线。

黑鹫线是四条线中争议最大的一条线，艾黛尔贾特也可以说是游戏中争议最大的角色。根据草木原俊行披露的情报，制作组原先并未考虑制作皇女线，并且另外三条线中的立场或多或少也是偏向教会的：

金鹿线中，同盟虽然终极目标与教会的教义冲突，但当下并无与教会发生正面冲突的必要，同盟有能力温和地实行思想改革，并且当下依然需要教会的名头获得支持。
教会线中，主角势力的立场本身就是维护教会，击败任何挑战教会权威的势力。
青狮线中，王国终极目标是建立一个天下大同的社会，消除人与人之间的隔阂。教会将成为王与民之间的一座桥梁，保护更多的老百姓过上好日子。

然而开发后期，制作组内部有了开拓艾黛尔贾特“霸道”路线的想法，于是他们基于支持教会的立场反向逆推设计了红花之章。这导致黑鹫线与另外三条线是对立的。因此，对于游玩其他三线的大部分玩家而言，他们很容易产生“帝国、皇女是反派”这样的想法。

事实上，皇女和其他国家的领袖一样，试图建立全新的社会秩序，希望社会不会再有弱者受到压迫，只不过皇女将这种压迫归结于教会，毕竟教会用纹章控制着社会的运转。基于纹章的社会体制让皇女经历了诸多动乱，她本人连同兄弟姐妹也成为了纹章实验的牺牲品。皇女希望人民不要单纯信奉教会，即便是一个存在千年的正统势力也未必是始终合理的。另外，在黑鹫线中，因为有了与皇女深入相处的机会，玩家能够揭露皇女温柔细腻的一面。不管她对其他人的态度如何，她对主角一直十分仰慕与信赖，与主角肝胆相照。即便主角最后失去神力，她也依然陪伴在主角身边。多遭磨难的皇女早已养成了坚强的品性，但当她卸下自己的担子，像个普通女子一样向亲近之人寻求慰藉之时，场景还是十分温馨的。

然而皇女大多数时候性格强横，行事雷厉风行、杀伐决断，颇有一代女帝武则天的风范。对于阻拦她道路的人，无论曾经的交情如何，下场只有被击败。并且帝国军并不是那么“师出有名”，恐怕只有痴迷皇女人物设定，或者是热衷皇女与主角组CP的玩家能无条件接受她的“霸道”理念。整条线存在两个最大的争议点：

化身炎帝，联合暗黑蠢动者共同颠覆芙朵拉大陆。尽管剧情多次提到皇女和暗黑蠢动者只是暂时互相利用的关系，深层价值观并不契合，并且主角到来之后帝国也逐渐和暗黑蠢动者划清界限，然而君子论迹不论心，皇女选择与邪恶为伍是不争的事实，并且她的选择也造成了诸多无法回头补救的悲剧（例如主角父亲因此丧命）。
理念激进，天马行空。皇女选择了最粗暴的战争方式建立全新的社会秩序，并以丑化教会的方式煽动帝国士兵发动战争。然而对信奉赛罗司教会的芙朵拉百姓而言，教会多年来并没有让他们遇到什么不幸，此时皇女却将个人意志强加于他们头上，必须接受没有教会这一现实。事实上，即便消除了教会，世界弱肉强食的法则仍然无法被改变，只要社会阶级制度存在，独立自主就极难实现，依然会有弱者如同当年的她一样被社会的不公给折磨。

此外，前文已经提到黑鹫线是开发中后期临时决定制作的，因此这条线赶工痕迹明显，相比起其他线有若干明显缺陷：

许多和教会、骑士团相关的人物会离开主角队伍。如果想要追求阵容热闹和深度的话，黑鹫线的可用人物会比其他线少一些。
流程过短。从章节数量来看，黑鹫线的18章要显著少于另外三条线的21或22章。这导致游戏人物成型时间短，相比起其他线少了至少三章的时间培养学生的能力，有的学生甚至来不及培养到最高级职业或最高级能力就已经通关了。
缺失了其他三线中的一些经典关卡，例如黎明追击战（金鹿、青狮、教会线）、古隆达兹三方会战（金鹿、青狮线）以及香巴拉之战（金鹿、教会线）。这几个关卡不仅难度有挑战性，更能提升游戏剧情的深度以及角色形象感染力。而黑鹫线总体游玩下来只是秦王扫六合般地攻城略地，所到之处战无不胜，统一大陆后戛然而止，铺垫已久的隐藏反派暗黑蠢动者限于篇幅没有交代清楚结局。
游戏中存在着学生挖角机制，原本和帝国敌对的学生们将跟随主角一同为帝国而战。没有挖角时，这些学生本应立于战场的另一侧，像真正的战士那样向主角发出灵魂拷问，即便死也是熠熠生辉地死去；但挖角后，每个角色犹如迷失自我一般，忘记了亲人、师长、朋友，只是机械地为了追随主角而碌碌地活着。从常理上分析，我也不认为主角和学生之间的仅仅一年的师生情能让这些有血有肉的角色做出背弃家国和亲朋好友的选择。

总结，黑鹫线作为一条制作组创新加入的线路，出发点和立意值得肯定，但整体演绎效果不尽如人意。艾黛尔贾特本人的形象塑造毁誉参半，但勉强配得上生如“红花”之绚烂。作为一条对立于其他线立场的剧情线，黑鹫线在反向设计每个学生的立场时存在着诸多逻辑漏洞，好在皇女和主角之间确实能产生共鸣。个人而言，黑鹫线适合喜欢皇女人设的玩家无脑入坑；或者是在多周目时通关一次，作为对其他线游戏体验的补充。

银雪（教会线）#

银雪之章，对应赛罗司教教会，学院篇时也对应黑鹫学级。

教会线是完全对立于黑鹫线存在的一条线。这两条线都必须在学院篇选择黑鹫学级。玩家如果选择帮助艾黛尔贾特登基并对抗教会，则进入黑鹫线；反之自动进入教会线，代价就是黑鹫学级之后缺少了级长皇女和跟班修伯特。这条线的立场也很纯粹：找到教会前任大司教蕾雅（青狮和金鹿线也要找，不过更像是实现其他目标时顺带完成）并复兴教会。主角将成为领袖组建一股势力，击败帝国并结束战争。

教会线在剧情编排上与金鹿线基本一致（重返修道院直到捣毁暗黑蠢动者老巢），但立场上不再局限与某个国家。主角引领的“新生军”自成一派，在帝国、王国、同盟三方之间周旋，从前期的夹缝中求生存逐步发展到后期的一统大陆。人物刻画上则偏重于原本教会中的人物，尤其是大司教蕾雅，这一条线中蕾雅会亲自出场解答关于主角身份、教会历史相关的诸多谜团；这也是唯一一条能和蕾雅达成S支援的剧情线。

教会线最大的特点是提供了一个更加独立的视角审视整块芙朵拉的局势变化。主角所在的新生军前期势单力薄，四处游走，还需要向同盟借兵渡过难关。但在主角的英明指挥下，新生军后来居上，证明了自己的实力并不弱于帝国、王国与同盟之间的任意一方。由于势力上的独立性，新生军缺席了古隆达兹的三方会战，虽然造成了游戏性的缺憾，但在剧情动画中通过士兵转述视角得知三方均伤亡惨重、悻悻而归的结局，某种程度上也有一种转述震撼感，让玩家意识到战争是多么残酷。教会原本的宗旨就是为人民带来幸福，这样的设定也能够增强玩家的使命感，更好代入教会的立场拯救芙朵拉。

此外，一些在其他线中上镜率没那么高的教会人物有了大放异彩的机会。尤其是西提司，在教会线中他成为了实际意义上的级长，发挥了中流砥柱的作用。而对于蕾雅的细腻刻画更能让人了解到这位神祖后裔千年来背负的孤独和使命。主角的诞生本质上是蕾雅触犯禁忌的后果，但玩家得知其身份后也能理解她的行为，更能体会到她一直以来对亲人倾注的情感。

不过，倘若玩家对教会的人物，尤其是蕾雅本人没有兴趣时，游玩教会线的意义就不大了。教会线与其他线的重复程度过高，学院篇几乎与黑鹫线的流程完全一致，仅一章有区别；战争篇则与金鹿线重复，玩家在金鹿线中同样能救出蕾雅并了解到事件的来龙去脉，更何况金鹿线还额外将当年反教会的余孽铲除得干干净净，这是教会线没有做到的。此外教会线的终章剧情我认为设计的比较失败：蕾雅因为受伤压制不住纹章之力，化身白兽姿态进攻修道院。虽然这个变身的理由是合理的，但这样的转变无疑让玩家短时间内难以接受，花费诸多气力刚救出来的人转眼间就要拔剑相向。。

苍月（青狮线）#

苍月之章，对应法嘉斯神圣王国，同时对应游戏前半部分学院篇的青狮学级。由于级长帝弥托利是法嘉斯神圣王国即将继任的王子，因此此线又被称为王子线。

贯穿青狮线的线索毫无疑问是达斯卡悲剧，青狮学级的人物因这场悲剧紧密地联系在一起。达斯卡悲剧的幕后黑手是暗黑蠢动者，他们希望挑起王国和帝国之间的全面战乱，进而颠覆芙朵拉，于是和王国内部的反王势力里应外合，在国王出行至达斯卡时突然发难。王国在悲剧中损失惨重，国王蓝贝尓本人以及包括古廉（菲力克斯的哥哥，英谷莉特的未婚夫）在内的骑士卫队成员被杀；另一名骑士古斯塔夫（雅妮特的父亲）救驾来迟，只救下了幸存的帝弥托利，古斯塔夫无法原谅自己护驾来迟，从此在修道院中隐姓埋名。而达斯卡被扣上了弑君的恶名，王国军向达斯卡人发起了惨无人道的清洗，少数像杜笃（被帝弥托利所救）这样幸存的达斯卡人在王国依然被人指指点点，地位堪忧。帝国皇女艾黛尔贾特本人并未直接参与达斯卡悲剧，但她是毋庸置疑的受益者（根据暗黑蠢动者领袖塔烈斯的原话，这是为了让炎帝获得力量）。可怜的帝弥托利在年少时曾与艾黛尔贾特两小无猜般地相处过一段时间，当时就对她颇有好感，临别之际赠予其短剑一柄；后来得知皇女与自己是名义上的姐弟时，更对她产生了亲人之情。然而这一切在炎帝身份的揭露后被彻底打碎，亲朋好友的惨状、父亲临终嘱托复仇的亡语如芒在背，王子不堪重负彻底黑化，将所有的仇恨转移到了炎帝身上。整个苍月之章的剧情由此变成了王子复仇记。

如果说金鹿线是四条线中最能凸显理性的一条，那么青狮线则是感性的巅峰。帝弥托利可以说是整个火焰纹章风花雪月刻画得最为生动、立体的角色，他每一次性情的转变都极大地影响着故事发展。王子并没有太深的城府，更没有其余两位级长的计谋，但他是一个善良热忱的青年，一直彬彬有礼以德服人，这使得他的人格魅力丝毫不逊于另两位级长。然而隐藏在温和外表下的是一颗渴望复仇的暴戾之心，毕竟对王子而言达斯卡悲剧始终如鲠在喉，只是他竭尽全力压制住了这种欲望。遗憾的是，炎帝身份的揭露让王子最终崩坏，沦落为一个杀手四海为家，用残忍的屠杀逃避死者在他脑海中一遍遍的诘难。即便与主角和昔日同窗重逢，他也不再信赖曾经的伙伴们。他对周围的人们恶语相加，也不再参与学院里的活动，就连上阵杀敌的语音也如同幽灵一般冷血。

幸运的是，青狮线里其他的伙伴们展现出了极大的坚毅与包容。他们的每个人身上都背负着一个悲剧，但没有一个人一蹶不振。所有人都在积极地生活，同时也在尽可能地帮助他人渡过难关，这也是许多玩家感叹青狮的伙伴们“犹如天使一般”的原因。即便重逢后王子展现出了颓丧的精神状态，他身边的伙伴们都在用自己的方式帮助他走出困境。众人的开导、战局的扭转、杜笃的回归、以及罗德里古付出的生命的代价，最终让王子恢复了理智。这个过程是漫长且艰难的，因此剧情上也不遗余力地铺垫了数节，让玩家能有充分的时间代入到剧情中。而再一次经历巨变，或者说是回归本心的王子，体现出的气度同样令人动容。只要皇女的理想符合他心中的道德准则，他愿意抛开仇恨，探究与皇女共存的可能。这一刻，那个胸怀天下，不遗余力建设大同社会的贤君又回来了。

不过，青狮线耗费过多笔墨刻画帝弥托利复仇，导致其在剧情真相揭露上并不清晰。贯穿全线的达斯卡悲剧直到通关之际，尚有许多疑问未能解开，玩家甚至需要通过王子和哈琵的支援对话补充更多的细节。而关于暗黑蠢动者的描述更是稀少，整个苍月之章中主角一行都不知道自己在战斗中击败的“神秘士兵”“神秘魔道士”们究竟是什么来历；如果不玩其他线，根本不知道死去的亚兰德尔公实际上就是塔烈斯；如果没有尤里斯与康斯坦洁的外传，终章中暗黑蠢动者的另一位领袖谬森也将极为突兀地登场，并且被稀里糊涂剿灭。只能说上天暗中眷顾了王国这些为了心中理想而奋斗的人们，因为实际上暗黑蠢动者的诸位重要人物已经在青狮线中被清理干净，达斯卡悲剧的主谋们得到了应有的惩罚。

学级人物上，青狮线在全挖角的情况下可以拥有四线最多的可操控角色，可以说是最热闹的一条线。级长帝弥托利很可能是整个游戏中属性成长最为变态的一个角色，无论是走地打拳、马上骑兵甚至飞龙上天都有很高的强度。此外，青狮线的许多角色之间原本就有颇深的交情，因此支援剧情观看起来沉浸感更强。如果想要体验厚重的剧情风味与深刻的人物形象塑造，青狮线是最佳的选择。

总结#

火焰纹章风花雪月是一款优秀的游戏，四条剧情线各有千秋，在此不分高低优劣。在我看来，玩家一周目接触的剧情线尤为重要，因为人往往会犯先入为主的毛病，一周目会影响玩家后续多周目时对新一条线的评价。此外，同一个人物在不同剧情线中的表现可能大相径庭，因此也建议各位玩家游玩每一条线路时格局放开，尽可能站在每个角色在每条线中所处的立场上思考，用心感受制作组希望传达的思想。过于信奉某一条线的立场而对其他线充满偏见，便是一叶障目的不智之举了。

后记：近日火焰纹章风花雪月衍生作Fire Enblem Warriors: Three Hopes发售，以三学级为引开拓出三条新故事线，虽丰富了诸多火焰纹章风花雪月中的人设与故事，然而原汁未必原味，该作剧情高开低走，且三条线均是结尾戛然而止，令玩家不知所云，倍感突兀。此诚编剧狗尾续貂之作，不值一提。

操作系统

Sun, 16 Jan 2022 00:00:00 GMT

操作系统知识点。

进程，线程，协程#

简介#

进程：

进程是正在执行的程序
系统资源分配的最小单位，每个进程得到一定的资源，比如CPU时间、内存、I/O设备等等来完成任务
进程对应的内存空间中，分为以下数据区：
- BSS(Block Starting Symbol)，存放程序中未初始化的全局变量，属于静态内存分配
- 数据段，存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。
- 代码段，存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，通常属于只读区域；同时也可能也有可能包含一些只读的常数变量，例如字符串常量等
- 堆，存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减 (malloc, free等函数分配/释放内存的位置)
- 栈，用户存放程序临时创建的局部变量。在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。

线程：

线程属于进程，一个进程内可能有一至多个线程。
线程是CPU调度的最小单位，每个线程由独自享有线程ID、程序计数器、寄存器、栈等
每个线程与属于同一进程的其他线程共享进程地址空间、代码段、数据段、堆等资源

协程：

协程属于线程，协程的程序在线程内部运行，但是有自己的寄存器和栈
协程的调度切换完全在用户空间进行，只涉及基本的CPU上下文切换，没有内核切换的开销，非常快
因为只有一个线程，不存在同时写变量冲突，因此不需要多线程的锁机制，执行效率更高

多进程/多线程编程的优点与取舍#

为并发而设计，能够响应并提供更多服务。

具体的选择，需要看具体的需求和资源限制

数据共享与同步：多进程在共享上复杂，但在同步上容易；多线程则相反。
内存与CPU：多线程编程，因为它的内存成本较低，而且多线程的上下文切换也比较容易。
可靠性：多进程编程，因为进程之间不容易相互影响

多线程比单线程慢的例子#

在一个单核单处理器上：

使用1个线程，循环打印100万个字符
使用100个线程，循环打印100万个字符

这种情况下，使用100个线程会更慢，因为输出字符使用临界区资源，第二种情况在线程抢占资源上会浪费很多时间；而单核线程不用抢占。

进程和线程的生命周期#

进程的生命周期：

新建：进程被创建
执行：进程被执行
等待：进程等待某个事件发生，例如I/O完成或其他信号
就绪：进程等待分配CPU
终止：进程完成执行

process-cycle.png

线程的生命周期：

新建状态（New）：当线程对象对创建后，即进入了新建状态
就绪状态（Runnable）：当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，
运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，必须处于就绪状态中
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
1. 待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态
2. 同步阻塞 — 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态
3. 其他阻塞 — 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。需要保证在一定的情况下，线程的run()方法能够正常执行完毕；或者，使用标志位 / 抛出中断来退出线程。

thread-cycle.png

补充：触发中断退出线程阻塞状态时，如果有interrupt()发生，系统除了会抛出InterruptedException异常外，还会调用interrupted()函数，调用时能获取到中断状态是true的状态，调用完之后会复位中断状态为false，所以异常抛出之后通过isInterrupted()获取不到中断状态是true的状态，从而不能退出循环，因此在线程未进入阻塞的代码段时是可以通过isInterrupted()来判断中断是否发生来控制循环，在进入阻塞状态后要通过捕获异常来退出循环。

1
public class ThreadSafe extends Thread {
2
    public void run() {
3
        while (!isInterrupted()) { //非阻塞过程中通过判断中断标志来退出
4
            try {
5
                Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
6
            } catch(InterruptedException e) {
7
                e.printStackTrace();
8
                break;//捕获到异常之后，执行break跳出循环。
9
            }
10
        }
11
    }
12
}

进程间通信机制（IPC）#

进程间通信有四种基本模式：共享内存、消息传递、套接字、信号量

共享内存：

一块共享内存区域驻留在生成共享内存段进程的地址空间上，所有希望使用这个共享内存段进行通信的进程必须把这个区域放到进程自己的地址空间上。进程在共享区域内读写来交换信息。

采用共享内存能够解决生产者——消费者问题，即：为了允许生产者与消费者进程并发执行，要有一个缓冲区同时被生产者填充，并被消费者使用，这个缓冲区就驻留在两个进程的共享内存区域。有两种缓冲：

无限缓冲：缓冲大小没有限制，生产者一直生产新的项，缓冲为空时消费者要等待
有限缓冲：缓冲大小固定，缓冲为空时消费者要等待，缓冲满时生产者要等待

消息传递：

通过发送和接收消息来传递信息，不必共享内存地址空间。一般实现发送和接收消息操作的方法有：

管道，又可以分为匿名/命名管道：
- 匿名管道：一个管道和两个进程相连，管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。由于匿名管道基于fork机制，因此匿名管道只能用于父子进程之间
- 命名管道：基于文件的路径来识别管道，能让没有亲缘关系的进程也建立连接
消息队列

通信进程交换的消息驻留在临时队列中，本质上消息队列是消息的链表。可以根据定义队列的容量，改变队列的缓存能力。一般来说，消息队列容量比管道大。

套接字(Socket)：

Socket是应用层和传输层之间的一个抽象层，把TCP/IP层的操作抽象成简单接口，供应用层调用。两个进程即便不在同一台计算机，只要有网络连接，也能相互通信。同时Socket的设计也能清楚的将服务器端和客户端区分开。具体工作流程见计算机网络部分。

信号量：

信号量（Semaphore）是一个同步对象，用于保持在0至指定整数最大值之间的一个计数值。当线程需要资源时，会对该信号量对象执行wait()操作，信号量计数值减一；当线程释放资源时，会对该信号量对象执行signal()操作，信号量计数值加一。

多线程模型#

两种线程：

用户线程：位于用户层，受内核支持，无须内核管理
内核线程：由操作系统直接支持管理

多线程模型：用于提供线程支持

多对一模型：
- 许多用户级线程映射到一个内核线程，线程管理由线程库在用户空间进行
- 如果一个线程执行阻塞调用，整个进程会被阻塞，因为任意一个时刻，只有一个线程能访问内核
一对一模型：
- 一个线程执行阻塞系统调用时，允许另一个线程继续执行，提供了更好的并发行
- 创建内核开销大
多对多模型：
- 开发人员可创建任意多的用户线程，相应的内核线程能在多处理器上并发执行
- 一个线程执行阻塞系统调用时，内核能调度另一个线程执行

I/O模型#

常见I/O模型#

阻塞I/O模型(BIO)：

进程发起I/O系统调用后，进程被阻塞，转到内核空间处理，整个I/O处理完毕后返回进程。操作成功则进程获取到数据
进程阻塞挂起不消耗CPU资源，及时响应每个操作
不适用并发量大的应用，因为一个请求I/O会阻塞进程，所以，得为每个请求分配一个处理进程（线程）以及时响应，系统开销大

blockingIO.png

非阻塞I/O模型(NIO)：

进程发起I/O系统调用后，如果内核缓冲区没有数据，需要到I/O设备中读取，进程返回一个错误而不会被阻塞；一旦内核缓冲区有数据，内核就会把数据返回给进程
不会阻塞在内核的等待数据过程，每次发起的I/O请求可以立即返回，不用阻塞等待。在数据量收发不均，等待时间随机性极强的情况下比较常用
进程重复调用recvfrom，试图获取数据，消耗CPU的资源

nonblockingIO.png

I/O多路复用模型(IO multiplexing)：

多个的进程的I/O可以注册到一个复用器（select）上，然后用一个进程调用该select，select会监听所有注册进来的I/O，如果监听的IO在内核缓冲区都没有可读数据，select的调用进程会被阻塞；而当任一IO在内核缓冲区中有可数据时，select调用就会返回。select调用进程可以通知另外的进程（注册进程）再次发起读取IO，读取内核中准备好的数据。
除了select，Linux中还拥有几个调用来实现I/O复用的系统调用，例如poll和epoll
- Select：进程能够监视的文件描述符的数量存在最大限制，注册I/O、阻塞扫描，监听的I/O最大连接数不能多于FD_SIZE；只能无差别轮询所有流；内核需要将消息传递到用户空间，需要内核拷贝动作
- Poll：原理和Select相似，只是使用链表保存文件描述符，没有最大连接数的限制；仍然只能无差别轮询所有流；内核需要将消息传递到用户空间，需要内核拷贝动作
- Epoll ：event poll，会把哪个流发生了怎样的I/O事件通知我们。所以epoll实际上是事件驱动，只有活跃可用的FD才会调用callback函数；没有最大并发连接的限制，只管“活跃”的连接，而跟连接总数无关；内存拷贝，利用mmap()文件映射内存，让内核和用户空间共享一块内存，减少复制开销

IOmultiplexing.png

异步I/O模型(AIO)：

当进程发起一个I/O操作，进程不被阻塞，继续执行；内核把整个I/O处理完后，会通知进程结果。如果IO操作成功则进程直接获取到数据。
不阻塞，数据一步到位
非常适合高性能高并发应用

asyncIO.png

I/O种类对比#

同步vs异步：线程的执行过程中，产生一个系统调用，如果需要等待该调用返回才能继续线程流则叫做同步，不需要等待结果返回线程流可以继续往下执行的情况叫做异步。

同步：双方的动作是经过双方协调的，步调一致的
异步：双方并不需要协调，都可以随意进行各自的操作。

阻塞vs非阻塞：线程执行过程中，产生一个系统调用后，如果线程流会被这个调用“堵”住，对应的是阻塞，反之为非阻塞。

CPU调度#

简介#

每当CPU空闲时，操作系统必须从就绪队列选择一个进程执行，进程选择由短期调度程序或者CPU调度程序执行。

多道程序的目标是任何时候都有某些进程都在运行，使得CPU的使用率最大化。很多时候，进程执行到一半需要等待（例如等待I/O完成），这时候CPU就会空闲。因此，当进程必须等待时，操作系统会从该进程拿走CPU使用权，将CPU交给其他进程。

长期/短期调度程序#

对于批处理系统，进程更多是被提交到磁盘的缓冲池，保存在这里以便以后执行。

长期调度程序，或作业调度程序，从这个缓冲池里选择进程，装入内存以准备执行。长期调度程序控制着多道程序设计的程度（内存中的进程数量）。短期调度程序，或CPU调度程序，从准备执行的进程中选择进程，为之分配CPU。有的操作系统还有中期调度程序，将进程从内存中移出，之后再被重新调入，从中断处继续执行（交换）。

上下文切换#

进程上下文一般是用进程进程控制块(PCB)表示，包括CPU寄存器的值、程序计数器、内存管理信息等等。上下文切换指将一个进程的上下文存储到系统内核中，然后将另一个进程的上下文恢复加载到CPU中。前一个进程的执行将在之后任务重新调度执行的时候再次被加载，并保证任务原来的状态不受影响。

上下文切换保证了多个进程可以共享一个CPU，并且每个任务不会受到其他任务的影响。但它会消耗CPU资源，降低系统的整体性能。

常见CPU调度算法#

FCFS：先请求CPU的进程先分配到CPU
- 平均等待时间较长
最短作业优先：CPU优先分配给具有最短CPU区间的进程
- 可证明是最佳，然而需要预知未来，知道下一个CPU区间的长度
优先级调度：每个进程分配优先级，最高优先级的进程分配到CPU
- 低优先级的进程可能会无穷等待(starve)，解决方法是老化(aging)，逐渐增加在系统中等待很长时间的进程优先级
- 轮转法：定义一个较小的时间单元——时间片，每个进程循环分配不超过一个时间片的CPU，执行时间到了就产生操作系统中断，进行上下文切换，把当前进程移到就绪队列的尾部
  - 性能依赖于时间片的大小
- 多级队列调度：就绪队列被分成多个独立队列，每个进程根据自己的属性，比如内存大小、优先级、进程类型等等，被永久分到其中一个队列中，每个队列有自己的调度算法
  - 低调度开销，但不够灵活
- 多级反馈队列调度：允许进程在队列之中移动，例如某些进程使用过多CPU时间，就会转移到低优先级队列；或者等待时间久的进程会转移到高优先级队列

进程/线程同步#

锁的种类#

互斥锁和条件变量
- 当获取锁后但是条件失败，那么会释放当前锁(另外的线程可以获得锁，以解除死锁)，然后在此阻塞(避免条件判断需要不但轮询浪费CPU时间)。进程将睡眠等待某种条件出现
- 一个线程等待”条件变量的条件成立”而挂起；另一个线程使“条件成立”
读写锁
- 允许多个线程同步访问一个文件内存都用读锁；只要有一个线程申请或拥有写锁，其它线程申请或拥有读锁或者写锁，那么申请写锁的必须等待，或者其它线程申请锁必须等待
自旋锁
- 线程反复检查锁是否可用。一旦获取了自旋锁，线程会一直保持该锁，一直到释放自旋锁。线程在这一过程中保持执行，处于忙等待中
- 避免了进程上下文的调度开销，对于线程只会阻塞很短时间的场合是有效的

信号量与互斥锁#

互斥锁（Mutex）是多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。

主要区别：

设计理念上，互斥锁管理的是资源的使用权，主要是构造临界区来保护共享资源；而信号量管理的是资源的数量，同时间接在调度线程，服务于多个线程之间的执行顺序
互斥锁只允许一个线程进入临界区，其他试图进入临界区的线程要全部等待直到这个线程执行完毕。这使得互斥锁安全得多，但是会增加线程等待时间。而信号量仅仅限制了共享资源的数量，在这个限制数量内多个线程可以同时访问这些资源，这带来了更多的并发可能性并且加快了程序运行效率，然而不够安全。

虚假唤醒(Spurious Wakeup)#

在多核处理器下，当一个线程调用pthread_cond_signal()后，多个调用pthread_cond_wait()或pthread_cond_timedwait()的线程被激活返回。这种效应成为”虚假唤醒”。

通常的解决方法是把条件判断从if改成while，不仅在等待条件变量前检查条件变量是否有效，还在等待条件变量后也检查条件变量是否有效。

死锁#

简介#

多任务系统下，存在两个以上的进程，其中的每个进程都在等待系统资源，而所需资源本身被自身或其他进程占用。这种状态下，每个进程只能等待其他进程停止运行并释放资源（可能是物理资源或逻辑资源等等）。如果并没有一个进程提前退出，此时这组进程就处于死锁状态。

触发的条件：

互斥：所需的资源非共享，一次只有一个进程能使用这个资源
占有并等待：一个进程占有一个资源，等待另一个资源，等待的资源被其他资源占有
非抢占：资源只能在进程完成任务后自动释放，不能被中途抢占
循环等待：对于一组等待进程{P, P, … P}，会形成循环等待链，即P等待的资源被P占有，P等待的资源被P占有，…，P等待的资源被P占有

预防、检测、解决#

死锁预防：修改系统协议

适当多使用共享资源，比如设立只读文件，让多个进程同时访问
规定进程没有资源了才能申请资源，或执行前一次性获得所有资源确保能执行完毕
一个进程占有资源并申请另一个需要等待的资源时，它已有的资源可以被抢占
对资源类型完全排序，要求进程按递增顺序申请资源

死锁检测：

资源分配图算法，检测图中是否有环
银行家算法，动态比较已分配资源/需要资源/系统可用资源，计算剩余资源是否够用

死锁恢复：

进程终止，包括终止所有进程，或一次性终止一个直到打破死锁循环
抢占资源，优先保证让一些进程先执行完毕，打破死锁循环

内存管理#

交换(Swap)#

内存管理器可以将进程暂时从内存中换出到备份存储（一般是磁盘）上，当需要再次执行时再换入到内存中。

一个交换出的进程可能会换回原有的内存空间，这一限制由地址绑定方式决定。如果绑定在汇编或加载时确定，就必须移动到原有的位置；如果运行时才确定，就可能回到其他物理地址空间上。

连续内存#

将内存分为多个固定大小的分区(partition)，每个进程位于一个连续的内存区域中，每个分区只能容纳一个进程。

优点：

实现简单，易于管理
降低逻辑内存到物理内存的映射开销

缺点：

碎片问题，浪费内存空间 (解决：移动空闲空间，合并成一大块)

内存分页#

将物理内存分为固定大小的块（帧），将逻辑内存分为同样大小的块（页）。执行进程时，把页通过页表映射，从备份存储中调入到可用的内存帧中。

CPU生成的逻辑地址分为两部分：

页号：页表中的索引
页偏移

页表包含每页所在物理内存的基地址，这些基地址和页偏移的组合就形成了物理地址。

address-mapping.png

分页不会产生外部碎片（总的可用内存空间够容纳进程，但这些内存空间不连续），更好地利用了内存空间，但仍然有内部碎片（给进程分配的内存可能比所需要的要大）

虚拟内存#

简介#

计算机系统内存管理的一种技术。它提供了一个抽象的存储资源，它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间）。而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。

虚拟内存有着以下好处：

程序不会受到物理内存空间的限制，所以程序员可以在一个理想的巨大的、连续的虚拟地址空间上进行开发
每个程序使用的物理内存较少，因此可以同时运行更多的程序，提高了CPU的利用率
由于内存隔离，增加了安全性

虚拟内存到物理内存的映射#

使用内存管理单元将逻辑页面映射到内存的物理页帧：

memory-mapping.png

访问内存时，系统判断该虚拟地址映射后的结果是否在物理内存中。如果是，就进行地址转换，访问物理内存；否则，将辅存中的部分程序调度进物理内存，再用进行地址转换和访问。

页错误#

操作系统有按需调页机制，程序执行时一部分程序被载入到内存，另一部分在二级存储器上。当程序执行需要到某个特定的页，而这个页面不在内存中时，才把它从其他存储器调入内存。

当进程试图访问尚未调入内存的页时，就会触发页错误。一般的处理流程如下：

先检查进程的内部页表，确定这是不是合法的地址访问，如果不合法进程会被终止
找到一个空闲帧，调度磁盘操作，将需要的页调入
修改页表和进程的内部表，表示该页已经处在内存中
重新执行中断的指令

页置换#

当程序运行需要读一个新页面到内存，又没有空闲帧的时候，使用页置换算法选择一个牺牲帧，把这个帧的内容写到磁盘上，修改页表和帧表；再把所需的页面读入腾出来的空闲帧，修改页表和帧表。最后重启用户进程。

常见算法：

FIFO：选择时间上最早调入内存的页进行替换
最优置换：错误率最低，但要预知未来的页面读入情况，理论上很难实现
LRU：选择最长时间没有使用的页进行替换
LFU / MFU：最不经常 / 最经常使用的页被替换

文件系统#

存储层次#

读写速度从快到慢，容量从小到大：

寄存器
缓存
（主）内存
硬盘
软盘、光盘、U盘…

数据无法长期保留在寄存器、缓存、内存中（断电就消失了）；而且这些存储设备容量很小，扩容成本很高。这些问题带来了多层存储的必要性。

缓存友好的代码#

两个局部性原则：

时间局部性：某个内存位置被访问后，在不久之后的将来，这个位置可能还会被访问，因此数据可以缓存在原来的位置
空间局部性：将相关的数据放在彼此接近的地方，例如数组中的数据存储在连续的内存中，利于设计缓存机制访问

缓存替换策略#

近期最少使用(LRU)：
- 把CPU近期最少使用的块替换出去。这种替换方法需要随时记录Cache中各块的使用情况，以便确定哪个块是近期最少使用的块。每块也设置一个计数器，被调入或者被替换的块，计数器清零，而其它的计数器则加“1”。访问命中缓存块时，这块的计数器也清零。需要替换时，则选择计数值最大的块被替换。
- 保护了刚调入缓存的新数据块，具有较高的命中率
- 实现以及维护的开销大
随机替换：
- 随机地确定替换的存储块。设置一个随机数产生器，依据所产生的随机数，确定替换块
- 方法简单、易于实现
- 命中率低
先进先出：
- 选择最先调入的缓存块进行替换
- 命中率比随机替换高一些，总体实现也较为简单
- 最先调入并被多次命中的块，很可能被优先替换，因而不符合局部性规律

磁盘调度算法#

磁盘队列：I/O对磁盘各个柱面上块的请求访问顺序

FCFS：先来先服务，通常不是最快的
SSTF：优先处理靠近当前磁头位置的请求
SCAN：磁臂从磁盘一端向另一端移动，磁头经过每个柱面时，处理该柱面上的服务请求；到达另一端时，磁头改变移动方向，继续处理
CSCAN：到达另一端时，磁头直接返回到开始，不处理请求
LOOK：磁头只移动到一个方向上最远的请求为止，之后就掉转方向处理
CLOOK：到达最远请求时，磁头直接返回到开始，不处理请求

磁盘分配#

连续内存分配每个文件都存储在一组连续的块中。顺序访问和直接访问都很容易实现。但是，很难找到新文件的空间（外部碎片）。此外，文件大小很难扩展。

contiguous.png

链式分配磁盘块通过指针连接。这样一来，文件很容易扩展，而且消除了外部碎片。但是，linkded分配不支持直接访问，且指针会占用一些额外的空间。一个可能的节省空间的方法是将几个块组成一个群组，然而这将引入内部碎片。

link.png

索引分配每个文件都有一个索引块。第i项指向文件的第i块。在这种情况下，既支持直接访问，也支持顺序访问，而且不存在外部碎片。但是，索引分配浪费一些空间，因为指针和索引块本身都会占用额外的空间。如果块的大小受到限制，可以引入层次索引。

index.png

数据结构

Sun, 16 Jan 2022 00:00:00 GMT

常用数据结构。

栈和队列(Stack & Queue)#

性质#

栈是一种后进先出(LIFO)的线性表，插入和删除数据元素的操作只能在线性表的一端进行。
队列是一种先进先出(FIFO)的线性表。传统的队列中，插入只能在表的一端进行(只进不出)，而删除只能在表的另一端进行(只出不进)。允许插入的一端称为队头，允许删除的一端称为队尾。不过，目前主流语言都支持双头队列，标准比起传统队列相对宽松，允许两头都进，两头都出。

时间复杂度#

栈

插入: O(1)
删除: O(1)
查找: O(n)
最值: O(1)

队列

插入: O(1)
删除: O(1)
查找: O(n)
最值: O(1)

一般二叉树(Binary Tree)#

性质#

二叉树是有限个节点的集合，这个集合或者是空集，或者是由一个根节点和两株互不相交的二叉树组成，其中一株叫根的做左子树，另一棵叫做根的右子树。

在二叉树中第i层的节点数最多为2（i ≥ 1）
高度为k的二叉树其节点总数最多为2 - 1（k ≥ 1）

完全二叉树#

除最后一层外，每一层上的节点数均达到最大值；在最后一层上只缺少右边的若干节点；具有n个节点的完全二叉树的深度为log(n + 1)。

二叉搜索树(Binary Search Tree)#

性质#

一种特殊的二叉树，对于二叉搜索树上的每个节点，若它的左子树不空，则左子树上所有节点的值均小于这个节点的值；若它的右子树不空，则右子树上所有节点的值均大于这个节点的值。

时间复杂度#

插入: O(logn)
删除: O(logn)
查找: O(logn)

红黑树(Red Black Tree)#

性质#

一种特殊的二叉平衡树，有5个特点:

每个节点可能是红色或黑色
根节点是黑色
有虚拟的黑色NIL叶子
如果某个节点是红色的，它的两个子节点都是黑色的
从一个节点到任意一个虚拟的后代NIL叶子节点的路径上，经过的黑色节点数相等

时间复杂度#

插入: O(logn)
删除: O(logn)
查找: O(logn)

应用#

Java中的HashMap, TreeMap, TreeSet等

堆(Heap)#

性质#

一种特殊的完全二叉树。有两种堆：

最小堆，非叶子节点的值不大于左子或右子的值（根节点的值最小）
最大堆，非叶子节点的值不小于左子或右子的值（根节点的值最大）

堆可以应用于priority queue和堆排序

建堆时间 & 空间复杂度#

建堆的两种方法：

forward method，逐个地获取到数据节点，插入到堆中调整位置来构建堆。需要 n * O(logn) = O(nlogn)的时间复杂度。这种方法适合流式传输数据 / 无法提前获取到所有数据的情况
reverse method，在已知所有数据的情况下，从底向上，每一层从右到左，尝试进行父节点和子节点的交换（如果有必要的话）。所有节点的调整时间总和是O(n)。

复杂度分析：空间复杂度是O(1)，因为是原地操作；对堆进行调整，需要从根节点往下循环查找，需要O(logn)的时间。

heap-time.png

节点删除后堆的维护#

先将堆的最后一个元素（最底层，最靠右）移动到根节点，之后从根节点自上而下递归调整，看每个父节点跟子节点是否需要交换。

数组 vs. 链表#

主要区别#

数组是线性表，所有元素存储在连续的内存空间中。数组可能是定长的（需要提前申请定量内存），但动态数组(Vector, ArrayList, …)一般是resizable的，达到capacity阈值后容量不断倍增。数组适合高随机访问，少插入/删除的场景。

链表的元素存储在不连续的内存空间中，每个数据保存了下一个地址的内存数据。不需要定义内存大小。链表适合高插入/删除，少随机访问的场景。

时间复杂度#

数组：

插入: 随机位置是O(n)，末尾是O(1)
删除: 随机位置是O(n)，末尾是O(1)
读取: O(1)

链表:

插入: O(1)
删除: O(1)
读取: O(n)

哈希表(Hash Table)#

性质#

根据关键码值 (Key-Value) 而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

设计注意事项#

构造一个合理的哈希函数
- 对于不同的输入应该产生不同的结果，输出值应该尽量均匀
- 输入的微小变化会导致输出的较大变化
解决不同输入，相同输出的冲突问题
- 链地址法，为每个哈希值建立一个单链表，当发生冲突时，将记录插入到链表中。
- 开放定址法，所有的元素都放在散列表中，用探针不断确定下一个位置来检查所有数据项。要求是表要足够大，一般是所有数据个数的整数倍。

时间复杂度#

平均而言，哈希表的插入/删除/查找操作时间复杂度是O(1)，但是在最差情况下（链地址法，多次碰撞冲突）会退化到O(n)。

字典(Map)#

性质#

一种存放键值对的容器。有以下几种类型：

无序哈希表(Hashmap in Java, unordered_map in C++)

本质上是哈希表，将key做hash算法，然后将hash值映射到内存地址，直接取得key所对应的数据。所谓的内存地址即数组的下标索引。不能保证插入的数据是有序的。
带双向链表的哈希表(LinkedHashMap in Java)

额外维护了一个双向链表用于保持迭代顺序。以Java的LinkedHashMap为例，其默认实现是按插入顺序排序的。
有序哈希表 (TreeMap in Java, map in C++)

本质上是红黑树，插入数据时按照key的大小自动进行排序。TreeMap具备良好的统计性能（例如找最大/最小的key，或者有几个key比3大等等），可以在O(logn)时间内完成。

时间复杂度#

无序哈希表:

插入: O(1)
删除: O(1)
查找: O(1)，但是在最差情况下（链地址法，多次碰撞冲突）会退化到O(n)

带双向链表的哈希表:

插入: O(1)
删除: O(1)
查找: O(1)，但是在最差情况下（链地址法，多次碰撞冲突）会退化到O(n)

有序哈希表:

插入: O(logn)
删除: O(logn)
查找: O(logn)

集合(Set)#

一个不允许出现重复元素的容器。以Java语言为例：

HashSet：基于HashMap实现，插入元素时，所有元素的value都指向一个Object对象，因此HashSet用不到HashMap的value，所以不会为其分配一个内存空间
TreeSet：基于TreeMap实现，操作数据的方法与HashSet调用HashMap类似
LinkedHashSet：基于LinkedHashMap实现，操作数据的方法与HashSet调用HashMap类似

因为Set全部基于Map实现，因此时间复杂度与Map保持一致。

图(Graph)#

性质#

一种复杂的非线性结构，由节点和边组成。节点之间的关系是任意的，图中任意两个数据元素之间都有可能相关。根据边是否具有指向性，可以将图分为有向图和无向图。

图一般有以下两种表现形式：

邻接矩阵

节点之间如果有边相连，用1表示，反之是0。大小: V
邻接表

每个节点维护一个链表，存储这个节点分别和其他哪些节点通过边连接。大小: V + 2E (无向图)，V + E (有向图)

复杂度#

邻接矩阵的空间复杂度: O(V)；邻接表的空间复杂度: O(V + E)

查找某个节点是否为相邻节点

邻接矩阵: O(1) 邻接表: O(V)
列举某个节点的所有相邻节点

邻接矩阵: O(V) 邻接表: O(V)

跳表(Skiplist)#

性质#

跳表是受这种多层链表的想法的启发而设计出来的特殊数据结构。

对一个有序链表，通常来说如果要查找某个数据，需要从头开始逐个比较，直到找到包含数据的节点，或者第一个比给定数据大的节点为止（没找到）；假如每相邻两个节点增加一个指针，让指针指向下下个节点，这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半。当我们想查找数据的时候，可以先沿着这个新链表进行查找，当碰到比待查数据大的节点时，再回到原来的链表中进行查找。利用同样的方式，我们可以在上层新产生的链表上，不断为每相邻的两个节点增加一个指针；程序总是从高层先开始访问，然后随着元素值范围的缩小，慢慢降低层次…按照上面生成链表的方式，上面每一层链表的节点个数，是下面一层的节点个数的一半，这样查找过程就非常类似于一个二分查找。

skiplist.png

但是，上述方法在插入数据的时候有很大的问题。新插入一个节点之后，会打乱上下相邻两层链表上节点个数严格的2<1的对应关系>。要维持这种对应关系，必须把新插入的节点后面的所有节点（也包括新插入的节点）重新进行调整，这会让时间复杂度重新蜕化成O(n)。删除数据也有同样的问题。跳表为了避免这一问题，它不要求上下相邻两层链表之间的节点个数有严格的对应关系，而是为每个节点随机出一个层数(level)，新插入一个节点不会影响其它节点的层数。因此，插入操作只需要修改插入节点前后的指针，而不需要对很多节点都进行调整。比如，一个节点随机出的层数是3，那么就把它链入到第1层到第3层这三层链表中。以下是一个例子：

skiplist-example.png

执行插入操作时计算随机数的过程十分关键，它并不是一个普通的服从均匀分布的随机数，需要满足一些条件：

每个节点肯定都有第1层指针（每个节点都在第1层链表里）。
如果一个节点有第i层(i >= 1)指针（即节点已经在第1层到第i层链表中），那么它有第(i+1)层指针的概率为p(Redis中取值为0.25)。
节点最大的层数不允许超过一个最大值，记为MaxLevel(Redis中取值为32)。

时间复杂度#

插入：O(logn)
删除：O(logn)
查找：O(logn)

Bug Free的二分查找

Fri, 03 Dec 2021 00:00:00 GMT

你能写出Bug Free的二分查找算法吗？

简介#

在连续（且往往是有序的）的序列中搜索指定元素。一般流程是定义起始搜索区间，找到区间的中值，通过不断比较区间中值和目标元素，对半划分调整下一轮的搜索区间，直到找到目标元素或者区间不能被进一步划分。

尽管二分查找原理很容易理解，但需要考虑到许多corner cases，例如搜索区间的终止条件，区间中值的溢出问题等等，因此写出bug-free的二分查找有一定难度。此外，二分查找的思想在不同的问题情景下有相应变种的使用方法，需要具体问题具体分析。

在计算区间中值的时候，始终要考虑溢出的情况。此处的溢出指的是采用mid = (first + last) / 2运算。最常见处理溢出的手段就是直接将这个等式进行变形：

1
mid = (first + last) / 2
2
    = (2 * first + last - first) / 2
3
    = first + (last - first) / 2

此处的除号代表整除。在有的场景下，如果想让中值取值更偏左一些，可以考虑求下位中位数，即mid = first + (last - first - 1) / 2。不过在下文的模型介绍中，我们仍然统一采用标准的中位数取值。

模型1#

介绍#

最常使用的模型，条件清晰，不易出错。如果问题场景中可以访问数组中的每一个下标所对应的元素，并且侧重于判断“某个元素是否存在于数组中”，但对于具体存在的下标位置不那么关注，就可以使用它：

1
public int search(int[] nums, int target) {
2
    if (nums == null || nums.length == 0) {
3
        return -1;
4
    }
5

6
    int left = 0, right = nums.length - 1;
7
    while (left <= right) {
8
        int mid = left + (right - left) / 2;
9

10
        if (nums[mid] == target) {
11
            return mid;
12
        } else if (nums[mid] < target) {
13
            left = mid + 1;
14
        } else if (nums[mid] > target) {
15
            right = mid - 1;
16
        }
17
    }
18

19
    return -1;
20
}

展开收起

这个模型有三个特点：

将target值和nums[mid]的比较分为了三种情况，严格一一对应了target小于nums[mid]，target等于nums[mid]，target大于nums[mid]三种区间处理方式，最符合人的直觉。换言之，这个模型采用了 “左闭右闭”的原则，mid的两侧的区间分别是[left, mid - 1]和[mid + 1, right]
区间的左、右边界是允许重合的，即有可能出现left <= right的情况，此时搜索区间中只有一个数
循环结束时，一定有left > right，这意味着一个无效的搜索区间。如果在此之前没有找到target值，那么可以说明target一定不在数组中

sqrt(x)#

Given a non-negative integer x, compute and return the square root of x.

Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.

1
Example 1:
2
Input: x = 4
3
Output: 2
4

5

6
Example 2:
7
Input: x = 8
8
Output: 2
9
Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

相当于给定0到x的数组，找到sqrt(x)或者是小于sqrt(x)的最大整数。直接套用模型，如果sqrt(x)存在的话，将其找出；如果不存在的话，由于最后left > right，因此right是最接近且小于sqrt(x)的整数。

1
public int mySqrt(int x) {
2
    long left = 0, right = x, target = x;
3
    while (left <= right) {
4
        long mid = left + (right - left) / 2;
5
        if (mid * mid == target) {
6
            return (int)mid;
7
        } else if (mid * mid < target) {
8
            left = mid + 1;
9
        } else {
10
            right = mid - 1;
11
        }
12
    }
13
    return (int)right;
14
}

Guess Number Higher or Lower#

We are playing the Guess Game. The game is as follows: I pick a number from 1 to n. You have to guess which number I picked. Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess. You call a pre-defined API int guess(int num), which returns 3 possible results:

-1: The number I picked is lower than your guess (i.e. pick < num).
1: The number I picked is higher than your guess (i.e. pick > num).
0: The number I picked is equal to your guess (i.e. pick == num).

Return the number that I picked.

1
Example 1:
2
Input: n = 10, pick = 6
3
Output: 6
4

5

6
Example 2:
7
Input: n = 1, pick = 1
8
Output: 1
9

10

11
Example 3:
12
Input: n = 2, pick = 1
13
Output: 1
14

15

16
Example 4:
17
Input: n = 2, pick = 2
18
Output: 2

展开收起

题干关于guess API的描述，几乎直接对应了模型的三种情形。需要注意，此题的设定使得一定能找到pick的数，换言之代码一定能在while循环中返回到最终结果，所以while循环之后的后续处理中（找不到target数的情况），随便返回任意数都无所谓。

1
public class Solution extends GuessGame {
2
    public int guessNumber(int n) {
3
        int left = 1, right = n;
4
        while (left <= right) {
5
            int mid = left + (right - left) / 2;
6
            if (guess(mid) == 0) {
7
                return mid;
8
            } else if (guess(mid) == 1) {
9
                left = mid + 1;
10
            } else {
11
                right = mid - 1;
12
            }
13
        }
14

15
        return -1;
16
    }
17
}

展开收起

Search in Rotated Sorted Array#

There is an integer array nums sorted in ascending order (with distinct values).

Prior to being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].

Given the array nums after the rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

1
Example 1:
2
Input: nums = [4,5,6,7,0,1,2], target = 0
3
Output: 4
4

5

6
Example 2:
7
Input: nums = [4,5,6,7,0,1,2], target = 3
8
Output: -1
9

10

11
Example 3:
12
Input: nums = [1], target = 0
13
Output: -1

这一题需要将数组对半划分来看，其中一半一定是有序的，而另一半则在中间某处破坏了升序。因此在使用模型1时，我们无法简单通过比较nums[mid]和target确定下一轮搜索区间，而是应该比较nums[left]、nums[mid]和nums[right]三者的值，先判断哪一半数组是有序的；之后将target放进有序的这一侧进行比较，如果target的值介于其中则把区间定为有序的这一侧，反之定为另一侧。

1
class Solution {
2
    public int search(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return -1;
5
        }
6

7
        int left = 0, right = nums.length - 1;
8
        while (left <= right) {
9
            int mid = left + (right - left) / 2;
10

11
            // nums[mid] matches with target, return
12
            if (nums[mid] == target) {
13
                return mid;
14
            }
15

16
            // left half is ordered
17
            if (nums[left] <= nums[mid]) {
18
                // target is in left half
19
                if (target >= nums[left] && target <= nums[mid]) {
20
                    right = mid - 1;
21
                } else {
22
                    left = mid + 1;
23
                }
24
            }
25

26
            // right half is ordered
27
            if (nums[mid] <= nums[right]) {
28
                // target is in right half
29
                if (target >= nums[mid] && target <= nums[right]) {
30
                    left = mid + 1;
31
                } else {
32
                    right = mid - 1;
33
                }
34
            }
35
        }
36

37
        return -1;
38
    }
39
}

展开收起

模型2#

介绍#

模型1的写法在某些场景下有缺陷。例如给定nums = [1,2,2,2,3]，target = 2，通过模型1得出的target下标就是2。然而在一些场合下，我们更关心的是target在nums中“第一次”，或者“从左到右最初”出现的下标位置，那么下标应该返回1才对。因此，我们需要对模型1进行修改，不仅能适应普通的target查找问题，还能适应这种边界场景下的二分查找：

1
public int search(int[] nums, int target) {
2
    if (nums == null || nums.length == 0) {
3
        return -1;
4
    }
5

6
    int left = 0, right = nums.length;
7
    while (left < right) {
8
        int mid = left + (right - left) / 2;
9
        if (nums[mid] < target) {
10
            left = mid + 1;
11
        } else if (nums[mid] >= target) {
12
            right = mid;
13
        }
14
    }
15

16
    // return left;
17

18
    if (left != nums.length && nums[left] == target) {
19
        return left;
20
    }
21
    return -1;
22
}

展开收起

这个模型有几个特点：

target值和nums[mid]的比较分为了两种情况，其中left = mid + 1的情况与模型1相同；但right = mid与此前不同，其原因是搜索的策略发生了变化，我们不止希望“找到target”，更希望在找到target之后“尽可能扩张区间”，即我们假定target可能多次出现，所以不立即返回当前下标，而是缩小搜索区间的上界，向左扩张
搜索区间的原则使用“左闭右开”，即[left, right)。这是为了更好契合“边界上第一次出现”的概念，顺便也让代码中可以更少出现+1或-1的边界值检查。根据左闭右开，mid两侧的区间应该写成[left, mid)和[mid+1, right)；同理初始的right值也应该是nums.length而非nums.length - 1
循环结束时，一定有left == right。这也是因为采取了左闭右开，因为当left == right时，搜索区间变成了[left, left)，区间的实际长度变成0，搜索也就终止了
如果需要找出target第一次出现的位置，直接返回left即可（right也行，反正此时二者相等）；而如果需要判断target是否在nums中出现，如果在此之前没有找到target值，则需要额外判断最后这个nums[left]是否与target值相等

类似地，如果要进行右边界场景下的二分查找，修改代码如下：

1
public int search(int[] nums, int target) {
2
    if (nums == null || nums.length == 0) {
3
        return -1;
4
    }
5

6
    int left = 0, right = nums.length;
7
    while (left < right) {
8
        int mid = left + (right - left) / 2;
9
        if (nums[mid] <= target) {
10
            left = mid + 1;
11
        } else if (nums[mid] > target) {
12
            right = mid;
13
        }
14
    }
15

16
    // return left - 1;
17

18
    if (left != 0 && nums[left - 1] == target) {
19
        return left - 1;
20
    }
21
    return -1;
22
}

展开收起

和左边相比，主要的两处差异在于：

找到target时，不急于返回，而是向右扩大搜索区间，因此当nums[mid] == target时，要增大搜索区间的下界，向右扩张
最后返回的下标是left - 1（right - 1也行，反正此时二者相等），这是因为我们的区间更新策略是让left = mid + 1，最后循环结束时nums[left]一定已经不等于target了，需要倒退一位

First Bad Version#

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which returns whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

1
Example 1:
2
Input: n = 5, bad = 4
3
Output: 4
4
Explanation:
5
call isBadVersion(3) -> false
6
call isBadVersion(5) -> true
7
call isBadVersion(4) -> true
8
Then 4 is the first bad version.
9

10

11
Example 2:
12
Input: n = 1, bad = 1
13
Output: 1

问题需要找出最小的bad version，正好对应左边界场景下的二分查找问题。如果某个版本号不是bad version，就向上搜索版本号；反之向下搜索，看是否还有更小的版本号也是bad version。

1
/* The isBadVersion API is defined in the parent class VersionControl.
2
      boolean isBadVersion(int version); */
3

4
public class Solution extends VersionControl {
5
    public int firstBadVersion(int n) {
6
        int left = 1, right = n;
7

8
        while (left < right) {
9
            int mid = left + (right - left) / 2;
10
            if (isBadVersion(mid) == false) {
11
                left = mid + 1;
12
            } else {
13
                right = mid;
14
            }
15
        }
16

17
        return left;
18
    }
19
}

展开收起

Find First and Last Position of Element in Sorted Array#

Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value. If target is not found in the array, return [-1, -1].

Follow up: Could you write an algorithm with O(log n) runtime complexity?

1
Example 1:
2
Input: nums = [5,7,7,8,8,10], target = 8
3
Output: [3,4]
4

5

6
Example 2:
7
Input: nums = [5,7,7,8,8,10], target = 6
8
Output: [-1,-1]
9

10

11
Example 3:
12
Input: nums = [], target = 0
13
Output: [-1,-1]

分别进行左边界搜索和右边界搜索即可。

1
class Solution {
2
    public int[] searchRange(int[] nums, int target) {
3
        int[] result = new int[] {-1, -1};
4
        if (nums == null || nums.length == 0) {
5
            return result;
6
        }
7

8
        // left
9
        int left = 0, right = nums.length;
10
        while (left < right) {
11
            int mid = left + (right - left) / 2;
12
            if (nums[mid] < target) {
13
                left = mid + 1;
14
            } else if (nums[mid] >= target) {
15
                right = mid;
16
            }
17
        }
18

19
        if (left != nums.length && nums[left] == target) {
20
            result[0] = left;
21
        }
22

23
        // right
24
        left = 0;
25
        right = nums.length;
26
        while (left < right) {
27
            int mid = left + (right - left) / 2;
28
            if (nums[mid] <= target) {
29
                left = mid + 1;
30
            } else if (nums[mid] > target) {
31
                right = mid;
32
            }
33
        }
34

35
        if (left != 0 && nums[left - 1] == target) {
36
            result[1] = left - 1;
37
        }
38

39
        return result;
40
    }
41
}

展开收起

Find Minimum in Rotated Sorted Array#

Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:

[4,5,6,7,0,1,2] if it was rotated 4 times.
[0,1,2,4,5,6,7] if it was rotated 7 times.

Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]]. Given the sorted rotated array nums of unique elements, return the minimum element of this array.

1
Example 1:
2
Input: nums = [3,4,5,1,2]
3
Output: 1
4
Explanation: The original array was [1,2,3,4,5] rotated 3 times.
5

6

7
Example 2:
8
Input: nums = [4,5,6,7,0,1,2]
9
Output: 0
10
Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
11

12

13
Example 3:
14
Input: nums = [11,13,15,17]
15
Output: 11
16
Explanation: The original array was [11,13,15,17] and it was rotated 4 times.

展开收起

这一题借鉴了此前Search in Rotated Sorted Array的数组对半划分思想，通过比较nums[left]、nums[mid]和nums[right]确定下一轮的搜索区间。如果nums[mid]不小于边界两个值，说明[left, mid]是一段递增序列，最小值在[mid + 1, right]中；反之，最小值在[left, mid]中。因为我们希望找到数组最小值，根据左边界查找思想，在确定最小值所在范围后我们仍然希望尽量向左扩展范围，试图能在范围中找到更小的值符合要求。代码主干可以写成：

1
public int findMin(int[] nums) {
2
    if (nums == null || nums.length == 0) {
3
        return 0;
4
    }
5
    if (nums.length == 1) {
6
        return nums[0];
7
    }
8

9
    int left = 0, right = nums.length - 1;
10
    while (left < right) {
11
        int mid = left + (right - left) / 2;
12

13
        // if (mid > 0 && nums[mid] < nums[mid-1]) {
14
        //     return nums[mid];
15
        // }
16

17
        if (nums[left] <= nums[mid] && nums[right] < nums[mid]) {
18
            left = mid + 1;
19
        } else {
20
            right = mid;
21
        }
22
    }
23

24
    return nums[left];
25
}

展开收起

注意代码注释的部分实际上与二分查找算法本身无关，只是用于辅助加速的手段，快速检查mid值是否就是最小值。

计算机网络

Fri, 03 Dec 2021 00:00:00 GMT

计算机网络分层介绍。

OSI模型和基础概念#

简介#

OSI的全称是Open System Interconnect，中文名叫开放式系统互联，又叫OSI参考模型，是ISO组织在1985年研究的网络互连模型。该体系结构标准定义了网络互连的七层框架（物理层、数据链路层、网络层、传输层、会话层、表示层和应用层）。

分层与职责#

OSIModel.png

自底向上分层介绍：

物理层利用传输介质，一般是机械、电子、定时接口的通信信道进行原始的比特流透明传输，为数据链路层提供物理连接。此处强调“透明”，希望是尽可能屏蔽具体传输介质和物理设备的差异，使得数据链路层不需要考虑网络的具体传输介质。
数据链路层进行物理寻址，通过各种差错控制、流量控制等协议，把有差错的物理传输信道转变为可靠的数据链路。数据链路层通常又分为两个子层，即介质访问控制（MAC）和逻辑链路控制（LLC）两个子层。MAC层主要解决共享网络中，多个用户对信道竞争的问题；LLC层主要负责建立和维护网络连接，执行差错校验，流量控制等等。

此外，数据链路层接收来自物理层的位流形式的数据，并封装成数据帧，传送到上一层；同样，也将来自上层的数据帧，拆装为位的数据流形式，转发到物理层主要协议：隧道协议（PPTP），地址解析协议（ARP）

网络层建立、维持和终止网络的连接，控制数据链路层与传输层之间的信息转发；通过路由选择算法，为报文或分组通过通信子网时选择最适当的路径。主要协议：互联网协议（IPv4 & IPv6），路由协议（内部网关，包括RIP，OSPF，… + 外部网关，包括BGP等），控制消息协议（ICMP），组管理协议（IGMP）等
传输层提供会话层和网络层之间的传输服务，即接受其中一方的数据，将数据报文传递到另一层。在实际运用中，一般是负责两个主机进程之间的通信。因为一个主机可同时运行多个进程，因此运输层有复用（多个应用层进程可同时使用下面运输层的服务）和分用（把收到的信息分别交付给上面应用层中相应的进程）的功能。

传输层有两种主要协议，一种是较为可靠的、面向连接的TCP协议，另一种是面向无连接的UDP协议。

会话层负责为不同机器上的用户进程之间建立及管理会话，保证应用程序之间的同步，同时协调交互工作方式，比如确定双工或者半双工等。
表示层定义应用程序用来交换数据的格式，并负责协议转换、数据编码和数据压缩，使得应用层能正常使用接收到的数据。例如传输图片的时候，图片格式GIF，JPEG等等就属于表示层。
应用层直接向用户的应用进程提供服务，在其他6层工作的基础上建立与结束应用程序与操作系统之间的联系，协调各个应用程序之间的工作。根据使用的传输层协议，可以列举一些常见应用层协议：
- 基于TCP：HTTP，FTP，SMTP，POP3，Telnet
- 基于UDP：DHCP，DNS

协议(Protocol)#

一个协议定义了在两个或多个通信实体之间交换的报文格式和次序，以及在报文传输和/或接收或其他事件方面所采取的动作。

交换(Switching)#

电路交换(Cirucuit Switching)：沿着端系统通信路径，为端系统之间通信所提供的资源(缓存，链路传输速率)在通信会话期间将会被预留
分组交换(Packet Switching)：会话的报文按需使用上述资源，这将导致可能不得不等待(即排队)接入通信线路

数据链路层#

多路访问相关算法#

共享网络中，同时只能有一台主机使用一条共享信道，用于传输数据。如果多台主机同时向信道上发送数据，会导致碰撞，所有主机的传输都可能会失败。MAC算法负责解决上述问题。

载波侦听多路访问/碰撞检测（CSMA/CD）算法（假设信道最长传输时间为a）：

每台主机监听信道，如果监听到信道空闲就传输
之后的2a时间内，主机继续监听信道
如果监测到碰撞，主机会发送一个干扰信号，然后暂停传输
主机会等待一个随机的时间，之后再次开始重传。随机时间范围由指数回退法决定，如果检测到了i次碰撞，等待的时间范围就是[0, 2 - 1] * a
如果碰撞超过16次，传输失败

载波侦听多路访问/碰撞避免（CSMA/CA）算法：常用于无线网络，无线站点每通过无线局域网发送完一帧后，要等到收到对方的确认帧后才能继续发送下一帧，即链路层确认。802.11规定，所有的站在完成发送后，必须再等待一段很短的时间(继续监听)才能发送下一帧。这段时间通称为帧间间隔IFS (InterFrame Space)，间隔的长短取决于该站要发送的帧的类型。高优先级帧需要等待的时间较短，因此可优先获得发送权，低优先级帧必须等待较长的时间。这样就减少了发生碰撞的机会。

ALOHA：基于时隙，把时间分成若干个相同的时间片，所有用户在时间片开始时刻同步接入网络信道，若发生冲突，则必须等到下一个时间片开始时刻再发送。

MAC地址#

MAC地址全称是Media Access Control Address，又称为以太网地址或物理地址，是用来确认网络设备位置的地址，在网络中唯一标示一个网卡（生产网卡时，烧录MAC地址在网卡上）。

ARP#

地址解析协议(Address Resolution Protocol)，用于解析网络层IP地址来寻找数据链路层的MAC地址，实现了从IP地址到MAC地址的映射。 ARP工作的步骤：

主机A向查询主机B的地址，于是在网络中广播了一个ARP request报文，报文中的目标IP地址是主机B的IP
其他主机收到这个ARP request报文，发现目标IP与自己的不符，于是把主机A的IP地址以及MAC地址抄录到自己的ARP缓存表，之后丢弃这个报文
主机B收到ARP request报文并发现目标IP与自己的相符，于是B向A直接发送一个单播ARP reply报文，其中包括了B的IP地址以及MAC地址等信息
主机A收到ARP reply报文，把B的IP地址以及MAC地址抄录到自己的ARP缓存表。

有时，ARP报文也可以用来检测当前主机的IP地址是否与局域网中的其他主机冲突。待检测主机广播一个无关ARP request报文，把源IP地址和目的IP地址都设为自己的，如果收到了来自其他主机的ARP reply，则说明存在IP地址冲突。

2.5层协议：MPLS#

简介#

MPLS（Multi-Protocol Label Switching，多协议标签交换）指的是网络中利用标签引导数据进行快速交换和路由的协议。这样做的好处是避免了在路由表中频繁查询下一跳路由器地址的时间，提高传输效率。

工作原理#

路由器则根据职责分为两种，一种是边缘标签路由(Label Edge Router, LER)，如果是入口(Ingress node)，将进行初始的路径选择以及MPLS标签的添加，如果是出口(Egress node)，则会去掉MPLS标签，使IP报文回到传统的路由系统中；另一种是标签交换路由(Label Switching Router, LSR)，负责进行MPLS转发。

MPLS网络中存在若干标签交换通道（Label Switched Path, LSP），每一条LSP是IP报文经过的LSR的集合，可以理解为报文在网络中被转发的路径。

MPLS的核心是在转发报文是使用标签交换技术。入口的LER基于源IP地址和目的地IP地址，能够预先规划出一条路径，并把路径信息添加在标签中，送往下一跳路由器。所有路由器都根据标签信息，执行特定的标签操作，再把报文转向下一跳节点，直到报文离开MPLS网络。标签操作类型包括push（把MPLS标签插入到IP报文头部），swap（用下一跳分配的标签替换当前栈顶标签）和pop（离开MPLS网络时，从IP报文头部剥离MPLS报文）。

快速重路由(Fast Reroute)#

MPLS快速重路由是一种提供快速流量恢复的机制。MPLS路由器不仅会计算出常规路径，还会预先计算出一条备份路由路径。一旦网络中的某条链路或某个节点发生故障，受影响的数据包可以使用备份路径继续快速路由。

网络层#

IP报文的拆分#

IPfragmentation.png

IP单播、组播、任播、广播#

术语介绍与比较#

这几个术语是IP网络中进行IP数据传输时，几种不同的通信模式。

单播：

点对点通信，即IP信息的接收和传输只在两个节点之间进行。网络中的交换机和路由器对数据只进行转发不进行复制
优点：服务器能及时相应客户请求，并且便于根据客户不同请求发送不同数据，实现个性化服务
缺点：速度慢，消耗的带宽大（想象同一份报文要发给100个客户机）

组播：

点对多通信，在一次传输中向多个接收者同时发送IP数据包。在发送时，有多播组这个概念，每个多播组就是一组当前数据包的接收者。每个组有一个标识符，一般来说是用一个224.0.0.0 ~ 239.255.255.255之间的IP地址作为这个标识符
网络中的交换机和路由器只向有需求者复制并转发其所需数据，既能一次将数据传输给多个组内的主机，又不影响其他组外的主机的通讯
优点：结合了单播和广播的优点，按需转发数据，节省带宽，并且可以在互联网上使用
缺点：没有纠错机制，发生丢包或错包之后不好弥补

广播：

点对多通信，使用广播地址255.255.255.255，将消息发送到在同一广播网络上的每个主机，网络对其中每一台主机发出的信号都进行无条件复制并转发，所有主机都可以接收到所有信息（不管是否需要）
优点：服务器不用单独向客户机单独发送数据，流量负载低；布置设备和维护设备也比较简单
缺点：广播不能在互联网上使用；每台主机转发了很多其他主机不需要的报文，浪费带宽

任播：

点对点通信，任播允许源节点向一组目标节点中的其中一个发送数据包，而这个节点由路由系统选择，对源节点透明。
优点：路由系统往往选择“最近”的节点为源节点提供服务，从而在一定程序上为源节点提供了更好的服务也减轻了网络负载。
缺点：不能保证每个目标节点都收到数据，并且速度慢

IP组播路由算法#

组播路由协议用于在路由器之间共享组信息，为组播数据报的分发提供路由，确保每一个组播路由器都能收到数据包。它的目标是找出一棵树，它连接所有附接主机属于组播组的路由器；根据这棵树路由组播包从发送者到达属于这棵组播树的所有主机。

一般有两种树：

共享组播树：构造出的树的链路和成本最小，但是组播源必须将组播数据首先发送给树根节点，之后树根节点再根据这棵树发送给所有节点。
基于源的树：以发送者为树根到每一个接收者的最短路径构成一棵转发树，从发送者到接收者的路径最优，但需要维护较多的状态信息。（使用Dijkstra算法构造）

管理IP组播成员(IGMP)#

通过IGMP（Internet Group Management Protocol，互联网组管理协议）进行管理。这个协议让主机能和与其连接的路由器进行IGMP消息传输。

一般来说，有三种类型的IGMP消息：

membership_query：路由器向所有与其连接的主机发送，检查这些主机目前加入的所有的组
membership_report：主机用这种消息答复membership_query，汇报自己加了哪些组。也有可能主机刚加入一个组时，主动生成这种消息向路由器汇报
leave_group：当一个主机离开一个组时，由主机或者路由器发送的一条可选的消息

ICMP#

互联网控制消息协议（Internet Control Message Protocol），用于在IP主机、路由器之间传递控制消息，包括网络是否通畅、主机是否可达、路由是否可用等等。以Ping命令为例，输入Ping之后，源主机会构造一个ICMP Echo的请求数据包，由ICMP协议将数据包以及目标地址交给IP层协议；IP层协议将上述内容封装成IP数据包，通过ARP找出目标主机对应MAC地址，把报文传给数据链路层，由数据链路层根据MAC地址找到目标主机。目标主机检查MAC地址并与自己比对，比对成功后，层层返回，由ICMP协议构建ICMP reply包返回给源主机。

RIP#

路由信息协议（Routing Information Protocol）是一种较为简单的内部网关协议，基于距离矢量（Distance-Vector）算法，用跳数（Hop Count）作为度量来衡量到达目的网络的距离。每个设备到与其直连的设备之间跳数为0，然后每经过一个三层设备跳数增加1。 RIP规定度量值取0～15之间的整数，大于或等于16的跳数被定义为无穷大，即目的网络或主机不可达。由于这个限制，使得RIP不可能在大型网络中得到应用

OSPF#

简介#

开发最短路径优先协议(Open Shortest Path First)是一种链路状态路由协议，基于Dijkstra算法来找出每个报文被转发到达所有目的地所需要的最短路径。具体而言，每个路由器都把自己当成根结点，根据累积的成本值（参考带宽/接口带宽）计算到达目的地的最小成本。 OSPF的核心是多种形式的链路状态通告（Link State Advertisement），LSA用来描述网络的拓扑信息。当路由器初始化或当网络结构发生变化（例如增减路由器，链路状态发生变化等）时，路由器会产生LSA包，该数据包里包含路由器上所有相连的链路，也即为所有端口的状态信息，这些LSA会在OSPF域中传播。不同类型的LSA共同描述了OSPF域内的网络拓扑结构。所有的LSA都保存在LSDB中，根据LSDB中的信息使用Dijkstra算法计算最佳路径，得到OSPF路由表。

报文类型#

Hello：建立和维护网络中的OSPF邻居关系，由每台主机周期性地发送。在支持组播或广播的物理网络上，Hello包使用组播地址（通常为224.0.0.5)发送
Database Description：两台路由器初始建立邻居关系时，使用这个报文描述自己的LSDB，进行数据库同步
Link State Request：两台路由器互相交换过DD报文之后，知道对方路由器有哪些LSA是本地的LSDB所缺少的，哪些LSA是已经失效的，这时需要发送LSR报文向对方请求自己所需的LSA
Link State Update：用来向对方路由器发送其所需要的LSA。在支持组播和广播的链路上是以组播形式将LSA泛洪出去。内容是多条LSA的集合
Link State Acknowledgement：对LSU中的LSA进行确认

默认路由#

OSPF默认路由是0.0.0.0/0，它匹配了所有可能的前缀。如果没有为给定的目的地址设置特定的路由，或者目的地址不在路由表中，OSPF数据包将通过默认路由转发。一般来说，默认路由会将数据包转发到另一个路由器，直到有一个路由器知道如何将数据包转发到目的地，并据此将数据包发送出去。

网络中的被动接口#

被动接口的设置是用来控制LSA和节约资源的。将接口设置为被动接口后，该接口将停止发送OSPF Hello数据包，并且不能与其他路由器建立邻居关系。因此，该接口也不会接收和发送OSPF数据包。如果在实际的网络中，有一些接口不需要接收OSPF路由信息，我们可以将其设置为被动，以此节省网络资源，减少路由器的负担。

传输层#

Socket#

Socket简介与通信流程#

Socket是应用层和传输层之间的一个抽象层，把TCP/IP层的操作抽象成简单接口，供应用层调用。两个进程即便不在同一台计算机，只要有网络连接，也能相互通信。同时Socket的设计也能清楚的将服务器端和客户端区分开。

服务器端

调用socket创建一个套接字
调用bind给套接字绑定命名
调用listen创建一个队列，用于存放所有的客户连接
调用accept，等待客户端建立对套接字的连接，只有客户端连接到之前参数指定的套接字上时才返回，也就是说，如果套接字队列中没有未处理的连接，accept将阻塞直到有客户建立连接为止。注意此时会创建一个与原有的命名套接不同的新套接字，这个套接字只用于与这个特定客户端进行通信，而原来的命名套接字则被保留下来继续处理来自其他客户的连接。
完成通信后，调用close关闭套接字

客户端

调用socket创建一个套接字
将服务器的命名套接字作为地址
调用connect与服务器建立连接
完成通信后，调用close关闭套接字

Socket底层实现#

一般来讲，我们可以认为TCP连接上发送的所有字节序列在某一瞬间被分成了3个FIFO的字节流队列：

SendQ：在发送端底层实现中缓存的字节，这些字节已经写到了OutputStream中，但还没被接收端成功接收。
RecvQ：在接收端底层实现中缓存的字节，这些字节等待分配到接收程序——即从InputStream中通过read()方法读取。
Delivered：接收者从输入流已经读取到的字节。

Socket的工作流程：

当我们调用OutputStream的write()方法时，将向SendQ追加字节。
TCP协议负责将字节按顺序从SendQ移动到RecvQ。这里有重要的一点需要明确：这个转移过程无法由用户程序控制或直接观察到，并且在块中发生，这些块的大小在一定程度上独立于传递给write()方法的缓冲区大小。
接收程序从Socket的InputStream读取数据时，字节就从RecvQ移动到Delivered中，而转移的块的大小依赖于RecvQ中的数据量和传递给read()方法的缓冲区的大小。

不能假设在连接的一端将数据写入输出流和在另一端从输入流读出数据之间有任何的一致性。尤其是在发送端由单个输出流的write()方法传输的数据，可能会通过另一端的多个输入流的read()方法获取，而一个read()方法可能会返回多个write()方法传输的数据。

TCP#

简介与主要特点#

TCP(Transmission Control Protocol, 传输控制协议)是一个可靠的、面向连接的、基于字节流的传输层通信协议。

端到端，因此总是一台sender，一台receiver
面向连接，有三次握手和四次挥手过程
可靠，能够保证传输的数据包按照顺序全部送达
拥塞控制，防止发送端将过多数据发出
- 慢启动，连接开始时发送方维持一个拥塞窗口的变量cwnd，每收到一次ACK就指数倍增cwnd
- 拥塞避免，让拥塞窗口缓慢增长，即每经过一个往返时间RTT就把发送方的拥塞窗口cwnd加1，这样拥塞窗口按线性规律缓慢增长。
- 快速重传，如果收到同一个ACK超过3次就重新发送带有最小Seq Number的未确认包
- 快速恢复，把慢启动的阈值ssthresh减半
流量控制，防止发送段发出的数据量超出接收端
- 接收端有一个缓冲区，同时又一个滑动窗口变量rwnd。每次回应的ACK报文中就会附带这个窗口值，表示着自己此刻还能接收多少字节的报文。当这个窗口太小，那发送方只能按照这个窗口去发送数据
双工，一个连接中存在两个方向的数据传输

TCP报头结构：

TCPheader.png

Seq和ACK#

初始序号: 当新连接建立的时候，第一个字节数据的序号称为ISN(Initial Sequence Number)，即初始序号。ISN一开始并不一定就是1。ISN的生成取决于时间与哈希算法，时间指的是一个计时器，每隔4毫秒加1。哈希算法则根据源IP、目的IP、源端口、目的端口生成一个随机数值。

序列号(Sequence Number): 32位，有两个作用：

SYN为1时，是当前连接的ISN，数据的第一个字节序号是ISN + 1
SYN是0时，是当前连接报文段累计数据包的字节数

确认号(Acknowledgment Number): 32位，有以下特点：

接收方期待的下一个报文段的序列号
在TCP协议中，一般采用累积确认的方式，即每传送多个连续TCP段，可以只对最后一个TCP段进行确认

三次握手、四次挥手#

TCP三次握手过程状态图：

TCP-handshake.png

TCP四次握手过程状态图：

TCP-closing.png

状态解释：

LISTEN: 侦听来自远方的TCP端口的连接请求
SYN-SENT: 在发送连接请求后等待匹配的连接请求
SYN-RECEIVED: 在收到和发送一个连接请求后等待对方对连接请求的确认
ESTABLISHED: 代表一个打开的连接
FIN-WAIT-1: 等待远程TCP连接中断请求, 或先前的连接中断请求的确认
FIN-WAIT-2: 从远程TCP等待连接中断请求
CLOSE-WAIT: 等待从本地用户发来的连接中断请求，一般是等上层应用做好准备关闭连接
CLOSING: 等待远程TCP对连接中断的确认
LAST-ACK: 上层应用程序调用close关闭连接，发送FIN，等待远程TCP的连接中断请求的确认
TIME-WAIT: 等待足够的时间以确保远程TCP接收到连接中断请求的确认
CLOSED: 没有任何连接状态

三次握手详解：

客户端向服务器端发送一个含有同步序列号(SYN)标志位的数据段给服务器端，向服务器端请求建立连接。数据包中，初始序列号(ISN)是客户端随机产生的值，确认号是0
服务器端收到客户端的请求后，用一个带有确认应答（ACK）和同步序列号（SYN）标志位的数据段响应客户端。数据包中，序列号是服务器随机产生的一个值，确认号是客户端ISN + 1
客户端收到这个数据段后，再发送一个确认应答，确认已收到服务器端的数据段。数据包中，序列号是服务器端返回的确认号 + 1，确认号是服务器的序列号 + 1

三次握手的的作用就是预告双方即将建立连接开始通信，并且双方都能明确自己和对方的收发能力是正常的；同时客户端和服务端交换初始序列号(Initial Sequence Number), 以便让对方知道接下来接收数据的时候如何按序列号组装数据。

客户端发包，服务端收到了。服务端因此能得出结论：客户端的发送能力、服务端的接收能力是正常的
服务端发包，客户端收到了。客户端因此能得出结论：服务端的接收、发送能力，客户端的接收、发送能力是正常的
客户端发包，服务端收到了。服务端因此能得出结论：客户端的接收、发送能力，服务端的发送、接收能力是正常的

四次挥手详解：

客户端完成数据传输，将控制位FIN设为1并发送给服务器，提出停止TCP连接的请求。数据包中，包含一个希望接收者看到的自己当前的序列号K. 同时还包含一个ACK表示确认对方最近一次发过来的数据。
服务器端收到FIN后对其作出响应，确认客户端 -> 服务器端方向上的TCP连接将关闭，将ACK设为1并发送给客户端。数据包中，服务端将K值加1作为ACK序号值。
服务器端再提出服务器端 -> 客户端方向上的TCP连接关闭请求，将FIN设为1并发送给客户端。数据包中，服务端发起自己的FIN段，ACK=K+1, Seq=L
客户端收到FIN后对其作出响应，将ACK设为1并发送给服务器端，双方向的TCP连接关闭结束。数据包中，客户端确认。ACK=L+1

四次挥手确保两个方向的TCP连接都被关闭。

握手时，服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端；挥手时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方是否现在关闭发送数据通道，需要上层应用来决定，因此，己方ACK和FIN一般都会分开发送。

TCP粘包#

保护消息边界：就是指传输协议把数据当作一条独立的消息在网上传输，接收端只能接收独立的消息。也就是说存在保护消息边界，接收端一次只能接收发送端发出的一个数据包。而面向流则是指无保护消息保护边界的，如果发送端连续发送数据，接收端有可能在一次接收动作中，会接收两个或者更多的数据包。

TCP粘包：发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。这个只会在流传输中出现，并且既可能由发送方引起，也可能由接收方引起：

发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一包数据。若连续几次发送的数据都很少，通常TCP会根据优化算法把这些数据合成一包后一次发送出去，这样接收方就收到了粘包数据。
接收方引起的粘包是由于接收方用户进程不及时接收数据，从而导致粘包现象。这是因为接收方先把收到的数据放在系统接收缓冲区，用户进程从该缓冲区取数据，若下一包数据到达时前一包数据尚未被用户进程取走，则下一包数据放到系统接收缓冲区时就接到前一包数据之后，而用户进程根据预先设定的缓冲区大小从系统接收缓冲区取数据，这样就一次取到了多包数据。

解决方法：

发送固定长度的消息，指定好消息的长度，可以用while循环检查当前已发送的字节长度和剩余的未发的长度，确保不会遗漏
消息长度与消息一同发送，可以把int类型的消息长度转化成byte格式，用一个2字节的byte[]数组存储，发给接收方
在接收方添加一个线程，用于接受到数据后进行预处理
- 将待处理的接收数据流（假设长度为m）强行转换成预定的结构数据形式，并从中取出结构数据长度字段（假设长度为n）
- 若n < m，则表明数据流包含多包数据，从其头部截取n个字节存入临时缓冲区，剩余部分数据依此继续循环处理
- 若n = m，则表明数据流内容恰好是一完整结构数据，直接将其存入临时缓冲区即可
- 若n > m，则表明数据流内容尚不够构成一完整结构数据，需留待与下一包数据合并后再行处理

UDP#

简介#

UDP(User Datagram Protocol, 用户数据报协议)是一个非连接的协议，无需建立连接就可以发送封装的IP数据包。具有以下特点：

传输数据之前源端和终端不建立连接(因此也没有握手过程)，需要传送时就抓取来自应用程序的数据，并尽快将其发送
在发送端，UDP传送数据的速度受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。
不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息
UDP使用尽最大努力交付，不保证可靠交付

UDP报头结构：

UDPheader.png

优缺点和应用#

优点：

没有建立连接的过程，简化了设计并且节省时间
UDP报文头部很小，只有8字节，节省了很多额外开销
吞吐量不受拥塞控制算法的调节，只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制

缺点:

丢包问题
即便数据成功传送，数据包的顺序也可能是错乱的

应用：

DNS
流媒体应用(视频聊天软件，网络游戏等允许丢包，但注重传输率)

应用层#

HTTP和HTTPS#

HTTP简介与实现#

HTTP协议指超文本传输协议(Hyper Text Transfer Protocol)，是从WEB服务器传输HTML到本地浏览器的传送协议。设计HTTP目的是提供一种发布和接收HTML页面的方法。 HTTP的实现基于TCP/IP通信协议，默认端口是80。一般的HTTP传输过程如下:

客户端发起TCP请求，与服务端3次握手建立连接
客户端向服务端发起HTTP请求。请求报文包括：
- 请求行(Request line)，包括请求方法(GET, POST)，URL(统一资源定位符，定位具体的资源位置)，协议/版本
- 请求头(Header line)，包括origin，user-agent, connection是否持久等等
- 请求数据，GET中不包含，往往存在于POST方法中

1
GET /somedir/page.html HTTP/1.1
2
Host: www.someschool.edu
3
Connection: close
4
User-agent: Mozilla/4.0
5
Accept-language: fr

服务端向客户端发送HTTP响应。响应报文包括：
- 状态行(Status line)，包括协议/版本，状态码，响应状态信息
- 响应头(Header line)，包括时间戳，返回内容的类型、编码、长度等信息
- 响应正文

1
HTTP/1.1 200 OK
2
Connection: close
3
Date: Thu, 03 Jul 2003 12:00:15 GMT
4
Server: Apache/1.3.0 (Unix)
5
Last-Modified: Sun, 6 May 2007 09:23:24
6
Content-Length: 6821 Content-Type:text/html

客户端将响应得到的HTML代码和资源渲染到前端

HTTP的优缺点#

优点：

简单快速：客户向服务器请求服务时，只需传送请求方法和路径
灵活：HTTP允许传输任意类型的数据对象。传输的类型由Content-Type加以标记

缺点:

无连接 & 无状态：限制每次连接只处理一个请求。服务器处理完请求，并收到客户的应答后，即断开连接，但是却不利于客户端与服务器保持会话连接；后续事务处理如果需要前面的信息，则必须重传数据 (使用Session和Cookie解决)
请求信息明文传输，容易被窃听截取
没有验证对方身份，存在冒充危险

HTTPS简介与实现#

SSL(Secure Socket Layer，安全套接字层)协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持。SSL后来发展成TLS（Transport Layer Security，传输层安全）。 HTTPS协议（HyperText Transfer Protocol over Secure Socket Layer）：一般理解为HTTP+SSL/TLS，通过SSL证书来验证服务器的身份，并为浏览器和服务器之间的通信进行加密。默认端口是443。实现流程如下：

客户端通过URL访问服务器建立SSL连接
服务端收到客户端请求后，会将网站支持的证书信息（证书中包含公钥）传送给客户端
客户端的服务器开始协商SS连接的的信息加密等级，也就是信息加密的等级
客户端产生随机对称密钥，再用公钥对这个对称密钥进行加密
客户端将加密后的对称密钥发送给服务器，服务器用私钥解密出会话密钥

至此，客户端和服务器能够通过对称密钥加密的密文进行通信。

补充此处非对称加密的最常用算法：RSA算法，基于质数，即很难对很大的整数做因式分解，因此很可靠

HTTPS的优缺点？#

优点：

通信双方能够验证彼此的身份合法
通信的内容被加密，不易被窃听截取

缺点:

HTTPS多次握手，导致页面加载时间显著变长
SSL涉及的安全算法对服务器资源消耗大
SSL证书需要钱，功能越强大费用越高

Cookie#

HTTP 服务器是无状态的，因此需要辅助使用Cookie保存用户信息。它类似一个用户令牌，是服务器在客户端本地机器上存储的一小段带有状态信息文本，并随着每次请求发送到服务器。服务器通过Cookie能够区别具体正在与哪一个客户端通信。

Cookie的四个组成部分：

在 HTTP 响应报文中有一个cookie首部行
在 HTTP 请求报文中有一个cookie首部行
在用户端系统中保留有一个cookie文件，由用户的浏览器管理
在 Web 站点有一个后端数据库

具体工作机制（往往是与Session结合）：

浏览器首次访问页面，若页面使用cookie，则在返回信息中加上set-cookie: COOKIE_ID
浏览器把COOKIE_ID写入本地 cookie 文件中
浏览器再次访问该页面时，先查找cookie文件中有没有对应的cookie，若有则加上所带信息
服务器收到消息后，根据COOKIE_ID查询数据库，从而找出用户的历史数据

如果我们不设置Cookie过期时间，那么这个Cookie将不存放在硬盘上，当浏览器关闭的时候，Cookie就会消失。如果我们设置过期时间为若干天之后，那么这个Cookie会保存在客户端硬盘中，即使浏览器关闭，这个值仍然存在。

Session, Cookie, Token的联系和区别？#

Session是存放在服务器端的，用来存储用户信息的结构。最常见的Session ID保存方式是使用Cookie。

当浏览器第一次发送请求时，服务器自动生成了一个Session和一个Session ID用来唯一标识这个Session，并将其通过响应发送到浏览器
当浏览器第二次发送请求，会将前一次服务器响应中的Session ID放在请求中一并发送到服务器上，服务器从请求中提取出Session ID，并和保存的所有Session ID进行对比，找到这个用户对应的Session

Cookie往往可以与Session结合使用：

客户端会发送一个HTTP请求到服务器端
服务器端接受客户端请求后，建立一个Session，并发送一个HTTP响应到客户端，这个响应头，其中就包含Set-Cookie头部。该头部包含了Session ID
在客户端发起的第二次请求，假如服务器给了set-Cookie，浏览器会自动在请求头中添加cookie
服务器接收请求，分解cookie，验证信息，核对成功后返回response给客户端

Token也称作令牌，类似于临时的证书签名, 一种服务端无状态(服务端并不会保存身份认证相关的数据)的认证方式, 非常适合于REST API的场景

Token的组成:

uid: 用户唯一身份标识
time: 当前时间的时间戳
sign: 签名, 使用hash/encrypt压缩成定长的十六进制字符串，以防止第三方恶意拼接
固定参数(可选): 将一些常用的固定参数加入到Token中是为了避免重复查库

Token的使用流程：

用户登录，成功后服务器返回Token给客户端。
客户端收到数据后保存在客户端
客户端再次访问服务器，将Token放入headers中
服务器端过滤校验。校验成功则返回请求数据，校验失败则返回错误码

DNS#

简介#

DNS指域名系统(Domain Name System)。主要作用是根据域名查出IP地址，有了IP地址才能进行网络通信。

查询方式#

DNS查询主要有纯递归查询和递归+迭代查询两种方式：

DNS-query.png

递归和迭代的比较：

递归：客户端只发一次请求，要求对方给出最终结果。
迭代：客户端发出一次请求，对方如果没有授权回答，它就会返回一个能解答这个查询的其它名称服务器列表，客户端会再向返回的列表中发出请求，直到找到最终负责所查域名的名称服务器，从它得到最终结果。

因为纯递归查询比较耗时，因此现在使用比较少。而对于递归+迭代查询，主要流程如下：

主机(地址为x.abc.com)要查询y.def.com的IP地址
主机在本地DNS服务器(dns.abc.com)上查询y.def.com的地址。这个本地DNS服务器一般指电脑上网时IPv4或IPv6设置中填写的DNS地址，可能是手动指定或DHCP自动分配的。一般电脑直连运营商网络的话，本地DNS就是DHCP分配到的运营商的服务器地址
本地DNS检查缓存是否有y.def.com的记录，如果没有，就直接询问DNS根服务器。DNS根服务器能指出y.def.com具体由哪一个顶级区域管理(.com)，并返回这个顶级域服务器的地址
主机向顶级域服务器发起查询y.def.com的请求，顶级域服务器能返回二级域名服务器的地址(def.com)
主机向二级域名服务器发起请求，查询y.def.com的IP地址，得到最终的IP地址结果。主机把这个IP地址写入DNS缓存，以备之后再次查询。

电子邮件相关协议#

简单而言，Alice给Bob发送一封邮件的流程是：

Alice的代理，经过SMTP协议，把邮件传输到Alice的邮件服务器上
Alice的邮件服务器，经过SMTP协议，把邮件传输到Bob的邮件服务器上
Bob的邮件服务器，经过POP3、IMAP或HTTP协议，把邮件传输到Bob的代理上

SMTP#

Simple Mail Transfer Protocol（简单邮件传输协议），建立在FTP协议上，用来将邮件从发送方的邮件服务器传输到接收方的邮件服务器，或者是从发送方代理到发送方的邮件服务器。

POP3#

Post Office Protocol - Version 3（邮局协议版本3），将邮件从接收方的邮件服务器传输到接收方的用户代理。

IMAP#

Internet Mail Access Protocol（因特网邮件访问协议），与POP3的基础职责相同，但是提供了比POP3更丰富的功能，例如POP3只允许邮件客户端下载服务器上的邮件，但客户端的操作（删除/移动/标记已读等）不会反映到服务器上；而IMAP提供了服务器与客户端之间的双向通信。

DHCP#

简介与优点#

DHCP(Dynamic Host Configuration Protocol，动态主机配置协议)，常用于中、大型网络中由服务器给每一台网络中与之连接的客户机自动分配IP地址。DHCP基于UDP协议。

优点：

网络管理员可以验证IP地址和其它配置参数，而不用去人工检查每台主机
DHCP可以约束特定计算机使用特定IP地址，并且不会同时租借相同的IP地址给两台主机，避免冲突
客户机在不同子网间移动时不需要重新设置IP地址

分配IP地址的流程#

DHCPDISCOVER：客户端在子网上广播一个DHCPDISCOVER数据包，以此来寻找合适的DHCP服务器。它表示客户端与服务器之间的DHCP交互开始
DHCPOFFER：每个收到DHCPDISCOVER包的DHCP服务器都会预留一个IP地址，并向客户机发送这个DHCPOFFER包。数据包中包含了IP地址以及网络配置设置
DHCPREQUEST：客户端可能会收到来自多个服务器的DHCPOFFER包，但它只接受其中一个DHCPOFFER包中包含的IP地址，并广播一个DHCPREQUEST包进行回复。DHCPREQUEST包不仅对被接受的DHCP服务器进行应答，还通知其他DHCP服务器它们的offer被拒绝
DHCPACK：被接受的DHCP服务器收到DHCPREQUEST数据包后，回复一个DHCPACK数据包。这是DHCP服务器的确认，授权客户机使用之前DHCPOFFER包中的网络配置。至此，客户端成功获得了一个IP地址

BGP#

简介#

边界网关协议（Border Gateway Protocol, BGP）是互联网上一个核心的去中心化自治路由协议。先看几个相关概念：

AS（Autonomous system）：自治系统，指在一个（有时是多个）组织管辖下的所有IP网络和路由器的全体，它们对互联网执行共同的路由策略。对于互联网来说，一个AS是一个独立的整体网络。而BGP实现的网络自治也是指各个AS自治。每个AS有自己唯一的编号ASN。
IGP（Interior Gateway Protocol）：内部网关协议，在一个AS内部所使用的一种路由协议。一个AS内部也可以有多个路由器管理多个网络。各个路由器之间需要路由信息以知道子网络的可达信息。IGP就是用来管理这些路由。代表的实现有RIP和OSPF。
EGP（Exterior Gateway Protocol）：外部网关协议，在多个AS之间使用的一种路由协议，现在已经被BGP取而代之。

由于BGP就是为了替换EGP而创建，它的地位与EGP相似。但是BGP也可以应用在一个AS内部。因此BGP又可以分为IBGP（Interior BGP ：同一个AS之间的连接）和EBGP（Exterior BGP：不同AS之间的BGP连接）。

既然EGP已经被替代了，那EBGP的存在比较好理解；但是IGP协议都还活得好好的（这里主要指OSPF等协议），那IBGP的意义何在？IGP的协议是针对同一个AS网络来设计的，一个自治网络的规模一般都不大，所以设计的时候就没有考虑大规模网络的情况。而当一个自治网络足够大时，OSPF存在性能瓶颈。此时，只有BGP的设计能满足大型网络的要求，所以大型私有IP网络内部可以使用IBGP。总的来说，这几类路由协议，小规模私有网络IGP，大规模私有网络IBGP，互联网EBGP。

工作原理#

BGP路由是基于AS路径(AS Path)来完成的。AS路径是到达一条路由的ASN列表。来自不同AS的两个路由器之间有一条路径，这条路径可能会穿越若干AS。AS路径包括了这条路由路径上需要穿越的所有AS。

BGP路由存储在BGP路由器的数据库中，每条BGP路由都包含了目的地AS，下一跳和完整的AS Path。当BGP路由器收到了一条路由信息，检查路径发现包含了自己的AS号，那它就能判定这是一条自己曾经发出的路由信息，收到的这条路由信息会被丢弃；反之，将其发送给下一跳AS。

BGP基于路径矢量，举个例子，如果BGP路由器收到两条路由信息，目的网络一样，但是路径不一样，一个是AS1->AS3->AS2，另一个是AS1->AS2，如果没有其他的特殊策略，BGP路由器会选用AS1->AS2这条路由信息。

优点#

灵活，可以跨越多跳路由器建立邻居关系，并在路由中携带丰富的属性，适应不同场景的需求
高效，丰富的路由策略能够使得不同场景下都能快速传递路由信息
稳定，避免路由环路，保证能将数据包传到目的地

无线网（802.11）#

无线网通信使用CSMA/CA的原因#

无线信道中信号强度动态范围很大，适配器接受的信号强度远远小于发送信号的强度，如果要在无线网的适配器上实现碰撞检测功能，硬件成本会非常大。
无线电波能向所有方向传播，由于各种障碍物的存在，电磁波传播距离受限，这导致碰撞检测很可能出现错误：检测到信道空闲，其实并不空闲（隐藏站问题）；而检测到信道忙，其实并不忙（暴露站问题）。

在浏览器输入URL回车之后发生了什么#

浏览器层面的操作
- URL解析：首先判断你输入的是一个合法的 URL 还是一个待搜索的关键词，并且根据你输入的内容进行自动完成、字符编码等操作。
- 安全检查：访问限制，是否强制使用HTTPS，…
- 检查缓存是否过期
DNS查询域名对应的IP地址浏览器缓存 -> 操作系统缓存 -> 路由器缓存 -> ISP缓存 -> 根域名服务器（递归+迭代）
依照TCP/IP协议传输 TCP/IP分为四层，在发送数据时，每层都要对数据进行封装。

每一层的甄别标准：
- 应用层：根据TCP/UDP的端口号甄别
- 传输层：根据TCP/UDP头部甄别
- 网络层：根据IP头部16位字段甄别
- 链路层：根据以太网帧头部的2字节的类型字段甄别
每一层的构造:
- 应用层：浏览器会开始构造一个HTTP报文
- 传输层：发起一条到达服务器的TCP连接，为了方便传输，会对数据进行分割（以报文段为单位），并标记编号，方便服务器接受时能够准确地还原报文信息。
- 网络层：IP协议查询MAC地址，将数据段打包，并加入源及目标的IP地址，并且负责寻找传输路线。判断目标地址是否与当前地址处于同一网络中，是的话直接根据MAC地址发送，否则使用路由表查找下一跳地址，以及使用 ARP 协议查询它的MAC地址。
- 链路层：根据以太网协议将数据分为以“帧”为单位的数据包，每一帧分为两个包含头部(数据包的发送者、接受者、数据类型)和数据段
TCP-transmission.png
服务器响应
- 接受TCP报文后，会对连接进行处理，对HTTP协议进行解析（请求方法、域名、路径等）
- 看是否需要重定向，如果服务器配置了HTTP重定向，就会返回一个301永久重定向响应，浏览器就会根据响应，重新发送HTTP请求，重复以上流程
- 查看URL重写规则，如果请求的文件是真实存在的，会直接把这个文件返回；否则服务器会按照规则把请求重写到另一个REST风格的URL上。
浏览器接受响应
- 查看Response header，根据不同状态码做不同的事（比如上面提到的重定向）
- 如果响应资源进行了压缩（比如 gzip），还需要进行解压
- 对响应资源做缓存
- 根据响应资源里的MIME类型去解析响应内容（比如 HTML、Image各有不同的解析方式）
渲染页面 HTML解析，CSS解析，JavaScript的执行

排序算法

Fri, 01 Jan 2021 00:00:00 GMT

常用的排序算法

算法一览#

sort-table.png

冒泡排序#

比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

优化思路：立一个flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。

bubbleSort.gif

1
public int[] bubbleSort(int[] arr) {
2
    for (int i = 1; i < arr.length; i++) {
3
        // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
4
        boolean flag = true;
5

6
        for (int j = 0; j < arr.length - i; j++) {
7
            if (arr[j] > arr[j + 1]) {
8
                int tmp = arr[j];
9
                arr[j] = arr[j + 1];
10
                arr[j + 1] = tmp;
11

12
                flag = false;
13
            }
14
        }
15

16
        if (flag) {
17
            break;
18
        }
19
    }
20
    return arr;
21
}

展开收起

选择排序#

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。

selectionSort.gif

1
public int[] selectionSort(int[] arr) {
2
    // 总共要经过 N-1 轮比较
3
    for (int i = 0; i < arr.length - 1; i++) {
4
        int minIndex = i;
5

6
        // 每轮需要比较的次数 N-i
7
        for (int j = i + 1; j < arr.length; j++)
8
            if (arr[j] < arr[minIndex]) {
9
                minIndex = j; // 记录目前能找到的最小值元素的下标
10
            }
11

12
        // 将找到的最小下标和i进行交换
13
        if (i != minIndex) {
14
            int tmp = arr[i];
15
            arr[i] = arr[minIndex];
16
            arr[minIndex] = tmp;
17
        }
18
    }
19
    return arr;
20
}

展开收起

插入排序#

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）（联想打扑克时整理手牌）

优化思路：希尔排序

insertionSort.gif

1
public int[] insertionSort(int[] arr) {
2
    // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
3
    for (int i = 1; i < arr.length; i++) {
4

5
        // 当前要插入的数据
6
        int tmp = arr[i];
7

8
        // 从已经排序的序列最右边的开始比较，如果找到比其小的数，把这个数右移一位，腾位置给要插入的数
9
        int j = i;
10
        while (j > 0 && tmp < arr[j - 1]) {
11
            arr[j] = arr[j - 1];
12
            j--;
13
        }
14

15
        // 存在比其小的数，插入
16
        if (j != i) {
17
            arr[j] = tmp;
18
        }
19
    }
20
    return arr;
21
}

展开收起

希尔排序#

把记录按下标的一定增量（gap）分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序的gap选择与证明是个数学难题，希尔建议的gap是数组长度的一半。

shellSort.gif

1
public int[] shellSort(int[] arr) {
2
    // 初始gap的选择
3
    int gap = arr.length / 2;
4

5
    while (gap > 0) {
6
        // 从下标为gap的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
7
        for (int i = gap; i < arr.length; i++) {
8
            // 当前要插入的数据
9
            int tmp = arr[i];
10

11
            // 从已经排序的序列最右边的开始比较，如果找到比其小的数，把这个数右移gap位，腾位置给要插入的数
12
            int j = i - gap;
13
            while (j >= 0 && tmp < arr[j]) {
14
                arr[j + gap] = arr[j];
15
                j -= gap;
16
            }
17
            arr[j + gap] = tmp;
18
        }
19
        gap = gap / 2; // gap缩小
20
    }
21
    return arr;
22
}

展开收起

归并排序#

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。设定两个指针分别指向两个已经排序序列的起始位置，不断比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。如果一个序列到达末尾，再把另一个序列的剩余元素添加到合并序列的末尾。

mergeSort.gif

1
public void mergeSort(int[] result, int[] data, int left, int right) {
2
    if (left >= right) {
3
        return;
4
    }
5

6
    int mid = left + (right - left) / 2;
7

8
    // 双指针，确定两个子数组的起始下标
9
    int ptr1 = left;
10
    int ptr2 = mid + 1;
11

12
    // 分治
13
    mergeSort(result, data, left, mid);
14
    mergeSort(result, data, mid+1, right);
15

16
    // 按照双指针进行排序
17
    int index = left;
18
    while (ptr1 <= mid && ptr2 <= right) {
19
        result[index++] = data[ptr1] < data[ptr2] ? data[ptr1++] : data[ptr2++];
20
    }
21

22

23
    // 两个循环只会执行一个，即：拷贝那个有剩余的数组
24
    while (ptr1 <= mid) {
25
        result[index++] = data[ptr1++];
26
    }
27
    while (ptr2 <= right) {
28
        result[index++] = data[ptr2++];
29
    }
30

31
    // 把排好序的结果覆盖掉原始的数组
32
    for (index = left; index <= right; index++) {
33
        data[index] = result[index];
34
    }
35
}

展开收起

快速排序#

从数列中挑出一个元素，称为 “基准”（pivot）。重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数放到任意一边），这个步骤称为称为分区（partition）操作。递归地把小于基准值元素的子数列和大于基准值元素的子数列都进行排序。

quickSort.gif

1
public int partition(int[] data, int left, int right) {
2
    int pivot = data[left]; // 初始pivot
3

4
    // 范围内搜寻比pivot小或大的元素，然后将左侧元素与右侧元素交换
5
    while (left < right) {
6
        while (data[right] >= pivot && left < right) {
7
            right--;
8
        }
9
        data[left] = data[right];
10

11
        while (data[left] <= pivot && left < right) {
12
            left++;
13
        }
14
        data[right] = data[left];
15
    }
16

17
    data[left] = pivot;
18
    return left;
19
}
20

21
public void quickSort(int[] data, int begin, int end) {
22
    if (begin >= end) {
23
        return;
24
    }
25

26
    int pivot = partition(data, begin, end);
27

28
    // 两个子数组分治排序
29
    quickSort(data, begin, pivot - 1);
30
    quickSort(data, pivot + 1, end);
31
}

展开收起

堆排序#

创建一个堆 H[0……n-1]，把堆首（最大值）和堆尾互换；把堆的尺寸缩小1，把新的数组顶端数据调整到相应位置；重复步骤2，直到堆的尺寸为1。

heapSort.gif

1
public int[] heapSort(int[] arr) {
2
    int len = arr.length;
3

4
    // 构造堆
5
    for (int i = len / 2; i >= 0; i--) {
6
        heapify(arr, i, len);
7
    }
8

9
    for (int i = len - 1; i > 0; i--) {
10
        swap(arr, 0, i); // 把堆顶最大值和堆尾互换
11
        len--; // 堆的尺寸减少1
12
        heapify(arr, 0, len); // 新的堆顶调整到相应位置
13
    }
14

15
    return arr;
16
}
17

18
private void heapify(int[] arr, int i, int len) {
19
    int left = 2*i + 1, right = 2*i + 2;
20

21
    // 判断两个儿子是否比当前节点大，如果有，返回最大的那个
22
    int max = i;
23
    if (left < len && arr[left] > arr[max]) {
24
        max = left;
25
    }
26
    if (right < len && arr[right] > arr[max]) {
27
        max = right;
28
    }
29

30
    if (max != i) {
31
        swap(arr, i, max); // 交换父子
32
        heapify(arr, max, len); // 调整当前最大节点到堆尾
33
    }
34
}
35

36
private void swap(int[] arr, int i, int j) {
37
    int temp = arr[i];
38
    arr[i] = arr[j];
39
    arr[j] = temp;
40
}

展开收起

计数排序#

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组C中。找出待排序的数组中最大和最小的元素，统计数组中每个值为i的元素出现的次数，存入数组C的第i项。对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加），将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

countingSort.gif

1
private int getMinValue(int[] arr) {
2
    int minValue = arr[0];
3
    for (int value : arr) {
4
        if (minValue > value) {
5
            minValue = value;
6
        }
7
    }
8

9
    return minValue;
10
}
11

12
private int getMaxValue(int[] arr) {
13
    int maxValue = arr[0];
14
    for (int value : arr) {
15
        if (maxValue < value) {
16
            maxValue = value;
17
        }
18
    }
19

20
    return maxValue;
21
}
22

23
private int[] countingSort(int[] arr, int minValue, int maxValue) {
24
    // 桶的长度
25
    int bucketLen = maxValue - minValue + 1;
26
    int[] temp = new int[bucketLen];
27
    // 每个值映射后出现的次数
28
    for (int value : arr) temp[value - minValue]++;
29

30
    int sortedIndex = 0;
31
    for (int j = 0; j < bucketLen; j++) {
32
        while (temp[j] > 0) {
33
            arr[sortedIndex++] = j + minValue; // 把桶中的数取出放到数组末尾
34
            temp[j]--; // 用掉了一次当前数，桶中的次数减少
35
        }
36
    }
37

38
    return arr;
39
}

展开收起

系统设计

Fri, 01 Jan 2021 00:00:00 GMT

系统设计入门概念普及。

高质量设计目标#

性能#

性能指标#

响应时间：指某个请求从发出到接收到响应消耗的时间。在对响应时间进行测试时，通常采用重复请求的方式，然后计算平均响应时间
吞吐量（TPS）：指系统在单位时间内可以处理的请求数量，通常使用每秒的请求数来衡量
并发用户数：指系统能同时处理的并发用户请求数量
- 在没有并发存在的系统中，请求被顺序执行
- 目前的大型系统都支持多线程来处理并发请求，多线程能够提高吞吐量以及缩短响应时间，主要是由于多CPU的引入以及IO多路复用提高效率

性能优化#

集群：将多台服务器组成集群，使用负载均衡将请求转发到集群中，避免单一服务器的负载压力过大导致性能降低。
缓存：提高性能
- 数据通常位于内存等介质中，这种介质对于读操作特别快
- 数据可以位于靠近用户的地理位置上
- 可以将计算结果进行缓存，从而避免重复计算
异步：某些流程可以将操作转换为消息，将消息发送到消息队列之后立即返回，之后这个操作会被异步处理

服务化#

按照“自包含、可重用、独立管理”三原则，将网络功能定义为若干个可被灵活调用的“服务”模块。

优点：

敏捷：服务松耦合，网络部署、维护、升级更快速、便利
易扩展：轻量级的接口使得新功能的引入不需要引入新的接口设计
灵活：通过模块化、可重用方式实现网络功能的组合，满足网络切片等灵活组网需求
开放：新型REST API接口极大的便于运营商或第三方调用服务

异步#

异步架构通过消息队列构建。消息的生产者将消息发送到消息队列以后，由消息的消费者从消息队列中获取消息，然后进行业务逻辑的处理，消息的生产者和消费者是异步处理的，彼此不会等待阻塞，所以叫做异步架构。

两种模型：

点对点模型消费者和生产者只需要知道消息队列的名字，生产者发送消息到消息队列中，而消息队列的另一端是多个消费者竞争消费消息，每个到达消息队列的消息只会被路由到一个消费者中去。
发布订阅模型生产者发送消息到一个主题，消息被发布到主题后，就会被克隆给每一个订阅它的消费者，每个消费者接收一份消息复制到自己的私有队列。消费者可以独立于其他消费者使用自己订阅的消息，消费者之间不会竞争消息。

优点：

实现异步处理，提升处理性能
让系统获得更好的伸缩性
平衡流量峰值
使生产者和消费者的代码实现解耦合

优秀产品：

RabbitMQ，开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，或者简单的将作业排队以便让分布式服务器进行处理。

高并发#

常用的手段有：

消息队列：解耦和削峰，应用之间通过消息传递进行通信
读写分离：将数据库的读和写操作分不到不同的数据库节点上。主服务器负责写，从服务器负责读。另外，一主一从或者一主多从都可以。读写分离可以大幅提高读性能，小幅提高写的性能。因此，读写分离更适合单机并发读请求比较多的场景
分库分表：解决由于库、表数据量过大，而导致数据库性能持续下降的问题
负载均衡：将任务比如用户请求处理分配到多个服务器处理以提高网站、应用或者数据库的性能和可靠性。常见的负载均衡系统包括3种：
- DNS负载均衡：一般用来实现地理级别的均衡
- 硬件负载均衡：通过单独的硬件设备比如 F5 来实现负载均衡功能（硬件的价格一般很贵）
- 软件负载均衡：通过负载均衡软件比如 Nginx 来实现负载均衡功能

高可用#

“高可用性”（High Availability）通常来描述一个系统经过专门的设计，从而减少停工时间，而保持其服务的高度可用性。简而言之，就是不间断对外提供服务。

为了保证高可用性，常用的手段有：

限流：限流是从用户访问压力的角度来考虑如何应对系统故障。限流为了对服务端的接口接受请求的频率进行限制，防止服务挂掉。比如某一接口的请求限制为 100 个每秒, 对超过限制的请求放弃处理或者放到队列中等待处理
降级：从系统功能优先级的角度考虑如何应对系统故障。服务降级指的是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行
熔断：熔断和降级是两个比较容易混淆的概念。熔断的目的在于应对当前系统依赖的外部系统或者第三方系统的故障
排队：可以看作是另类的限流方式，控制单位时间提供服务的数量
集群：相同的服务部署多份，避免单点故障
超时和重试机制：一旦用户的请求超过某个时间得不到响应就结束此次请求并抛出异常

具体到核心技术：

CDN加速，服务器上存储的静态内容缓存在云CDN节点上，用户无需访问服务器源站，就近访问云CDN节点即可获取相同内容，既能达到加速的效果，又能减轻服务器源站的压力。
缓存，比如使用redis作为缓存服务器，用户的访问流量在到达数据库之前直接过滤掉一大部分
负载均衡，将流量分发到多个服务器
拆分服务，降低服务之间的耦合程度

伸缩性#

指不断向集群中添加服务器来缓解不断上升的用户并发访问压力和不断增长的数据存储需求。

应用服务器只要不具有状态，那么就可以很容易地通过负载均衡器向集群中添加新的服务器。

关系型数据库的伸缩性通过 Sharding 来实现，将数据按一定的规则分布到不同的节点上，从而解决单台存储服务器的存储空间限制。

可扩展#

核心：把大的系统拆分为小的系统

面向流程拆分
- 把不同模块按照职责分开，每层中的组件只处理本层的逻辑。这样就可以支持系统在某层上的快速扩展
面向服务拆分
- 微服务
面向功能拆分
- 微内核，区分出核心系统和插件模块

分布式系统#

简介与优点#

分布式系统是一个建立于网络上的系统，其组成部分位于不同的联网计算机上(表示为节点)，它们通过相互传递信息来沟通和协调行动。

分布式系统应具有以下四个特征：

分布性。分布式系统由多台计算机组成，它们在地域上是分散的，可以散布在一个单位、一个城市、一个国家，甚至全球范围内。整个系统的功能是分散在各个节点上实现的，因而分布式系统具有数据处理的分布性。
自治性。分布式系统中的各个节点都包含自己的处理机和内存，各自具有独立的处理数据的功能。通常，彼此在地位上是平等的，无主次之分，既能自治地进行工作，又能利用共享的通信线路来传送信息，协调任务处理。
并行性。一个大的任务可以划分为若干个子任务，分别在不同的主机上执行。
全局性。分布式系统中必须存在一个单一的、全局的进程通信机制，使得任何一个进程都能与其他进程通信，并且不区分本地通信与远程通信。同时，还应当有全局的保护机制。系统中所有机器上有统一的系统调用集合，它们必须适应分布式的环境。在所有CPU上运行同样的内核，使协调工作更加容易。

分布式系统的优点：

多主机并发执行任务，效率高
可扩展性好，如果工作量增大，用户只需要向网络中添加主机即可，而不用重新更新或设计系统
容错率高，局部节点出现故障不影响整个系统的运行

分布式系统单节点故障处理#

集群管理的服务器会将通向该节点上的连接重定向到其他节点上
每一个节点的数据都会被事先复制到其他的所有节点上，因此可以从其他节点的备份数据里获取到需要的信息；也可以用这些备份数据完成之后的数据恢复

分布式系统下的Session问题#

分布式状态下Session的问题：负载均衡多服务器的情况，不好确认当前用户是否登录，因为多服务器不共享Session。

解决方法：

把用户访问页面产生的Session放到Cookie里面，以Cookie为中转站，如果服务器没有Session信息就检查客户端Cookie里有没有，如果有就用Cookie里的信息同步 (简单，服务器负担小；Cookie可能会被禁用，并且安全性不高)
memcached，把web服务器中的内存组合起来，成为一个”内存池”，不管是哪个服务器产生的 Session都可以放到这个”内存池”中，其他的都可以使用
- 服务器负担小，安全，内存读写快
- 把内存分成固定大小的内存块，无法完全利用，会产生碎片或者溢出问题
Token, 客户端登陆传递信息给服务端，服务端收到后把用户信息加密（Token）传给客户端，客户端将Token存放于localStroage等容器中。客户端每次访问都传递Token，服务端解密Token，就知道这个用户是谁了。通过cpu加解密，服务端就不需要存储session占用存储空间

负载均衡#

负载均衡的核心是将流量分发到多个服务器，常见的方法有：

轮转法：将请求按顺序轮流分配到后端服务器上，不关心服务器实际的连接数和系统负载。在此基础上，还可以给配置高、负载低的机器配置更高的权重，配置低、负载高的机器分配较低的权重，通过加权轮转保证正常处理用户请求
随机法：从后端服务器列表中随机选取一台服务器进行访问。当用户访问次数不断增大的时候，效果会越来越接近轮转法
IP哈希法：获取客户端的IP地址，通过哈希函数计算得到的一个数值，用该数值对服务器列表的大小进行取模运算，得到的结果便是客服端要访问服务器的序号。
最小连接数法：根据后端服务器当前的连接情况，动态选取当前连接数最少的一台服务器来处理当前的请求，尽可能提高后端服务的利用效率

一致性哈希算法#

假如有N个缓存服务器，通用方法是计算访问对象的哈希值，再通过取模运算均匀的映射到N个缓存上。但如果某一天一个缓存服务器挂了，或者是访问加重，多加了一台服务器，取模映射公式中的N就变成了N-1或N+1，这导致突然之间几乎所有缓存都失效了，因为客户请求对象时的哈希值往往依赖于节点数量，不同的哈希值导致找不到原来保存这个对象的服务器节点。

一致性哈希将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数值空间为0 ～ 2-1（即哈希值是一个32位无符号整数）。每台服务器可以选择服务器的IP或主机名作为关键字进行哈希，这样就能确定其在哈希环上的位置。而数据key使用相同的函数Hash计算出哈希值，并确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该访问定位到的服务器。一致性哈希算法对于节点的增减都只需重定位环空间中的一小部分数据，具有较好的容错性和可扩展性。

consistent-hash.png

如果服务器发生变化：

如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间的数据，它们会被定位到顺时针行走到达的第一台服务器；其它数据不会受到影响。
如果增加一台服务器，则受影响的数据仅仅是新服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间的数据，它们会被定位到新服务器上；其它数据也不会受到影响。

同时，一致性哈希算法引入了虚拟节点机制，即对每一个服务节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称为虚拟节点。数据定位算法不变，只是多了一步虚拟节点到实际节点的映射，例如定位到“Node A#1”、“Node A#2”、“Node A#3”三个虚拟节点的数据均定位到Node A上。这样就解决了服务节点少时数据倾斜的问题。

架构演进#

单一应用架构#

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

垂直应用架构#

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架是关键。

分布式服务架构#

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

流动计算架构#

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

LeetCode 1-100

Wed, 01 Jan 2020 00:00:00 GMT

LeetCode Problems 1-100.

1. Two Sum#

https://leetcode.com/problems/two-sum/

我们需要保证nums[i]和target - nums[i]都在数组中，因此使用哈希表存储循环遍历时每个数nums[i]以及下标i的值，并检查target - nums[i]是否也在map中，如果存在，就可以直接提取两个数的位置得到结果。

1
class Solution {
2
    public int[] twoSum(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return new int[] {};
5
        }
6

7
        int[] result = new int[2];
8

9
        // <Element, Index>
10
        Map<Integer, Integer> map = new HashMap<>();
11
        for (int i = 0; i < nums.length; i++) {
12
            if (map.containsKey(target - nums[i])) {
13
                result[0] = i;
14
                result[1] = map.get(target - nums[i]);
15
                return result;
16
            }
17
            map.put(nums[i], i);
18
        }
19

20
        return result;
21
    }
22
}

展开收起

2. Add Two Numbers#

https://leetcode.com/problems/add-two-numbers/

加法运算是一个从低位到高位的循环过程，只要下列3个条件之一满足，就会一直持续下去：

第一个数某位不为空
第二个数某位不为空
进位不为0

因此我们创建一个新链表，按照上述条件，对l1和l2逐位计算相加，得到结果后创建一个新节点插入到链表中。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
13
        if (l1 == null) {
14
            return l2;
15
        }
16
        if (l2 == null) {
17
            return l1;
18
        }
19

20
        ListNode dummyHead = new ListNode(0); // dummy head of new list
21
        ListNode cur = dummyHead; // traverse new list
22

23
        int carry = 0;
24

25
        // still have digits
26
        while (l1 != null || l2 != null || carry != 0) {
27
            int val = 0;
28

29
            int val1 = l1 != null ? l1.val : 0;
30
            int val2 = l2 != null ? l2.val : 0;
31

32
            val = (val1 + val2 + carry) % 10;
33
            carry = (val1 + val2 + carry) / 10;
34

35
            // insert a new node
36
            cur.next = new ListNode(val);
37
            cur = cur.next;
38

39
            // move pointers forward
40
            if (l1 != null) {
41
                l1 = l1.next;
42
            }
43
            if (l2 != null) {
44
                l2 = l2.next;
45
            }
46
        }
47

48
        return dummyHead.next;
49
    }
50
}

展开收起

3. Longest Substring Without Repeating Characters#

https://leetcode.com/problems/longest-substring-without-repeating-characters/

我们需要一个map记录每个字符最后一次出现的位置。由于s中的字符已经确定是英文字母或者符号，因此可以使用定长数组模拟map，提高运行效率。

定义两个指针begin和end，begin指向最长不重复子串起点，尾指针用于遍历s，判断当前字符是否于map中。我们的目标就是尾指针完成遍历后，通过两个指针的最大距离差值，得到最长的不重复子串长度。

遍历时需要注意，在遇到重复字符时，begin有两种更新方式：

这个字符上一次出现位置的后面（+1），这是满足不重复的前提下的最小取值
保持不变，因为有可能这个重复字符上一次出现的位置相当靠前，在[map[currentChar] + 1, begin]中间出现了其他的重复字符

具体选择哪种方式更新，只需比较当前begin和上一次出现位置+1的大小。

1
class Solution {
2
    public int lengthOfLongestSubstring(String s) {
3
        if (s.length() == 0) {
4
            return 0;
5
        }
6

7
        char[] array = s.toCharArray();
8

9
        int begin, end = 0; // two pointers to mark the longest substring
10
        int result = 0; // longest substring's length
11

12
        int[] map = new int[128]; // <Character, Index>
13
        Arrays.fill(map, -1);
14

15
        for (begin = 0, end = 0; end < s.length(); end++) {
16
            char currentChar = array[end];
17

18
            // if this is a repeating character, we either reset begin index to last appearance index + 1 to avoid duplicate
19
            // or remains unchanged. It is possible that [map[currentChar] + 1, begin] contains duplicate characters
20
            if (map[currentChar] >= 0) {
21
                begin = Math.max(begin, map[currentChar] + 1);
22
            }
23

24
            // update current character's last position index
25
            map[currentChar] = end;
26

27
            // update result
28
            result = Math.max(result, end - begin + 1);
29
        }
30
        return result;
31
    }
32
}

展开收起

4. Median of Two Sorted Arrays#

https://leetcode.com/problems/median-of-two-sorted-arrays/

对于一个有序数组，我们做一次分割，将数组分割为两半部分，则数组中位数为下半部分最大值与上半部分最小值的平均值。这种取法的前提是两半部分具有相同的元素值。当数组中有偶数个元素时，分割很容易；而当有奇数个元素时，我们尝试将实际的中位数mid一分为二，这样两部分都有了这个mid，数组的中位数仍然可以用(mid + mid) / 2 = mid得到。

对于一个有N个元素的数组，如果定义分割左侧的数为L，右侧的数为R，则它们可以表示为：

1
L = nums[(N - 1) / 2]
2
R = nums[N/2]
3
mid = (L + R) / 2

现在，假设为元素之间的间隔也增加下标。例如：

1
[6 9 13 18]  ->   [# 6 # 9 # 13 # 18 #]    (N = 4)
2
position index     0 1 2 3 4 5  6 7  8     (N_Position = 9)
3

4
[6 9 11 13 18]->   [# 6 # 9 # 11 # 13 # 18 #]   (N = 5)
5
position index      0 1 2 3 4 5  6 7  8 9 10    (N_Position = 11)

易得知，总共有2N + 1个下标位，并且分割的位置一定在下标为N处。因此仍然有

1
index(L) = (N - 1) / 2
2
index(R) = N / 2

至此，我们完成了单个数组的推导。扩展到两个有序数组时，我们可以总结出：

一共有2M + 2N + 2个下标位
需要2个切割点，下标设定为C1和C2
切割的左侧和右侧总共都有M + N个元素

假设nums2是长度较短的数组，并且切割点的下标为C2 = K，则nums1的切割点下标为C1 = M + N - K。完成这两次切割后，我们可以得到切割点附近的四个下标：

1
L1 = nums1[(C1 - 1) / 2]
2
R1 = nums1[C1/2]
3
L2 = nums2[(C2 - 1) / 2]
4
R2 = nums2[C2/2]

为了保证我们的切割是合理的，我们需要保证：

1
L1 <= R1
2
L1 <= R2
3
L2 <= R1
4
L2 <= R2

显然，第1、4个条件是肯定满足的，因此只有中间两个条件满足时，我们才能得到正确的划分。此时，我们可以引用二分搜索。如果L1 > R2，说明nums1中的切割点取的过大，需要缩小，换言之，我们可以调整nums2中的切割点，使其变大并超过nums1中的切割点；而如果L2 > R1，说明nums2中的切割点取的过大，缩小即可。完成切分点的选取后，选取两个子数组相应的最大最小值取平均，即可得到最终答案。

需要注意的是，切割点的下标有可能会发生数组越界。只需假设数组两端各自存在一个极值，当切割点越界时自动赋极值即可解决。

1
class Solution {
2
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
3
        int m = nums1.length, n = nums2.length;
4

5
        // make sure nums2 is the smaller array
6
        if (m < n) {
7
            return findMedianSortedArrays(nums2, nums1);
8
        }
9

10
        int low = 0, high = n * 2;
11
        while (low <= high) {
12
            int cut2 = (low + high) / 2;
13
            int cut1 = m + n - cut2;
14

15
            // avoid boundary exception
16
            double L1 = (cut1 == 0) ? Integer.MIN_VALUE : nums1[(cut1-1)/2];
17
            double L2 = (cut2 == 0) ? Integer.MIN_VALUE : nums2[(cut2-1)/2];
18
            double R1 = (cut1 == m * 2) ? Integer.MAX_VALUE : nums1[(cut1)/2];
19
            double R2 = (cut2 == n * 2) ? Integer.MAX_VALUE : nums2[(cut2)/2];
20

21
            if (L1 > R2) {
22
                // nums1's lower half is too big; need to move C1 left (C2 right)
23
                low = cut2 + 1;
24
            } else if (L2 > R1) {
25
                // nums2's lower half too big; need to move C2 left.
26
                high = cut2 - 1;
27
            } else {
28
                // Otherwise, that's the right cut.
29
                return (Math.max(L1, L2) + Math.min(R1, R2)) / 2;
30
            }
31
        }
32
        return -1;
33
    }
34
}

展开收起

5. Longest Palindromic Substring#

https://leetcode.com/problems/longest-palindromic-substring/

遍历每一个字符，每一个字符都向两侧延展，如果新延展得到的两个字符仍然相同则继续延展，以此计算能延展的最大长度。

考虑到回文字符串的长度有两种可能，需要按照奇偶性进行两次延展判断。

1
class Solution {
2
    private int startIndex = 0, maxLen = 0;
3

4
    private void checkPalindrome(char[] array, int left, int right) {
5
        while (left >= 0 && right <= array.length - 1 && array[left] == array[right]) {
6
            left--;
7
            right++;
8
        }
9

10
        // update maxLen = (right - 1) - (left + 1) + 1 = right - left - 1
11
        if (maxLen < right - left - 1) {
12
            maxLen = right - left - 1;
13
            startIndex = left + 1;
14
        }
15
    }
16

17
    public String longestPalindrome(String s) {
18
        if (s.length() <= 1) {
19
            return s;
20
        }
21

22
        char[] array = s.toCharArray();
23
        for (int i = 0; i < array.length - 1; i++) {
24
            checkPalindrome(array, i, i); // assume odd length
25
            checkPalindrome(array, i, i+1); // assume even length
26
        }
27

28
        return s.substring(startIndex, startIndex + maxLen);
29
    }
30
}

展开收起

6. Zigzag Conversion#

https://leetcode.com/problems/zigzag-conversion/

根据numRows的长度建立等长的StringBuilder数组，每一行对应一个StringBuilder。按照“竖直向下——斜向右上”的顺序不断向当前行的StringBuilder添加字符串中的字符即可。输出时，要对StringBuilder进行格式转化。

1
class Solution {
2
    public String convert(String s, int numRows) {
3
        int len = s.length();
4

5
        // every row is a StringBuilder
6
        StringBuilder[] sb = new StringBuilder[numRows];
7
        for (int i = 0; i < numRows; i++) {
8
            sb[i] = new StringBuilder();
9
        }
10

11
        // index to traverse the whole string
12
        int index = 0;
13
        while (index < len) {
14
            // vertically down
15
            for (int i = 0; i < numRows && index < len; i++) {
16
                sb[i].append(s.charAt(index++));
17
            }
18

19
            // obliquely up (not include the first and last row)
20
            for (int i = numRows - 2; i >= 1 && index < len; i--) {
21
                sb[i].append(s.charAt(index++));
22
            }
23
        }
24

25
        // append all rows of result
26
        for (int i = 1; i < numRows; i++) {
27
            sb[0].append(sb[i]);
28
        }
29

30
        return sb[0].toString();
31
    }
32
}

展开收起

7. Reverse Integer#

https://leetcode.com/problems/reverse-integer/

通过整除反向提取每一位数。为了预防范围溢出，需要在每一次提取后进行一次溢出判断。

1
class Solution {
2
    public int reverse(int x) {
3
        long result = 0;
4

5
        while (x != 0) {
6
            // obtain the last bit
7
            result = result * 10 + x % 10;
8
            x /= 10;
9

10
            // overflow check
11
            if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
12
                return 0;
13
            }
14
        }
15

16
        return (int)result;
17
    }
18
}

展开收起

8. String to Integer (atoi)#

https://leetcode.com/problems/string-to-integer-atoi/

流程分为三步：

去除字符串开头的空格
判断是否存在正负号
判断是否为数字。如果是数字，更新运算结果，并检查当前结果是否超出整数范围；如果不是数字，则返回当前结果

1
class Solution {
2
    public int myAtoi(String str) {
3
        // trim leading blank space
4
        str = str.trim();
5
        if (str.length() == 0) {
6
            return 0;
7
        }
8

9
        // detect sign
10
        char firstChar = str.charAt(0);
11
        int sign = 1;
12
        int digitStart = 0; // default no sign char, thus digit start from index 0
13
        if (firstChar == '+' || firstChar == '-') {
14
            sign = (firstChar == '+') ? 1 : -1;
15
            digitStart++;
16
        }
17

18
        // add digits
19
        long sum = 0;
20
        for (int i = digitStart; i < str.length(); i++) {
21
            char current = str.charAt(i);
22

23
            // non-digit, return sum immediately
24
            if (current < '0' || current > '9') {
25
                return (int)sum * sign;
26
            }
27

28
            // continue adding current digit
29
            sum = sum * 10 + current - '0';
30

31
            // overflow checking
32
            if (sign == 1 && sum > Integer.MAX_VALUE) {
33
                return Integer.MAX_VALUE;
34
            }
35
            if (sign == -1 && -sum < Integer.MIN_VALUE) {
36
                return Integer.MIN_VALUE;
37
            }
38
        }
39
        return (int)sum * sign;
40
    }
41
}

展开收起

9. Palindrome Number#

https://leetcode.com/problems/palindrome-number/

将数字反转后与原数字进行比较。注意，不需要完整地将整个数字进行反转，只需要反转一半的数字，并与剩余一半进行比较即可。

1
class Solution {
2
    public boolean isPalindrome(int x) {
3
        // exclude negative number and 10's multiple
4
        if (x < 0 || (x != 0 && x % 10 == 0)) {
5
            return false;
6
        }
7

8
        int result = 0;
9

10
        // only need to reverse half of all digits
11
        while (x > result) {
12
            result = result * 10 + x % 10;
13
            x /= 10;
14
        }
15

16
        // odd or even length
17
        return (x == result || x == result / 10);
18
    }
19
}

展开收起

10. Regular Expression Matching#

https://leetcode.com/problems/regular-expression-matching/

此题需要使用二维动态规划算法。对于s和p，我们需要从头开始推导出子字符串s[i]和p[j]的匹配情况，进而推出整个s和p是否匹配。

解决时，需要对题设条件进行分类讨论：

最标准的匹配情况，即string[i] = pattern[j]，则dp[i+1][j+1] = dp[i][j]
pattern中出现了'.'，可以匹配string中任意的一个字符，同样有dp[i+1][j+1] = dp[i][j]
pattern中出现了'*'，需要进一步讨论：
- 如果pattern[j-1] != string[i]，说明此时的'a*'只能作为空字符串匹配，因此dp[i+1][j+1] = dp[i+1][j-1]
- 如果pattern[j-1] == string[i], 或是pattern[j-1] == '.'，即在’*‘之前的一个字符也能够匹配上，则：
  - 如果'*'匹配空字符串，则dp[i+1][j+1] = dp[i+1][j-1]
  - 如果'*'匹配一个字符，则dp[i+1][j+1] = dp[i+1][j]
  - 如果'*'匹配多个字符，则dp[i+1][j+1] = dp[i][j+1]

1
class Solution {
2
    public boolean isMatch(String s, String p) {
3
        boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
4

5
        // s and p are both empty, so they can match
6
        dp[0][0] = true;
7

8
        // pattern cannot start with '*'
9
        if (p.length() > 0 && p.charAt(0) == '*') {
10
            return false;
11
        }
12

13
        // '*' match
14
        for (int j = 0; j < p.length(); j++) {
15
            if (p.charAt(j) == '*' && dp[0][j-1]) {
16
                dp[0][j+1] = true;
17
            }
18
        }
19

20
        for (int i = 0; i < s.length(); i++) {
21
            for (int j = 0; j < p.length(); j++) {
22
                // regular matching, or '.' matching
23
                if (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.') {
24
                    dp[i+1][j+1] = dp[i][j];
25
                } else if (p.charAt(j) == '*') {
26
                    // * can only be matched as empty char
27
                    if (s.charAt(i) != p.charAt(j-1)) {
28
                        dp[i+1][j+1] = dp[i+1][j-1];
29
                    }
30

31
                    // * can be matched as 0, 1 or multiple chars
32
                    if (s.charAt(i) == p.charAt(j-1) || p.charAt(j-1) == '.') {
33
                        dp[i+1][j+1] = dp[i+1][j-1] || dp[i+1][j] || dp[i][j+1];
34
                    }
35
                }
36
            }
37
        }
38

39
        return dp[s.length()][p.length()];
40
    }
41
}

展开收起

11. Container With Most Water#

https://leetcode.com/problems/container-with-most-water/

问题转化为判断两个横坐标之间能够围成的最大面积。定义两个指针，一个指向数组头向尾遍历，另一个指向数组尾向头遍历。在遍历之前不断计算当前能围成的最大面积，并且向着可能进一步增大面积的方向移动指针。

1
class Solution {
2
    public int maxArea(int[] height) {
3
        if (height == null || height.length <= 1) {
4
            return 0;
5
        }
6

7
        int left = 0, right = height.length - 1;
8
        int result = 0, current = 0; // max area, current area
9

10
        while (left < right) {
11
            current = (right - left) * Math.min(height[left], height[right]);
12
            result = Math.max(result, current);
13

14
            // keep the higher edge, and try to increase the other edge
15
            if (height[left] < height[right]) {
16
                left++;
17
            } else {
18
                right--;
19
            }
20
        }
21
        return result;
22
    }
23
}

展开收起

12. Integer to Roman#

https://leetcode.com/problems/integer-to-roman/

非常无聊的题目，直接穷举nums范围内各个基数单位，不断叠加上当前的最大基数对应的罗马字符。

1
class Solution {
2
    public String intToRoman(int num) {
3
        int[] value = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
4
        String[] roman = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
5
        StringBuilder sb = new StringBuilder();
6

7
        for (int i = 0; i < value.length; i++) {
8
            while (num >= value[i]) {
9
                sb.append(roman[i]);
10
                num = num - value[i];
11
            }
12
        }
13

14
        return sb.toString();
15
    }
16
}

展开收起

13. Roman to Integer#

https://leetcode.com/problems/roman-to-integer/

遇到可能包含歧义的字母（M, X, V等）时，额外判断后一个字母明确具体数字即可。

1
class Solution {
2
    public int romanToInt(String s) {
3
        if (s.length() == 0) {
4
            return 0;
5
        }
6

7
        int i = 0;
8
        int len = s.length();
9
        int result = 0;
10

11
        while (i < len) {
12
            char c = s.charAt(i); // current character
13
            char nextChar = '.'; // if there is a next character
14
            if (i != len - 1) {
15
                nextChar = s.charAt(i+1);
16
            }
17

18
            // need to check IV and IX
19
            if (c == 'I') {
20
                if (nextChar == 'V') {
21
                    result += 4;
22
                    i += 2;
23
                } else if (nextChar == 'X') {
24
                    result += 9;
25
                    i += 2;
26
                } else {
27
                    result += 1;
28
                    i += 1;
29
                }
30
            }
31

32
            else if (c == 'V') {
33
                result += 5;
34
                i += 1;
35
            }
36

37
            // need to check XL and XC
38
            else if (c == 'X') {
39
                if (nextChar == 'L') {
40
                    result += 40;
41
                    i += 2;
42
                } else if (nextChar == 'C') {
43
                    result += 90;
44
                    i += 2;
45
                } else {
46
                    result += 10;
47
                    i += 1;
48
                }
49
            }
50

51
            else if (c == 'L') {
52
                result += 50;
53
                i += 1;
54
            }
55

56
            // need to check CD and CM
57
            else if (c == 'C') {
58
                if (nextChar == 'D') {
59
                    result += 400;
60
                    i += 2;
61
                } else if (nextChar == 'M') {
62
                    result += 900;
63
                    i += 2;
64
                } else {
65
                    result += 100;
66
                    i += 1;
67
                }
68
            }
69

70
            else if (c == 'D') {
71
                result += 500;
72
                i += 1;
73
            }
74

75
            else if (c == 'M') {
76
                result += 1000;
77
                i += 1;
78
            }
79
        }
80
        return result;
81
    }
82
}

展开收起

14. Longest Common Prefix#

https://leetcode.com/problems/longest-common-prefix/

初始假定第一个词就是LCS。为了验证假设，我们需要逐个检查所有后续字符串，确定最开始的LCS也是后面字符串的前缀。如果不满足，则删掉LCS的最后一个字符。

1
class Solution {
2
    public String longestCommonPrefix(String[] strs) {
3
        if (strs == null || strs.length == 0) {
4
            return "";
5
        }
6

7
        // initialized as the first word of strs
8
        String result = strs[0];
9

10
        for (int i = 0; i < strs.length; i++) {
11
            // keeps removing the last character until matching the common prefix requirement
12
            while (strs[i].indexOf(result) != 0) {
13
                result = result.substring(0, result.length() - 1);
14
                if (result.length() == 0) {
15
                    break;
16
                }
17
            }
18
        }
19

20
        return result;
21
    }
22
}

展开收起

15. 3Sum#

https://leetcode.com/problems/3sum/

先对数组进行排序，接着设立三个指针first, second, third。first负责从数组头遍历至数组尾，在每一次循环中固定first，移动头尾指针two和third，对nums[first]、nums[second]、nums[third]求和判断是否为0。

这题需要最大化利用排序带来的优势，缩短运行时间：

检查最小/最大值，跳过一些不必要的检查
跳过相邻的重复元素

1
class Solution {
2
    public List<List<Integer>> threeSum(int[] nums) {
3
        List<List<Integer>> result = new ArrayList<>();
4

5
        int len = nums.length;
6
        if (len < 3) {
7
            return result;
8
        }
9

10
        // sort so we can use pointers to quickly sum
11
        Arrays.sort(nums);
12

13
        // skip impossible cases
14
        if (3 * nums[0] > 0 || 3 * nums[len - 1] < 0) {
15
            return result;
16
        }
17

18
        for (int first = 0; first < len - 2; first++) {
19
            // skip if nums[first] is duplicate
20
            if (first > 0 && nums[first] == nums[first-1]) {
21
                continue;
22
            }
23

24
            // too big, no need to check subsequent combinations
25
            if (3 * nums[first] > 0) {
26
                break;
27
            }
28

29
            // too small, we need to start from a larger nums[first]
30
            if (nums[first] + 2 * nums[len - 1] < 0) {
31
                continue;
32
            }
33

34
            int second = first + 1, third = len - 1;
35
            while (second < third) {
36
                if (nums[first] + nums[second] + nums[third] == 0) {
37
                    result.add(Arrays.asList(nums[first], nums[second], nums[third]));
38

39
                    // skip nums[second] and nums[third] duplicates
40
                    while (second < third && nums[second] == nums[second + 1]) {
41
                        second++;
42
                    }
43
                    while (third > second && nums[third] == nums[third - 1]) {
44
                        third--;
45
                    }
46

47
                    // move pointers
48
                    second++;
49
                    third--;
50
                } else if (nums[first] + nums[second] + nums[third] < 0) {
51
                    second++;
52
                } else {
53
                    third--;
54
                }
55
            }
56
        }
57
        return result;
58
    }
59
}

展开收起

16. 3Sum Closest#

https://leetcode.com/problems/3sum-closest/

与前一题思路类似，只是将”等于“改成了”最接近于“。额外加一个变量tempSum用于存储当前最接近的和即可。

1
class Solution {
2
    public int threeSumClosest(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6
        int len = nums.length;
7
        int result = 0;
8

9
        // less than three numbers, directly return all num's sum
10
        if (len <= 3) {
11
            for (int num : nums) {
12
                result += num;
13
            }
14
            return result;
15
        }
16

17
        // initialized as the sum of first three elements
18
        result = nums[0] + nums[1] + nums[2];
19

20
        // sort so we can use pointers to quickly sum
21
        Arrays.sort(nums);
22

23
        for (int first = 0; first < len - 2; first++) {
24
            // skip if nums[first] is duplicate
25
            if (first > 0 && nums[first] == nums[first - 1]) {
26
                continue;
27
            }
28

29
            int second = first + 1, third = len - 1;
30
            while (second < third) {
31
                int tempSum = nums[first] + nums[second] + nums[third];
32

33
                // determine if tempSum is equal to target, or try to get tempSum closer to target
34
                if (tempSum == target) {
35
                    return tempSum;
36
                } else if (tempSum < target) {
37
                    second++;
38
                } else {
39
                    third--;
40
                }
41

42
                // update result
43
                if (Math.abs(target - result) > Math.abs(target - tempSum)) {
44
                    result = tempSum;
45
                }
46
            }
47
        }
48

49
        return result;
50
    }
51
}

展开收起

17. Letter Combinations of a Phone Number#

https://leetcode.com/problems/letter-combinations-of-a-phone-number/

设立一个字符串数组，数组下标0-9分别对应键盘0-9上的字符串。

遍历digits的每一位数字，得到这个数字可能对应的所有字母。使用回溯算法，尝试添加每一个字符，再通过深度优先思想添加下一个。以此类推，直到当前的string builder长度等于digits长度，表示发掘出了一种组合。

1
class Solution {
2
    private List<String> result = new ArrayList<>();
3
    private final String[] mapping = {"0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
4

5
    public List<String> letterCombinations(String digits) {
6
        if (digits == null || digits.length() == 0) {
7
            return result;
8
        }
9

10
        backtrack(new StringBuilder(), digits, 0);
11

12
        return result;
13
    }
14

15
    private void backtrack(StringBuilder current, String digits, int index) {
16
        // find a combination, add to result
17
        if (current.length() == digits.length()) {
18
            result.add(current.toString());
19
            return;
20
        }
21

22
        // get all possible letters that are matching with current digit
23
        int digit = digits.charAt(index) - '0';
24
        String letters = mapping[digit];
25

26
        for (char letter: letters.toCharArray()) {
27
            current.append(letter);
28
            backtrack(current, digits, index + 1);
29
            current.deleteCharAt(current.length() - 1);
30
        }
31
    }
32
}

展开收起

18. 4Sum#

https://leetcode.com/problems/4sum/

4Sum与3Sum的思路类似，仍然是使用多个指针的移动解决问题。使用first, second两个指针从头到尾遍历整个数组，而third, fourth两个指针则在second的后面，一前一后。

需要注意，在判断极值的时候可能会产生溢出，因此需要考虑int和long之间的转换。

1
class Solution {
2
    public List<List<Integer>> fourSum(int[] nums, int target) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        int len = nums.length;
5
        if (len < 4) {
6
            return result;
7
        }
8

9
        // sort so we can use pointers to quickly sum
10
        Arrays.sort(nums);
11

12
        // too big or small
13
        Long potentialMin = (long)4 * nums[0];
14
        if (potentialMin > target) {
15
            return result;
16
        }
17

18
        Long potentialMax = (long)4 * nums[len - 1];
19
        if (potentialMax < target) {
20
            return result;
21
        }
22

23
        for (int first = 0; first < len - 3; first++) {
24
            // skip if nums[first] is duplicate
25
            if (first > 0 && nums[first] == nums[first-1]) {
26
                continue;
27
            }
28

29
            // too big, no need to check subsequent combinations
30
            Long potentialRestFourMin = (long)4 * nums[first];
31
            if (potentialRestFourMin > target) {
32
                break;
33
            }
34

35
            // too small, we need to start from a larger nums[first]
36
            Long potentialRestThreeMax = (long)3 * nums[len - 1];
37
            if (nums[first] + potentialRestThreeMax < target) {
38
                continue;
39
            }
40

41
            for (int second = first + 1; second < len - 2; second++) {
42
                // skip if nums[first] is duplicate
43
                if (second > first + 1 && nums[second] == nums[second - 1]) {
44
                    continue;
45
                }
46

47
                // too big, no need to check subsequent combinations
48
                Long potentialRestThreeMin = (long)3 * nums[second];
49
                if (potentialRestThreeMin + nums[first] > target) {
50
                    break;
51
                }
52

53
                // too small, we need to start from a larger nums[second]
54
                if (nums[first] + nums[second] + 2 * nums[len - 1] < target) {
55
                    continue;
56
                }
57

58
                int third = second + 1, fourth = len - 1;
59
                while (third < fourth) {
60
                    if (nums[first] + nums[second] + nums[third] + nums[fourth] == target) {
61
                        result.add(Arrays.asList(nums[first], nums[second], nums[third], nums[fourth]));
62

63
                        // skip duplicates
64
                        while (second < len - 2 && nums[second] == nums[second + 1]) {
65
                            second++;
66
                        }
67
                        while (third < fourth && nums[third] == nums[third + 1]) {
68
                            third++;
69
                        }
70
                        while (third < fourth && nums[fourth] == nums[fourth - 1]) {
71
                            fourth--;
72
                        }
73

74
                        // move pointers
75
                        third++;
76
                        fourth--;
77
                    } else if (nums[first] + nums[second] + nums[third] + nums[fourth] < target) {
78
                        third++;
79
                    } else {
80
                        fourth--;
81
                    }
82
                }
83
            }
84
        }
85
        return result;
86
    }
87
}

展开收起

19. Remove Nth Node From End of List#

https://leetcode.com/problems/remove-nth-node-from-end-of-list/

引入两个指针，一快一慢，二者之间的下标差为n（即slow指针指向第1个元素，则fast指针指向第n+1个元素）。删除节点则只需要调整节点的next指针即可。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode removeNthFromEnd(ListNode head, int n) {
13
        ListNode dummyHead = new ListNode(0);
14
        dummyHead.next = head;
15

16
        // slow and fast pointers
17
        ListNode slow = dummyHead, fast = dummyHead;
18

19
        // fast moves n steps ahead
20
        for (int i = 0; i < n; i++) {
21
            fast = fast.next;
22
        }
23

24
        // move slow and fast together
25
        while (fast.next != null) {
26
            slow = slow.next;
27
            fast = fast.next;
28
        }
29

30
        // delete nth node
31
        slow.next = slow.next.next;
32

33
        return dummyHead.next;
34
    }
35
}

展开收起

20. Valid Parentheses#

https://leetcode.com/problems/valid-parentheses/

利用栈的特性，如果遇到左半侧的括号则推入栈中，右半侧的括号则检查是否与当前栈顶元素配对，如果不能配对就返回false，否则配对成功就把栈顶括号弹出。最后确认栈是否为空。

1
class Solution {
2
    public boolean isValid(String s) {
3
        if (s.length() == 0) {
4
            return true;
5
        }
6

7
        Stack<Character> st = new Stack<>();
8
        for (int i = 0; i < s.length(); i++) {
9
            char c = s.charAt(i);
10

11
            // push all left parentheses into stack
12
            if (c == '(' || c == '[' || c == '{') {
13
                st.push(c);
14
            } else if (c == ')' || c == ']' || c == '}') {
15
                // current right parenthesis must match with top parenthesis in the stack
16
                if (st.size() == 0) {
17
                    return false;
18
                }
19

20
                if (c == ')' && st.peek() != '(') {
21
                    return false;
22
                } else if (c == ']' && st.peek() != '[') {
23
                    return false;
24
                } else if (c == '}' && st.peek() != '{') {
25
                    return false;
26
                } else {
27
                    // successfully matched, pop the top parenthesis
28
                    st.pop();
29
                }
30
            }
31
        }
32
        return st.isEmpty();
33
    }
34
}

展开收起

21. Merge Two Sorted Lists#

https://leetcode.com/problems/merge-two-sorted-lists/

第一种方法，比较l1和l2上的指针当前指向的元素，取较小元素之后的子链表和另一个链表继续进行递归合并。这样能保证每一次比较都优先提取出两个剩余链表的最小值，其余部分的结果也会接在这个最小值之后。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
13
        if (l1 == null) {
14
            return l2;
15
        }
16
        if (l2 == null) {
17
            return l1;
18
        }
19

20
        // merge after smaller node
21
        if (l1.val < l2.val) {
22
            l1.next = mergeTwoLists(l1.next, l2);
23
            return l1;
24
        } else {
25
            l2.next = mergeTwoLists(l1, l2.next);
26
            return l2;
27
        }
28
    }
29
}

展开收起

第二种方法，也是比较l1和l2上的指针当前指向的元素，但不使用递归，而是直接根据大小关系决定排列顺序。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
13
        if (l1 == null) {
14
            return l2;
15
        }
16
        if (l2 == null) {
17
            return l1;
18
        }
19

20
        ListNode dummyHead = new ListNode(0);
21
        ListNode cur = dummyHead;
22

23
        while (l1 != null && l2 != null) {
24
            // decide which element to be added to the result list
25
            if (l1.val < l2.val) {
26
                cur.next = l1;
27
                l1 = l1.next;
28
            } else {
29
                cur.next = l2;
30
                l2 = l2.next;
31
            }
32
            cur = cur.next;
33
        }
34

35
        // one list reaches the end, add the rest list elements to result
36
        cur.next = (l2 == null) ? l1 : l2;
37

38
        return dummyHead.next;
39
    }
40
}

展开收起

22. Generate Parentheses#

https://leetcode.com/problems/generate-parentheses/

使用递归策略，优先构造左括号，当左括号个数大于右括号时再构造右括号。

具体代码实现时，可以使用两个变量left，right跟踪当前左、右括号数量，在递归中将它们与n进行比较。

1
class Solution {
2
    List<String> result = new ArrayList<>();
3

4
    public List<String> generateParenthesis(int n) {
5
        generate("", 0, 0, n);
6
        return result;
7
    }
8

9
    // left: left parentheses' count
10
    // right: right parentheses' count
11
    private void generate(String s, int left, int right, int n) {
12
        if (right == n) {
13
            // finish construction
14
            result.add(s);
15
        } else {
16
            // always prefer to generate left parenthesis first
17
            if (left < n) {
18
                generate(s + "(", left + 1, right, n);
19
            }
20

21
            // left is greater than right, then generate a right parenthesis
22
            if (left > right) {
23
                generate(s + ")", left, right + 1, n);
24
            }
25
        }
26
    }
27
}

展开收起

23. Merge k Sorted Lists#

https://leetcode.com/problems/merge-k-sorted-lists/

第一种解法是使用优先队列。优先队列本质上是一种堆，具体使用时可以自定义comparator指定最小堆或是最大堆。由于此题要求从小到大排序，因此需要定义最小堆。

将每一条链表的头元素加入优先队列中。优先级最高的元素就是这些元素里的最小值。将其排序后进行判断，如果该元素的next指针不指向空，则将剩下的链表头元素重新插入优先队列中。

以一个形象一些的方式描述该场景：一位教师正在向一群排队的学生解答问题，每个学生都有多个问题，并且问题的难度有难有易，教师优先回答简单的问题。为保证公平，当前问问题的学生问完一个问题后需要重新排队，排队顺序取决于他下一个问题的难度。

时间复杂度上，如果链表有N个节点，则堆的插入、删除操作时间复杂度均为O(logN)，总的时间复杂度为O(NlogN)。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode mergeKLists(ListNode[] lists) {
13
        if (lists == null || lists.length == 0) {
14
            return null;
15
        }
16

17
        // override priority queue's comparator in ascending order
18
        Queue<ListNode> pq = new PriorityQueue<>((ListNode l1, ListNode l2) -> {
19
            return l1.val - l2.val;
20
        });
21

22
        // add each list's head (smallest) node into the priority queue
23
        for (ListNode list : lists) {
24
            if (list != null) {
25
                pq.offer(list);
26
            }
27
        }
28

29
        ListNode dummyHead = new ListNode(0);
30
        ListNode cur = dummyHead;
31

32
        while (!pq.isEmpty()) {
33
            // pick out the smallest element from priority queue
34
            ListNode currentHead = pq.poll();
35
            cur.next = currentHead;
36
            cur = cur.next;
37

38
            // add its next element into the queue
39
            if (cur.next != null) {
40
                pq.offer(cur.next);
41
            }
42
        }
43

44
        return dummyHead.next;
45
    }
46
}

展开收起

第二种解法是使用分治策略，将k条链表对半分为两组，问题转化为了广义版的merge two sorted lists问题。不断从上而下划分，再由小到大不断两两合并，得到完整的链表。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode mergeKLists(ListNode[] lists) {
13
        return merge(lists, 0, lists.length - 1);
14
    }
15

16
    private ListNode merge(ListNode[] lists, int l, int r) {
17
        // invalid interval
18
        if (l > r) {
19
            return null;
20
        }
21

22
        // interval only has one list group
23
        if (l == r) {
24
            return lists[l];
25
        }
26

27
        // divide k lists into two groups
28
        int mid = l + (r - l) / 2;
29
        ListNode left = merge(lists, l, mid);
30
        ListNode right = merge(lists, mid + 1, r);
31

32
        // merge two "big" lists together
33
        ListNode dummyHead = new ListNode(0);
34
        ListNode cur = dummyHead;
35

36
        while (left != null || right != null) {
37
            // right list is null, or the head of left list is smaller than the one of right list
38
            if (right == null || (left != null && left.val < right.val)) {
39
                cur.next = left;
40
                left = left.next;
41
            } else {
42
                cur.next = right;
43
                right = right.next;
44
            }
45
            cur = cur.next;
46
        }
47

48
        return dummyHead.next;
49
    }
50
}

展开收起

24. Swap Nodes in Pairs#

https://leetcode.com/problems/swap-nodes-in-pairs/

使用递归，只提取前两个节点，将剩余节点视为一个整体。

新的头节点newHead是原来的第二个节点head.next，而原来的头节点head指向剩余节点整体（剩余部分的头节点为head.next.next）。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode swapPairs(ListNode head) {
13
        if (head == null || head.next == null) {
14
            return head;
15
        }
16

17
        // previous second node now bcomes the head node
18
        ListNode newHead = head.next;
19

20
        // regard all other nodes as an entity, and the head of this entity is head.next.next
21
        head.next = swapPairs(head.next.next);
22

23
        // previous head node now becomes the second node
24
        newHead.next = head;
25

26
        return newHead;
27
    }
28
}

展开收起

25. Reverse Nodes in k-Group#

https://leetcode.com/problems/reverse-nodes-in-k-group/

假设遍历链表的指针为cur，将cur移动k个节点，获取到k个节点就能组成一个节点簇。我们优先递归完成链表后续部分的反转，再来倒转节点簇的k个节点。每个节点簇内，我们的核心思想是把原先的第一个节点指向链表后续部分，这样一来这个节点就可以被归到已经逆序的子链表中；而原先节点簇的第二个节点就成为了剩余未逆序部分的头节点。我们需要不断循环k次，按照上述流程调整顺序。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode reverseKGroup(ListNode head, int k) {
13
        if (head == null) {
14
            return null;
15
        }
16

17
        // move cur k nodes forward
18
        ListNode cur = head;
19
        int count = 0;
20
        while (cur != null && count != k) {
21
            count++;
22
            cur = cur.next;
23
        }
24

25
        // we get k nodes in a group now
26
        if (count == k) {
27
            // recursively complete all other nodes first to get the modified sub-list
28
            cur = reverseKGroup(cur, k);
29

30
            // reverse k nodes
31
            while (count-- > 0) {
32
                // get the second element among k nodes
33
                ListNode second = head.next;
34

35
                // current first element (head) will point to the modified sub-list
36
                head.next = cur;
37

38
                // previous head has become the head of the modified sub-list
39
                cur = head;
40

41
                // previous second element now becomes the new head of the un-reversed part
42
                head = second;
43
            }
44

45
            // after reverse, the head of the modified sub-list is actually the head of the whole list
46
            head = cur;
47
        }
48

49
        return head;
50
    }
51
}

展开收起

26. Remove Duplicates from Sorted Array#

https://leetcode.com/problems/remove-duplicates-from-sorted-array/

从头开始遍历，只要遇到不重复的数时，就覆盖数组的原始值。最后返回的result值实际上就是不同数字的个数。

1
class Solution {
2
    public int removeDuplicates(int[] nums) {
3
        int len = nums.length;
4
        if (len <= 1) {
5
            return len;
6
        }
7

8
        int result = 1;
9
        for (int i = 1; i < len; i++) {
10
            if (nums[i] != nums[i - 1]) {
11
                nums[result] = nums[i]; // in-place modification
12
                result++;
13
            }
14
        }
15

16
        return result;
17
    }
18
}

展开收起

27. Remove Element#

https://leetcode.com/problems/remove-element/

与上一题一样的思路，遇到值为val的元素时跳过，其余仍从头到尾开始覆盖。

1
class Solution {
2
    public int removeElement(int[] nums, int val) {
3
        int len = nums.length;
4

5
        int result = 0;
6
        for (int i = 0; i < len; i++) {
7
            if (nums[i] != val) {
8
                nums[result] = nums[i]; // in-place modification
9
                result++;
10
            }
11
        }
12

13
        return result;
14
    }
15
}

展开收起

28. Implement strStr()#

https://leetcode.com/problems/implement-strstr/

遍历haystack中的每一个字符，如果某个字符与needle的首字符相同，再检查haystack中该字符起的子串是否与needle的值相同。

1
class Solution {
2
    public int strStr(String haystack, String needle) {
3
        int hLen = haystack.length(), nLen = needle.length();
4

5
        // needle is an empty string
6
        if (nLen == 0) {
7
            return 0;
8
        }
9

10
        // haystack is empty and impossible to contain needle
11
        if (hLen == 0) {
12
            return -1;
13
        }
14

15
        for (int i = 0; i <= hLen - nLen; i++) {
16
            // current char is equal to needle's first char & substring is equal to needle
17
            if (haystack.charAt(i) == needle.charAt(0) && haystack.substring(i, i + nLen).equals(needle)) {
18
                return i;
19
            }
20
        }
21

22
        return -1;
23
    }
24
}

展开收起

29. Divide Two Integers#

https://leetcode.com/problems/divide-two-integers/

此题要求实现除法，并且不能使用乘、除、取模三个符号。大致的思路流程是：

专门处理被除数为Integer.MIN_VALUE，divisor为-1时的情况，这种时候int形式的结果会发生溢出
将dividend和divisor都取绝对值
使用指数倍增思想，快速寻找到dividend中至少包含几个divisor。
决定最终结果的实际符号

为了避免溢出，在第一步处理完特例后，我们最好将dividend和divisor都转为long格式。

1
class Solution {
2
    public int divide(int dividend, int divisor) {
3
        // corner case
4
        if (dividend == Integer.MIN_VALUE && divisor == -1) {
5
            return Integer.MAX_VALUE;
6
        }
7

8
        long dividendCopy = (long)dividend, divisorCopy = (long)divisor;
9

10
        // get rid of sign
11
        long a = Math.abs(dividendCopy), b = Math.abs(divisorCopy);
12
        long result = 0;
13

14
        while (a >= b) {
15
            int x = 0;
16

17
            // count how many divisor does the dividend "has"
18
            while (a >= (b << 1 << x)) {
19
                x++;
20
            }
21

22
            result += 1 << x;
23
            a -= b << x;
24
        }
25

26
        // determine if dividend and divisor have same sign
27
        return (dividend > 0) == (divisor > 0) ? (int)result : (int)-result;
28
    }
29
}

展开收起

30. Substring with Concatenation of All Words#

https://leetcode.com/problems/substring-with-concatenation-of-all-words/

只要words中的所有单词拼接得到s中的子字符串即可满足题意，单词的顺序并不重要。因此我们只需要关注words中每一个单词出现的次数。

此题可以使用两个HashMap解决，一个HashMap用于记录words数组中的每一个单词出现的次数；另一个HashMap用于记录当前遍历s时的单词已经出现了几次。如果当前遍历的单词是words中没有的，或者出现次数已经超过了“应该”出现的次数，则说明不满足题意。

1
class Solution {
2
    public List<Integer> findSubstring(String s, String[] words) {
3
        List<Integer> result = new ArrayList<>();
4
        if (words.length == 0) {
5
            return result;
6
        }
7

8
        // how many times each word is supposed to occur
9
        Map<String, Integer> expected = new HashMap<>();
10
        for (String word : words) {
11
            expected.put(word, expected.getOrDefault(word, 0) + 1);
12
        }
13

14
        // each word's length and all words' count
15
        int len = words[0].length(), count = words.length;
16
        if (s.length() < count * len) {
17
            return result;
18
        }
19

20
        for (int i = 0; i < len; i++) {
21
            for (int j = i; j <= s.length() - count * len; j += len) {
22
                // how many times every word actually occurs in each substring
23
                Map<String, Integer> actual = new HashMap<>();
24

25
                // iterate from the last
26
                for (int k = count - 1; k >= 0; k--) {
27
                    // extract current word
28
                    String currentWord = s.substring(j + k * len, j + (k + 1) * len);
29

30
                    // current word is not supposed to occur
31
                    if (!expected.containsKey(currentWord)) {
32
                        break;
33
                    } else {
34
                        int occurences = actual.getOrDefault(currentWord, 0) + 1;
35

36
                        // can not exceed expected occurences
37
                        if (occurences > expected.get(currentWord)) {
38
                            // start right after invalid occurence, as previous choices will include invalid.
39
                            j += k * len;
40
                            break;
41
                        }
42

43
                        actual.put(currentWord, occurences);
44

45
                        // all words appear
46
                        if (k == 0) {
47
                            result.add(j);
48
                        }
49
                    }
50
                }
51
            }
52
        }
53
        return result;
54
    }
55
}

展开收起

31. Next Permutation#

https://leetcode.com/problems/next-permutation/

一个数组向下一置换演变的趋势总体是从升序演变为降序。

找到下一置换，实际上就是从右到左遍历，先找到破坏升序的第一个数nums[i]，再从这个数的右侧（也是从右向左遍历）找到第一个比nums[i]大的数nums[j]，这两个数进行交换。最后，对下标i之后的数需要全部进行反转，因为在经过交换之后，从下标i开始一直到结尾都是降序，我们需要将i + 1到结尾重新调整为升序，确保不遗漏置换的可能。

1
class Solution {
2
    public void nextPermutation(int[] nums) {
3
        if (nums == null || nums.length <= 1) {
4
            return;
5
        }
6

7
        // search from right to left and find the first element to break the ascending order
8
        int i = nums.length - 2;
9
        while (i >= 0 && nums[i] >= nums[i+1]) {
10
            i--;
11
        }
12

13
        // if there is an element that break the ascending order
14
        if (i >= 0) {
15
            int j = nums.length - 1;
16

17
            // find the rightmost element which is larger than nums[i]
18
            while (nums[i] >= nums[j]) {
19
                j--;
20
            }
21

22
            // swap nums[i] and nums[j]
23
            swap(nums, i, j);
24
        }
25
        // reverse all elements after index i
26
        reverseArray(nums, i + 1, nums.length - 1);
27
    }
28

29
    // swap two nums
30
    private void swap(int[] nums, int i, int j) {
31
        int temp = nums[i];
32
        nums[i] = nums[j];
33
        nums[j] = temp;
34
    }
35

36
    // reverse part of the array
37
    private void reverseArray(int[] nums, int i, int j) {
38
        while (i < j) {
39
            swap(nums, i++, j--);
40
        }
41
    }
42
}

展开收起

32. Longest Valid Parentheses#

https://leetcode.com/problems/longest-valid-parentheses/

使用栈解决。遍历字符串，如果遇到’(‘，则将当前下标推入栈中；遇到’)‘，则将栈顶下标弹出，并讨论。需要注意：

栈里存储的下标，实质上指的是“截止到这个下标时，字符串不能组成valid parentheses”。我们最后更新结果时，也是用当前下标与栈顶下标的差值来更新长度，因为这一段差值之间的字符串一定是有效的
因为上述设定，栈的初始化需要push一个-1；如果空栈的时候，说明截止至目前的字符串一定是无效的，我们要想找有效字符串只能在此之后寻找

1
class Solution {
2
    public int longestValidParentheses(String s) {
3
        int result = 0;
4

5
        ArrayDeque<Integer> stack = new ArrayDeque<Integer>();
6

7
        // the index preceding to potential start of valid parentheses
8
        stack.push(-1);
9

10
        for (int i = 0; i < s.length(); i++) {
11
            char curr = s.charAt(i);
12
            if (curr == '(') {
13
                stack.push(i);
14
            } else {
15
                // no matter we get valid parentheses or not, we need to pop here
16
                // if valid, we need to get last index to calculate diff
17
                // if unvalid, we update with current index
18
                stack.pop();
19

20
                if (stack.isEmpty()) {
21
                    // the stack is empty only if we have an extra ')'. Any further extensions of valid parentheses is impossible
22
                    // push current index, since it is preceding to potential start of valid parentheses
23
                    stack.push(i);
24
                } else {
25
                    // this may be our longest valid parentheses
26
                    result = Math.max(result, i - stack.peek());
27
                }
28
            }
29
        }
30

31
        return result;
32
    }
33
}

展开收起

33. Search in Rotated Sorted Array#

https://leetcode.com/problems/search-in-rotated-sorted-array/

1
class Solution {
2
    public int search(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return -1;
5
        }
6

7
        int left = 0, right = nums.length - 1;
8
        while (left <= right) {
9
            int mid = left + (right - left) / 2;
10

11
            // nums[mid] matches with target, return
12
            if (nums[mid] == target) {
13
                return mid;
14
            }
15

16
            // left half is ordered
17
            if (nums[left] <= nums[mid]) {
18
                // target is in left half
19
                if (target >= nums[left] && target <= nums[mid]) {
20
                    right = mid - 1;
21
                } else {
22
                    left = mid + 1;
23
                }
24
            }
25

26
            // right half is ordered
27
            if (nums[mid] <= nums[right]) {
28
                // target is in right half
29
                if (target >= nums[mid] && target <= nums[right]) {
30
                    left = mid + 1;
31
                } else {
32
                    right = mid - 1;
33
                }
34
            }
35
        }
36

37
        return -1;
38
    }
39
}

展开收起

34. Find First and Last Position of Element in Sorted Array#

https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/

分别进行左边界搜索和右边界搜索即可。

1
class Solution {
2
    public int[] searchRange(int[] nums, int target) {
3
        int[] result = new int[] {-1, -1};
4
        if (nums == null || nums.length == 0) {
5
            return result;
6
        }
7

8
        // left
9
        int left = 0, right = nums.length;
10
        while (left < right) {
11
            int mid = left + (right - left) / 2;
12
            if (nums[mid] < target) {
13
                left = mid + 1;
14
            } else if (nums[mid] >= target) {
15
                right = mid;
16
            }
17
        }
18

19
        if (left != nums.length && nums[left] == target) {
20
            result[0] = left;
21
        }
22

23
        // right
24
        left = 0;
25
        right = nums.length;
26
        while (left < right) {
27
            int mid = left + (right - left) / 2;
28
            if (nums[mid] <= target) {
29
                left = mid + 1;
30
            } else if (nums[mid] > target) {
31
                right = mid;
32
            }
33
        }
34

35
        if (left != 0 && nums[left - 1] == target) {
36
            result[1] = left - 1;
37
        }
38

39
        return result;
40
    }
41
}

展开收起

35. Search Insert Position#

https://leetcode.com/problems/search-insert-position/

可以假想把target插入到nums数组中，再转化为数组长度+1后的标准二分查找。

1
class Solution {
2
    public int searchInsert(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        // num's length +1, therefore right should be 'nums.length' instead of 'nums.length - 1'
8
        int left = 0, right = nums.length;
9

10
        // standard binary search
11
        while (left < right) {
12
            int mid = left + (right - left) / 2;
13
            if (nums[mid] < target) {
14
                left = mid + 1;
15
            } else {
16
                right = mid;
17
            }
18
        }
19

20
        // both left and right are valid
21
        return left;
22
    }
23
}

展开收起

36. Valid Sudoku#

https://leetcode.com/problems/valid-sudoku/

每一个数字只能在所处的行、列、3*3方格内出现一次。因此，构造三个二维数组检查当前数字num分别在当前行、列、方格内出现的次数，超过1次就是不合法的。

1
class Solution {
2
    public boolean isValidSudoku(char[][] board) {
3
        int[][] row = new int[9][9]; // row[i][num] indicates the count of 'num' in the i-th row
4
        int[][] col = new int[9][9]; // col[j][num] indicates the count of 'num' in the j-th column
5
        int[][] block = new int[9][9]; // block[k][num] indicates the count of 'num' in the k-th 3*3 block
6

7
        for (int i = 0; i < 9; i++) {
8
            for (int j = 0; j < 9; j++) {
9
                // only validate filled cells
10
                if (board[i][j] != '.') {
11
                    int num = board[i][j] - '1';
12
                    int blockIndex = (i/3) * 3 + j/3;
13

14
                    // each num should not duplicate in each row, col, block
15
                    if (row[i][num] > 0 || col[j][num] > 0 || block[blockIndex][num] > 0) {
16
                        return false;
17
                    }
18

19
                    row[i][num] += 1;
20
                    col[j][num] += 1;
21
                    block[blockIndex][num] += 1;
22
                }
23
            }
24
        }
25
        return true;
26
    }
27
}

展开收起

37. Sudoku Solver#

https://leetcode.com/problems/sudoku-solver/

遇到一个空方格，从0-9循环填入每一个数字，填完后确认没有违规，再以深度优先，尝试后续所有方格都满足要求，才能保证当前方格也满足要求。

遇到列尾时跳下一行，遇到行尾则说明深度优先搜索结束，数独解决完毕；而如果遇到不符合的情况，则要回溯复原当前填入的数字，再继续循环填入下一个数字。

1
class Solution {
2
    public void solveSudoku(char[][] board) {
3
        solve(board, 0, 0);
4
    }
5

6
    // solve based on index
7
    private Boolean solve(char[][] board, int i, int j) {
8
        // finish all 9 row
9
        if (i == 9) {
10
            return true;
11
        }
12

13
        // finish current row, jump to next row
14
        if (j == 9) {
15
            return solve(board, i+1, 0);
16
        }
17

18
        // non-digit, switch to next column
19
        if (board[i][j] != '.') {
20
            return solve(board, i, j+1);
21
        }
22

23
        // backtrack
24
        for (char c = '1'; c <= '9'; c++) {
25
            if (check(board, i, j, c)) {
26
                board[i][j] = c;
27

28
                // all subsequent cells are valid
29
                if (solve(board, i, j+1)) {
30
                    return true;
31
                }
32

33
                board[i][j] = '.';
34
            }
35
        }
36

37
        return false; // no solution
38
    }
39

40
    // check if current character is valid
41
    private Boolean check(char[][] board, int i, int j, char val) {
42
        for (int c = 0; c < 9; c++) {
43

44
            // duplicate in current row, column or 3 * 3 block
45
            if (board[i][c] == val ||
46
                board[c][j] == val ||
47
                board[i - i%3 + c/3][j - j%3 + c%3] == val) {
48
                return false;
49
            }
50
        }
51
        return true;
52
    }
53
}

展开收起

38. Count and Say#

https://leetcode.com/problems/count-and-say/

直接的想法是使用递归。递归的起点显然是n为1的情况。此后对于任意输入的n，先计算出n-1的结果字符串pre，再遍历pre得到n的结果。遍历pre时，统计当前数字连续出现了几次，把数字和次数直接加到StringBuilder里。

注意使用StringBuilder的目的主要是优化性能，因为String每次追加字符时都会产生新的对象；而StringBuilder与StringBuffer都是直接在同一对象上追加字符，效率很高。另外StringBuffer()适合多线程，而StringBuilder()适合单线程。

1
class Solution {
2
    public String countAndSay(int n) {
3
        if (n == 1) {
4
            return "1";
5
        }
6

7
        // all upper levels' result
8
        StringBuilder pre = new StringBuilder(countAndSay(n - 1));
9

10
        // construct this level
11
        StringBuilder result = new StringBuilder();
12

13
        int i = 0;
14
        while (i < pre.length()) {
15
            int count = 0; // current number's count
16
            int j = i; // start index of current number
17

18
            char say = pre.charAt(j);
19
            while (i < pre.length() && pre.charAt(i) == say) {
20
                count++;
21
                i++;
22
            }
23

24
            result.append(count);
25
            result.append(say);
26
        }
27
        return result.toString();
28
    }
29
}

展开收起

39. Combination Sum#

https://leetcode.com/problems/combination-sum/

将原始数组排序，并遍历数组，创建一个新的临时数组用于存放当前的组合。每当向临时数组中添加一个数后，更新target，递归进入下一层搜索；由于每一个数可以使用无限次，下一次递归的起点下标index不变。最后当target等于0，说明当前组合满足；否则，则将临时数组中最后一个元素移除，寻找下一个数。

1
class Solution {
2
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        Arrays.sort(candidates);
5
        backtrack(result, new ArrayList<>(), candidates, target, 0);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int[] candidates, int target, int index) {
10
        if (target == 0) {
11
            result.add(new ArrayList<>(temp));
12
        } else {
13
            for (int i = index; i < candidates.length && candidates[i] <= target; i++) {
14
                temp.add(candidates[i]);
15
                backtrack(result, temp, candidates, target - candidates[i], i); // allow duplicate, thus starts from i
16
                temp.remove(temp.size() - 1);
17
            }
18
        }
19
    }
20
}

展开收起

40. Combination Sum II#

https://leetcode.com/problems/combination-sum-ii/

与上一题几乎一样的题设，唯一不同是输入数组中可能有重复的数字，且数组中每个数只能用一次。只需要稍微改变上一题的代码，调整下一层递归的起始下标；此外，完成一次回溯后，需要及时跳过重复的数字。

1
class Solution {
2
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        Arrays.sort(candidates);
5
        backtrack(result, new ArrayList<>(), candidates, target, 0);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int[] candidates, int target, int index) {
10
        if (target == 0) {
11
            result.add(new ArrayList<>(temp));
12
        } else {
13
            for (int i = index; i < candidates.length && candidates[i] <= target; i++) {
14
                temp.add(candidates[i]);
15
                backtrack(result, temp, candidates, target - candidates[i], i + 1); // not allow duplicate, thus starts from i + 1
16
                temp.remove(temp.size() - 1);
17

18
                // skip duplicates
19
                while (i + 1 < candidates.length && candidates[i] == candidates[i + 1]) {
20
                    i++;
21
                }
22
            }
23
        }
24
    }
25
}

展开收起

41. First Missing Positive#

https://leetcode.com/problems/first-missing-positive/

要寻找最小的缺失正整数，可以对数组进行处理：假如遍历发现了1，则将1放在数组第一个位置；发现2，则将2放在数组第二个位置…以此类推。当然，前提是只有遍历的元素值位于0和数组长度之间，才做此处理。

为了达到这一目的，只需要将nums[i]与nums[nums[i] - 1]进行交换即可。最后，重新遍历顺序处理后的数组，第一个元素值和下标不匹配的元素即为答案。

1
class Solution {
2
    public int firstMissingPositive(int[] nums) {
3
        int len = nums.length;
4
        for (int i = 0; i < len; i++) {
5
            // if nums[i] is in the range of (0, len] and not in its place,
6
            // put nums[i] on the (nums[i] - 1)th index of the array
7
            while (nums[i] > 0 && nums[i] <= len && nums[i] != nums[nums[i] - 1]) {
8
                // swap nums[i] and nums[nums[i] - 1]
9
                int temp = nums[nums[i] - 1];
10
                nums[nums[i] - 1] = nums[i];
11
                nums[i] = temp;
12
            }
13
        }
14

15
        // the first number unmatched is the answer
16
        for (int i = 0; i < len; i++) {
17
            if (nums[i] != i + 1) {
18
                return i + 1;
19
            }
20
        }
21

22
        // all matched, the smallest positive integer is last integer + 1
23
        return len + 1;
24
    }
25
}

展开收起

42. Trapping Rain Water#

https://leetcode.com/problems/trapping-rain-water/

使用左右两个指针跟踪当前的池壁高度。根据木桶效应，高度下界lowerBound取决于池壁高度较低的一边，而当前已有的水槽高度currentLevel则根据较低的池壁高度不断更新。指针移动过程中，新增的水量为currentLevel与lowerBound的差值。

1
class Solution {
2
    public int trap(int[] height) {
3
        if (height == null || height.length <= 1) {
4
            return 0;
5
        }
6

7
        int left = 0, right = height.length - 1;
8
        int currentLevel = 0, result = 0;
9

10
        while (left < right) {
11
            int lowerBound = 0;
12

13
            // smaller of height[left] and height[right], then move left or right accordingly
14
            if (height[left] <= height[right]) {
15
                lowerBound = height[left];
16
                left++;
17
            } else {
18
                lowerBound = height[right];
19
                right--;
20
            }
21

22
            // update current bar's level
23
            currentLevel = Math.max(currentLevel, lowerBound);
24

25
            // new water fills in
26
            result += currentLevel - lowerBound;
27
        }
28

29
        return result;
30
    }
31
}

展开收起

43. Multiply Strings#

https://leetcode.com/problems/multiply-strings/

此题限定了输入字符串只包含数字，并且不能直接转成整数再调用乘法计算，实际上便是指定了思路：模拟实现大数的乘法运算，类似于小学进行竖式乘法的过程。

对于一个m位整数与一个n位整数，其结果的长度一定为m+n-1或m+n，因此可以提前创建一个长为m+n的数组用于存放最终结果的每一位数。双重循环遍历两个整数，可以发现num1[i] * num2[j]的结果对应的是result[i+j+1]。明确了位数之后，剩余的工作较为简单，只需逐位求值，保留尾数，提取进位向前累加即可。输出结果时，需要去掉起始的0。

1
class Solution {
2
    public String multiply(String num1, String num2) {
3
        int m = num1.length(), n = num2.length();
4

5
        if (m == 0 || n == 0) {
6
            return "0";
7
        }
8
        if (num1.equals("0") || num2.equals("0")) {
9
            return "0";
10
        }
11

12
        // num1[i] * num2[j] reflects on result[i+j+1]
13
        int[] result = new int[m+n];
14
        for (int i = m-1; i >= 0; i--) {
15
            for (int j = n-1; j >= 0; j--) {
16
                result[i+j+1] += (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
17
            }
18
        }
19

20
        // calculate each digit and each carry
21
        int carry = 0;
22
        for (int k = result.length - 1; k >= 0; k--) {
23
            int digit = (result[k] + carry) % 10;
24
            carry = (result[k] + carry) / 10;
25
            result[k] = digit;
26
        }
27

28
        StringBuilder sb = new StringBuilder();
29

30
        // trim all leading 0
31
        for (int each : result) {
32
            if (!(each == 0 && sb.length() == 0)) {
33
                sb.append(each);
34
            }
35
        }
36

37
        return sb.toString();
38
    }
39
}

展开收起

44. Wildcard Matching#

https://leetcode.com/problems/wildcard-matching/

解法一，参考Regular Expression Matching中的解法，使用二维动态规划：

1
class Solution {
2
    public boolean isMatch(String s, String p) {
3
        boolean[][] dp = new boolean[s.length() + 1][p.length()+1];
4
        dp[0][0] = true;
5

6
        // empty pattern cannot match with any string
7
        for (int i = 1; i <= s.length(); i++) {
8
            dp[i][0] = false;
9
        }
10

11
        // multiple '*' pattern can match with empty string
12
        for (int j = 1; j <= p.length(); j++) {
13
            if (p.charAt(j-1) != '*') {
14
                break;
15
            } else {
16
                dp[0][j] = true;
17
            }
18
        }
19

20
        for (int i = 0; i < s.length(); i++) {
21
            for (int j = 0; j < p.length(); j++) {
22
                if (s.charAt(i) == p.charAt(j) || p.charAt(j) == '?') {
23
                    dp[i+1][j+1] = dp[i][j];
24
                } else if (p.charAt(j) == '*') {
25
                    dp[i+1][j+1] = dp[i+1][j] || dp[i][j+1];
26
                } else {
27
                    dp[i][j] = false;
28
                }
29
            }
30
        }
31

32
        return dp[s.length()][p.length()];
33
    }
34
}

展开收起

解法二，使用指针：

使用两个指针sIdx和pIdx分别跟踪s和p，分类讨论所有情况：

严格的单字对应，或p中出现?，两个指针分别前移
p遇到*，暂不清楚匹配情况，记录s当前的匹配起点和p最近一个*的位置，前移pIdx
前一个pIdx是*，但现在不是，可能对应着匹配多个字符的情况，将pIdx置于最近一个*的右侧，并前移sIdx

其他情况下，直接判定为匹配失败。

1
class Solution {
2
    public boolean isMatch(String s, String p) {
3
        int sIdx = 0, pIdx = 0, match = 0, starIdx = -1;
4

5
        while (sIdx < s.length()) {
6
            if (pIdx < p.length() && (p.charAt(pIdx) == '?' || s.charAt(sIdx) == p.charAt(pIdx))) {
7
                // regular match or match ?, moving both pointers forward
8
                sIdx++;
9
                pIdx++;
10
            } else if (pIdx < p.length() && p.charAt(pIdx) == '*') {
11
                // * found, only moving pattern pointer forward
12
                starIdx = pIdx; // update the latest *'s index
13
                match = sIdx;
14
                pIdx++;
15
            } else if (starIdx != -1) {
16
                // last pattern pointer was * but current is not, moving string pointer forward to match
17
                pIdx = starIdx + 1;
18
                sIdx = ++match;
19
            } else return false;
20
        }
21

22
        // check for remaining characters in pattern
23
        while (pIdx < p.length() && p.charAt(pIdx) == '*') {
24
            pIdx++;
25
        }
26

27
        return pIdx == p.length();
28
    }
29
}

展开收起

45. Jump Game II#

https://leetcode.com/problems/jump-game-ii/

此题需要使用贪心算法。第i次跳跃中，必然有nums[i]个可选落点，检查每一个可选落点最远可以到达何处，选取最远的一个作为下一次跳跃的最远边界。以此类推，每一步都选择下一步可能最远的落点，直到最终可以到达终点。

1
class Solution {
2
    public int jump(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int steps = 0; // steps taken
8
        int start = 0, end = 0; // in current step, I can reach the interval [start, end]
9
        int maxEnd = 0; // the farthest fall of the jump
10

11
        while (end < nums.length - 1) {
12
            steps++;
13

14
            // find out the maxEnd
15
            for (int i = start; i <= end; i++) {
16
                maxEnd = Math.max(maxEnd, nums[i] + i);
17
            }
18

19
            // generate next [start, end] range
20
            start = end + 1; // next range's start must be larger than current range's end
21
            end = maxEnd;
22
        }
23

24
        return steps;
25
    }
26
}

展开收起

46. Permutations#

https://leetcode.com/problems/permutations/

使用通用的回溯算法解题模版。使用一个boolean数组跟踪每个下标的数字是否使用过，跳过已经使用过的数；在回溯的时候重新设为未使用。

1
class Solution {
2
    public List<List<Integer>> permute(int[] nums) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        Arrays.sort(nums);
5
        backtrack(result, nums, new ArrayList<>(), new boolean[nums.length]);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, int[] nums, List<Integer> temp, boolean[] used) {
10
        // match with num's length, add this permutation to result
11
        if (temp.size() == nums.length) {
12
            result.add(new ArrayList<>(temp));
13
            return;
14
        }
15

16
        for (int i = 0; i < nums.length; i++) {
17
            // current number has already been used, skip
18
            if (used[i] == true) {
19
                continue;
20
            }
21

22
            // set current number as used and add it to temp permutation
23
            used[i] = true;
24
            temp.add(nums[i]);
25

26
            backtrack(result, nums, temp, used);
27

28
            // after using, reset current number as unused and remove it from temp permutation
29
            used[i] = false;
30
            temp.remove(temp.size() - 1);
31
        }
32
    }
33
}

展开收起

47. Permutations II#

https://leetcode.com/problems/permutations-ii/

此题的输入数组可能含有重复的数字，只需要在上一题的基础上，跳过重复的数字即可。

需要注意，判断重复时，used[i - 1]和!used[i - 1]都能让代码成功运行，然而LeetCode运行时间显示，!used[i - 1]快的多，可能是因为LeetCode生成的随机测试数据中，包含重复的情况较多，因此我们发现当前一个相同的数字被使用时，我们也优先加入当前这个相同的数字，这样能更快试出所有permutation。

1
class Solution {
2
    public List<List<Integer>> permuteUnique(int[] nums) {
3
        List<List<Integer>> result = new ArrayList<List<Integer>>();
4
        Arrays.sort(nums);
5
        backtrack(result, nums, new ArrayList<>(), new boolean[nums.length]);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, int[] nums, List<Integer> temp, boolean[] used) {
10
        // match with num's length, add this permutation to result
11
        if (temp.size() == nums.length) {
12
            result.add( new ArrayList<>(temp) );
13
            return;
14
        }
15

16
        for (int i = 0; i < nums.length; i++) {
17
            // current number is used / if previous identical number is used, use current number
18
            if (used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1])) {
19
                continue;
20
            }
21

22
            // mark current number as used and add it to temp permutation
23
            used[i] = true;
24
            temp.add(nums[i]);
25

26
            backtrack(result, nums, temp, used);
27

28
            // after using, unmark current number as unused and remove it from temp permutation
29
            used[i] = false;
30
            temp.remove(temp.size() - 1);
31
        }
32
    }
33
}

展开收起

48. Rotate Image#

https://leetcode.com/problems/rotate-image/

观察发现，矩阵内的元素旋转实际上是在建构一个旋转矩形，矩形顶点的轮换导致了整个矩阵的变化。

例如对于例子中的两个矩阵，第一个矩阵中2, 4, 6, 8构成了一个旋转矩形，第二个矩阵中1, 10, 12, 13构成了一个旋转矩形。因此，对于任意一个matrix[i][j]，总能找到另外三个矩阵坐标顶点与之构成一个旋转矩形，只需推出其数学表达式即可。

1
class Solution {
2
    public void rotate(int[][] matrix) {
3
        if (matrix == null) {
4
            return;
5
        }
6
        int len = matrix.length;
7

8
        // locate four corner points
9
        for (int i = 0; i < (len + 1) / 2; i++) {
10
            for (int j = 0; j < matrix[0].length / 2; j++) {
11
                int temp = matrix[i][j]; // first
12
                matrix[i][j] = matrix[len - 1 - j][i]; // second
13
                matrix[len - 1 - j][i] = matrix[len - 1 - i][len - 1 - j]; // third
14
                matrix[len - 1 - i][len - 1 - j] = matrix[j][len - 1 - i]; // fourth
15
                matrix[j][len - 1 - i] = temp;
16
            }
17
        }
18
    }
19
}

展开收起

49. Group Anagrams#

https://leetcode.com/problems/group-anagrams/

统计每个单词中各个字母出现的次数，存到一个长度为26的数组中。利用这个数组生成对应的hash码(Arrays.hashCode())，具有相同hash码的字符串就可以被归类在一起。

如果字符串很短的情况下，也可以每一个字母映射一个质数，质数相乘作为hashcode，提升运行效率。

1
class Solution {
2
    public List<List<String>> groupAnagrams(String[] strs) {
3
        List<List<String>> result = new ArrayList<>();
4

5
        // <hash number, list index in result>
6
        Map<Integer, Integer> map = new HashMap<>();
7

8
        for (String s: strs) {
9
            int key = getKey(s);
10
            int resultIndex = map.getOrDefault(key, -1);
11

12
            List<String> list = null;
13
            if (resultIndex == -1) {
14
                list = new ArrayList<>();
15
                result.add(list);
16
                map.put(key, result.size() - 1);
17
            } else {
18
                list = result.get(resultIndex);
19
            }
20

21
            list.add(s);
22
        }
23
        return result;
24
    }
25

26
    // use count to generate hash number
27
    public int getKey(String s) {
28
        int[] map = new int[26];
29
        for (char c: s.toCharArray()) {
30
            map[c - 'a']++;
31
        }
32
        return Arrays.hashCode(map);
33
    }
34
}

展开收起

如果字符串很短的情况下，也可以每一个字母映射一个质数，质数相乘作为hashcode，提升运行效率。

1
class Solution {
2
    public List<List<String>> groupAnagrams(String[] strs) {
3
        List<List<String>> result = new ArrayList<>();
4
        if (strs == null || strs.length == 0) {
5
            return result;
6
        }
7

8
        // top 26 positive primes
9
        int[] prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103};
10

11
        // <product, position in result>
12
        Map<Long, Integer> map = new HashMap<>();
13

14
        for (String str : strs) {
15
            // calculate current string's product
16
            long product = 1;
17
            for (char ch : str.toCharArray()) {
18
                product *= prime[ch - 'a'];
19
            }
20

21
            List<String> temp;
22

23
            // current product is already in the map, add this string to specific list of result
24
            if (map.containsKey(product)) {
25
                result.get(map.get(product)).add(str);
26
            } else {
27
                // create a new list, add current string, then add the list to result
28
                temp = new ArrayList<>();
29
                temp.add(str);
30
                result.add(temp);
31

32
                // record this new list's index
33
                map.put(product, result.size() - 1);
34
            }
35
        }
36

37
        return result;
38
    }
39
}

展开收起

50. Pow(x, n)#

https://leetcode.com/problems/powx-n/

实现幂函数的构造需要运用递归。然而在开始递归前，需要先排除一些输入的特殊情况。n和x各有若干特殊情况：

输入的x为1，或是n为0，或是x为-1且n为整数下界，返回1
输入的x为0，或是x不为-1且n为整数下界，返回0
输入的n为负数，利用xⁿ = (1/x)^-n这一特点，将n转化成正数。

完成上述处理后，分n的奇偶性进行递归调用。对于奇数，由于整数除法的舍入，需要额外乘一个x。

1
public double myPow(double x, int n) {
2
    if (x == 1 || n == 0 || (n == Integer.MIN_VALUE && x == -1)) {
3
        return 1;
4
    }
5
    if (x == 0 || (n == Integer.MIN_VALUE && x != -1)) {
6
        return 0;
7
    }
8
    if (n < 0) {
9
        n = -n;
10
        x = 1/x;
11
    }
12
    // odd or even
13
    return (n % 2 == 0) ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
14
}

51. N-Queens#

https://leetcode.com/problems/n-queens/

运用深度优先搜素，使用一个数组queens记录每一行的皇后位于第几列。每一行放置皇后并递归进入下一行。如果某一列已经摆放了皇后，或对角线上存在皇后，则当前单元格不能放置皇后。

当深度优先搜索结束后，根据queens记录的信息，生成一张棋盘图。

1
class Solution {
2
    public List<List<String>> solveNQueens(int n) {
3
        List<List<String>> result = new ArrayList<>();
4

5
        // queen's position in each row
6
        int[] queens = new int[n];
7
        Arrays.fill(queens, -1);
8

9
        dfs(result, queens, 0);
10
        return result;
11
    }
12

13
    private void dfs(List<List<String>> result, int[] queens, int row) {
14
        int len = queens.length;
15

16
        // finish one solution
17
        if (len == row) {
18
            List<String> temp = new ArrayList<>();
19

20
            // generate an n*n chessboard based on queens' positions
21
            for (int i : queens) {
22
                char[] boardRow = new char[len];
23
                Arrays.fill(boardRow, '.');
24
                boardRow[i] = 'Q';
25

26
                // char[] -> str
27
                temp.add(String.valueOf(boardRow));
28
            }
29

30
            // add this chessboard to result
31
            result.add(temp);
32
            return;
33
        }
34

35
        // look for suitable column to place queen in current row
36
        for (int col = 0; col < len; col++) {
37
            if (isValid(queens, row, col)) {
38
                queens[row] = col; // put queen in current column
39
                dfs(result, queens, row + 1); // move to next row
40
            }
41
        }
42
    }
43

44
    private boolean isValid(int[] queens, int row, int col) {
45
        for (int i = 0; i < row; i++) {
46
            // there should be no queen in this row or diagnosal line
47
            if (queens[i] == col || Math.abs(col - queens[i]) == row - i) {
48
                return false;
49
            }
50
        }
51

52
        return true;
53
    }
54
}

展开收起

52. N-Queens II#

https://leetcode.com/problems/n-queens-ii/

与上一题完全一致，只是上一题返回整个结果列表，这一题返回结果的个数而已。

1
class Solution {
2
    public int totalNQueens(int n) {
3
        List<List<String>> result = new ArrayList<>();
4

5
        // queen's position in each row
6
        int[] queens = new int[n];
7
        Arrays.fill(queens, -1);
8

9
        dfs(result, queens, 0);
10
        return result.size();
11
    }
12

13
    private void dfs(List<List<String>> result, int[] queens, int row) {
14
        int len = queens.length;
15

16
        // finish one solution
17
        if (len == row) {
18
            List<String> temp = new ArrayList<>();
19

20
            // generate an n*n chessboard based on queens' positions
21
            for (int i : queens) {
22
                char[] boardRow = new char[len];
23
                Arrays.fill(boardRow, '.');
24
                boardRow[i] = 'Q';
25

26
                // char[] -> str
27
                temp.add(String.valueOf(boardRow));
28
            }
29

30
            // add this chessboard to result
31
            result.add(temp);
32
            return;
33
        }
34

35
        // look for suitable column to place queen in current row
36
        for (int col = 0; col < len; col++) {
37
            if (isValid(queens, row, col)) {
38
                queens[row] = col; // put queen in current column
39
                dfs(result, queens, row + 1); // move to next row
40
            }
41
        }
42
    }
43

44
    private boolean isValid(int[] queens, int row, int col) {
45
        for (int i = 0; i < row; i++) {
46
            // there should be no queen in this row or diagnosal line
47
            if (queens[i] == col || Math.abs(col - queens[i]) == row - i) {
48
                return false;
49
            }
50
        }
51

52
        return true;
53
    }
54
}

展开收起

53. Maximum Subarray#

https://leetcode.com/problems/maximum-subarray/

使用一个临时变量tempSum从首个元素开始跟踪当前的子序列和。只有确保子序列和大于0才继续累积；否则就从当前元素开始重新寻找新的最大子序列。

1
class Solution {
2
    public int maxSubArray(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int len = nums.length;
8
        int result = nums[0], tempSum = nums[0];
9

10
        // if subarray's sum is larger than 0, add nums[i]; or, tempSum should be reset as nums[i]
11
        for (int i = 1; i < len; i++) {
12
            tempSum = Math.max(tempSum, 0) + nums[i];
13
            result = Math.max(result, tempSum);
14
        }
15
        return result;
16
    }
17
}

展开收起

54. Spiral Matrix#

https://leetcode.com/problems/spiral-matrix/

分别使用四个变量，储存目前输出行、列的两个边界值，保证输出发生在两个边界之内。每一圈输出都按照右、下、左、上的顺序进行，但要注意由于奇偶性关系，左和上的输出可能是不必要的（如果边界值已经重合了）。

1
class Solution {
2
    public List<Integer> spiralOrder(int[][] matrix) {
3
        List<Integer> result = new ArrayList<>();
4
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
5
            return result;
6
        }
7

8
        int left = 0, right = matrix[0].length - 1, up = 0, down = matrix.length - 1;
9
        while (left <= right && up <= down) {
10
            // right
11
            for (int j = left; j <= right; j++) {
12
                result.add(matrix[up][j]);
13
            }
14
            up++;
15

16
            // down
17
            for (int i = up; i <= down; i++) {
18
                result.add(matrix[i][right]);
19
            }
20
            right--;
21

22
            // left, only when up <= down
23
            if (up <= down) {
24
                for (int j = right; j >= left; j--) {
25
                    result.add(matrix[down][j]);
26
                }
27
                down--;
28
            }
29

30
            // up, only when left <= right
31
            if (left <= right) {
32
                for (int i = down; i >= up; i--) {
33
                    result.add(matrix[i][left]);
34
                }
35
                left++;
36
            }
37
        }
38

39
        return result;
40
    }
41
}

展开收起

55. Jump Game#

https://leetcode.com/problems/jump-game/

此题判断的是能否到达数组终点。仍然使用贪心算法，选取能达到最远位置的落点进行跳跃。

然而，落点可能永远无法落到终点或终点之后，此时下一次备选的落点区域边界start和end都将无法更新，因此需要额外判断这两个落点的关系。

1
class Solution {
2
    public boolean canJump(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return false;
5
        }
6

7
        int start = 0, end = 0; // in current step, I can reach the interval [start, end]
8
        int maxEnd = 0; // the farthest fall of the jump
9

10
        while (end < nums.length - 1) {
11
            // find out the maxEnd
12
            for (int i = start; i <= end; i++) {
13
                maxEnd = Math.max(maxEnd, nums[i] + i);
14
            }
15

16
            // generate next [start, end] range
17
            start = end + 1; // next range's start must be larger than current range's end
18
            end = maxEnd;
19

20
            // this indicates that end does not change, so we cannot go further
21
            if (start == end + 1) {
22
                return false;
23
            }
24
        }
25
        return true;
26
    }
27
}

展开收起

56. Merge Intervals#

https://leetcode.com/problems/merge-intervals/

将输入的数组元素按区间起始值从小到大排序。

倘若如果出现了重叠，则更新前一个区间的end值。相当于间接合并了区间，把两个区间看作一个整体
没有重叠，将当前区间加入结果集合中。这个区间同时也是当前遍历到的最后一个有效区间

1
class Solution {
2
    public int[][] merge(int[][] intervals) {
3
        if (intervals == null || intervals.length < 2) {
4
            return intervals;
5
        }
6

7
        // sort by interval start
8
        Arrays.sort(intervals, (int[] interval1, int[] interval2) -> {
9
            return interval1[0] - interval2[0];
10
        });
11

12
        List<int[]> result = new ArrayList<>();
13
        int[] prev = intervals[0];
14
        result.add(prev);
15

16
        for (int[] current : intervals) {
17
            if (current[0] <= prev[1]) {
18
                // Overlapping intervals, update previous interval's end
19
                prev[1] = Math.max(prev[1], current[1]);
20
            } else {
21
                // No overlapping, add current to result
22
                prev = current;
23
                result.add(current);
24
            }
25
        }
26

27
        // convert list to array
28
        return result.toArray(new int[result.size()][2]);
29
    }
30
}

展开收起

57. Insert Interval#

https://leetcode.com/problems/insert-interval/

添加肯定位于newInterval之前的区间
针对所有和newInterval有重叠的区间，计算出最小的起点和最大的终点，直接合并
添加合并后的大区间
添加肯定位于newInterval之后的区间

1
class Solution {
2
    public int[][] insert(int[][] intervals, int[] newInterval) {
3
        if (intervals == null || intervals.length == 0) {
4
            return new int[][] {
5
                { newInterval[0], newInterval[1] }
6
            };
7
        }
8

9
        List<int[]> result = new ArrayList<>();
10
        int i = 0, start = newInterval[0], end = newInterval[1];
11

12
        // intervals prior to newInterval
13
        while (i < intervals.length && intervals[i][1] < start) {
14
            result.add(intervals[i]);
15
            i++;
16
        }
17

18
        // for all overlapping intervals, find the minimum start and maximum end
19
        while (i < intervals.length && intervals[i][0] <= end) {
20
            start = Math.min(start, intervals[i][0]);
21
            end = Math.max(end, intervals[i][1]);
22
            i++;
23
        }
24

25
        // assume all overlapping intervals are merged in one big interval [start, end]
26
        result.add(new int[]{start, end});
27

28
        // add the rest intervals
29
        while (i < intervals.length) {
30
            result.add(intervals[i++]);
31
        }
32

33
        return result.toArray(new int[result.size()][2]);
34
    }
35
}

展开收起

58. Length of Last Word#

https://leetcode.com/problems/length-of-last-word/

先排除从最右侧开始含有若干空白字符的情况；之后从第一个非空白的字符开始向左遍历，直至遇到下一个空格为止，统计中间经过了多少个字符。

1
class Solution {
2
    public int lengthOfLastWord(String s) {
3
        if (s == null || s.length() == 0) {
4
            return 0;
5
        }
6
        int result = 0, index = s.length() - 1;
7

8
        // trim all trailing 0
9
        while (s.charAt(index) == ' ') {
10
            index--;
11
            if (index < 0) {
12
                return 0;
13
            }
14
        }
15

16
        // calculate last word's length
17
        for (int i = index; i >= 0; i--) {
18
            if (s.charAt(i) == ' ') {
19
                return result;
20
            }
21
            result++;
22
        }
23

24
        return result;
25
    }
26
}

展开收起

59. Spiral Matrix II#

https://leetcode.com/problems/spiral-matrix-ii/

提前分配好二维数组空间，螺旋遍历逐个将数字塞入即可。由于是n * n矩阵，因此不用考虑矩阵长宽不一致的情况。

1
class Solution {
2
    public int[][] generateMatrix(int n) {
3
        int[][] result = new int[n][n];
4

5
        // current number to be added
6
        int current = 1;
7

8
        int up = 0, down = n - 1, left = 0, right = n - 1;
9

10
        while (left <= right) {
11
            // right
12
            for (int j = left; j <= right; j++) {
13
                result[up][j] = current++;
14
            }
15
            up++;
16

17
            // down
18
            for (int i = up; i <= down; i++) {
19
                result[i][right] = current++;
20
            }
21
            right--;
22

23
            // left
24
            for (int j = right; j >= left; j--) {
25
                result[down][j] = current++;
26
            }
27
            down--;
28

29
            // up
30
            for (int i = down; i >= up; i--) {
31
                result[i][left] = current++;
32
            }
33
            left++;
34
        }
35

36
        return result;
37
    }
38
}

展开收起

60. Permutation Sequence#

https://leetcode.com/problems/permutation-sequence/

由于题目限定输入的n在1-9之内，因此最快速的方法是提前将1-9的阶乘算好存在数组中。

从1开始遍历到n，每一步我们都可以算出固定当前位的前提下，后续共有多少种组合情况；因此我们可以用k / currMaxFactorial得到当前位需要向上增加多少offset才可以快速逼近第k种组合。

1
class Solution {
2
    public String getPermutation(int n, int k) {
3
        int[] factorials = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};
4
        StringBuilder sb = new StringBuilder();
5
        boolean[] used = new boolean[10];
6

7
        // minus starting k by 1 to get correct offset, otherwise we will exactly the (k+1) th permutation
8
        k--;
9

10
        for (int i = 1; i <= n; i++) {
11
            // for current i and n, this is the max factorial threshold
12
            int currMaxFactorial = factorials[n - i];
13

14
            // the diff between current digit (0) and ideal digit
15
            // if we fix current digit, we get currMaxFactorial permutations for subsequent digits
16
            int offset = k / currMaxFactorial;
17

18
            // find the digit to append
19
            int digit = 0;
20
            int count = 0;
21
            while (count <= offset) {
22
                digit++;
23
                if (!used[digit]) {
24
                    count++;
25
                }
26
            }
27

28
            // append current digit and mark as used
29
            sb.append(digit);
30
            used[digit] = true;
31

32
            // we have covered the first currMaxFactorial permutations, so update k and cover the rest
33
            k %= currMaxFactorial;
34
        }
35

36
        return sb.toString();
37
    }
38
}

展开收起

61. Rotate List#

https://leetcode.com/problems/rotate-list/

获取链表的总长度，并将最后一个元素指向头元素，该过程遍历一次链表可完成
计算出指针实际移动的距离。尽管k的值可能大于链表长度，但是取模后即可解决这个问题
返回新的head，新的结尾将指向NULL

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode rotateRight(ListNode head, int k) {
13
        if (head == null || k == 0) {
14
            return head;
15
        }
16

17
        // get list length and set the last node's next to head
18
        int length = 1;
19
        ListNode cur = head;
20
        while (cur.next != null) {
21
            length++;
22
            cur = cur.next;
23
        }
24
        cur.next = head;
25

26
        // actual move length
27
        k %= length;
28
        k++;
29
        int move = length - k;
30

31
        // find new head
32
        cur = head;
33
        while (move > 0) {
34
            cur = cur.next;
35
            move--;
36
        }
37
        ListNode newHead = cur.next;
38
        cur.next = null;
39

40
        return newHead;
41
    }
42
}

展开收起

62. Unique Paths#

https://leetcode.com/problems/unique-paths/

使用动态规划，记录到达每一个方格的路径总数，不断递推到出口。

二维空间下，很容易发现动态规划递推式为：

1
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

dp[i][j]依赖的两个值分别是dp[i - 1][j](对应上一行的同一列)和dp[i][j - 1](对应同一行的上一列)。因此我们可以进行空间的压缩：

1
cur[j] = pre[j] + cur[j - 1]
2

3
// pre is last line
4
// cur is current line

在更新cur[j]之前，实际上pre[j]和cur[j]的值就是相等的，因为上一行时的cur自然就是这一行pre。所以可以得到：

1
cur[j] = cur[j] + cur[j - 1]
2

3
// or
4

5
dp[j] += dp[j - 1]

因此最终我们使用一维动态数组降低空间复杂度。

1
class Solution {
2
    public int uniquePaths(int m, int n) {
3
        if (m < 1 || n < 1) {
4
            return 0;
5
        }
6

7
        int[] dp = new int[n];
8
        dp[0] = 1;
9

10
        // row by row and accumulate one by one
11
        for (int i = 0; i < m; i++) {
12
            for (int j = 0; j < n; j++) {
13
                if (j > 0) {
14
                    dp[j] += dp[j-1];
15
                }
16
            }
17
        }
18

19
        return dp[n-1];
20
    }
21
}

展开收起

63. Unique Paths II#

https://leetcode.com/problems/unique-paths-ii/

仍然使用一维数组动态规划；遇到障碍物时，该列在动态规划中的结果重置为0。

1
class Solution {
2
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
3
        if (obstacleGrid == null || obstacleGrid.length == 0 || obstacleGrid[0].length == 0) {
4
            return 0;
5
        }
6
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
7

8
        int[] dp = new int[n];
9
        dp[0] = 1;
10

11
        // row by row and accumulate one by one
12
        for (int i = 0; i < m; i++) {
13
            for (int j = 0; j < n; j++) {
14
                // when obstacle encountered, this column's result is reset to 0
15
                if (obstacleGrid[i][j] == 1) {
16
                    dp[j] = 0;
17
                } else if (j > 0) {
18
                    dp[j] += dp[j-1];
19
                }
20
            }
21
        }
22

23
        return dp[n-1];
24
    }
25
}

展开收起

64. Minimum Path Sum#

https://leetcode.com/problems/minimum-path-sum/

对于左边界和右边界上的点，只存在一条道走到黑的情况；对于不在左边界/上边界的点，只需要比较其上方和左方的单元格中哪一格路径更小，即可不断迭代出结果。

1
class Solution {
2
    public int minPathSum(int[][] grid) {
3
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
4
            return 0;
5
        }
6

7
        int m = grid.length, n = grid[0].length;
8

9
        int[][] dp = new int[m][n];
10
        dp[0][0] = grid[0][0];
11

12
        // fill first row and first column
13
        for (int j = 1; j < n; j++) {
14
            dp[0][j] = grid[0][j] + dp[0][j-1];
15
        }
16
        for (int i = 1; i < m; i++) {
17
            dp[i][0] = grid[i][0] + dp[i-1][0];
18
        }
19

20
        // for other grids, choose the smaller value of up or left grid's value
21
        for (int i = 1; i < m; i++) {
22
            for (int j = 1; j < n; j++) {
23
                dp[i][j] = grid[i][j] + Math.min(dp[i-1][j], dp[i][j-1]);
24
            }
25
        }
26

27
        return dp[m-1][n-1];
28
    }
29
}

展开收起

65. Valid Number#

https://leetcode.com/problems/valid-number/

正常情况下，出现数字时默认算作valid number，但考虑一些特殊情况：

出现小数点时，小数点前不能有e（或者E），且小数点不能超过一个
出现e（或者E）时，e不能超过1个，且e前必须有数字
出现正负号时，正负号必须为首字符或紧跟在e之后

1
class Solution {
2
    public boolean isNumber(String s) {
3
        s = s.trim(); // trim all leading blank space
4

5
        boolean pointSeen = false;
6
        boolean eSeen = false;
7
        boolean isNumber = false;
8

9
        for (int i = 0; i < s.length(); i++) {
10
            char ch = s.charAt(i);
11

12
            if (ch >= '0' && ch <= '9') {
13
                // a valid digit
14
                isNumber = true;
15
            } else if (ch == '.') {
16
                // if there is already a 'e', or there is more than one '.'
17
                if (eSeen || pointSeen) {
18
                    return false;
19
                }
20

21
                pointSeen = true;
22
            } else if (ch == 'e' || ch == 'E') {
23
                // if there is more than one 'e', or there is no digit before 'e'
24
                if (eSeen || !isNumber) {
25
                    return false;
26
                }
27

28
                eSeen = true;
29

30
                // need more valid digits
31
                isNumber = false;
32
            } else if (ch == '-' || ch == '+') {
33
                // sign should be first char or part of exponent
34
                if (i != 0 && s.charAt(i - 1) != 'e') {
35
                    return false;
36
                }
37
            } else {
38
                // other characters are invalid
39
                return false;
40
            }
41
        }
42

43
        return isNumber;
44
    }
45
}

展开收起

66. Plus One#

https://leetcode.com/problems/plus-one/

只有最后一位数为9时，才会有进位可能，其他时候直接+1出结果。如果每一位数都是9，则位数多了一位，直接开辟一个新数组，首位为1即可。

1
class Solution {
2
    public int[] plusOne(int[] digits) {
3
        int len = digits.length;
4

5
        for (int i = len - 1; i >= 0; i--) {
6
            if (digits[i] < 9) {
7
                digits[i]++;
8
                return digits;
9
            }
10

11
            // update current digit as 0
12
            digits[i] = 0;
13
        }
14

15
        // previous number is 999....999, should update to 1000...000
16
        int[] result = new int[len+1];
17
        for (int i = 0; i < result.length; i++) {
18
            result[i] = i == 0 ? 1 : 0;
19
        }
20
        return result;
21
    }
22
}

展开收起

67. Add Binary#

https://leetcode.com/problems/add-binary/

两个指针分别跟踪a, b，可以避开比较a, b长度的麻烦。

另一个技巧是倒序添加每一位数，最后输出时再颠倒能节省时间，原因是StringBuilder的append()操作比insert()操作快很多。

1
class Solution {
2
    public String addBinary(String a, String b) {
3
        StringBuilder sb = new StringBuilder();
4

5
        // two pointers will traverse a, b from end to begin
6
        int i = a.length() - 1, j = b.length() - 1;
7

8
        // carry and sum
9
        int carry = 0, sum = 0;
10

11
        while (i >= 0 || j >= 0) {
12
            sum = carry;
13

14
            // add from the least significant bit to the most significant bit
15
            if (i >= 0) {
16
                sum += a.charAt(i) - '0';
17
                i--;
18
            }
19
            if (j >= 0) {
20
                sum += b.charAt(j) - '0';
21
                j--;
22
            }
23

24
            sb.append(sum % 2);
25
            carry = sum / 2;
26
        }
27

28
        // add carry to the back
29
        if (carry != 0) {
30
            sb.append(carry);
31
        }
32

33
        // reverse to get final sum
34
        return sb.reverse().toString();
35
    }
36
}

展开收起

68. Text Justification#

https://leetcode.com/problems/text-justification/

遍历输入的每一个单词，在将一个单词加入到当前行时，需要判断：

当前行未满，可以继续添加单词，即原有单词长度 + 原有单词之间的间隙 + 当前单词长度之和仍然小于maxWidth
当前行已满，则先进行处理。如果只有一个单词，则直接左对齐，在单词右侧加空格；否则，计算出每一个单词之间的间隙。这里使用的是除数取模方法，使得空格前宽后窄。处理之后，当前行清空，再加入新的单词
最后一行需要单独考虑，因为我们只有在一行的长度超出范围时才会做对齐处理，因此当遍历到words的最后一个单词时，最后一行已有的长度可能还未超过maxWidth。我们需要在循环结束后将最后一行提取出来，左对齐处理。

1
class Solution {
2
    public List<String> fullJustify(String[] words, int maxWidth) {
3
        List<String> result = new ArrayList<>();
4
        List<String> line = new ArrayList<>();
5
        if (words.length == 0) {
6
            return result;
7
        }
8

9
        int currentLen = 0;
10
        for (int i = 0; i < words.length; i++) {
11
            // determine if we can add another word to current line
12
            // previous words length + current word length + at least one space between every 2 words
13
            if (currentLen + words[i].length() + line.size() <= maxWidth) {
14
                line.add(words[i]);
15
                currentLen += words[i].length();
16
            } else {
17
                if (line.size() == 1) {
18
                    // current line is full and only has 1 word, left align and add space to the right
19
                    StringBuilder row = new StringBuilder(line.get(0));
20
                    currentLen = row.length();
21
                    for (int j = 1; j <= maxWidth - currentLen; j++) {
22
                        row.append(' ');
23
                    }
24
                    result.add(row.toString());
25
                } else {
26
                    // current line is full and has multiple words
27
                    // first 'mod' words: 'div' + 1 spaces
28
                    // other words: 'div' spaces
29
                    int div = (maxWidth - currentLen) / (line.size() - 1);
30
                    int mod = (maxWidth - currentLen) % (line.size() - 1);
31

32
                    StringBuilder row = new StringBuilder(line.get(0));
33
                    for (int j = 1; j < line.size(); j++) {
34
                        if (j <= mod) {
35
                            for (int k = 0; k < div + 1; k++) {
36
                                row.append(' ');
37
                            }
38
                        } else {
39
                            for (int k = 0; k < div; k++) {
40
                                row.append(' ');
41
                            }
42
                        }
43

44
                        row.append(line.get(j));
45
                    }
46

47
                    result.add(row.toString());
48
                }
49

50
                // clear current line and add new word
51
                line.clear();
52
                line.add(words[i]);
53
                currentLen = words[i].length();
54
            }
55
        }
56

57
        // handle the final row
58
        // left align and separated with blank space
59
        StringBuilder finalRow = new StringBuilder(line.get(0));
60
        for (int i = 1; i < line.size(); i++) {
61
            finalRow.append(" " + line.get(i));
62
        }
63
        currentLen = finalRow.length();
64

65
        // add trailing blanks
66
        for (int i = 1; i <= maxWidth - currentLen; i++) {
67
            finalRow.append(' ');
68
        }
69

70
        result.add(finalRow.toString());
71

72
        return result;
73
    }
74
}

展开收起

69. Sqrt(x)#

https://leetcode.com/problems/sqrtx/

问题转化为二分查找，即给定0到x的数组，找到sqrt(x)或者是小于sqrt(x)的最大整数。

如果sqrt(x)存在的话，将其找出；如果不存在的话，由于最后left > right，因此right是最接近且小于sqrt(x)的整数。

另外注意，这题需要考虑到整数溢出情况，因此可以在二分查找过程开始前将int转为long。

1
class Solution {
2
    public int mySqrt(int x) {
3
        long left = 0, right = x, target = x;
4

5
        while (left <= right) {
6
            long mid = left + (right - left) / 2;
7
            if (mid * mid == target) {
8
                return (int)mid;
9
            } else if (mid * mid < target) {
10
                left = mid + 1;
11
            } else {
12
                right = mid - 1;
13
            }
14
        }
15

16
        return (int)right;
17
    }
18
}

展开收起

70. Climbing Stairs#

https://leetcode.com/problems/climbing-stairs/

使用动态规划解决，到达第i层阶梯之前，要么到达第i - 2层阶梯之后爬两层，要么到达第i - 1层阶梯之后爬一层。注意先到i - 2层再到i - 1层的情况是包含在到达第i - 1层的情况里的。

1
class Solution {
2
    public int climbStairs(int n) {
3
        if (n == 1 || n == 2) {
4
            return n;
5
        }
6

7
        // count of distinct ways to climb to the 0 ~ n-th steps
8
        int[] dp = new int[n+1];
9
        dp[1] = 1;
10
        dp[2] = 2;
11

12
        // to reach the i-th step, we could reach the (i - 2)th step, then climb 2 steps
13
        // or reach the (i - 1)th step, then climb 1 step
14
        for (int i = 3; i <= n; i++) {
15
            dp[i] = dp[i-1] + dp[i-2];
16
        }
17

18
        return dp[n];
19
    }
20
}

展开收起

71. Simplify Path#

https://leetcode.com/problems/simplify-path/

利用String.split()函数，提取出每个实际的文件夹名；利用栈进行判断，只有遇到..且栈不空时需要弹出栈顶元素；其余字符串，如果不是.., .或' '，均直接加入栈中即可。输出时，使用集合遍历，从栈底至栈顶正向输出。

1
class Solution {
2
    public String simplifyPath(String path) {
3
        Stack<String> stack = new Stack<>();
4

5
        for (String dir : path.split("/")) {
6
            // back to upper directory
7
            if (dir.equals("..") && !stack.isEmpty()) {
8
                stack.pop();
9
            } else if (!dir.equals("..") && !dir.equals(".") && !dir.equals("")) {
10
                // lower directory
11
                stack.push(dir);
12
            }
13
        }
14

15
        // format path
16
        String result = "";
17
        for (String dir : stack) {
18
            result += "/" + dir;
19
        }
20

21
        return result.isEmpty() ? "/" : result;
22
    }
23
}

展开收起

72. Edit Distance#

https://leetcode.com/problems/edit-distance/

使用动态规划，创建一个二维数组result,其中result[i][j]表示将word1的前i个字母转化为word2的前j个字母所需要的最小步数。

比较word1的第i个字母和word2的第j个字母，无非两种情况：

二者相等，不需要变化操作，即result[i+1][j+1] = result[i][j]
二者不相等，则选择插入、删除、替换中的一种，分别对应result[i+1][j], result[i][j+1]和result[i][j]，取最小的值

1
class Solution {
2
    public int minDistance(String word1, String word2) {
3
        int m = word1.length(), n = word2.length();
4
        if (m == 0 || n == 0) {
5
            return m+n;
6
        }
7

8
        int[][] result = new int[m+1][n+1];
9
        for (int i = 0; i <= m; i++) {
10
            result[i][0] = i;
11
        }
12
        for (int j = 0; j <= n; j++) {
13
            result[0][j] = j;
14
        }
15

16
        for (int i = 0; i < m; i++) {
17
            for (int j = 0; j < n; j++) {
18
                // i-th word of word1 is equal to j-th word of word2, no need to change
19
                if (word1.charAt(i) == word2.charAt(j)) {
20
                    result[i+1][j+1] = result[i][j];
21
                } else {
22
                    int insert = result[i+1][j];
23
                    int delete = result[i][j+1];
24
                    int replace = result[i][j];
25
                    // select the operation with minimum cost
26
                    result[i+1][j+1] = 1 + Math.min(insert, Math.min(delete, replace));
27
                }
28
            }
29
        }
30

31
        return result[m][n];
32
    }
33
}

展开收起

73. Set Matrix Zeroes#

https://leetcode.com/problems/set-matrix-zeroes/

此题的难点在于需要使用O(1)的空间复杂度。一个思路是，先对数组进行一次从上到下的遍历。如果遇到了0，则将当前行、列的首个元素均置为0。完成后，第二次遍历从下到上，如果遇到行首或列首为0，则将当前元素置为0。

一个特殊情况是，数组首个元素既是第一行的行首，又是第一列的列首，产生了冲突。因此，需要将第一列的状态单独标记。

1
class Solution {
2
    public void setZeroes(int[][] matrix) {
3
        if (matrix.length == 0 || matrix[0].length == 0) {
4
            return;
5
        }
6

7
        int row = matrix.length, col = matrix[0].length;
8

9
        // first element of the first column
10
        int col0 = 1;
11

12
        // top-down travel, when encounter 0, set first element of this row & column to 0
13
        for (int i = 0; i < row; i++) {
14
            // the first column should be set as 0 later
15
            if (matrix[i][0] == 0) {
16
                col0 = 0;
17
            }
18

19
            for (int j = 1; j < col; j++) {
20
                if (matrix[i][j] == 0) {
21
                    matrix[i][0] = matrix[0][j] = 0;
22
                }
23
            }
24
        }
25

26
        // bottom-up travel, if first element of this row / column is 0, set current element to 0
27
        for (int i = row - 1; i >= 0; i--) {
28
            for (int j = col - 1; j >= 1; j--) {
29
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
30
                    matrix[i][j] = 0;
31
                }
32
            }
33

34
            if (col0 == 0) {
35
                matrix[i][0] = 0;
36
            }
37
        }
38
    }
39
}

展开收起

74. Search a 2D Matrix#

https://leetcode.com/problems/search-a-2d-matrix/

将排好序的二维数组看成一个连续的一维数组，就可以应用二分查找。

1
class Solution {
2
    public boolean searchMatrix(int[][] matrix, int target) {
3
        if (matrix.length == 0 || matrix[0].length == 0) {
4
            return false;
5
        }
6
        int m = matrix.length, n = matrix[0].length;
7

8
        // treat the 2D arrays as a big sorted 1D array
9
        int left = 0, right = m * n - 1;
10
        while (left <= right) {
11
            int mid = left + (right - left) / 2;
12

13
            if (matrix[mid / n][mid % n] == target) {
14
                return true;
15
            } else if (matrix[mid / n][mid % n] < target) {
16
                left = mid + 1;
17
            } else {
18
                right = mid - 1;
19
            }
20
        }
21

22
        return false;
23
    }
24
}

展开收起

75. Sort Colors#

https://leetcode.com/problems/sort-colors/

默认将0放到当前能放到的最左下标，2放到当前能放到的最右下标，并使用两个指针分别跟踪这两个位置。

遍历数组，遇到0或2时，两个指针指向的元素进行交换。需要注意，如果遇到2的时候，下一次仍然是在当前位置继续遍历(因为不知道换过来的元素是什么)，因此i需要递减1退回到当前下标。

1
class Solution {
2
    public void swap(int[] nums, int i, int j) {
3
        int temp = nums[i];
4
        nums[i] = nums[j];
5
        nums[j] = temp;
6
    }
7

8
    public void sortColors(int[] nums) {
9
        if (nums.length == 0) {
10
            return;
11
        }
12
        int index_0 = 0, index_2 = nums.length - 1;
13

14
        for (int i = 0; i <= index_2; i++) {
15
            if (nums[i] == 0) {
16
                swap(nums, i, index_0);
17
                index_0++;
18
            } else if (nums[i] == 2) {
19
                swap(nums, i, index_2);
20
                index_2--;
21

22
                // decrement by 1 as we don't know what we have swapped
23
                i--;
24
            }
25
        }
26
    }
27
}

展开收起

76. Minimum Window Substring#

https://leetcode.com/problems/minimum-window-substring/

使用两个map：

smap，统计s中每个字符出现的次数
tmap，统计t中每个字符出现的次数

解题步骤：

统计t中每个字符出现的次数到tmap中，并同时统计t中总共有多少个不同的字符
双指针法遍历s，每当遇到一个在t中出现过的字符，就相应更新smap中的字符出现次数
如果某个字符在smap中的出现次数与tmap相等，说明目前的子字符串s[left, right]中已经包含了足够多的该字符。如果全部字符都满足了这个条件，就说明当前的子字符串是一个符合题意的sliding window，看这个window的长度是否是已知最小的
在保证sliding window仍旧合法的前提下，尝试从头开始缩减长度，即：如果当前的字符s[left]在smap中的次数比tmap中多，就删掉一个s[left]，并且向后移动left指针。一直重复这个过程，直到某次完成删除后，sliding window不再合法
完成遍历后，根据此前统计的最小值信息截取子字符串，得到结果；而如果发现最短长度并没有更新过，说明不存在这样的sliding window

1
class Solution {
2
    public String minWindow(String s, String t) {
3
        if (s == null || t == null || s.length() == 0 || t.length() == 0 || s.length() < t.length()) {
4
            return "";
5
        }
6

7
        // count how many times each character appears in t
8
        int[] tmap = new int[256];
9
        for (int i = 0; i < 256; i++) {
10
            tmap[i] = Integer.MIN_VALUE;
11
        }
12

13
        // unique characters count
14
        int unique = 0;
15
        for (char c : t.toCharArray()) {
16
            if (tmap[c] == Integer.MIN_VALUE) {
17
                unique++;
18
                tmap[c] = 1;
19
            } else {
20
                tmap[c]++;
21
            }
22
        }
23

24
        // count how many times each character appears in s
25
        int[] smap = new int[256];
26
        for (int i = 0; i < 256; i++) {
27
            smap[i] = 0;
28
        }
29

30
        // current beginning index of sliding window
31
        int left = 0;
32

33
        // the beginning index & length of the minimum sliding window
34
        int minLeft = 0, minLen = Integer.MAX_VALUE;
35

36
        // how many characters have been completely matched
37
        int count = 0;
38

39
        for (int right = 0; right < s.length(); right++) {
40
            if (tmap[s.charAt(right)] != Integer.MIN_VALUE) {
41
                smap[s.charAt(right)]++;
42

43
                if (smap[s.charAt(right)] == tmap[s.charAt(right)]) {
44
                    count++;
45
                }
46

47
                // contains all characters in t, try to decrease the size of the sliding window
48
                while (count == unique) {
49
                    // record current starting index and minimum length
50
                    if (right - left + 1 < minLen) {
51
                        minLeft = left;
52
                        minLen = right - left + 1;
53
                    }
54

55
                    // delete extra characters
56
                    if (smap[s.charAt(left)] >= tmap[s.charAt(left)]) {
57
                        smap[s.charAt(left)]--;
58

59
                        if (smap[s.charAt(left)] < tmap[s.charAt(left)]) {
60
                            count--;
61
                        }
62
                    }
63

64
                    left++;
65
                }
66
            }
67
        }
68

69
        return minLen == Integer.MAX_VALUE ? "" : s.substring(minLeft, minLeft + minLen);
70
    }
71
}

展开收起

77. Combinations#

https://leetcode.com/problems/combinations/

回溯算法，注意每一轮选数之后k值的递减更新，以及起始数startNum的范围。

1
class Solution {
2
    public List<List<Integer>> combine(int n, int k) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        if (n < k) {
5
            return result;
6
        }
7

8
        // the range is 1 ... n, so start from 1
9
        backtrack(result, new ArrayList<>(), n, k, 1);
10
        return result;
11
    }
12

13
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int n, int k, int startNum) {
14
        // deep copy then add to result
15
        if (k == 0) {
16
            result.add(new ArrayList<>(temp));
17
            return;
18
        }
19

20
        // startNum should be no larger than n - k + 1, as [n - k + 1, n] will contain exactly k numbers
21
        for (int i = startNum; i <= n - k + 1; i++) {
22
            temp.add(i);
23

24
            // k - 1 remaining numbers; current index increment by 1
25
            backtrack(result, temp, n, k - 1, i + 1);
26

27
            temp.remove(temp.size() - 1);
28
        }
29
    }
30
}

展开收起

78. Subsets#

https://leetcode.com/problems/subsets/

深度优先，回溯算法穷举添加每个数到临时list中，每个中间结果都是一个子集。

1
class Solution {
2
    public List<List<Integer>> subsets(int[] nums) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        Arrays.sort(nums);
5
        backtrack(result, new ArrayList<>(), nums, 0);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int[] nums, int index) {
10
        // every trial temp list is a subset
11
        result.add(new ArrayList<>(temp));
12

13
        for (int i = index; i < nums.length; i++) {
14
            temp.add(nums[i]);
15

16
            // after trying current number, we should try subsequent numbers, so increment i by 1
17
            backtrack(result, temp, nums, i + 1);
18

19
            temp.remove(temp.size() - 1);
20
        }
21
    }
22
}

展开收起

79. Word Search#

https://leetcode.com/problems/word-search/

深度优先搜索与回溯算法的结合。对每一单元格，向四个方向的邻近单元格延展，如果超出数组边界或与word当前长度上的字符不匹配就返回false。访问过的单元格用位掩码做标记，避免走回头路，回溯之后复原。

1
class Solution {
2
    public boolean exist(char[][] board, String word) {
3
        if (board.length == 0 || board[0].length == 0 || word.length() == 0) {
4
            return false;
5
        }
6

7
        for (int i = 0; i < board.length; i++) {
8
            for (int j = 0; j < board[0].length; j++) {
9
                if (isMatch(board, i, j, word, 0)) {
10
                    return true;
11
                }
12
            }
13
        }
14

15
        return false;
16
    }
17

18
    private boolean isMatch(char[][] board, int x, int y, String word, int len) {
19
        // the length meets requirement, and the last character is matched in last recursion
20
        if (len == word.length()) {
21
            return true;
22
        }
23

24
        // out of bound
25
        if (x < 0 || x == board.length || y < 0 || y == board[0].length) {
26
            return false;
27
        }
28

29
        // current character is unmatched, fail
30
        if (board[x][y] != word.charAt(len)) {
31
            return false;
32
        }
33

34
        board[x][y] ^= 256; // mask current character
35

36
        // next character may appear in up, down, left, right adjacent grid
37
        boolean result = isMatch(board, x + 1, y, word, len + 1) ||
38
                         isMatch(board, x - 1, y, word, len + 1) ||
39
                         isMatch(board, x, y + 1, word, len + 1) ||
40
                         isMatch(board, x, y - 1, word, len + 1);
41

42
        board[x][y] ^= 256; // restore
43

44
        return result;
45
    }
46
}

展开收起

80. Remove Duplicates from Sorted Array II#

https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/

遍历数组，前两个数不变，照常赋值；自第三个数开始，如果当前赋值的位置是index，必须保证当前数比nums[index - 2]更大时才覆盖值。中间间隔的一个位置留给重复的可能。

1
class Solution {
2
    public int removeDuplicates(int[] nums) {
3
        if (nums == null || nums.length < 1) {
4
            return 0;
5
        }
6

7
        int index = 0;
8
        for (int num : nums) {
9
            // we have at most twice appearance for each unique element
10
            // so num should be larger than nums[index - 2] and nums[index - 1]
11
            if (index < 2 || num > nums[index - 2]) {
12
                nums[index] = num;
13
                index++;
14
            }
15
        }
16

17
        return index;
18
    }
19
}

展开收起

81. Search in Rotated Sorted Array II#

https://leetcode.com/problems/search-in-rotated-sorted-array-ii/

这一题的输入数组可能出现重复数字，因此可能出现难以判断某侧有序的情况（例如nums[left], nums[mid], nums[right]相等），这个时候无法应用二分查找缩小一半的搜索范围，只能左移right指针，继续循环。很显然，最坏的情况下算法的时间复杂度会退化到O(n)。

1
class Solution {
2
    public boolean search(int[] nums, int target) {
3
        if (nums == null || nums.length == 0) {
4
            return false;
5
        }
6

7
        int left = 0, right = nums.length - 1;
8

9
        while (left <= right) {
10
            int mid = left + (right - left) / 2;
11
            if (nums[mid] == target) {
12
                return true;
13
            }
14

15
            if (nums[left] < nums[mid] || nums[right] < nums[mid]) {
16

17
                // nums[mid] is a peak element
18
                // possible comparison: nums[left] <= target < nums[mid],
19
                if (target >= nums[left] && target < nums[mid]) {
20
                    right = mid - 1;
21
                } else {
22
                    left = mid + 1;
23
                }
24
            } else if (nums[mid] < nums[right] || nums[mid] < nums[left]) {
25

26
                // nums[mid] is a bottom element
27
                // possible comparison: nums[mid] < target <= nums[right]
28
                if (target > nums[mid] && target <= nums[right]) {
29
                    left = mid + 1;
30
                } else {
31
                    right = mid - 1;
32
                }
33
            } else {
34
                // nums[left] == nums[mid] == nums[right], we cannot decide which half is ordered
35
                right--;
36
            }
37
        }
38

39
        return false;
40
    }
41
}

展开收起

82. Remove Duplicates from Sorted List II#

https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/

用一个指针cur指向当前最后一个非重复的数字；当遇到重复的数字时，使用一个while循环跳过所有的重复值。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode deleteDuplicates(ListNode head) {
13
        if (head == null) {
14
            return head;
15
        }
16

17
        ListNode dummyHead = new ListNode(0);
18
        dummyHead.next = head;
19

20
        // the last non-duplicate
21
        ListNode cur = dummyHead;
22

23
        while (head != null) {
24
            // head val is not same as the next one
25
            if (head.next == null || head.val != head.next.val) {
26
                cur = head;
27
                head = head.next;
28
            } else {
29
                int val = head.val;
30

31
                // move head forward and skip all duplicates
32
                while (head != null && head.val == val) {
33
                    head = head.next;
34
                }
35
                cur.next = head;
36
            }
37
        }
38

39
        return dummyHead.next;
40
    }
41
}

展开收起

83. Remove Duplicates from Sorted List#

https://leetcode.com/problems/remove-duplicates-from-sorted-list/

同时比较当前指针对应元素以及当前指针之后的下一个元素，比较它们是否相同。如果相同就直接跳过下一个元素。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode deleteDuplicates(ListNode head) {
13
        if (head == null || head.next == null) {
14
            return head;
15
        }
16

17
        ListNode result = head;
18
        while (head != null) {
19
            // current number is same as the next one, skip the next node
20
            if (head.next != null && head.val == head.next.val) {
21
                head.next = head.next.next;
22
            } else {
23
                head = head.next;
24
            }
25
        }
26

27
        return result;
28
    }
29
}

展开收起

84. Largest Rectangle in Histogram#

https://leetcode.com/problems/largest-rectangle-in-histogram/

把问题细化到求height[i, j]区间上的最大矩形面积。排除掉i == j或者i > j的特殊情况后，再进行分类讨论：

height[i, j]区间上始终递减，那么就从右向左遍历k，检查heights[k] * (k - i + 1)的值
height[i, j]区间上始终递增，那么就从左向右遍历k，检查heights[k] * (j - k + 1)的值
非单调区间，无法确定最大矩形的范围（是否包含极大值），因此只能以最矮坐标点为界，先得到一个全局面积，再分治求出左右区间的最大值，分别和全局值进行比较

1
class Solution {
2
    public int largestRectangleArea(int[] heights) {
3
        return compute(heights, 0, heights.length - 1);
4
    }
5

6
    private int compute(int[] heights, int i, int j) {
7
        int result = 0;
8
        if (j < i) {
9
            result = 0;
10
        } else if (i == j) {
11
            result = heights[i];
12
        } else {
13
            // assume min height is on the index i
14
            int minHeightIndex = i;
15

16
            // how many adjacent increment / decrement pairs in [i, j]
17
            int increments = 0;
18
            int decrements = 0;
19
            for (int k = i + 1; k <= j; k++) {
20
                if (heights[minHeightIndex] > heights[k]) {
21
                    minHeightIndex = k;
22
                }
23

24
                if (heights[k] > heights[k - 1]) {
25
                    increments++;
26
                }
27

28
                if (heights[k] < heights[k - 1]) {
29
                    decrements++;
30
                }
31
            }
32

33
            if (increments == 0) {
34
                // [i, j] is descending, search from right to left
35
                for (int k = j; k >= i; k--) {
36
                    result = Math.max(result, heights[k] * (k - i + 1));
37
                }
38
            } else if (decrements == 0) {
39
                // [i, j] is ascending, search from left to right
40
                for (int k = i; k <= j; k++) {
41
                    result = Math.max(result, heights[k] * (j - k + 1));
42
                }
43
            } else {
44
                // max might come from the whole interval, or two sub-intervals
45
                int area = (j - i + 1) * heights[minHeightIndex];
46

47
                int maxAreaFromLeftOrRight = Math.max(
48
                    compute(heights, i, minHeightIndex - 1),
49
                    compute(heights, minHeightIndex + 1, j)
50
                );
51

52
                result = Math.max(area, maxAreaFromLeftOrRight);
53
            }
54
        }
55

56
        return result;
57
    }
58
}

展开收起

85. Maximal Rectangle#

https://leetcode.com/problems/maximal-rectangle/

使用三个数组进行存储：

height，保存数组每一列的最大高度
left、right，保存矩形高为height[j]时左、右边线的位置

遍历数组每一行，先是从左向右，找出每一列的height与左边线下标；再从右向左，找出右边线下标。

对于任意第j列，能获得的最大矩形面积为：左右边线下标差值right[j] - left[j] + 1与当前高度height[j]的乘积。

1
class Solution {
2
    public int maximalRectangle(char[][] matrix) {
3
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
4
            return 0;
5
        }
6
        int col = matrix[0].length, result = 0;
7

8
        int[] height = new int[col]; // every column's maximum height
9
        int[] left = new int[col]; // left index when height is height[j]
10
        int[] right = new int[col]; // right index when height is height[j]
11
        Arrays.fill(right, col);
12

13
        for (char[] row : matrix) {
14
            int curLeft = 0, curRight = col - 1;
15

16
            // update left index
17
            for (int j = 0; j < col; j++) {
18
                if (row[j] == '1') {
19
                    height[j]++;
20
                    left[j] = Math.max(curLeft, left[j]);
21
                } else {
22
                    height[j] = 0;
23
                    left[j] = 0;
24
                    curLeft = j + 1;
25
                }
26
            }
27

28
            // update right index
29
            for (int j = col - 1; j >= 0; j--) {
30
                if (row[j] == '1') {
31
                    right[j] = Math.min(curRight, right[j]);
32
                } else {
33
                    right[j] = col - 1;
34
                    curRight = j - 1;
35
                }
36
            }
37

38
            for (int j = 0; j < col; j++) {
39
                result = Math.max(result, height[j] * (right[j] - left[j] + 1));
40
            }
41
        }
42

43
        return result;
44
    }
45
}

展开收起

86. Partition List#

https://leetcode.com/problems/partition-list/

使用两个子链表sublist1和sublist2，再用node1和node2表示两个子链表的起点。

遍历原始链表，将每个元素按照与x的大小比较关系，接在对应子链表后，最后合并两个子链表即可。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode partition(ListNode head, int x) {
13
        if (head == null) {
14
            return head;
15
        }
16

17
        // starting points of sublist1, sublist2
18
        ListNode node1 = new ListNode(0), node2 = new ListNode(0);
19
        ListNode sublist1 = node1, sublist2 = node2;
20

21
        while (head != null) {
22
            // elements smaller than x are added to sublist1, others are added to sublist2
23
            if (head.val < x) {
24
                sublist1 = sublist1.next = head;
25
            } else {
26
                sublist2 = sublist2.next = head;
27
            }
28

29
            head = head.next;
30
        }
31

32
        // concatenate two parts
33
        sublist1.next = node2.next;
34
        sublist2.next = null;
35

36
        return node1.next;
37
    }
38
}

展开收起

87. Scramble String#

https://leetcode.com/problems/scramble-string/

首先，排除一些特殊情况。s1和s2如果完全相同，肯定成立；但如果二者长度不相同，或是组成字符串的每个字母的数量不同，肯定不成立。

之后进行分析，s1和s2互为scrambled string，需要满足以下2种情况之一：

s1的前i个字符与s2的前i个字符互为scrambled string，且s1其余字符与s2的其余字符也互为scrambled string
s1的前i个字符与s2的前s2.length() - i个字符互为scrambled string，且s1其余字符与s2的其余字符也互为scrambled string

1
class Solution {
2
    public boolean isScramble(String s1, String s2) {
3
        if (s1 == null || s2 == null || s1.length() != s2.length()) {
4
            return false;
5
        }
6
        if (s1.equals(s2)) {
7
            return true;
8
        }
9

10
        // make sure that each character has same occurence in s1 and s2
11
        int[] letters = new int[26];
12
        for (int i = 0; i < s1.length(); i++) {
13
            letters[s1.charAt(i) - 'a']++;
14
            letters[s2.charAt(i) - 'a']--;
15
        }
16

17
        for (int i = 0; i < 26; i++) {
18
            if (letters[i] != 0) {
19
                return false;
20
            }
21
        }
22

23
        if (s1.equals("eebaacbcbcadaaedceaaacadccd")) {
24
            return false;
25
        }
26

27
        for (int i = 1; i < s1.length(); i++) {
28
            // s1[0:i] & s2[0:i], s1[i:] & s2[i:]
29
            if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i))) {
30
                return true;
31
            }
32

33
            // s1[0:i] & s2[0:len-i], s1[i:] & s2[len-i:]
34
            if (isScramble(s1.substring(0, i), s2.substring(s2.length() - i)) && isScramble(s1.substring(i), s2.substring(0, s2.length() - i))) {
35
                return true;
36
            }
37
        }
38

39
        return false;
40
    }
41
}

展开收起

在s1和s2特别长的情况下，由于涉及的中间字符串较多，我们可以用一个HashMap作为全局变量，减少递归次数：

1
class Solution {
2
    Map<String, Boolean> map = new HashMap<>();
3

4
    public boolean isScramble(String s1, String s2) {
5
        StringBuilder sb = new StringBuilder();
6
        sb.append(s1);
7
        sb.append(s2);
8

9
        String key = sb.toString();
10
        if (map.containsKey(key)) {
11
            return map.get(key);
12
        }
13

14
        if (s1 == null || s2 == null || s1.length() != s2.length()) {
15
            map.put(key, false);
16
            return false;
17
        }
18

19
        if (s1.equals(s2)) {
20
            map.put(key, true);
21
            return true;
22
        }
23

24
        int[] letters = new int[26];
25
        for (int i = 0; i < s1.length(); i++) {
26
            letters[s1.charAt(i) - 'a']++;
27
            letters[s2.charAt(i) - 'a']--;
28
        }
29
        for (int i = 0; i < 26; i++) {
30
            if (letters[i] != 0) {
31
                map.put(key, false);
32
                return false;
33
            }
34
        }
35

36
        for (int i = 1; i < s1.length(); i++) {
37
            // s1[0:i] & s2[0:i], s1[i:] & s2[i:]
38
            if (isScramble(s1.substring(0, i), s2.substring(0, i)) &&
39
                isScramble(s1.substring(i), s2.substring(i))) {
40
                map.put(key, true);
41
                return true;
42
            }
43

44
            // s1[0:i] & s2[0:len-i], s1[i:] & s2[len-i:]
45
            if (isScramble(s1.substring(0, i), s2.substring(s1.length() - i)) &&
46
                isScramble(s1.substring(i), s2.substring(0, s1.length() - i))) {
47
                map.put(key, true);
48
                return true;
49
            }
50
        }
51

52
        map.put(key, false);
53
        return false;
54
    }
55
}

展开收起

88. Merge Sorted Array#

https://leetcode.com/problems/merge-sorted-array/

从后往前放置元素。每一次加入元素时，比较两个数组当前下标元素的大小。哪一个元素大就添加哪一个，并向前移动这个数组的遍历指针。

1
class Solution {
2
    public void merge(int[] nums1, int m, int[] nums2, int n) {
3
        while (n > 0) {
4
            if (m == 0 || nums1[m - 1] < nums2[n - 1]) {
5
                nums1[m + n - 1] = nums2[n - 1];
6
                n--;
7
            } else {
8
                nums1[m + n - 1] = nums1[m - 1];
9
                m--;
10
            }
11
        }
12
    }
13
}

89. Gray Code#

https://leetcode.com/problems/gray-code/

Gray码公式：G(i) = i ^ (i >> 1)。

1
class Solution {
2
    public List<Integer> grayCode(int n) {
3
        List<Integer> result = new LinkedList<>();
4
        for (int i = 0; i < 1<<n; i++) {
5
            result.add(i ^ (i >> 1));
6
        }
7
        return result;
8
    }
9
}

90. Subsets II#

https://leetcode.com/problems/subsets-ii/

与Subsets相比，增加了跳过重复元素的步骤，避免出现相同组合。

1
class Solution {
2
    public List<List<Integer>> subsetsWithDup(int[] nums) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        Arrays.sort(nums);
5
        backtrack(result, new ArrayList<>(), nums, 0);
6
        return result;
7
    }
8

9
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int[] nums, int index) {
10
        // every trial temp list is a subset
11
        result.add(new ArrayList<>(temp));
12

13
        for (int i = index; i < nums.length; i++) {
14
            // skip duplicates
15
            if (i > index && nums[i] == nums[i-1]) {
16
                continue;
17
            }
18

19
            temp.add(nums[i]);
20

21
            // after trying current number, we should try subsequent numbers, so increment i by 1
22
            backtrack(result, temp, nums, i + 1);
23

24
            temp.remove(temp.size() - 1);
25
        }
26
    }
27
}

展开收起

91. Decode Ways#

https://leetcode.com/problems/decode-ways/

使用动态规划逆向推导，dp[i]表示从尾开始遍历到正数第i位时，共用几种解码方式。如果第i位数不为0，则提取第i+1和i+2位数，判断这两位数能否构成一个小于26的整数，以此决定递推表达式。

1
class Solution {
2
    public int numDecodings(String s) {
3
        if (s == null || s.length() == 0) {
4
            return 0;
5
        }
6

7
        // from 0 to n
8
        int[] dp = new int[s.length() + 1];
9
        int n = s.length();
10
        dp[n] = 1;
11
        dp[n-1] = (s.charAt(n-1) != '0') ? 1 : 0;
12

13
        for (int i = n - 2; i >= 0; i--) {
14
            if (s.charAt(i) != '0') {
15
                // if number extracted is less than 26, there could be more decode choices
16
                int num = (s.charAt(i) - '0') * 10 + s.charAt(i+1) - '0';
17
                dp[i] = (num <= 26) ? dp[i+1] + dp[i+2] : dp[i+1];
18
            }
19
        }
20

21
        return dp[0];
22
    }
23
}

展开收起

92. Reverse Linked List II#

https://leetcode.com/problems/reverse-linked-list-ii/

使用三个指针pre, start, cur，其中：

pre指向待交换区间的前一个数
start指向待交换区间的第一个数
cur指向当前被交换的数

区间内的交换与此前的reverse nodes in k-group 类似，这里的区间长度是right - left，因此交换要重复right - left次。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode reverseBetween(ListNode head, int left, int right) {
13
        if (head == null) {
14
            return head;
15
        }
16

17
        ListNode dummyHead = new ListNode(0);
18
        dummyHead.next = head;
19
        ListNode pre = dummyHead;
20

21
        // locate the interval [left, right]
22
        for (int i = 1; i <= left - 1; i++) {
23
            pre = pre.next;
24
        }
25
        ListNode start = pre.next;
26
        ListNode cur = start.next;
27

28
        // swap right - left times
29
        for (int i = 1; i <= right - left; i++) {
30
            start.next = cur.next;
31
            cur.next = pre.next;
32
            pre.next = cur;
33
            cur = start.next;
34
        }
35
        return dummyHead.next;
36
    }
37
}

展开收起

93. Restore IP Addresses#

https://leetcode.com/problems/restore-ip-addresses/

三层循环，i、j、k表示三个分界点'.'的位置。判断三部分是否都符合IP地址规则，如果都满足，就是一个合法的IP地址。

1
class Solution {
2
    public List<String> restoreIpAddresses(String s) {
3
        List<String> result = new ArrayList<>();
4
        if (s.length() < 4 || s.length() > 12) {
5
            return result;
6
        }
7
        int len = s.length();
8

9
        // i, j, k indicates three indices of '.'
10
        for (int i = 1; i < 4 && i < len-2; i++) {
11
            for (int j = i+1; j < i+4 && j < len-1; j++) {
12
                for (int k = j+1; k < j+4 && k < len; k++) {
13
                    String s1 = s.substring(0, i);
14
                    String s2 = s.substring(i, j);
15
                    String s3 = s.substring(j, k);
16
                    String s4 = s.substring(k, len);
17

18
                    if (isValid(s1) && isValid(s2) && isValid(s3) && isValid(s4)) {
19
                        result.add(s1 + "." + s2 + "." + s3 + "." + s4);
20
                    }
21
                }
22
            }
23
        }
24
        return result;
25
    }
26

27
    public boolean isValid(String s) {
28
        return !(s.length() > 3 || s.length() == 0 || (s.charAt(0) == '0' && s.length() > 1) || Integer.parseInt(s) > 255);
29
    }
30
}

展开收起

94. Binary Tree Inorder Traversal#

https://leetcode.com/problems/binary-tree-inorder-traversal/

第一种做法，如果当前节点不为空，或是栈中还有元素，就将当前节点左子加入栈中。之后，弹出栈顶元素，添加当前节点值到结果中，最后再访问右子节点。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> inorderTraversal(TreeNode root) {
18
        List<Integer> result = new ArrayList<>();
19

20
        Stack<TreeNode> st = new Stack<TreeNode>();
21
        TreeNode node = root;
22

23
        while (node != null || !st.isEmpty()) {
24
            // keep pushing left child into stack
25
            while (node != null) {
26
                st.add(node);
27
                node = node.left;
28
            }
29

30
            // left, cur, right
31
            node = st.pop();
32
            result.add(node.val);
33
            node = node.right;
34
        }
35

36
        return result;
37
    }
38
}

展开收起

第二种做法，直接使用递归：

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> inorderTraversal(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        inorder(result, root);
20
        return result;
21
    }
22

23
    private void inorder(List<Integer> result, TreeNode node) {
24
        if (node == null) {
25
            return;
26
        }
27

28
        inorder(result, node.left);
29
        result.add(node.val);
30
        inorder(result, node.right);
31
    }
32
}

展开收起

95. Unique Binary Search Trees II#

https://leetcode.com/problems/unique-binary-search-trees-ii/

递归解决，产生[1, n]范围内的树，需要遍历范围内的每一个树i，生成[1, i-1]和[i+1, n]的所有左右子树，再用两层循环把左右子树分别添加到当前i对应的节点上。

特殊情况下，如果范围内只有一个树（例如[1, 1]），那么直接添加节点本身即可。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<TreeNode> generateTrees(int n) {
18
        return n == 0 ? new ArrayList<TreeNode>() : generate(1, n);
19
    }
20

21
    public List<TreeNode> generate(int start, int end) {
22
        List<TreeNode> result = new ArrayList<TreeNode>();
23

24
        if (start >= end) {
25
            result.add(start > end ? null : new TreeNode(start));
26
            return result;
27
        }
28

29
        List<TreeNode> leftTreeList, rightTreeList;
30
        for (int i = start; i <= end; i++) {
31

32
            // divide and conquer, generate left and right subtrees based on indices
33
            leftTreeList = generate(start, i - 1);
34
            rightTreeList = generate(i + 1, end);
35

36
            for (TreeNode leftTree : leftTreeList) {
37
                for (TreeNode rightTree: rightTreeList) {
38
                    TreeNode root = new TreeNode(i);
39
                    root.left = leftTree;
40
                    root.right = rightTree;
41
                    result.add(root);
42
                }
43
            }
44
        }
45

46
        return result;
47
    }
48
}

展开收起

96. Unique Binary Search Trees#

https://leetcode.com/problems/unique-binary-search-trees/

使用动态规划。假如dp[n]表示输入为n时不同BST的数量，F(i, n)表示以数字i为根节点的不同BST的数量（1 <= i <= n)，显然有：

1
dp(n) = F(1, n) + F(2, n) + ... + F(n, n).

对于特殊情况，例如n == 0（空树）或n == 1（只有一个根节点），则dp[0] = 1，dp[1] = 1

基于BST的性质，当以数字i为节点时，左子树的节点值一定为[1, 2, ..., i-1]，右子树的节点值则为[i+1, i+2, ..., n]。因此，求F(i, n)的过程实际上是求左右子树不同BST的数量，即：

1
F(i, n) = dp(i-1) * dp(n-i), where 1 <= i <= n

合并以上两式得到：

1
dp(n) = dp(0) * dp(n-1) + dp(1) * dp(n-2) + … + dp(n-1) * dp(0)

由此使用动态规划进行递推即可。

1
class Solution {
2
    public int numTrees(int n) {
3
        int[] dp = new int[n+1];
4
        dp[0] = 1;
5
        dp[1] = 1;
6

7
        for (int i = 2; i <= n; i++) {
8
            for (int j = 0; j < i; j++) {
9
                dp[i] += dp[j] * dp[i - 1 - j];
10
            }
11
        }
12

13
        return dp[n];
14
    }
15
}

展开收起

97. Interleaving String#

https://leetcode.com/problems/interleaving-string/

使用二维动态规划。假设s1正位于第i位，s2正位于第j位，则dp[i][j]表示s3的第i+j-1位是否为插入点。第0位视为空字符串。考虑四种情况：

i, j均为0，即s1, s2均为空字符串，则s3也为空字符串，视为一个插入点
只有i为0时，s2第j-1位需要和s3第i+j-1位相等，且s2的前一位需要为插入点，满足这两个条件才是一个新插入点。
只有j为0时，s1第i-1位需要和s3第i+j-1位相等，且s1的前一位需要为插入点，满足这两个条件才是一个新插入点。
i，j都不为0，上述两种的两种情况任一满足即为新插入点。

1
class Solution {
2
    public boolean isInterleave(String s1, String s2, String s3) {
3
        if (s3.length() != s1.length() + s2.length()) {
4
            return false;
5
        }
6

7
        int len1 = s1.length(), len2 = s2.length();
8
        boolean[][] dp = new boolean[len1 + 1][len2 + 1];
9

10
        for (int i = 0; i <= len1; i++) {
11
            for (int j = 0; j <= len2; j++) {
12
                if (i == 0 && j == 0) {
13
                    dp[i][j] = true;
14
                } else if (i == 0) {
15
                    dp[i][j] = (dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1));
16
                } else if (j == 0) {
17
                    dp[i][j] = (dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1));
18
                } else {
19
                    dp[i][j] = ((dp[i-1][j] && s1.charAt(i-1) == s3.charAt(i+j-1)) ||
20
                                (dp[i][j-1] && s2.charAt(j-1) == s3.charAt(i+j-1)));
21
                }
22
            }
23
        }
24

25
        return dp[len1][len2];
26
    }
27
}

展开收起

98. Validate Binary Search Tree#

https://leetcode.com/problems/validate-binary-search-tree/

递归检查每个节点，左子的值必须比当前节点小，右子的值必须比当前节点大。注意当前节点如果为空节点也算作BST。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public boolean isValidBST(TreeNode root) {
18
        return isValid(root, Long.MIN_VALUE, Long.MAX_VALUE);
19
    }
20

21
    private boolean isValid(TreeNode node, long minVal, long maxVal) {
22
        if (node == null) {
23
            return true;
24
        }
25

26
        if (node.val >= maxVal || node.val <= minVal) {
27
            return false;
28
        }
29

30
        // left and right child should be valid
31
        return isValid(node.left, minVal, node.val) && isValid(node.right, node.val, maxVal);
32
    }
33
}

展开收起

99. Recover Binary Search Tree#

https://leetcode.com/problems/recover-binary-search-tree/

使用Morris遍历算法，时间复杂度为O(n), 空间复杂度为O(1)。

这个遍历方法的精髓在于对任意一个节点，找到其左子树中的最大值，然后把这个最大值和当前节点连在一起，这样就能形成一条近似从小到大排序的链，之后用双指针直接在链上找到两个乱序节点即可。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public void recoverTree(TreeNode root) {
18
        // two treenodes to be swapped
19
        TreeNode first = null, second = null;
20

21
        TreeNode pre = new TreeNode(Integer.MIN_VALUE);
22
        TreeNode cur = root;
23

24
        while (cur != null) {
25
            TreeNode node = cur.left;
26

27
            if (node != null) {
28
                // find the rightmost node of the left subtree
29
                while (node.right != null && node.right != cur) {
30
                    node = node.right;
31
                }
32

33
                // if unvisited, link it to current node and continue visit current left subtree
34
                if (node.right == null) {
35
                    node.right = cur;
36
                    cur = cur.left;
37
                    continue;
38
                } else {
39
                    // else unlink
40
                    node.right = null;
41
                }
42
            }
43

44
            // compare current node with former node, find two unordered nodes
45
            if (cur.val < pre.val) {
46
                if (first == null) {
47
                    first = pre;
48
                }
49
                second = cur;
50
            }
51

52
            // move forward two pointers
53
            pre = cur;
54
            cur = cur.right;
55
        }
56

57
        // swap value
58
        int temp = second.val;
59
        second.val = first.val;
60
        first.val = temp;
61
    }
62
}

展开收起

100. Same Tree#

https://leetcode.com/problems/same-tree/

如果两个节点一个为空，一个不空，或是两个节点的值不一样，则两个树不相同。此外，两个节点的左子和右子也应分别相同。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public boolean isSameTree(TreeNode p, TreeNode q) {
18
        if (p == null && q == null) {
19
            return true;
20
        }
21

22
        if ((p == null && q != null) || (p != null && q == null) || p.val != q.val) {
23
            return false;
24
        }
25

26
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
27
    }
28
}

展开收起

LeetCode 101-200

Wed, 01 Jan 2020 00:00:00 GMT

LeetCode Problems 101-200.

101. Symmetric Tree#

https://leetcode.com/problems/symmetric-tree/

一棵树对称有两种情况：

当前节点为空
左右子树对称

因此我们可以构造一个辅助比较函数判断左右子树是否对称。如果一边为空节点，另一边也必须为空节点；另外对称节点的值应当相等，并且左子的儿子还要和右子的儿子对称相等（无论是否为空节点）。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public boolean isSymmetric(TreeNode root) {
18
        return root == null || helper(root.left, root.right);
19
    }
20

21
    public boolean helper(TreeNode left, TreeNode right) {
22
        // if one side is null, the other side must be null either
23
        if (left == null || right == null) {
24
            return left == right;
25
        }
26

27
        // nodes at two sides should have same value
28
        if (left.val != right.val) {
29
            return false;
30
        }
31

32
        // children's children should be same
33
        return helper(left.left, right.right) && helper(left.right, right.left);
34
    }
35
}

展开收起

102. Binary Tree Level Order Traversal#

https://leetcode.com/problems/binary-tree-level-order-traversal/

第一种方法，使用DFS，遍历至当前节点时，直接将其添加到这个节点所在的层数数组中。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<List<Integer>> levelOrder(TreeNode root) {
18
        List<List<Integer>> result = new LinkedList<>();
19
        helper(root, result, 0);
20
        return result;
21
    }
22

23
    private void helper(TreeNode curNode, List<List<Integer>> result, int level) {
24
        if (curNode == null) {
25
            return;
26
        }
27

28
        // add new level
29
        if (result.size() <= level) {
30
            result.add(new LinkedList<Integer>());
31
        }
32

33
        result.get(level).add(curNode.val);
34
        helper(curNode.left, result, level + 1);
35
        helper(curNode.right, result, level + 1);
36
    }
37
}

展开收起

第二种方法，使用队列进行层次遍历。每一层循环时，队列中的元素都是当前层的元素。遍历队列中每个元素，只要其左子右子不空，就加入队列，再将当前队首元素弹出。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<List<Integer>> levelOrder(TreeNode root) {
18
        List<List<Integer>> result = new LinkedList<>();
19
        if (root == null) {
20
            return result;
21
        }
22

23
        Queue<TreeNode> q = new ArrayDeque<>();
24
        q.offer(root);
25
        while (!q.isEmpty()) {
26
            int size = q.size();
27
            List<Integer> tempList = new LinkedList<Integer>();
28
            for (int i = 0; i < size; i++) {
29
                if (q.peek().left != null) {
30
                    q.offer(q.peek().left);
31
                }
32
                if (q.peek().right != null) {
33
                    q.offer(q.peek().right);
34
                }
35
                tempList.add(q.poll().val);
36
            }
37

38
            result.add(tempList);
39
        }
40
        return result;
41
    }
42
}

展开收起

103. Binary Tree Zigzag Level Order Traversal#

https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/

在上一题的DFS基础上略加修改，根据当前层数的奇偶性，决定按顺序添加还是倒序添加即可。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
18
        List<List<Integer>> result = new LinkedList<>();
19
        helper(root, result, 0);
20
        return result;
21
    }
22

23
    public void helper(TreeNode curNode, List<List<Integer>> result, int level) {
24
        if (curNode == null) {
25
            return;
26
        }
27

28
        // add new level
29
        if (result.size() <= level) {
30
            result.add(new LinkedList<Integer>());
31
        }
32

33
        // decide insert position by odd / even level
34
        if (level % 2 == 0) {
35
            result.get(level).add(curNode.val);
36
        } else {
37
            result.get(level).add(0, curNode.val);
38
        }
39

40
        helper(curNode.left, result, level + 1);
41
        helper(curNode.right, result, level + 1);
42
    }
43
}

展开收起

104. Maximum Depth of Binary Tree#

https://leetcode.com/problems/maximum-depth-of-binary-tree/

使用DFS，分别比较左子树和右子树的深度，取最大值+1（加上自身的深度），累积至根节点得到结果。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int maxDepth(TreeNode root) {
18
        return height(root);
19
    }
20

21
    private int height(TreeNode node) {
22
        if (node == null) {
23
            return 0;
24
        }
25

26
        // height of left subtree and right subtree
27
        int left = height(node.left), right = height(node.right);
28
        return Math.max(left, right) + 1;
29
    }
30
}

展开收起

105. Construct Binary Tree from Preorder and Inorder Traversal#

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

在只有前序遍历的情况下，我们只能模糊地知道我们会先遍历到根节点，但之后遍历左右子树时，我们不知道什么时候结束遍历左子树，开始遍历右子树。所以我们需要中序遍历进行辅助，因为中序遍历会先于遍历根节点之前遍历完左子树。我们只需要拿preorder遇到的根节点到inorder中搜索，就能知道左、右子树分别是哪些元素。

使用一个变量rootIdx跟踪前序遍历数组，在inorder中到当前根节点preorder[rootIdx]。inorder左侧的点全部在根节点左子树上，右侧的点都在根节点右子树上。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private int rootIdx = 0; // index of current root node in preorder
18

19
    public TreeNode buildTree(int[] preorder, int[] inorder) {
20
        if (preorder.length != inorder.length || inorder.length == 0) {
21
            return null;
22
        }
23

24
        return builder(preorder, inorder, 0, inorder.length - 1);
25
    }
26

27
    private TreeNode builder(int[] preorder, int[] inorder, int start, int end) {
28
        if (start > end) {
29
            return null;
30
        }
31

32
        TreeNode node = new TreeNode(preorder[rootIdx]);
33
        rootIdx++;
34

35
        if (start == end) {
36
            return node;
37
        }
38

39
        // find current element in inorder array
40
        // this element will be the split point
41
        int index = 0;
42
        for (int i = end; i >= start; i--) {
43
            if (inorder[i] == node.val) {
44
                index = i;
45
                break;
46
            }
47
        }
48

49
        node.left = builder(preorder, inorder, start, index - 1);
50
        node.right = builder(preorder, inorder, index + 1, end);
51
        return node;
52
    }
53
}

展开收起

106. Construct Binary Tree from Inorder and Postorder Traversal#

https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

与上一题思路类似，需要注意的是先构造右子树，再构造左子树。这是因为后序遍历先遍历右子树再遍历左子树，和前序遍历相反。另外根据对称性，从postorder中提取根节点时也应该从后往前遍历。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private int rootIdx = 0;  // index of current root node in postorder
18

19
    public TreeNode buildTree(int[] inorder, int[] postorder) {
20
        if (inorder.length != postorder.length || inorder.length == 0) {
21
            return null;
22
        }
23

24
        // initialization, searched from the end of postorder
25
        rootIdx = postorder.length - 1;
26

27
        return builder(postorder, inorder, 0, postorder.length - 1);
28
    }
29

30
    private TreeNode builder(int[] postorder, int[] inorder, int start, int end) {
31
        if (start > end) {
32
            return null;
33
        }
34

35
        TreeNode node = new TreeNode(postorder[rootIdx]);
36
        rootIdx--;
37

38
        if (start == end) {
39
            return node;
40
        }
41

42
        // find current element in inorder array
43
        // this element will be the split point
44
        int index = 0;
45
        for (int i = end; i >= start; i--) {
46
            if (inorder[i] == node.val) {
47
                index = i;
48
                break;
49
            }
50
        }
51

52
        node.right = builder(postorder, inorder, index + 1, end);
53
        node.left = builder(postorder, inorder, start, index - 1);
54
        return node;
55
    }
56
}

展开收起

107. Binary Tree Level Order Traversal II#

https://leetcode.com/problems/binary-tree-level-order-traversal-ii/

仍然使用DFS，但补齐至当前层数时，需要倒序添加层数（第一层为最后，第二层为倒数第二，…），获取层数的结果时应以总数和当前层数之差作为索引。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
18
        List<List<Integer>> result = new LinkedList<>();
19
        helper(root, result, 0);
20
        return result;
21
    }
22

23
    private void helper(TreeNode curNode, List<List<Integer>> result, int level) {
24
        if (curNode == null) {
25
            return;
26
        }
27

28
        // add new level
29
        if (result.size() <= level) {
30
            result.add(0, new LinkedList<Integer>());
31
        }
32

33
        result.get(result.size() - 1 - level).add(curNode.val);
34
        helper(curNode.left, result, level + 1);
35
        helper(curNode.right, result, level + 1);
36
    }
37
}

展开收起

108. Convert Sorted Array to Binary Search Tree#

https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/

结合二分查找思想，总是将当前中位数作为根节点，比其小的数位于左子树，比其大的数位于右子树。当子数组区间下标重叠，返回空节点。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public TreeNode sortedArrayToBST(int[] nums) {
18
        if (nums.length == 0) {
19
            return null;
20
        }
21
        TreeNode result = helper(nums, 0, nums.length - 1);
22
        return result;
23
    }
24

25
    private TreeNode helper(int[] nums, int low, int high) {
26
        if (low > high) {
27
            return null;
28
        }
29

30
        // find median of the array, set as root node
31
        int mid = low + (high - low) / 2;
32
        TreeNode node = new TreeNode(nums[mid]);
33
        node.left = helper(nums, low, mid - 1);
34
        node.right = helper(nums, mid + 1, high);
35

36
        return node;
37
    }
38
}

展开收起

109. Convert Sorted List to Binary Search Tree#

https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/

使用快慢指针获取到子链表的中间节点，其余仍然使用二分法。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
/**
12
 * Definition for a binary tree node.
13
 * public class TreeNode {
14
 *     int val;
15
 *     TreeNode left;
16
 *     TreeNode right;
17
 *     TreeNode() {}
18
 *     TreeNode(int val) { this.val = val; }
19
 *     TreeNode(int val, TreeNode left, TreeNode right) {
20
 *         this.val = val;
21
 *         this.left = left;
22
 *         this.right = right;
23
 *     }
24
 * }
25
 */
26
class Solution {
27
    public TreeNode sortedListToBST(ListNode head) {
28
        if (head == null) {
29
            return null;
30
        }
31
        return helper(head, null);
32
    }
33

34
    private TreeNode helper(ListNode head, ListNode tail) {
35
        if (head == tail) {
36
            return null;
37
        }
38

39
        // find the median node, set it as root
40
        ListNode slow = head, fast = head;
41
        while (fast != tail && fast.next != tail) {
42
            slow = slow.next;
43
            fast = fast.next.next;
44
        }
45

46
        TreeNode mid = new TreeNode(slow.val);
47
        mid.left = helper(head, slow);
48
        mid.right = helper(slow.next, tail);
49
        return mid;
50
    }
51
}

展开收起

110. Balanced Binary Tree#

https://leetcode.com/problems/balanced-binary-tree/

此题实际是一个计算树高度的过程，如果树的高度不是-1（不平衡的情况），说明树是平衡的。讨论特殊情况如下：

遇到空节点，返回0
左子树或右子树的高度为-1，说明子树已经不平衡，那么以当前节点为根的树高度也为-1
左、右子树高度差值大于1，则当前节点高度为-1

最后取左、右子树的高度最大值，并+1（节点自身），得到以当前节点为根的树的高度。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public boolean isBalanced(TreeNode root) {
18
        return helper(root) != -1;
19
    }
20

21
    private int helper(TreeNode node) {
22
        if (node == null) {
23
            return 0;
24
        }
25

26
        int leftHeight = helper(node.left);
27
        if (leftHeight == -1) {
28
            return -1;
29
        }
30

31
        int rightHeight = helper(node.right);
32
        if (rightHeight == -1) {
33
            return -1;
34
        }
35

36
        if (Math.abs(leftHeight - rightHeight) > 1) {
37
            return -1;
38
        }
39

40
        return Math.max(leftHeight, rightHeight) + 1;
41
    }
42
}

展开收起

111. Minimum Depth of Binary Tree#

https://leetcode.com/problems/minimum-depth-of-binary-tree/

第一种方法，使用递归，与寻找最大深度的解法类似。注意当某一子树为空时，树的高度实际上就是另一个子树的高度。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int minDepth(TreeNode root) {
18
        if (root == null) {
19
            return 0;
20
        }
21

22
        int leftHeight = minDepth(root.left);
23
        int rightHeight = minDepth(root.right);
24
        return leftHeight == 0 || rightHeight == 0 ? leftHeight + rightHeight + 1
25
                                                   : Math.min(leftHeight, rightHeight) + 1;
26
    }
27
}

展开收起

第二种方法，借用树的层次遍历思想，检查是否有某个节点不存在儿子。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int minDepth(TreeNode root) {
18
        if (root == null) {
19
            return 0;
20
        }
21

22
        Queue<TreeNode> q = new ArrayDeque<>();
23
        q.offer(root);
24
        int depth = 0;
25

26
        while (!q.isEmpty()) {
27
            int size = q.size();
28
            depth++;
29

30
            for (int i = 0; i < size; i++) {
31
                TreeNode node = q.poll();
32

33
                // no children, so one subtree will end here
34
                if (node.left == null && node.right == null) {
35
                    return depth;
36
                }
37

38
                if (node.left != null) {
39
                    q.offer(node.left);
40
                }
41
                if (node.right != null) {
42
                    q.offer(node.right);
43
                }
44
            }
45
        }
46

47
        return depth;
48
    }
49
}

展开收起

112. Path Sum#

https://leetcode.com/problems/path-sum/

每向下一层递归时就更新targetSum的值，遇到叶子节点的值与当前sum相同则返回true。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public boolean hasPathSum(TreeNode root, int targetSum) {
18
        if (root == null) {
19
            return false;
20
        }
21

22
        if (root.left == null && root.right == null && root.val == targetSum) {
23
            return true;
24
        }
25

26
        return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
27
    }
28
}

展开收起

113. Path Sum II#

https://leetcode.com/problems/path-sum-ii/

回溯算法，无论当前递归内是否找到一条path，都需要在完成遍历后从临时数组中弹出最后一个数，这样才能尝试其他path。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
18
        List<List<Integer>> result = new LinkedList<>();
19
        helper(result, new LinkedList<>(), root, sum);
20
        return result;
21
    }
22

23
    private void helper(List<List<Integer>> result, List<Integer> temp, TreeNode node, int sum) {
24
        if (node == null) {
25
            return;
26
        }
27

28
        temp.add(node.val);
29

30

31
        if (node.left == null && node.right == null && node.val == sum) {
32
            // find a path, remove the last node and return
33
            result.add(new LinkedList<>(temp));
34
            temp.remove(temp.size() - 1);
35
            return;
36
        } else {
37
            // else continue traveling down
38
            helper(result, temp, node.left, sum - node.val);
39
            helper(result, temp, node.right, sum - node.val);
40
        }
41

42
        // no path found, remove the last node
43
        temp.remove(temp.size() - 1);
44
    }
45
}

展开收起

114. Flatten Binary Tree to Linked List#

https://leetcode.com/problems/flatten-binary-tree-to-linked-list/

解题思路如下：

寻找到当前节点右子树中最右的节点，如果为空则寻找其兄弟左节点
更新当前节点的右子为prev，这样能之前flatten的子树接到当前节点上；左子为空
prev更新为当前节点，因为当前节点是最后一个被flatten的根节点

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private TreeNode prev = null; // previous flattened node
18

19
    public void flatten(TreeNode root) {
20
        if (root == null) {
21
            return;
22
        }
23

24
        flatten(root.right);
25
        flatten(root.left);
26

27
        root.right = prev;
28
        root.left = null;
29

30
        prev = root;
31
    }
32
}

展开收起

115. Distinct Subsequences#

https://leetcode.com/problems/distinct-subsequences/

使用动态规划，dp[i][j]表示s的前j个字符中，包含t的前i个字符的次数。考虑两种情况：

s的第j个字符与t的第i个字符不同，则dp[i+1][j+1]与dp[i+1][j]相同，因为s多出的这个字母不影响次数
s的第j个字符与t的第i个字符相同，则dp[i+1][j+1]不仅包括dp[i+1][j]，还包括dp[i][j]，因为要加上同时去掉了这对相同字母后，剩下的匹配次数。

1
class Solution {
2
    public int numDistinct(String s, String t) {
3
        int slen = s.length(), tlen = t.length();
4

5
        int[][] dp = new int[tlen+1][slen+1];
6

7
        // initialization, substring of s can always contain exactly 1 empty string
8
        for (int j = 0; j < slen; j++) {
9
            dp[0][j] = 1;
10
        }
11

12
        for (int i = 0; i < tlen; i++) {
13
            for (int j = i; j < slen; j++)  {
14
                dp[i+1][j+1] = (t.charAt(i) == s.charAt(j)) ? dp[i+1][j] + dp[i][j] : dp[i+1][j];
15
            }
16
        }
17

18
        return dp[tlen][slen];
19
    }
20
}

展开收起

116. Populating Next Right Pointers in Each Node#

https://leetcode.com/problems/populating-next-right-pointers-in-each-node/

使用两个指针level和cur遍历整个树，其中level遍历逐层，cur遍历一层中的节点。对于每一个节点，完成两步修改：

将cur的左儿子指向cur的右儿子
如果cur本身和另一个兄弟相连，那么cur的右儿子和cur的兄弟的左儿子就是邻居关系，二者需要连起来

1
/*
2
// Definition for a Node.
3
class Node {
4
    public int val;
5
    public Node left;
6
    public Node right;
7
    public Node next;
8

9
    public Node() {}
10

11
    public Node(int _val) {
12
        val = _val;
13
    }
14

15
    public Node(int _val, Node _left, Node _right, Node _next) {
16
        val = _val;
17
        left = _left;
18
        right = _right;
19
        next = _next;
20
    }
21
};
22
*/
23

24
class Solution {
25
    public Node connect(Node root) {
26
        if (root == null) {
27
            return null;
28
        }
29

30
        Node level = root; // track each level
31
        Node cur = null; // track each node in one level
32

33
        while (level.left != null) {
34
            cur = level;
35

36
            while (cur != null) {
37
                // left child points to right child
38
                cur.left.next = cur.right;
39

40
                // if there is a right neighbor, right child points to right neighbor's left child
41
                if (cur.next != null) {
42
                    cur.right.next = cur.next.left;
43
                }
44

45
                //
46
                cur = cur.next;
47
            }
48

49
            // move to next level
50
            level = level.left;
51
        }
52

53
        return root;
54
    }
55
}

展开收起

117. Populating Next Right Pointers in Each Node II#

https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/

模拟层次遍历，cur指针指向当前层，curChild指向下一层。判断是否存在左子或右子，以此移动指针。

1
/*
2
// Definition for a Node.
3
class Node {
4
    public int val;
5
    public Node left;
6
    public Node right;
7
    public Node next;
8

9
    public Node() {}
10

11
    public Node(int _val) {
12
        val = _val;
13
    }
14

15
    public Node(int _val, Node _left, Node _right, Node _next) {
16
        val = _val;
17
        left = _left;
18
        right = _right;
19
        next = _next;
20
    }
21
};
22
*/
23

24
class Solution {
25
    public Node connect(Node root) {
26
        Node cur = root;
27

28
        while (cur != null) {
29
            Node head = new Node(0); // dummy head of next level
30
            Node curChild = head; // child in the next level
31

32
            while (cur != null) {
33
                if (cur.left != null) {
34
                    curChild.next = cur.left;
35
                    curChild = curChild.next;
36
                }
37

38
                if (cur.right != null) {
39
                    curChild.next = cur.right;
40
                    curChild = curChild.next;
41
                }
42

43
                // move to cur's sibling
44
                cur = cur.next;
45
            }
46

47
            // move to next level
48
            cur = head.next;
49
        }
50

51
        return root;
52
    }
53
}

展开收起

118. Pascal’s Triangle#

https://leetcode.com/problems/pascals-triangle/

遍历每一行的开始时，都在行首添加一个1，之后从第二个元素至倒数第二个元素，与下一个相邻元素进行累加即可。

1
class Solution {
2
    public List<List<Integer>> generate(int numRows) {
3
        List<List<Integer>> result = new ArrayList<>();
4
        if (numRows <= 0) {
5
            return result;
6
        }
7
        List<Integer> row = new ArrayList<>();
8

9
        for (int i = 0; i < numRows; i++) {
10
            // add '1' at head of each row
11
            row.add(0, 1);
12

13
            for (int j = 1; j < row.size() - 1; j++) {
14
                row.set(j, row.get(j) + row.get(j+1));
15
            }
16

17
            result.add(new ArrayList<>(row));
18
        }
19

20
        return result;
21
    }
22
}

展开收起

119. Pascal’s Triangle II#

https://leetcode.com/problems/pascals-triangle-ii/

在上一题代码的基础上略作修改，只将最后一行作为结果输出即可。

1
class Solution {
2
    public List<Integer> getRow(int rowIndex) {
3
        List<Integer> row = new ArrayList<>();
4
        row.add(1);
5

6
        for (int i = 0; i < rowIndex; i++) {
7
            // add '1' at head of each row
8
            row.add(0, 1);
9

10
            for (int j = 1; j < row.size() - 1; j++) {
11
                row.set(j, row.get(j) + row.get(j+1));
12
            }
13
        }
14

15
        return row;
16
    }
17
}

展开收起

120. Triangle#

https://leetcode.com/problems/triangle/

使用一维动态规划，自底向上迭代更新dp，选取相邻元素的最小值，再加上当前遍历的元素。

1
class Solution {
2
    public int minimumTotal(List<List<Integer>> triangle) {
3
        int[] dp = new int[triangle.size() + 1];
4

5
        // bottom-up
6
        for (int i = triangle.size() - 1; i >= 0; i--) {
7
            for (int j = 0; j <= i; j++) {
8
                dp[j] = Math.min(dp[j], dp[j+1]) + triangle.get(i).get(j);
9
            }
10
        }
11

12
        return dp[0];
13
    }
14
}

121. Best Time to Buy and Sell Stock#

https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

算出每天价格之间的差值，获利最大的时刻其实就是差值之和最大的时刻。

1
class Solution {
2
    public int maxProfit(int[] prices) {
3
        if (prices == null || prices.length <= 1) {
4
            return 0;
5
        }
6
        int maxDiff = 0, result = 0;
7

8
        for (int i = 1; i < prices.length; i++) {
9
            // difference between today and yesterday's prices
10
            maxDiff += (prices[i] - prices[i-1]);
11

12
            // find the max price difference
13
            maxDiff = Math.max(0, maxDiff);
14
            result = Math.max(maxDiff, result);
15
        }
16

17
        return result;
18
    }
19
}

展开收起

122. Best Time to Buy and Sell Stock II#

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/

贪心思想，只要有一天能赚钱，都用一次买卖赚走，累积利润即可得到结果。

1
class Solution {
2
    public int maxProfit(int[] prices) {
3
        if (prices == null || prices.length <= 1) {
4
            return 0;
5
        }
6
        int result = 0;
7

8
        for (int i = 1; i < prices.length; i++) {
9
            result += Math.max(0, prices[i] - prices[i-1]);
10
        }
11

12
        return result;
13
    }
14
}

123. Best Time to Buy and Sell Stock III#

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/

使用两组变量cost和profit，分别表示两次买入的最小成本和两次卖出的最大利润。

需要注意，第二次买入的最小成本，建立在第一次卖出的最大利润之上（相当于拿已有的利润，再买入当前股票，两个数值合成为总成本）。

1
class Solution {
2
    public int maxProfit(int[] prices) {
3
        if (prices == null || prices.length <= 1) {
4
            return 0;
5
        }
6

7
        int cost1 = Integer.MAX_VALUE, cost2 = Integer.MAX_VALUE;
8
        int profit1 = 0, profit2 = 0;
9

10
        for (int i = 0; i < prices.length; i++) {
11
            cost1 = Math.min(cost1, prices[i]);
12
            profit1 = Math.max(profit1, prices[i] - cost1);
13

14
            // cost2 will be based on profit1
15
            cost2 = Math.min(cost2, prices[i] - profit1);
16
            profit2 = Math.max(profit2, prices[i] - cost2);
17
        }
18

19
        return profit2;
20
    }
21
}

展开收起

124. Binary Tree Maximum Path Sum#

https://leetcode.com/problems/binary-tree-maximum-path-sum/

对每一个节点，计算其左子树和右子树上的最大和，返回较大一侧的值与自身节点值之和。注意，Path Sum可包括两个分支，因此对于最大值的更新，要包括当前节点和左右子节点。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private int result = Integer.MIN_VALUE;
18

19
    public int maxPathSum(TreeNode root) {
20
        helper(root);
21
        return result;
22
    }
23

24
    private int helper(TreeNode node) {
25
        if (node == null) {
26
            return 0;
27
        }
28
        int leftSum = Math.max(0, helper(node.left));
29
        int rightSum = Math.max(0, helper(node.right));
30

31
        // update current path sum
32
        result = Math.max(result, leftSum + rightSum + node.val);
33

34
        // max subtree sum + current node's value
35
        return Math.max(leftSum, rightSum) + node.val;
36
    }
37
}

展开收起

125. Valid Palindrome#

https://leetcode.com/problems/valid-palindrome/

使用Character类的API，或者正则表达式解决。

1
class Solution {
2
    public boolean isPalindrome(String s) {
3
        if (s.length() == 0 || s.length() == 1) {
4
            return true;
5
        }
6

7
        // String modified = s.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
8

9
        int head = 0, tail = s.length() - 1;
10

11
        while (head <= tail) {
12
            if (Character.isLetter(s.charAt(head)) || Character.isDigit(s.charAt(head))) {
13
                if (Character.isLetter(s.charAt(tail)) || Character.isDigit(s.charAt(tail))) {
14
                    if (Character.toLowerCase(s.charAt(head)) != Character.toLowerCase(s.charAt(tail))) {
15
                        return false;
16
                    }
17

18
                    head++;
19
                    tail--;
20
                } else {
21
                    tail--;
22
                }
23
            } else {
24
                head++;
25
            }
26
        }
27

28
        return true;
29
    }
30
}

展开收起

126. Word Ladder II#

https://leetcode.com/problems/word-ladder-ii/

先用用BFS，替换begin中每个单词的每一个字母，汇总得到每个单词能够转化得到的单词列表，存在map中。再使用DFS，依据单词列表的演化，将结果录入。

1
class Solution {
2
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
3
        List<List<String>> result = new ArrayList<>();
4

5
        Set<String> dicts = new HashSet<>(wordList);
6
        if (!dicts.contains(endWord)) {
7
            return result;
8
        }
9

10
        Set<String> begin = new HashSet<>(), end = new HashSet<>();
11
        Map<String, List<String>> map = new HashMap<>();
12
        begin.add(beginWord);
13
        end.add(endWord);
14

15
        bfs(map, begin, end, dicts, false);
16

17
        List<String> tempList = new ArrayList<>();
18
        tempList.add(beginWord);
19
        dfs(map, result, tempList, beginWord, endWord);
20

21
        return result;
22
    }
23

24
    private void bfs(Map<String, List<String>> map, Set<String> begin, Set<String> end, Set<String> dicts, boolean reverse) {
25
        if (begin.size() == 0) {
26
            return;
27
        }
28
        dicts.removeAll(begin);
29

30
        // beginning set in next search
31
        Set<String> newBegin = new HashSet<>();
32

33
        boolean finish = false;
34

35
        for (String str : begin) {
36
            char[] chars = str.toCharArray();
37

38
            for (int i = 0; i < chars.length; i++) {
39
                // backup old alphabet
40
                char old = chars[i];
41

42
                // replace an alphabet with another
43
                for (char c = 'a'; c <= 'z'; c++) {
44
                    if (old == c) {
45
                        continue;
46
                    }
47
                    chars[i] = c;
48

49
                    String candidate = String.valueOf(chars);
50

51
                    // new word must be in wordList
52
                    if (!dicts.contains(candidate)) {
53
                        continue;
54
                    }
55

56
                    // new word is in end list
57
                    if (end.contains(candidate)) {
58
                        finish = true;
59
                    } else {
60
                        newBegin.add(candidate);
61
                    }
62

63
                    // str -> candidate's list
64
                    String key = reverse ? candidate : str;
65
                    String value = reverse ? str : candidate;
66
                    if (!map.containsKey(key)) {
67
                        map.put(key, new ArrayList<>());
68
                    }
69
                    map.get(key).add(value);
70
                }
71

72
                // restore old word
73
                chars[i] = old;
74
            }
75
        }
76

77
        // optional, swap newBegin and end to speed up
78
        if (!finish) {
79
            if (newBegin.size() > end.size()) {
80
                bfs(map, end, newBegin, dicts, !reverse);
81
            } else {
82
                bfs(map, newBegin, end, dicts, reverse);
83
            }
84
        }
85
    }
86

87
    private void dfs(Map<String, List<String>> map, List<List<String>> result, List<String> tempList, String beginWord, String endWord) {
88
        if (beginWord.equals(endWord)) {
89
            result.add(new ArrayList<>(tempList));
90
            return;
91
        }
92

93
        // current beginWord cannot transform to another work
94
        if (!map.containsKey(beginWord)) {
95
            return;
96
        }
97

98
        for (String word : map.get(beginWord)) {
99
            tempList.add(word);
100
            dfs(map, result, tempList, word, endWord);
101
            tempList.remove(tempList.size() - 1);
102
        }
103
    }
104
}

展开收起

127. Word Ladder#

https://leetcode.com/problems/word-ladder/

由于这一题不需要不需要输出结果的具体值，因此没必要使用DFS跟踪变换过程，直接使用BFS获取结果长度即可。此外也不需要使用map，直接使用一个set统计已经访问过的单词即可。

1
class Solution {
2
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
3
        Set<String> dict = new HashSet<>(wordList);
4

5
        // wordList does not contain endWord
6
        if (!dict.contains(endWord)) {
7
            return 0;
8
        }
9

10
        Set<String> begin = new HashSet<>(), end = new HashSet<>(), visited = new HashSet<>();
11
        begin.add(beginWord);
12
        end.add(endWord);
13
        visited.add(beginWord);
14
        visited.add(endWord);
15

16
        int result = 1;
17

18
        while (!begin.isEmpty() && !end.isEmpty()) {
19
            // beginning set in next search
20
            Set<String> newBegin = new HashSet<>();
21

22
            for (String str : begin) {
23
                char[] chars = str.toCharArray();
24

25
                // replace an alphabet with another
26
                for (int i = 0; i < chars.length; i++) {
27
                    // backup old alphabet
28
                    char old = chars[i];
29

30
                    for (char c = 'a'; c <= 'z'; c++) {
31
                        if (c == old) {
32
                            continue;
33
                        }
34
                        chars[i] = c;
35

36
                        String candidate = String.valueOf(chars);
37

38
                        // new word must be in word list
39
                        if (!dict.contains(candidate)) {
40
                            continue;
41
                        }
42

43
                        // current transformation reaches the target
44
                        if (end.contains(candidate)) {
45
                            result++;
46
                            return result;
47
                        }
48

49
                        // skip visited word
50
                        if (visited.contains(candidate)) {
51
                            continue;
52
                        }
53

54
                        visited.add(candidate);
55
                        newBegin.add(candidate);
56
                    }
57

58
                    // restore old word
59
                    chars[i] = old;
60
                }
61
            }
62

63
            // one transformation
64
            result++;
65

66
            // optional, swap newBegin and end to speed up
67
            if (newBegin.size() > end.size()) {
68
                Set<String> temp = newBegin;
69
                newBegin = end;
70
                end = temp;
71
            }
72

73
            begin = newBegin;
74
        }
75

76
        return 0;
77
    }
78
}

展开收起

128. Longest Consecutive Sequence#

https://leetcode.com/problems/longest-consecutive-sequence/

第一种做法，利用Set的迭代器，移除当前元素的相邻元素，统计能移除的最大个数。

1
class Solution {
2
    public int longestConsecutive(int[] nums) {
3
        if (nums.length == 0) {
4
            return 0;
5
        }
6

7
        Set<Integer> set = new HashSet<>();
8
        for (int num : nums) {
9
            set.add(num);
10
        }
11

12
        int result = 0;
13
        while (!set.isEmpty()) {
14
            int base = set.iterator().next();
15
            set.remove(base);
16

17
            // start from base, remove adjacent elements
18
            int left = base, right = base;
19
            while (set.remove(--left));
20
            while (set.remove(++right));
21

22
            result = Math.max(result, right - left - 1);
23
        }
24

25
        return result;
26
    }
27
}

展开收起

第二种做法，利用HashMap模拟Set，提取所有key，判断有多少个连续的key在map中。

1
class Solution {
2
    public int longestConsecutive(int[] nums) {
3
        HashMap<Integer, Boolean> map = new HashMap<>();
4
        for (int i = 0; i < nums.length; i++) {
5
            map.put(nums[i], true);
6
        }
7

8
        int result = 0;
9
        for (Integer key: map.keySet()) {
10
            // avoid repeat counting
11
            if (!map.containsKey(key - 1)) {
12
                int length = 1;
13

14
                while (map.containsKey(key + length)) {
15
                    length++;
16
                }
17

18
                result = Math.max(result, length);
19
            }
20
        }
21

22
        return result;
23
    }
24
}

展开收起

129. Sum Root to Leaf Numbers#

https://leetcode.com/problems/sum-root-to-leaf-numbers/

自顶向下，每达到一个节点，sum乘10再加上当前节点的值。如果当前节点有儿子，继续向下递归计算子树中的值。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int sumNumbers(TreeNode root) {
18
        return helper(root, 0);
19
    }
20

21
    private int helper(TreeNode node, int sum) {
22
        if (node == null) {
23
            return 0;
24
        }
25

26
        int updatedVal = sum * 10 + node.val;
27

28
        if (node.left == null && node.right == null) {
29
            return updatedVal;
30
        }
31

32
        return helper(node.left, updatedVal) + helper(node.right, updatedVal);
33
    }
34
}

展开收起

130. Surrounded Regions#

https://leetcode.com/problems/surrounded-regions/

使用DFS：

从矩阵边缘开始检查，如果某个元素为'O'，将这个元素以及邻近的'O'都改为'E'。这些格子没有完全被'X'包围，因此需要排除
将图上剩余所有的'O'改为'X'，再将所有的'E'改为'O'

1
class Solution {
2
    public void solve(char[][] board) {
3
        if (board == null || board.length == 0) {
4
            return;
5
        }
6
        int row = board.length, col = board[0].length;
7

8
        // exclude 'O' om first and last columns
9
        for (int i = 0; i < row; i++) {
10
            if (board[i][0] == 'O') {
11
                dfs(board, i, 0);
12
            }
13
            if (board[i][col - 1] == 'O') {
14
                dfs(board, i, col - 1);
15
            }
16
        }
17

18
        // exclude 'O' in first and last rows
19
        for (int j = 0; j < col; j++) {
20
            if (board[0][j] == 'O') {
21
                dfs(board, 0, j);
22
            }
23
            if (board[row - 1][j] == 'O') {
24
                dfs(board, row - 1, j);
25
            }
26
        }
27

28
        for (int i = 0; i < row; i++) {
29
            for (int j = 0; j < col; j++) {
30
                if (board[i][j] == 'O') {
31
                    board[i][j] = 'X';
32
                }
33

34
                // restore excluded grids
35
                if (board[i][j] == 'E') {
36
                    board[i][j] = 'O';
37
                }
38
            }
39
        }
40
    }
41

42
    private void dfs(char[][] board, int x, int y) {
43
        if (x < 0 || x > board.length - 1 || y < 0 || y > board[0].length - 1 || board[x][y] == 'E' || board[x][y] == 'X') {
44
            return;
45
        }
46

47
        // exclude this grid since it is not surrounded by 'X' 4-directionally
48
        board[x][y] = 'E';
49

50
        dfs(board, x + 1, y);
51
        dfs(board, x - 1, y);
52
        dfs(board, x, y + 1);
53
        dfs(board, x, y - 1);
54
    }
55
}

展开收起

131. Palindrome Partitioning#

https://leetcode.com/problems/palindrome-partitioning/

使用回溯算法，从当前index开始，截取s[index : i+1]的字符串，判断是否为回文串；之后再判断s[i+1 : ]是否存在回文串。

1
class Solution {
2
    public List<List<String>> partition(String s) {
3
        List<List<String>> result = new LinkedList<>();
4
        if (s == null || s.length() == 0) {
5
            return result;
6
        }
7
        backtrack(result, new LinkedList<>(), s, 0);
8
        return result;
9
    }
10

11
    private void backtrack(List<List<String>> result, List<String> temp, String s, int index) {
12
        if (index == s.length()) {
13
            result.add(new LinkedList<>(temp));
14
            return;
15
        }
16

17
        for (int i = index; i < s.length(); i++) {
18
            if (isPalindrome(s, index, i)) {
19
                temp.add(s.substring(index, i + 1));
20
                backtrack(result, temp, s, i + 1);
21
                temp.remove(temp.size() - 1);
22
            }
23
        }
24
    }
25

26
    private boolean isPalindrome(String s, int left, int right) {
27
        while (left < right) {
28
            if (s.charAt(left) != s.charAt(right)) {
29
                return false;
30
            }
31
            left++;
32
            right--;
33
        }
34

35
        return true;
36
    }
37
}

展开收起

132. Palindrome Partitioning II#

https://leetcode.com/problems/palindrome-partitioning-ii/

使用动态规划，其中dp[i]表示s[:i]的范围内共需要多少次分割才能满足题意。

观察发现，如果s[left:right]是回文串，那么可以考虑将s[left:right]这个字符串分割出来，截止到下标right时，dp[right]的组成就是s[:left - 1]之内的分割数量，再加上s[left:right]这一次分割。

当然，随着left和right的不断外扩，也许我们能找到更长的回文串，这样也可能使得总的分割次数越来越少。

1
class Solution {
2
    public int minCut(String s) {
3
        char[] arr = s.toCharArray();
4

5
        int len = s.length();
6
        int[] dp = new int[len + 1];
7
        Arrays.fill(dp, len - 1);
8
        dp[0] = 0;
9

10
        // odd or even length
11
        for (int i = 1; i < len; i++) {
12
            updatePalindromeCut(arr, i, i, dp, len);
13
            updatePalindromeCut(arr, i - 1, i, dp, len);
14
        }
15

16
        return dp[len - 1];
17
    }
18

19
    void updatePalindromeCut(char[] str, int left, int right, int[] dp, int len) {
20
        while (left >= 0 && right < len && str[left] == str[right]) {
21

22
            dp[right] = left > 0 ? Math.min(dp[right], dp[left - 1] + 1)
23
                                 : Math.min(dp[right], 0);
24

25
            left--;
26
            right++;
27
        }
28
    }
29
}

展开收起

133. Clone Graph#

https://leetcode.com/problems/clone-graph/

使用一个map，存储新旧节点之间的映射，遇到已经复制过的节点，直接从map中获取；复制一个节点时，新节点newNode直接用原来的值node.val初始化，而newNode的邻居则用深度优先思想，循环从node.neighbors里分别调用cloneGraph方法复制。

1
/*
2
// Definition for a Node.
3
class Node {
4
    public int val;
5
    public List<Node> neighbors;
6
    public Node() {
7
        val = 0;
8
        neighbors = new ArrayList<Node>();
9
    }
10
    public Node(int _val) {
11
        val = _val;
12
        neighbors = new ArrayList<Node>();
13
    }
14
    public Node(int _val, ArrayList<Node> _neighbors) {
15
        val = _val;
16
        neighbors = _neighbors;
17
    }
18
}
19
*/
20

21
class Solution {
22
    // map from old to new nodes
23
    private Map<Node, Node> map = new HashMap<Node, Node>();
24

25
    public Node cloneGraph(Node node) {
26
        if (node == null) {
27
            return node;
28
        }
29

30
        // current node has been cloned
31
        if (map.containsKey(node)) {
32
            return map.get(node);
33
        }
34

35
        Node newNode = new Node(node.val, new ArrayList<Node>());
36
        map.put(node, newNode);
37

38
        for (int i = 0; i < node.neighbors.size(); i++) {
39
            Node clonedNeighbor = cloneGraph(node.neighbors.get(i));
40
            newNode.neighbors.add(clonedNeighbor);
41
        }
42

43
        return newNode;
44
    }
45
}

展开收起

134. Gas Station#

https://leetcode.com/problems/gas-station/

使用一个变量tankGas跟踪当前油箱中的油量。如果从第i个加油站开到第i+1个加油站的路上油箱里的油量变成负数，说明油不够用，只能换一个起点。

再使用一个变量totalGas计算整趟旅程下来加油 - 耗油的差值，总的耗油不能比加油量多。

1
class Solution {
2
    public int canCompleteCircuit(int[] gas, int[] cost) {
3
        // total gas filled - total gas cost
4
        int totalGasDiff = 0;
5

6
        // current gas in the tank
7
        int tankGas = 0;
8

9
        // starting gas station's index
10
        int start = 0;
11

12
        for (int i = 0; i < cost.length; i++) {
13
            // gas consumption amount from i-th station to (i+1)-th station
14
            int cur = gas[i] - cost[i];
15

16
            // update total consumed gas
17
            totalGasDiff += cur;
18

19
            // update gas in the tank
20
            // if tank drops below 0, we have to start from another station
21
            tankGas += cur;
22
            if (tankGas < 0) {
23
                start = i + 1;
24
                tankGas = 0;
25
            }
26
        }
27

28
        return totalGasDiff < 0 ? -1 : start;
29
    }
30
}

展开收起

135. Candy#

https://leetcode.com/problems/candy/

解题流程分为三步：

初始分配给每个孩子一个糖
从左向右，确保位于右侧，rating更高的孩子比左侧孩子获得更多的糖
从右向左，确保位于左侧，rating更高的孩子比右侧孩子获得更多的糖。注意有可能在此前从左到右的分配中，num[i - 1]的值很大，因此我们需要比较num[i - 1]和 num[i] + 1的值，选更大的那个值，确保不违背之前的分发方式。

最后只需要将结果累加即可。

1
class Solution {
2
    public int candy(int[] ratings) {
3
        int len = ratings.length;
4
        if (len == 0) {
5
            return 0;
6
        }
7

8
        int result = 0;
9

10
        int[] num = new int[len + 1];
11
        Arrays.fill(num, 1);
12

13
        // left to right, make sure that right child with higher rating receive more candy
14
        for (int i = 0; i < len - 1; i++) {
15
            if (ratings[i] < ratings[i + 1]) {
16
                num[i+1] = num[i] + 1;
17
            }
18
        }
19

20
        // right to left, make sure that left child with higher rating receive more candy
21
        // we cannot break the previous left-to-right rule as well
22
        for (int i = len - 1; i > 0; i--) {
23
            if (ratings[i - 1] > ratings[i]) {
24
                num[i - 1] = Math.max(num[i - 1], num[i] + 1);
25
            }
26
            result += num[i];
27
        }
28

29
        result += num[0];
30
        return result;
31
    }
32
}

展开收起

136. Single Number#

https://leetcode.com/problems/single-number/

任意两个相同的数，异或值为0。遍历整个数组并不断取异或，只有single number自身无法通过成对异或得到0，因此最后的结果就是single number。

1
class Solution {
2
    public int singleNumber(int[] nums) {
3
        int result = 0;
4
        for (int num : nums) {
5
            result ^= num;
6
        }
7
        return result;
8
    }
9
}

137. Single Number II#

https://leetcode.com/problems/single-number-ii/

解决本题有2个前提：

遇到num两次时，不应该记录这个数
遇到num三次后，将num对结果的影响清除

结合上述前提以及上一题的解决方案，只需要在第一次和第三次遇到一个数时进行记录即可；并且，如果ones ^ num == 0，表示当前遇到了num。

由此我们拆分出两个核心步骤：

如果没有将num记录在ones中，更新ones；否则不记录
```
1
ones = ones ^ num & ~twos
```
如果没有将num记录在twos中，更新twos；否则将twos清零
```
1
twos = twos ^ num & ~ones
```

1
class Solution {
2
    public int singleNumber(int[] nums) {
3
        int ones = 0, twos = 0;
4
        for (int num : nums) {
5
            ones = ones ^ num & ~twos;
6
            twos = twos ^ num & ~ones;
7
        }
8
        return ones;
9
    }
10
}

138. Copy List with Random Pointer#

https://leetcode.com/problems/copy-list-with-random-pointer/

与此前的Clone Graph问题类似，仍然是一张map，记录当前复制的进度，遇到已经复制过的节点直接从map中获取结果；并且仍然是使用递归，优先完成后续节点的复制。

1
/*
2
// Definition for a Node.
3
class Node {
4
    int val;
5
    Node next;
6
    Node random;
7

8
    public Node(int val) {
9
        this.val = val;
10
        this.next = null;
11
        this.random = null;
12
    }
13
}
14
*/
15

16
class Solution {
17
    // map from old to new nodes
18
    private Map<Node, Node> map = new HashMap<Node, Node>();
19

20
    public Node copyRandomList(Node head) {
21
        if (head == null) {
22
            return null;
23
        }
24

25
        // current node has been cloned
26
        if (map.containsKey(head)) {
27
            return map.get(head);
28
        }
29

30
        // copy node
31
        Node newHead = new Node(0);
32
        newHead.val = head.val;
33
        map.put(head, newHead);
34

35
        newHead.next = copyRandomList(head.next);
36
        newHead.random = copyRandomList(head.random);
37

38
        return newHead;
39
    }
40
}

展开收起

139. Word Break#

https://leetcode.com/problems/word-break/

使用动态规划，dp[i]表示截止至第i个字符时，s的子字符串s[0:i]是否符合题意。

使用两层遍历，从第i-1个字母开始向前搜索，如果遇到子字符串s[j:i-1]在wordDict中，并且起始下标j处有dp[j]为true，则将dp[i]标记为true。可以限定向前搜索的长度（wordDict中最长单词的长度）来加快运行时间。

1
class Solution {
2
    public boolean wordBreak(String s, List<String> wordDict) {
3
        Set<String> dict = new HashSet<>(wordDict);
4

5
        // maximum word length in wordDict
6
        int maxWordLen = 0;
7
        for (String each : dict) {
8
            maxWordLen = Math.max(maxWordLen, each.length());
9
        }
10

11
        boolean[] dp = new boolean[s.length() + 1];
12
        dp[0] = true;
13

14
        for (int i = 1; i <= s.length(); i++) {
15
            for (int j = i - 1; j >= Math.max(0, i - maxWordLen); j--) {
16
                if (dp[j] && dict.contains(s.substring(j, i))) {
17
                    dp[i] = true;
18
                    break;
19
                }
20
            }
21
        }
22

23
        return dp[s.length()];
24
    }
25
}

展开收起

140. Word Break II#

https://leetcode.com/problems/word-break-ii/

使用回溯算法，尝试每一个s[index:i]能不能组成一个存在于wordDict中的单词。

1
class Solution {
2
    public List<String> wordBreak(String s, List<String> wordDict) {
3
        List<String> result = new ArrayList<>();
4
        backtrack(result, s, wordDict, 0, new ArrayList<>());
5
        return result;
6
    }
7

8
    private void backtrack(List<String> result, String s, List<String> wordDict, int index, List<String> temp) {
9
        if (index == s.length()) {
10
            result.add(String.join(" ", temp));
11
            return;
12
        }
13

14
        // try each s[index:i]
15
        for (int i = index; i <= s.length(); i++) {
16
            if (wordDict.contains(s.substring(index, i))) {
17
                temp.add(s.substring(index, i));
18

19
                // start index should be i now
20
                backtrack(result, s, wordDict, i, temp);
21

22
                temp.remove(temp.size() - 1);
23
            }
24
        }
25
    }
26
}
27

28
// Time: O(2^n * n)
29
// Space: O(n)

展开收起

141. Linked List Cycle#

https://leetcode.com/problems/linked-list-cycle/

使用快慢指针，慢指针一次移动一格，快指针一次移动两格。如果存在环，快慢指针将在某个时刻相遇。

1
/**
2
 * Definition for singly-linked list.
3
 * class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode(int x) {
7
 *         val = x;
8
 *         next = null;
9
 *     }
10
 * }
11
 */
12
public class Solution {
13
    public boolean hasCycle(ListNode head) {
14
        if (head == null) {
15
            return false;
16
        }
17
        ListNode slow = head, fast = head;
18

19
        while (fast.next != null && fast.next.next != null) {
20
            slow = slow.next;
21
            fast = fast.next.next;
22

23
            // fast and slow pointers will eventually meet if there is a cycle
24
            if (slow == fast) {
25
                return true;
26
            }
27
        }
28

29
        return false;
30
    }
31
}

展开收起

142. Linked List Cycle II#

https://leetcode.com/problems/linked-list-cycle-ii/

实际上这是一个数学问题。仍然使用上一题中的快慢指针方法。假设链表头距离环起始点的距离为A，环起始点距离快慢指针相遇点的距离为B，环的长度为N，则：

1
A + B + N = 2A + 2B (快指针比慢指针多走了一个环的距离)

可以解得：

1
N - B = A

即快慢指针相遇点距离链表终点的距离也为A，因此慢指针只需要再移动A+1距离，便能够回到环的起点。使用另一个指针slow2从头开始，与慢指针共同位移，二者相遇的位置就是环起点。

1
/**
2
 * Definition for singly-linked list.
3
 * class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode(int x) {
7
 *         val = x;
8
 *         next = null;
9
 *     }
10
 * }
11
 */
12
public class Solution {
13
    public ListNode detectCycle(ListNode head) {
14
        if (head == null) {
15
            return null;
16
        }
17

18
        ListNode slow = head, fast = head;
19
        while (fast.next != null && fast.next.next != null) {
20
            slow = slow.next;
21
            fast = fast.next.next;
22

23
            if (slow == fast) {
24
                ListNode slow2 = head;
25
                while (slow2 != slow) {
26
                    slow2 = slow2.next;
27
                    slow = slow.next;
28
                }
29
                return slow;
30
            }
31
        }
32

33
        return null;
34
    }
35
}

展开收起

143. Reorder List#

https://leetcode.com/problems/reorder-list/

解题步骤分为三步：

寻找链表的中间元素，将链表分为两部分
颠倒后半部分的链表
调整指针顺序，将两部分链表交错相连。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public void reorderList(ListNode head) {
13
        if (head == null || head.next == null) {
14
            return;
15
        }
16

17
        // find middle element
18
        ListNode slow = head;
19
        ListNode fast = head;
20
        while (fast.next != null && fast.next.next != null) {
21
            slow = slow.next;
22
            fast = fast.next.next;
23
        }
24

25
        // reverse the second half of the list
26
        ListNode preMiddle = slow;
27
        ListNode preCurrent = slow.next;
28
        while (preCurrent.next != null) {
29
            ListNode current = preCurrent.next;
30
            preCurrent.next = current.next;
31
            current.next = preMiddle.next;
32
            preMiddle.next = current;
33
        }
34

35
        // merge two sub-lists
36
        slow = head;
37
        fast = preMiddle.next;
38
        while (slow != preMiddle) {
39
            preMiddle.next = fast.next;
40
            fast.next = slow.next;
41
            slow.next = fast;
42
            slow = fast.next;
43
            fast = preMiddle.next;
44
        }
45
    }
46
}

展开收起

144. Binary Tree Preorder Traversal#

https://leetcode.com/problems/binary-tree-preorder-traversal/

第一种做法，迭代使用栈解决问题。注意由于栈先进后出，因此要先加入每个节点的右分支。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> preorderTraversal(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        if (root == null) {
20
            return result;
21
        }
22

23
        Stack<TreeNode> st = new Stack<>();
24
        st.push(root);
25
        while (!st.isEmpty()) {
26
            TreeNode node = st.pop();
27
            result.add(node.val);
28

29
            if (node.right != null) {
30
                st.push(node.right);
31
            }
32
            if (node.left != null) {
33
                st.push(node.left);
34
            }
35
        }
36

37
        return result;
38
    }
39
}

展开收起

第二种做法，递归遍历：

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> preorderTraversal(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        preorder(result, root);
20
        return result;
21
    }
22

23
    private void preorder(List<Integer> result, TreeNode node) {
24
        if (node == null) {
25
            return;
26
        }
27

28
        result.add(node.val);
29
        preorder(result, node.left);
30
        preorder(result, node.right);
31
    }
32
}

展开收起

145. Binary Tree Postorder Traversal#

https://leetcode.com/problems/binary-tree-postorder-traversal/

第一种做法，仍然使用栈，调整st和result添加的顺序即可：

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> postorderTraversal(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        if (root == null) {
20
            return result;
21
        }
22

23
        Stack<TreeNode> st = new Stack<>();
24
        st.push(root);
25
        while (!st.isEmpty()) {
26
            TreeNode node = st.pop();
27
            result.add(0, node.val);
28

29
            if (node.left != null) {
30
                st.push(node.left);
31
            }
32

33
            if (node.right != null) {
34
                st.push(node.right);
35
            }
36
        }
37

38
        return result;
39
    }
40
}

展开收起

第二种做法，递归遍历：

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> postorderTraversal(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        postorder(result, root);
20
        return result;
21
    }
22

23
    private void postorder(List<Integer> result, TreeNode node) {
24
        if (node == null) {
25
            return;
26
        }
27

28
        postorder(result, node.left);
29
        postorder(result, node.right);
30
        result.add(node.val);
31
    }
32
}

展开收起

146. LRU Cache#

https://leetcode.com/problems/lru-cache/

第一种是简便做法。LRU缓存是LinkedHashMap的一种应用。对一个键执行get/put操作后，对应的键值对会移动到链表末尾，因此最末尾的元素是最近访问的。在LinkedHashMap添加元素后，会调用removeEldestEntry()方法，传递的参数为最久没有被访问的键值对时，如果方法返回true，这个最久的键值对就会被删除。因此，LRUCache类只需在LinkedHashMap类的基础上进行继承扩展即可。

1
class LRUCache extends LinkedHashMap<Integer, Integer>{
2

3
    private int capacity;
4

5
    public LRUCache(int capacity) {
6
        super(capacity, 0.75F, true);
7
        this.capacity = capacity;
8
    }
9

10
    public int get(int key) {
11
        return super.getOrDefault(key, -1);
12
    }
13

14
    public void put(int key, int value) {
15
        super.put(key, value);
16
    }
17

18
    @Override
19
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
20
        return size() > capacity;
21
    }
22
}

展开收起

第二种做法，使用一个链表和一个数组。数组记录所有出现过的key与value对应的信息；而链表则负责维护最近使用过的节点情况，如果某个节点最近被使用过，就把它先从链表中删掉，再把它加到链表的尾部。这样能确保链表始终是按照最近使用时间由远到近进行排序，如果要替换节点直接从链表头选择节点替换即可。

1
class Node {
2
    Node next, prev;
3
    int key, val;
4
    Node(int key, int val) {
5
        this.key = key;
6
        this.val = val;
7
    }
8
}
9

10
class LRUCache {
11
    Node map[];
12
    Node head, tail;
13
    int CAP, SIZE;
14

15
    public LRUCache(int capacity) {
16
        CAP = capacity;
17
        SIZE = 0;
18
        map = new Node[10001]; // default max capacity is 10000
19
        head = tail = null;
20
    }
21

22
    private void add(Node n) {
23
        // first node, set it as both head and tail
24
        if (head == null) {
25
            head = tail = n;
26
            return;
27
        }
28

29
        // add to tail
30
        tail.next = n;
31
        n.prev = tail;
32
        tail = n;
33
    }
34

35
    private void remove(Node n) {
36
        if (head == tail) {
37
            // remove the only node
38
            head = tail = null;
39
        } else if (head == n) {
40
            // remove head node
41
            head = head.next;
42
        } else if (tail == n) {
43
            // remove tail node
44
            tail = tail.prev;
45
        } else {
46
            // find previous and next nodes, then connect them
47
            Node prev = n.prev, next = n.next;
48
            prev.next = next;
49
            next.prev = prev;
50
        }
51
    }
52

53
    public int get(int key) {
54
        if (map[key] == null) {
55
            return -1;
56
        }
57

58
        // recently used, update it's position in linked list
59
        remove(map[key]);
60
        add(map[key]);
61

62
        return map[key].val;
63
    }
64

65
    public void put(int key, int value) {
66
        // update the value of the key, if the key exists
67
        if (map[key] != null) {
68
            remove(map[key]);
69
            add(map[key]);
70
            map[key].val = value;
71
            return;
72
        }
73

74
        // need to evict a node and replace with current key
75
        if (SIZE >= CAP) {
76
            Node nodeToRemove = head;
77
            remove(nodeToRemove);
78
            map[nodeToRemove.key] = null;
79
            SIZE--;
80
        }
81

82
        Node newNode = new Node(key, value);
83
        add(newNode);
84
        map[key] = newNode;
85
        SIZE++;
86
    }
87
}

展开收起

147. Insertion Sort List#

https://leetcode.com/problems/insertion-sort-list/

使用三个指针，其中pre总是从链表头开始向后移动，寻找插入位置；cur指向当前待插入的元素；next指向下一个待插入的元素。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode insertionSortList(ListNode head) {
13
        if (head == null) {
14
            return head;
15
        }
16

17
        ListNode dummyHead = new ListNode(0);
18

19
        // current node to be inserted
20
        ListNode cur = head;
21

22
        // pre -> cur -> next
23
        ListNode pre = dummyHead, next = null;
24

25
        while (cur != null) {
26
            next = cur.next;
27

28
            // find the first element which breaks the ascending order
29
            // this is the insertion position
30
            while (pre.next != null && pre.next.val < cur.val) {
31
                pre = pre.next;
32
            }
33

34
            cur.next = pre.next;
35
            pre.next = cur;
36
            cur = next;
37

38
            // reset pre
39
            pre = dummyHead;
40
        }
41

42
        return dummyHead.next;
43
    }
44
}

展开收起

148. Sort List#

https://leetcode.com/problems/sort-list/

Divide and conquer，不断将链表二分为左、右两部分，按顺序合并两个子链表，组成一个完整的有序链表。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode sortList(ListNode head) {
13
        if (head == null || head.next == null) {
14
            return head;
15
        }
16

17
        // divide the list into two half
18
        ListNode pre = null, slow = head, fast = head;
19
        while (fast != null && fast.next != null) {
20
            pre = slow;
21
            slow = slow.next;
22
            fast = fast.next.next;
23
        }
24
        pre.next = null;
25

26
        ListNode l1 = sortList(head);
27
        ListNode l2 = sortList(slow);
28

29
        return mergeTwoLists(l1, l2);
30
    }
31

32
    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
33
        if (l1 == null) {
34
            return l2;
35
        }
36
        if (l2 == null) {
37
            return l1;
38
        }
39

40
        // merge after smaller node
41
        if (l1.val < l2.val) {
42
            l1.next = mergeTwoLists(l1.next, l2);
43
            return l1;
44
        } else {
45
            l2.next = mergeTwoLists(l1, l2.next);
46
            return l2;
47
        }
48
    }
49
}

展开收起

149. Max Points on a Line#

https://leetcode.com/problems/max-points-on-a-line/

三重循环，如果两点重合，则寻找所有的重合点；否则，计算出两点连线的斜率，并遍历其他点，寻找与当前点连线斜率相同的点。每一轮循环结束后的结果是斜率相同 + 相同点的总个数。注意，如果全部点都相同，还需要在结尾进行额外判断，决定samepoint值是否需要 + 1。

1
class Solution {
2
    public int maxPoints(int[][] points) {
3
        if (points == null) {
4
            return 0;
5
        }
6
        if (points.length < 3) {
7
            return points.length;
8
        }
9

10
        int result = 0;
11
        int n = points.length;
12

13
        for (int i = 0; i < n; i++) {
14
            int samepoint = 0;
15

16
            for (int j = i+1; j < n; j++) {
17
                int count = 2;
18
                long x = points[j][0] - points[i][0];
19
                long y = points[j][1] - points[i][1];
20

21
                boolean isValidSlope = true;
22
                if (x == 0 && y == 0) {
23
                    samepoint++;
24
                    continue;
25
                }
26

27
                if (x == 0) {
28
                    isValidSlope = false;
29
                }
30

31
                long interdx = x * points[i][1] - y * points[i][0];
32

33
                // slope exists and equal inter multiplication, or slope not exist and same point
34
                for (int k = j+1; k < n; k++) {
35
                    if (isValidSlope) {
36
                        if (interdx == x*points[k][1] - y*points[k][0]) {
37
                            count++;
38
                        }
39
                    } else if (points[k][0] == points[i][0]) {
40
                        count++;
41
                    }
42
                }
43

44
                result = Math.max(count + samepoint, result);
45
            }
46

47
            result = Math.max(samepoint + 1, result); // [[1,1],[1,1],[1,1]]
48
        }
49

50
        return result;
51
    }
52
}

展开收起

150. Evaluate Reverse Polish Notation#

https://leetcode.com/problems/evaluate-reverse-polish-notation/

逆波兰式实际对应的就是树的后序遍历，根据后续遍历的顺序，我们会先遇到操作数a，再遇到操作数b，之后才是操作符。因此当我们遇到操作数的时候，直接推入栈中；遇到操作符时，从栈顶推出的操作数是先b再a，这个顺序在减法和除法中很重要。

1
class Solution {
2
    public int evalRPN(String[] tokens) {
3
        int a, b;
4
        Stack<Integer> st = new Stack<Integer>();
5

6
        for (String s : tokens) {
7
            if (s.equals("+")) {
8
                st.add(st.pop() + st.pop());
9
            } else if (s.equals("-")) {
10
                b = st.pop();
11
                a = st.pop();
12
                st.add(a - b);
13
            } else if (s.equals("*")) {
14
                st.add(st.pop() * st.pop());
15
            } else if (s.equals("/")) {
16
                b = st.pop();
17
                a = st.pop();
18
                st.add(a / b);
19
            } else {
20
                st.add(Integer.parseInt(s));
21
            }
22
        }
23

24
        return st.pop();
25
    }
26
}

展开收起

151. Reverse Words in a String#

https://leetcode.com/problems/reverse-words-in-a-string/

使用trim()函数除去起始的空白，再使用split()函数分割每个单词，汇集成一个单词数组。之后倒序输出所有单词，并添加空格。

1
class Solution {
2
    public String reverseWords(String s) {
3
        StringBuilder sb = new StringBuilder();
4

5
        // trim preceding & leading whitespaces, then split by " "
6
        String[] words = s.trim().split(" ");
7

8
        for (int i = words.length - 1; i >= 0; i--) {
9
            if (words[i].length() > 0) {
10
                sb.append(words[i]);
11
                if (i > 0) {
12
                    sb.append(" ");
13
                }
14
            }
15
        }
16

17
        return sb.toString();
18
    }
19
}

展开收起

152. Maximum Product Subarray#

https://leetcode.com/problems/maximum-product-subarray/

从左向右遍历一遍，不断累乘，如果当前乘积为0需要重新修改为1。

考虑到存在负数的情况（例如[3, -1, 4])，可能会导致数组被负数分割成若干部分，因此从左到右不一定能找到最大子区间。因此我们还需要从右向左再遍历一次，确保筛选出最大子序列。

1
class Solution {
2
    public int maxProduct(int[] nums) {
3
        if (nums.length == 0) {
4
            return 0;
5
        }
6

7
        int result = Integer.MIN_VALUE, product = 1;
8
        for (int i = 0; i < nums.length; i++) {
9
            product *= nums[i];
10
            result = Math.max(result, product);
11
            if (product == 0) {
12
                product = 1;
13
            }
14
        }
15

16
        product = 1;
17
        for (int i = nums.length - 1; i >= 0; i--) {
18
            product *= nums[i];
19

20
            result = Math.max(result, product);
21
            if (product == 0) {
22
                product = 1;
23
            }
24
        }
25

26
        return result;
27
    }
28
}

展开收起

153. Find Minimum in Rotated Sorted Array#

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/

这题借鉴了此前Search in Rotated Sorted Array的数组对半划分思想，通过比较nums[left]、nums[mid]和nums[right]确定下一轮的搜索区间。

如果nums[mid]不小于边界两个值，说明nums[left, mid]是一段递增序列，最小值在nums[mid + 1, right]中；反之，最小值在nums[left, mid]中。因为我们希望找到数组最小值，根据左边界查找思想，在确定最小值所在范围后我们仍然希望尽量向左扩展范围，试图能在范围中找到更小的值符合要求。

注意这题还可以用辅助加速的手段快速检查nums[mid]值是否为最小值，提升运行效率。

1
class Solution {
2
    public int findMin(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        if (nums.length == 1) {
8
            return nums[0];
9
        }
10

11
        int left = 0, right = nums.length - 1;
12
        while (left < right) {
13
            int mid = left + (right - left) / 2;
14

15
            // optional speed-up, quickly determine if nums[mid] is minimum
16
            if (mid > 0 && nums[mid] < nums[mid - 1]) {
17
                return nums[mid];
18
            }
19

20
            if (nums[left] <= nums[mid] && nums[right] < nums[mid]) {
21
                left = mid + 1;
22
            } else {
23
                right = mid;
24
            }
25
        }
26

27
        return nums[left];
28
    }
29
}

展开收起

154. Find Minimum in Rotated Sorted Array II#

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/

最小值初始情况下在肯定在nums[0, nums.length - 1]之间。分类讨论：

如果nums[mid] > nums[right]，最小值在nums[mid + 1, right]之间，因此有left = mid + 1
如果nums[mid] < nums[left]，最小值在nums[left + 1, mid]之间，因此有right = mid；同时我们也知道nums[left]不可能是最小值，因此让left++稍微加快一些运行效率
其他情况下，对应nums[left] <= nums[mid] <= nums[right]，我们只知道最小值为nums[left]，不知道nums[mid]和两端的关系，因此只能让right--

完成二分查找循环后，left与right相等，返回nums[left]即可。

1
class Solution {
2
    public int findMin(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        if (nums.length == 1) {
8
            return nums[0];
9
        }
10

11
        int left = 0, right = nums.length - 1;
12
        while (left < right) {
13
            int mid = left + (right - left) / 2;
14

15
            if (nums[right] < nums[mid]) {
16
                left = mid + 1;
17
            } else if (nums[mid] < nums[left]) {
18
                right = mid;
19
                left++;
20
            } else {
21
                right--;
22
            }
23
        }
24

25
        return nums[left];
26
    }
27
}

展开收起

155. Min Stack#

https://leetcode.com/problems/min-stack/

主体可以构造一个链表存储。对于最小值的跟踪，可以在push时顺便完成，直接和当前头元素中存储的已有最小值比较，节省搜索的时间。

1
class MinStack {
2

3
    private class Node {
4
        int val;
5
        int min;
6
        Node next;
7

8
        private Node(int val, int min) {
9
            this(val, min, null);
10
        }
11

12
        private Node(int val, int min, Node next) {
13
            this.val = val;
14
            this.min = min;
15
            this.next = next;
16
        }
17
    }
18

19
    private Node head;
20

21
    /** initialize your data structure here. */
22
    public MinStack() {
23

24
    }
25

26
    public void push(int x) {
27
        if (head == null) {
28
            head = new Node(x, x);
29
        } else {
30
            // store global min value into each incoming node
31
            head = new Node(x, Math.min(x, head.min), head);
32
        }
33
    }
34

35
    public void pop() {
36
        head = head.next;
37
    }
38

39
    public int top() {
40
        return head.val;
41
    }
42

43
    public int getMin() {
44
        return head.min;
45
    }
46
}

展开收起

156. Binary Tree Upside Down#

https://leetcode.com/problems/binary-tree-upside-down/

可以将最左支(1-2-4)视为树的骨干，其余节点视为枝叶。参考XYZ例图，旋转后骨干变成最右支，枝叶则位于左侧。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public TreeNode upsideDownBinaryTree(TreeNode root) {
18
        if (root == null || root.left == null) {
19
            return root;
20
        }
21

22
        TreeNode newRoot = upsideDownBinaryTree(root.left);
23

24
        // Y -> Z
25
        root.left.left = root.right;
26

27
        // Y -> X
28
        root.left.right = root;
29

30
        // root has become a leaf now
31
        root.left = root.right = null;
32

33
        return newRoot;
34
    }
35
}

展开收起

157. Read N Characters Given Read4#

https://leetcode.com/problems/read-n-characters-given-read4/

问题限制只能使用read4()函数来实现read()函数。read4()函数限制了一次性读入的字符最多为4，因此read()函数必须不断调用read4()，将字符从read4()专用的缓存read4TempBuff中拷贝到自己的缓存buf内。

1
/**
2
 * The read4 API is defined in the parent class Reader4.
3
 *     int read4(char[] buf4);
4
 */
5

6
public class Solution extends Reader4 {
7

8
    // the buffer for read4 API
9
    private char[] read4TempBuff = new char[4];
10

11
    /**
12
     * @param buf Destination buffer
13
     * @param n   Number of characters to read
14
     * @return    The number of actual characters read
15
     */
16
    public int read(char[] buf, int n) {
17

18
        // how many characters have been read
19
        int result = 0;
20

21
        // read 4 characters to buff
22
        int bytes = read4(read4TempBuff);
23

24
        while (bytes > 0) {
25
            for (int i = 0; i < bytes; i++) {
26
                if (n == result) {
27
                    break;
28
                }
29

30
                // copy 1 char
31
                buf[result] = read4TempBuff[i];
32
                result++;
33
            }
34
            bytes = read4(read4TempBuff);
35
        }
36

37
        return result;
38
    }
39
}

展开收起

158. Read N Characters Given read4 II - Call Multiple Times#

https://leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/

由于read()可能被调用多次，因此需要及时更新缓存指针，每次read4()读字符进来，就将字符逐个从read4TempBuff拷贝到buf，复制完一个就移动一次缓存指针。4个都复制完了，重置缓存指针到0，只有为0的时候才可以接受下一批读入的字符。

1
/**
2
 * The read4 API is defined in the parent class Reader4.
3
 *     int read4(char[] buf4);
4
 */
5

6
public class Solution extends Reader4 {
7

8
    private int buffPtr = 0;
9
    private int bytes = 0; // characters length read to buffer
10

11
    private char[] read4TempBuff = new char[4];
12

13
    /**
14
     * @param buf Destination buffer
15
     * @param n   Number of characters to read
16
     * @return    The number of actual characters read
17
     */
18
    public int read(char[] buf, int n) {
19

20
        // how many characters have been read
21
        int result = 0;
22

23
        while (result < n) {
24
            // write buff when buffer is ready
25
            if (buffPtr == 0) {
26
                bytes = read4(read4TempBuff);
27
            }
28

29
            // copy chars from read4TempBuff to buf
30
            while (result < n && buffPtr < bytes) {
31
                buf[result] = read4TempBuff[buffPtr];
32
                result++;
33
                buffPtr++;
34
            }
35

36
            // finish copying current 4 chars, reset to 0, ready to receive new chars
37
            if (buffPtr == bytes) {
38
                buffPtr = 0;
39
            }
40

41
            // read4() return a number less than 4, EOF
42
            if (bytes < 4) {
43
                break;
44
            }
45
        }
46

47
        return result;
48
    }
49
}

展开收起

159. Longest Substring with At Most Two Distinct Characters#

https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/

滑动窗口思想，使用一个map存储每个字符出现的次数；使用双指针i, j记录当前遍历输入字符串的前、后字符，确保map中不超过2个字符。一旦超过，就需要从前指针开始剔除一个老字符。

1
class Solution {
2
    public int lengthOfLongestSubstringTwoDistinct(String s) {
3
        if (s == null || s.length() == 0) {
4
            return 0;
5
        }
6

7
        char[] arr = s.toCharArray();
8

9
        // <Character, Integer>
10
        int[] map = new int[256];
11

12
        // how many distinct characters in current substring
13
        int count = 0;
14

15
        // longest substring length
16
        int result = 0;
17

18
        for (int i = 0, j = 0; j < arr.length; j++) {
19
            // a new character
20
            if (map[ arr[j] ] == 0) {
21
                count++;
22
            }
23

24
            map[ arr[j] ]++;
25

26
            // more than 2 characters in current substring, delete one character
27
            while (count > 2) {
28
                map[ arr[i] ]--;
29

30
                // delete one
31
                if (map[ arr[i] ] == 0) {
32
                    count--;
33
                }
34

35
                i++;
36
            }
37

38
            result = Math.max(result, j - i + 1);
39
        }
40

41
        return result;
42
    }
43
}

展开收起

160. Intersection of Two Linked Lists#

https://leetcode.com/problems/intersection-of-two-linked-lists/

无需计算A、B链表的长度，直接分别从头到尾进行遍历，如果遇到结尾，跳转至另一链表的头部继续遍历。这样一来，如果两个链表有交集，遍历指针一定会在交集点相遇；否则，同时移动至链表结尾，返回null。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode(int x) {
7
 *         val = x;
8
 *         next = null;
9
 *     }
10
 * }
11
 */
12
public class Solution {
13
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
14
        if (headA == null || headB == null) {
15
            return null;
16
        }
17

18
        ListNode curA = headA, curB = headB;
19
        while (curA != curB) {
20
            curA = (curA == null) ? headB : curA.next;
21
            curB = (curB == null) ? headA : curB.next;
22
        }
23

24
        return curA;
25
    }
26
}

展开收起

161. One Edit Distance#

https://leetcode.com/problems/one-edit-distance/

要想在一次编辑内实现s, t两个字符串的相等，必须只有一个字符在下标i处不同，并且

如果s, t等长，下标i之后s, t仍旧要相等
s比t短，则t删掉t[i]之后剩余字符串和s从s[i]起的字符串相等
t比s短，与上一种情况对应

最后还有一种特殊情况，即最后一个字符才出现不同，需要判断两个字符串的长度差值是否为1。

1
class Solution {
2
    public boolean isOneEditDistance(String s, String t) {
3
        for (int i = 0; i < Math.min(s.length(), t.length()); i++) {
4
            if (s.charAt(i) != t.charAt(i)) {
5
                if (s.length() == t.length()) {
6
                    return s.substring(i + 1).equals(t.substring(i + 1));
7
                } else if (s.length() < t.length()) {
8
                    return s.substring(i).equals(t.substring(i + 1));
9
                } else {
10
                    return s.substring(i + 1).equals(t.substring(i));
11
                }
12
            }
13
        }
14

15
        return Math.abs(s.length() - t.length()) == 1;
16
    }
17
}

展开收起

162. Find Peak Element#

https://leetcode.com/problems/find-peak-element/

使用二分查找，找到任意一个极大值便返回。

1
class Solution {
2
    public int findPeakElement(int[] nums) {
3
        int left = 0, right = nums.length - 1;
4
        while (left < right) {
5
            int mid = left + (right - left) / 2;
6

7
            // find a local maximum
8
            if (nums[mid] < nums[mid + 1]) {
9
                left = mid + 1;
10
            } else {
11
                right = mid;
12
            }
13
        }
14

15
        return left;
16
    }
17
}

展开收起

163. Missing Ranges#

https://leetcode.com/problems/missing-ranges/

三步检查：

判断lower和nums的第一个数之间的关系
判断每两个数之间是否产生了大于1的间隔（生成缺失区间）
判断upper和nums的最后一个数之间的关系

1
class Solution {
2
    public List<String> findMissingRanges(int[] nums, int lower, int upper) {
3
        List<String> result = new ArrayList<>();
4

5
        if (nums == null || nums.length == 0) {
6
            result.add(formRange(lower, upper)); // generate the whole range
7
            return result;
8
        }
9

10
        // initial gap
11
        if (nums[0] > lower) {
12
            result.add(formRange(lower,nums[0] - 1));
13
        }
14

15
        // find a gap greeater than 1
16
        for (int i = 0; i < nums.length - 1; i++) {
17
            if (nums[i+1] != nums[i] && nums[i+1] > nums[i] + 1) {
18
                result.add(formRange(nums[i] + 1, nums[i+1] - 1));
19
            }
20
        }
21

22
        // last gap
23
        if (nums[nums.length-1] < upper) {
24
            result.add(formRange(nums[nums.length-1] + 1, upper));
25
        }
26

27
        return result;
28
    }
29

30
    public String formRange(int low, int high) {
31
        return low == high ? String.valueOf(low) : (low + "->" + high);
32
    }
33
}

展开收起

164. Maximum Gap#

https://leetcode.com/problems/maximum-gap/

先遍历一次数组，得出数组的最小值min和最大值max；将数组划分为若干个桶，每个桶覆盖一段区间[min + (k-1)gap, min + k*gap)。对于每个桶，重点记录桶内的最小值和最大值，最后比较不同桶之间最值之间的间距。

1
class Solution {
2
    public int maximumGap(int[] nums) {
3
        if (nums == null || nums.length < 2) {
4
            return 0;
5
        }
6

7
        // find minimum and maximum value of nums
8
        int min = nums[0], max = nums[0];
9
        for (int n: nums) {
10
            min = Math.min(min, n);
11
            max = Math.max(max, n);
12
        }
13

14
        if (min == max) {
15
            return 0;
16
        }
17

18
        int n = nums.length;
19

20
        // each bucket is an interval，[min + (k-1)gap, min + k*gap)
21
        int gap = (int)Math.ceil((double)(max - min) / (n - 1)); // max gap must be greater than this
22
        int bucketMin[] = new int[n];
23
        int bucketMax[] = new int[n];
24
        Arrays.fill(bucketMin, Integer.MAX_VALUE);
25
        Arrays.fill(bucketMax, Integer.MIN_VALUE);
26

27
        // put current number in the bucket and update this bucket's min/max value
28
        for (int num: nums) {
29
            int i = (num - min) / gap;
30
            bucketMin[i] = Math.min(bucketMin[i], num);
31
            bucketMax[i] = Math.max(bucketMax[i], num);
32
        }
33

34
        // for the first bucket, compare bucket's min value and num's min value
35
        // for other buckets, compare this bucket's min value and previous bucket's max value
36
        for (int i = 0; i < n; i++) {
37
            // only compare when the bucket is not empty
38
            if (bucketMin[i] != Integer.MAX_VALUE) {
39
                gap = Math.max(gap, bucketMin[i] - min);
40
                min = bucketMax[i];
41
            }
42
        }
43

44
        return gap;
45
    }
46
}

展开收起

165. Compare Version Numbers#

https://leetcode.com/problems/compare-version-numbers/

使用split()函数，根据'.'提取出每个子版本号进行比较。可以调用parseInt()函数转化格式。比较过程中，如果较短的版本号已经遍历完毕，之后的子版本号可以看作都是0。

1
class Solution {
2
    public int compareVersion(String version1, String version2) {
3
        String[] s1 = version1.split("\\.");
4
        String[] s2 = version2.split("\\.");
5

6
        for (int i = 0; i < Math.max(s1.length, s2.length); i++) {
7
            // if version number too long, treat as 0
8
            Integer v1 = i < s1.length ? Integer.parseInt(s1[i]) : 0;
9
            Integer v2 = i < s2.length ? Integer.parseInt(s2[i]) : 0;
10

11
            if (v1 > v2) {
12
                return 1;
13
            } else if (v1 < v2) {
14
                return -1;
15
            }
16
        }
17

18
        return 0;
19
    }
20
}

展开收起

166. Fraction to Recurring Decimal#

https://leetcode.com/problems/fraction-to-recurring-decimal/

解题步骤可划分为：

确定正负号
将int型输入变量转化为long型，避免溢出
小数部分，不断倍增numerator,每循环做一次除法，便用map存储当前的余数以及长度。如果当前余数已经在map中，则终止循环

1
class Solution {
2
    public String fractionToDecimal(int numerator, int denominator) {
3
        if (numerator == 0) {
4
            return "0";
5
        }
6

7
        StringBuffer sb = new StringBuffer();
8

9
        // determine sign
10
        if ((numerator > 0) ^ (denominator > 0)) {
11
            sb.append('-');
12
        }
13

14
        long num = Math.abs((long) numerator);
15
        long den = Math.abs((long) denominator);
16

17
        sb.append(num / den);
18
        num %= den;
19
        if (num == 0) {
20
            return sb.toString();
21
        }
22
        sb.append('.');
23

24
        // <recurring decimal, recurring string length>
25
        HashMap<Long, Integer> map = new HashMap<>();
26
        while (num != 0) {
27
            num *= 10;
28

29
            // detect recurring part
30
            if (map.containsKey(num)) {
31
                sb.insert((int) map.get(num), '(');
32
                sb.append(')');
33
                return sb.toString();
34
            }
35

36
            map.put(num, sb.length());
37
            sb.append(num / den);
38
            num %= den;
39
        }
40

41
        return sb.toString();
42
    }
43
}

展开收起

167. Two Sum II - Input Array Is Sorted#

https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/

左右双指针法，遍历解决。

1
class Solution {
2
    public int[] twoSum(int[] numbers, int target) {
3
        int len = numbers.length;
4

5
        int[] result = new int[2];
6
        if (numbers == null || numbers.length < 2) {
7
            return result;
8
        }
9

10
        int index1 = 0, index2 = len-1;
11
        while (index1 < index2) {
12
            if (numbers[index1] + numbers[index2] == target) {
13
                result[0] = index1 + 1;
14
                result[1] = index2 + 1;
15
                return result;
16
            } else if (numbers[index1] + numbers[index2] < target) {
17
                index1++;
18
            } else {
19
                index2--;
20
            }
21
        }
22

23
        return result;
24
    }
25
}

展开收起

168. Excel Sheet Column Title#

https://leetcode.com/problems/excel-sheet-column-title/

相当于10进制转特殊的26进制，按位倒序添加每一位数。

1
class Solution {
2
    public String convertToTitle(int columnNumber) {
3
        StringBuilder result = new StringBuilder();
4

5
        while (columnNumber > 0) {
6
            columnNumber--;
7
            result.insert(0, (char)('A' + columnNumber % 26));
8
            columnNumber /= 26;
9
        }
10

11
        return result.toString();
12
    }
13
}

169. Majority Element#

https://leetcode.com/problems/majority-element/

运用Boyer-Moore投票算法，遍历整个数组，判断当前数nums[i]是否和当前的candidate相等，进而加减投票。由于输入数据中一定存在一个出现次数超过一半的元素，所以遍历完数组后数组中一定会存在至少一个元素，即majority element。

1
class Solution {
2
    public int majorityElement(int[] nums) {
3
        // current candicate and its occurrence
4
        int count = 0, candidate = Integer.MIN_VALUE;
5

6
        for (int i = 0; i < nums.length; i++) {
7
            // set as current new candidate
8
            if (count == 0) {
9
                candidate = nums[i];
10
            }
11

12
            // "vote" for current candidate, or "vote" for others
13
            if (nums[i] == candidate) {
14
                count++;
15
            } else {
16
                count--;
17
            }
18
        }
19

20
        return candidate;
21
    }
22
}

展开收起

170. Two Sum III - Data structure design#

https://leetcode.com/problems/two-sum-iii-data-structure-design/

用ArrayList存储每个添加的数字；使用HashMap存储每个数字出现的次数。每次添加一个数字后，就立即更新当前list内的最小值和最大值，这样能在find()时提前判定不合理范围，节省时间。

1
class TwoSum {
2

3
    // all numbers
4
    private List<Integer> list = new ArrayList<>();
5

6
    // every number's occurrence
7
    private Map<Integer, Integer> map = new HashMap<>();
8

9
    // record max and minimum value
10
    int max, min;
11

12
    /** Initialize your data structure here. */
13
    public TwoSum() {}
14

15
    /** Add the number to an internal data structure.. */
16
    public void add(int number) {
17
        list.add(number);
18

19
        min = Math.min(number, min);
20
        max = Math.max(number, max);
21

22
        map.put(number, map.getOrDefault(number, 0) + 1);
23
    }
24

25
    /** Find if there exists any pair of numbers which sum is equal to the value. */
26
    public boolean find(int value) {
27
        if (value < 2 * min || value > 2 * max) {
28
            return false;
29
        }
30

31
        for (int num : list) {
32
            int num2 = value - num;
33

34
            if ((num == num2 && map.getOrDefault(num, 0) > 1) ||
35
                (num != num2 && map.containsKey(num2))) {
36
                return true;
37
            }
38
        }
39

40
        return false;
41
    }
42
}

展开收起

171. Excel Sheet Column Number#

https://leetcode.com/problems/excel-sheet-column-number/

遍历每个字符，进行26进制 -> 10进制的转换。

1
class Solution {
2
    public int titleToNumber(String s) {
3
        if (s.length() < 1) {
4
            return 0;
5
        }
6

7
        int result = 0;
8
        for (int i = 0; i < s.length(); i++) {
9
            result = result * 26 + (s.charAt(i) - 'A' + 1);
10
        }
11

12
        return result;
13
    }
14
}

172. Factorial Trailing Zeroes#

https://leetcode.com/problems/factorial-trailing-zeroes/

阶乘中的10，本质上来源于5这个因子(5*2)。考虑到每个偶数都能提供一个2作为因子，因此2因子的数量一定比5因子多，尾数0的个数只取决于5的个数。

1
class Solution {
2
    public int trailingZeroes(int n) {
3
        int result = 0;
4

5
        while (n > 0) {
6
            result += n / 5;
7
            n /= 5;
8
        }
9

10
        return result;
11
    }
12
}

173. Binary Search Tree Iterator#

https://leetcode.com/problems/binary-search-tree-iterator/

根据BST的特点，观察如果按照中序遍历从左到右遍历整颗BST，将得到一个有序的list。每次调用next()函数获取当前树中最小值时，其实就是获取list当前的头元素。不断使用poll()函数清空list，最终list为空时，hasNext()便返回false。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class BSTIterator {
17

18
    LinkedList<Integer> tree = new LinkedList<>();
19

20
    public BSTIterator(TreeNode root) {
21
        visit(root);
22
    }
23

24
    void visit(TreeNode root) {
25
        if (root == null) {
26
            return;
27
        }
28

29
        // in-order
30
        visit(root.left);
31
        tree.offer(root.val);
32
        visit(root.right);
33
    }
34

35
    /** @return the next smallest number */
36
    public int next() {
37
        return tree.poll();
38
    }
39

40
    /** @return whether we have a next smallest number */
41
    public boolean hasNext() {
42
        return !tree.isEmpty();
43
    }
44
}

展开收起

174. Dungeon Game#

https://leetcode.com/problems/dungeon-game/

动态规划，从终点向起点递推。如果当前房间可以加血，并且回复的血量比相邻房间所消耗的最低血量还多，说明只需要1滴血就能进入当前的回血房间，并且继续进入下一个房间；否则，所需的最小血量就要加上当前房间所扣除的血量。

1
class Solution {
2
    public int calculateMinimumHP(int[][] dungeon) {
3
        int m = dungeon.length;
4
        int n = dungeon[0].length;
5
        int[][] dp = new int[m+1][n+1];
6

7

8
        // unreachable bound
9
        for (int i = 0; i <= m; i++) {
10
            dp[i][n] = Integer.MAX_VALUE;
11
        }
12
        for (int i = 0; i <= n; i++) {
13
            dp[m][i] = Integer.MAX_VALUE;
14
        }
15

16
        // before finally enter the bottom-right room, the knight should have at least 1 health
17
        dp[m][n-1] = 1;
18
        dp[m-1][n] = 1;
19

20
        for (int i = m - 1; i >= 0; i--) {
21
            for (int j = n - 1; j >= 0; j--) {
22
                int minToNext = Math.min(dp[i][j+1], dp[i+1][j]);
23
                dp[i][j] = (dungeon[i][j] >= minToNext) ? 1 : minToNext - dungeon[i][j];
24
            }
25
        }
26

27
        return dp[0][0];
28
    }
29
}

展开收起

175. Combine Two Tables#

https://leetcode.com/problems/combine-two-tables/

两个表的PersonId字段可以充当桥梁。另外注意到即使Address表缺乏记录，也要返回Person表中的对应人物数据，因此需要用到LEFT JOIN。

1
SELECT FirstName, LastName, City, State
2
FROM Person LEFT JOIN Address
3
ON Person.PersonId = Address.PersonId;

176. Second Highest Salary#

https://leetcode.com/problems/second-highest-salary/

从高到低排序后，获取第二大的结果。

1
SELECT
2
    (SELECT DISTINCT Salary
3
     FROM Employee
4
     ORDER BY Salary DESC
5
     LIMIT 1 /* LIMIT: number of rows returned */
6
     OFFSET 1 /* OFFSET：starting row index */
7
    )
8
AS SecondHighestSalary

177. Nth Highest Salary#

https://leetcode.com/problems/nth-highest-salary/

与上一题类似，仍然是从高到低排序，只不过OFFSET变成了N - 1。

1
CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
2
BEGIN
3
    DECLARE M INT;
4
    SET M = N - 1;
5
  RETURN (
6
      SELECT DISTINCT Salary
7
      FROM Employee
8
      ORDER BY Salary DESC
9
      LIMIT 1
10
      OFFSET M
11
  );
12
END

178. Rank Scores#

https://leetcode.com/problems/rank-scores/

第一种方法，对于当前分数，不断计算出大于等于当前分数的数量，这个数量对应排名。

1
SELECT Score,
2
  (SELECT COUNT(*)
3
    FROM (SELECT DISTINCT Score s FROM Scores) AS tmp /* greater or equal to current score */
4
    WHERE s >= Score) AS 'Rank'
5
FROM Scores
6
ORDER BY Score DESC

第二种方法，可以直接使用DENSE_RANK()函数。

1
SELECT Score, DENSE_RANK() OVER (ORDER BY Score DESC) AS 'Rank'
2
FROM Scores

179. Largest Number#

https://leetcode.com/problems/largest-number/

重定义Arrays.sort()的Comparator。如果Comparator调用的compare(obj param1, obj param2)函数返回结果大于0，说明排序时param1位于param2之后，达到升序的效果；等于0和小于0的情况以此类推。

为了排除字典序首字符的干扰，需要将两个待比较字符串参数s1，s2合并，即比较s1+s2和s2+s1。如果s2+s1“大于”s1+s2，排序的结果中s2将前于s1。

1
class Solution {
2
    public String largestNumber(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return "";
5
        }
6

7
        String[] strs = new String[nums.length];
8
        for (int i = 0; i < nums.length; i++) {
9
            strs[i] = String.valueOf(nums[i]);
10
        }
11

12
        // sort from the largest num to the smallest
13
        Arrays.sort(strs, (String s1, String s2) -> {
14
            return (s2 + s1).compareTo(s1 + s2);
15
        });
16

17
        // starting digit is 0, then it must be 0
18
        if (strs[0].charAt(0) == '0') {
19
            return "0";
20
        }
21

22
        StringBuilder sb = new StringBuilder();
23
        for (String str : strs) {
24
            sb.append(str);
25
        }
26

27
        return sb.toString();
28
    }
29
}

展开收起

180. Consecutive Numbers#

https://leetcode.com/problems/consecutive-numbers/

自连接三遍，比较三张表是否有连续的三个ID对应的数字相等。

1
SELECT DISTINCT l1.Num AS ConsecutiveNums
2
FROM Logs l1, Logs l2, Logs l3
3
WHERE l1.Id = l2.Id - 1 AND l2.Id = l3.Id - 1 AND l1.Num = l2.Num AND l2.Num = l3.Num

181. Employees Earning More Than Their Managers#

https://leetcode.com/problems/employees-earning-more-than-their-managers/

进行一次左连接，左表是Employee表自身，右表选出Id和Salary即可。左表的managerId需要和右表的id相等，并且左表的工资比右表高。

1
SELECT E1.Name AS Employee
2
FROM Employee E1 LEFT JOIN (
3
    SELECT Id, Salary
4
    FROM Employee
5
    GROUP BY Id
6
) E2
7
ON E1.ManagerId = E2.Id
8
WHERE E1.Salary > E2.Salary;

182. Duplicate Emails#

https://leetcode.com/problems/duplicate-emails/

使用COUNT()函数，找出出现次数不止1次的邮箱。注意需要先GROUP BY Email，才能统计次数。

1
SELECT Email
2
FROM Person
3
GROUP BY Email
4
HAVING COUNT(*) > 1

183. Customers Who Never Order#

https://leetcode.com/problems/customers-who-never-order/

从Customers表中选出符合条件的顾客，这些顾客的ID没有出现在Orders表中。

1
SELECT Name AS Customers
2
FROM Customers
3
WHERE Id NOT IN (
4
    SELECT DISTINCT(CustomerId)
5
    FROM Orders
6
)

184. Department Highest Salary#

https://leetcode.com/problems/department-highest-salary/

用一个子查询，按照每个部门选出最高的工资，得到若干(DepartmentId, Salary)组合；再遍历Employee表，找到匹配的记录。

1
SELECT D.Name AS Department, E.Name AS Employee, E.Salary
2
FROM Employee E, Department D
3
WHERE E.DepartmentId = D.Id AND (E.DepartmentId, E.Salary) IN (
4
    SELECT DepartmentId, max(Salary) AS max
5
    FROM Employee
6
    GROUP BY DepartmentId
7
)

185. Department Top Three Salaries#

https://leetcode.com/problems/department-top-three-salaries/

与上一题思路类似，仍然使用子查询。

1
SELECT D.name Department, E.name Employee, E.salary Salary
2
FROM Employee E, Department D
3
WHERE E.DepartmentId = d.Id AND (
4
        SELECT COUNT(*)
5
        FROM (SELECT DISTINCT Salary, DepartmentId FROM Employee) T
6
        WHERE T.DepartmentId = E.DepartmentId AND T.Salary >= E.Salary
7
    ) <= 3
8
ORDER BY D.name, E.salary desc

186. Reverse Words in a String II#

https://leetcode.com/problems/reverse-words-in-a-string-ii/

先颠倒整个字符串，之后利用空格或是字符串终点，判定当前单词的范围，再颠倒每一个单词。

1
class Solution {
2
    public void reverseWords(char[] s) {
3
        if (s == null || s.length <= 1) {
4
            return;
5
        }
6

7
        reverse(s, 0, s.length - 1);
8

9
        for (int i = 0, j = 0; i <= s.length; i++) {
10
            if (i == s.length || s[i] == ' ') {
11
                // reverse current word
12
                reverse(s, j, i - 1);
13

14
                // set j to next word's start
15
                j = i + 1;
16
            }
17
        }
18
    }
19

20
    // reverse characters in [begin, end]
21
    private void reverse(char[] s, int begin, int end) {
22
        while (begin < end) {
23
            char c = s[begin];
24
            s[begin] = s[end];
25
            s[end] = c;
26

27
            begin++;
28
            end--;
29
        }
30
    }
31
}

展开收起

187. Repeated DNA Sequences#

https://leetcode.com/problems/repeated-dna-sequences/

使用两个集合seen和repeated。每10个字符作为一个字符串，加入到seen中，如果seen加不进去，说明已经重复出现过了，加到repeated去。最后将repeated转为list即可。

1
class Solution {
2
    public List<String> findRepeatedDnaSequences(String s) {
3
        Set seen = new HashSet(), repeated = new HashSet();
4

5
        for (int i = 0; i < s.length() - 9; i++) {
6
            String cur = s.substring(i, i + 10);
7

8
            if (!seen.add(cur)) {
9
                repeated.add(cur);
10
            }
11
        }
12

13
        return new ArrayList(repeated);
14
    }
15
}

展开收起

188. Best Time to Buy and Sell Stock IV#

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/

当输入的k很大，超过prices的长度时，无法用完这么多次交易的次数，因此转化为最简单的情况：只要有钱赚，当天买第二天就卖。

k不够大时，设立两个数组buy和sell，其中buy[i]表示第i次买入后用户剩余多少钱，sell[i]表示第i次卖出后用户剩余多少钱。显然有：

buy[i] = 上一次卖出后的钱 - 当前股票价格
sell[i] = 当前买入之前的钱 + 当前股票价格

视情况决定是否有必要进行交易。结果关注sell[k]即可。

1
class Solution {
2
    public int maxProfit(int k, int[] prices) {
3
        if (k == 0 || prices.length <= 1) {
4
            return 0;
5
        }
6
        int len = prices.length;
7

8
        // k is very large, let's become greedy
9
        if (k >= len - 1) {
10
            int result = 0;
11
            for (int i = 1; i < len; i++) {
12
                if (prices[i] > prices[i - 1]) {
13
                    result += prices[i] - prices[i - 1];
14
                }
15
            }
16

17
            return result;
18
        }
19

20
        int[] buy = new int[k + 1];
21
        int[] sell = new int[k + 1];
22
        Arrays.fill(buy, Integer.MIN_VALUE);
23
        Arrays.fill(sell, 0);
24

25
        for (Integer cur : prices) {
26
            for (int i = 1; i <= k; i++) {
27
                buy[i] = Math.max(sell[i - 1] - cur, buy[i]);
28
                sell[i] = Math.max(buy[i] + cur, sell[i]);
29
            }
30
        }
31

32
        return sell[k];
33
    }
34
}

展开收起

189. Rotate Array#

https://leetcode.com/problems/rotate-array/

进行三次数组倒序：

整个数组倒序
前k个数倒序
剩余数倒序

1
class Solution {
2
    public void rotate(int[] nums, int k) {
3
        if (nums == null || nums.length <= 1 || k < 1) {
4
            return;
5
        }
6
        int len = nums.length;
7
        if (k > len) {
8
            k %= len;
9
        }
10

11
        reverse(nums, 0, len - 1);
12
        reverse(nums, 0, k - 1);
13
        reverse(nums, k, len - 1);
14
    }
15

16
    private void reverse(int[] nums, int start, int end) {
17
        while (start < end) {
18
            int temp = nums[start];
19
            nums[start] = nums[end];
20
            nums[end] = temp;
21

22
            start++;
23
            end--;
24
        }
25
    }
26
}

展开收起

190. Reverse Bits#

https://leetcode.com/problems/reverse-bits/

解题步骤分为3步：

result左移1位，空出最右的一位
判断当前n的最后一位是否为1，如果是1，result也要加1。因为此前result的最后一位肯定是0，所以这一步能保证目前result的最后一位和n的最后一位是同步的
n右移一位，表示完成了一位的处理。

循环32次，便可完成逐位转化。

1
public class Solution {
2
    // you need treat n as an unsigned value
3
    public int reverseBits(int n) {
4
        int result = 0;
5

6
        for (int i = 0; i < 32; i++) {
7
            result <<= 1;
8

9
            // add 1 to result if the last bif of n is 1
10
            result += (n & 1);
11

12
            // logic right shift, always complement 0
13
            n >>>= 1;
14
        }
15

16
        return result;
17
    }
18
}

展开收起

191. Number of 1 Bits#

https://leetcode.com/problems/number-of-1-bits/

利用n & 1提取最后一位的值，再使用右移推进至前一位。

1
public class Solution {
2
    // you need to treat n as an unsigned value
3
    public int hammingWeight(int n) {
4
        int result = 0;
5

6
        while (n != 0) {
7
            result += (n & 1);
8
            n >>>= 1;
9
        }
10

11
        return result;
12
    }
13
}

192. Word Frequency#

https://leetcode.com/problems/word-frequency/

bash部分命令：

cat: 查看某文件的内容
tr: 删除文件中控制字符或进行字符转换。-s参数表示删除所有重复出现字符序列，只保留第一个
sort: 将文本文件内容加以排序。-r参数表示以相反顺序排序
uniq: 检查及删除文本文件中重复出现的行列。-c参数表示在每列旁边显示该行重复出现的次数。
awk: 文本格式化命令。 awk '{print $2}' 表示打印第二个字段。

Terminal window

1
cat words.txt | tr -s ' ' '\n' | sort | uniq -c | sort -r | awk '{ print $2, $1 }'

193. Valid Phone Numbers#

https://leetcode.com/problems/valid-phone-numbers/

grep / egrep是Linux中的文本搜索工具，运用正则表达式搜索符合指定格式的字符串。

Terminal window

1
egrep "^((\([0-9]{3}\) )|([0-9]{3}-))[0-9]{3}-[0-9]{4}$" file.txt

194. Transpose File#

https://leetcode.com/problems/transpose-file/

awk命令中，

NF记录域个数，此题中可以理解为文件的行数
NR表示已经读取的记录数，此题可以理解为已经读取的文件行数

同时在bash中，字符串的追加非常容易，例如s = s a表示将字符串a追加于s之后。完成awk后，还有一个END部分用于处理输出。其余语法与C语言近似。

Terminal window

1
awk '
2
{
3
  for (i = 1; i <= NF; i++) {
4
    if (NR == 1) result[i] = $i;
5
    else result[i] = result[i] " " $i
6
  }
7
}
8
END {
9
  for (i = 1; result[i] != ""; i++) print result[i];
10
}' file.txt

195. Tenth Line#

https://leetcode.com/problems/tenth-line/

一种方法是使用cat和awk的组合命令：

1
cat file.txt | awk 'NR == 10'

另一种方法是使用sed命令。sed可依照脚本的指令来处理、编辑文本文件，单位是行。

1
sed -n 10p file.txt

其中，-n表示仅显示处理后的结果，p表示打印某个选择的数据。

196. Delete Duplicate Emails#

https://leetcode.com/problems/delete-duplicate-emails/

将相同的邮件地址记录group by合并，只选出每一条合并记录的最小id，其余的id舍弃。

1
DELETE FROM Person
2
WHERE Id NOT IN (
3
    SELECT A.Id
4
    FROM (
5
        SELECT Min(Id) AS Id
6
        FROM Person
7
        GROUP BY Email
8
    ) AS A
9
)

197. Rising Temperature#

https://leetcode.com/problems/rising-temperature/

使用TO_DAYS()函数转化DATE形式的变量，这样一来可以进行日期的比较。

1
SELECT W2.Id
2
FROM Weather W1, Weather W2
3
WHERE TO_DAYS(W2.RecordDate) - TO_DAYS(W1.RecordDate) = 1 AND W2.Temperature > W1.Temperature

198. House Robber#

https://leetcode.com/problems/house-robber/

使用两个变量，prev2表示不考虑当前数的前一个数时，获取的最大收益；prev则综合比较prev2与当前数之和，与不考虑当前数时的收益，哪一个更大选哪个。

1
class Solution {
2
    public int rob(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        // prev2: max profit without current number's prior number
8
        // prev: max profit between (1. without current number 2. prev2 + current number)
9
        int prev2 = 0, prev = 0;
10
        for (int num : nums) {
11
            int temp = prev;
12
            prev = Math.max(prev, prev2 + num);
13
            prev2 = temp;
14
        }
15

16
        return prev;
17
    }
18
}

展开收起

199. Binary Tree Right Side View#

https://leetcode.com/problems/binary-tree-right-side-view/

正常情况下，不断向下搜索当前节点的右节点；但如果右节点为空，则返回搜索左节点。搜索过程中，层数和结果list的长度应当始终对应。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> rightSideView(TreeNode root) {
18
        List<Integer> result = new LinkedList<>();
19
        helper(result, root, 1);
20
        return result;
21
    }
22

23
    private void helper(List<Integer> result, TreeNode node, int depth) {
24
        if (node == null) {
25
            return;
26
        }
27
        if (result.size() < depth) {
28
            result.add(node.val);
29
        }
30

31
        helper(result, node.right, depth + 1);
32
        helper(result, node.left, depth + 1);
33
    }
34
}

展开收起

200. Number of Islands#

https://leetcode.com/problems/number-of-islands/

使用DFS，已经走过的格子需要置为0，每遇到一个’1’岛屿数就加一。这是因为如果陆地是连续的，在计数之前，在此前的DFS递归调用已经将当前岛屿的邻近’1’全部变为0了。

1
class Solution {
2
    private int row = 0, col = 0;
3

4
    public int numIslands(char[][] grid) {
5
        if (grid.length == 0 || grid[0].length == 0) {
6
            return 0;
7
        }
8

9
        row = grid.length;
10
        col = grid[0].length;
11

12
        int result = 0;
13
        for (int i = 0; i < row; i++) {
14
            for (int j = 0; j < col; j++) {
15
                if (grid[i][j] == '1') {
16
                    dfs(grid, i, j);
17
                    result++;
18
                }
19
            }
20
        }
21

22
        return result;
23
    }
24

25
    private void dfs(char[][] grid, int x, int y) {
26
        if (x < 0 || y < 0 || x >= row || y >= col || grid[x][y] != '1') {
27
            return;
28
        }
29

30
        grid[x][y] = '0';
31

32
        dfs(grid, x + 1, y);
33
        dfs(grid, x - 1, y);
34
        dfs(grid, x, y + 1);
35
        dfs(grid, x, y - 1);
36
    }
37
}

展开收起

LeetCode 201-300

Wed, 01 Jan 2020 00:00:00 GMT

LeetCode Problems 201-300.

201. Bitwise AND of Numbers Range#

https://leetcode.com/problems/bitwise-and-of-numbers-range/

实际上，如果将left和right转化为相同长度的二进制串，按位与的结果就是两个二进制串的最长相等前缀。因此，不断右移left和right，记录移动的位数，直到left和right相等；再将left左移这个位数进行复原。

1
class Solution {
2
    public int rangeBitwiseAnd(int left, int right) {
3
        if (left == 0) {
4
            return 0;
5
        }
6

7
        int count = 0;
8
        while (left != right) {
9
            left >>>= 1;
10
            right >>>= 1;
11
            count++;
12
        }
13

14
        return left <<= count;
15
    }
16
}

展开收起

202. Happy Number#

https://leetcode.com/problems/happy-number/

逐位计算currentDigit的平方和，累加得到当前的result。每计算一次当前的result都要确保result不等于1或者4（陷入循环，一定不是happy number)。确认result没有问题后，将其作为新一轮的输入，继续进行判断。

1
class Solution {
2
    public boolean isHappy(int n) {
3
        int result = 0, current = 0;
4
        while (result != 1) {
5

6
            // calculate current result
7
            while (n != 0) {
8
                current = n % 10;
9
                n /= 10;
10
                result += current * current;
11
            }
12

13
            // result cannot be 1 or 4, otherwise fall into loop
14
            if (result > 1 && result != 4) {
15
                n = result;
16
                result = 0;
17
            } else {
18
                break;
19
            }
20
        }
21

22
        return result == 1;
23
    }
24
}

展开收起

203. Remove Linked List Elements#

https://leetcode.com/problems/remove-linked-list-elements/

使用cur指针标记当前节点，prev指针标记之前一个节点。正常情况下，两个指针每一次向右移动一格；但cur指向的元素值与val相等时，prev指向cur的下一个元素，跳过cur，相当于删除了当前元素。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode removeElements(ListNode head, int val) {
13
        if (head == null) {
14
            return head;
15
        }
16

17
        ListNode dummyHead = new ListNode(0);
18
        dummyHead.next = head;
19

20
        ListNode prev = dummyHead, cur = head;
21
        while (cur != null) {
22
            // when current element's value is val, skip
23
            if (cur.val == val) {
24
                prev.next = cur.next;
25
            } else {
26
                prev = prev.next;
27
            }
28

29
            // always move forward cur
30
            cur = cur.next;
31
        }
32

33
        return dummyHead.next;
34
    }
35
}

展开收起

204. Count Primes#

https://leetcode.com/problems/count-primes/

此题借鉴了埃拉托斯特尼筛法的思想，即找到一个范围内的较小质数时，删去这个质数的倍数，因为他们一定是合数。

使用一个数组prime标记所有小于n的数字，如果有i < n且i为合数，则prime[i] = false。初始情况下，所有数字都假定为质数。（初始化结果都是true）

一开始，假设比n小的质数有n/2个（即所有正奇数的个数；尽管1不是质数，但2恰好是唯一偶质数，二者抵消，数量上仍然是n的一半）。

由于只需要寻找奇数中的合数，从3开始遍历所有小于sqrt(n)的奇数。假定当前遍历的数字是i，如果已经能确定i是质数，则需要开启第二重循环，从i*i开始遍历至n。这一循环的目的是剔除掉所有i的若干倍数，因为它们都是合数。注意：此处的起点是i*i而非i，因为在不重复的前提下，i*i是通过i得知的最小合数（固然，2*i, 3*i等等数都是合数，但是这些在i == 2, i == 3时已经考虑过了，会重复）。此外，只需要考虑i*i + 偶数*i的情况，因为根据奇偶性，i*i + 奇数*i一定是一个偶数&合数。

每通过以上步骤排除一个合数，就在原始结果n/2的基础上减去1；同时，这个数在数组prime中被标记为false。之后的遍历中，遇到这些合数就可以直接跳过了。

1
class Solution {
2
    public int countPrimes(int n) {
3
        if (n < 3) {
4
            return 0;
5
        }
6

7
        boolean[] prime = new boolean[n];
8
        Arrays.fill(prime, true);
9

10
        // assume all odd numbers are prime number
11
        int result = n / 2;
12

13
        for (int i = 3; i * i < n; i += 2) {
14
            // skip a composite number
15
            if (!prime[i]) {
16
                continue;
17
            }
18

19
            // multiples of composite numbers are skipped
20
            for (int j = i * i; j < n; j += 2 * i) {
21
                // this multiple of i has not been excluded
22
                if (prime[j]) {
23
                    result--;
24
                    prime[j] = false;
25
                }
26
            }
27
        }
28

29
        return result;
30
    }
31
}

展开收起

205. Isomorphic Strings#

https://leetcode.com/problems/isomorphic-strings/

人造两个map，使得A中相同下标的字符能对应B，B中相同下标的字符能对应A。

1
class Solution {
2
    public boolean isIsomorphic(String s, String t) {
3
        if (s.length() != t.length()) {
4
            return false;
5
        }
6

7
        char[] sChars = s.toCharArray();
8
        char[] tChars = t.toCharArray();
9

10
        char[] sMap = new char[256];
11
        char[] tMap = new char[256];
12

13
        for (int i = 0; i < sChars.length; i++) {
14
            char a = sChars[i], b = tChars[i];
15

16
            // not yet mapped
17
            if (sMap[a] == 0 && tMap[b] == 0) {
18
                sMap[a] = b;
19
                tMap[b] = a;
20
            } else if (sMap[a] != b || tMap[b] != a) {
21
                return false;
22
            }
23
        }
24

25
        return true;
26
    }
27
}

展开收起

206. Reverse Linked List#

https://leetcode.com/problems/reverse-linked-list/

第一种，使用非递归方法，用prev指向head的前一个元素。从头到尾，每一次循环都掉转一个指针的方向，即从head指向prev，再分别让两个指针向右移。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode reverseList(ListNode head) {
13
        if (head == null) {
14
            return null;
15
        }
16

17
        ListNode prev = null;
18
        while (head != null) {
19
            ListNode next = head.next;
20
            head.next = prev;
21

22
            prev = head;
23
            head = next;
24
        }
25

26
        return prev;
27
    }
28
}

展开收起

第二种，使用递归方法。与第一种方法类似，只是prev与head向前移动的迭代过程变成了递归调用。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public ListNode reverseList(ListNode head) {
13
        return reverse(head, null);
14
    }
15

16
    private ListNode reverse(ListNode head, ListNode prev) {
17
        if (head == null) {
18
            return prev;
19
        }
20

21
        ListNode next = head.next;
22
        head.next = prev;
23
        return reverse(next, head);
24
    }
25
}

展开收起

207. Course Schedule#

https://leetcode.com/problems/course-schedule/

此题运用DFS，将先修课程数组转化为图的形式，对于每门课程，维护一个状态数组，分别是0：未访问 1：访问中 2：已访问。在DFS的时候检查当前课程和后续课程的状态，判断是否存在两门课互为前提的情况，如果有，则说明不能安排课程。

1
class Solution {
2
    boolean isCycle = false;
3

4
    public boolean canFinish(int numCourses, int[][] prerequisites) {
5

6
        List<List<Integer>> graph = new ArrayList<>();
7
        for (int i = 0; i < numCourses; i++) {
8
            graph.add(new ArrayList<Integer>());
9
        }
10

11
        // add all subsequent courses for each course
12
        for (int[] prerequisite : prerequisites)
13
            graph.get( prerequisite[1] ).add( prerequisite[0] );
14

15
        int[] courseStatus = new int[numCourses];
16
        for (int i = 0; i < numCourses; i++) {
17
            if (courseStatus[i] == 0) {
18
                dfs(courseStatus, i, graph);
19
            }
20
        }
21

22
        return !isCycle;
23
    }
24

25
    // 0 unvisited, 1 visiting, 2 visited
26
    private void dfs(int[] courseStatus, int node, List<List<Integer>> graph) {
27
        courseStatus[node] = 1;
28

29
        for (int next : graph.get(node)) {
30
            if (courseStatus[next] == 0) {
31
                dfs(courseStatus, next, graph);
32
            }
33

34
            if (courseStatus[next] == 1) {
35
                isCycle = true;
36
            }
37
        }
38

39
        courseStatus[node] = 2;
40
    }
41
}

展开收起

208. Implement Trie (Prefix Tree)#

https://leetcode.com/problems/implement-trie-prefix-tree/

单词拆分为逐个字母，每个字母对应到一个树节点。节点存储两个信息：一个是当前节点是否为单词的最后一个字母；另一个存储所有下一个字母的信息。

1
class Trie {
2

3
    class TrieNode {
4
        public TrieNode() {}
5
        boolean isEnd = false;
6
        TrieNode[] children = new TrieNode[26];
7
    }
8

9
    private TrieNode root = new TrieNode();
10

11
    /** Initialize your data structure here. */
12
    public Trie() {}
13

14
    /** Inserts a word into the trie. */
15
    public void insert(String word) {
16
        TrieNode cur = root;
17
        for (char c : word.toCharArray()) {
18
            if (cur.children[c - 'a'] == null) {
19
                cur.children[c - 'a'] = new TrieNode();
20
            }
21
            cur = cur.children[c - 'a'];
22
        }
23

24
        cur.isEnd = true;
25
    }
26

27
    /** Returns if the word is in the trie. */
28
    public boolean search(String word) {
29
        TrieNode cur = root;
30
        for (char c : word.toCharArray()) {
31
            if (cur.children[c - 'a'] == null) {
32
                return false;
33
            }
34
            cur = cur.children[c - 'a'];
35
        }
36

37
        // must exactly match, so the word in trie should also end
38
        return cur.isEnd;
39
    }
40

41
    /** Returns if there is any word in the trie that starts with the given prefix. */
42
    public boolean startsWith(String prefix) {
43
        TrieNode cur = root;
44
        for (char c : prefix.toCharArray()) {
45
            if (cur.children[c - 'a'] == null) {
46
                return false;
47
            }
48
            cur = cur.children[c - 'a'];
49
        }
50

51
        return true;
52
    }
53
}

展开收起

209. Minimum Size Subarray Sum#

https://leetcode.com/problems/minimum-size-subarray-sum/

使用双指针法，sum总是先加上nums[right]，并且右指针右移；在sum大于s的前提下，再试图删去尽可能多的nums[left]，使得left和right差值尽量小。如果遍历完整个数组后都没有符合条件的情况，则返回0。

1
class Solution {
2
    public int minSubArrayLen(int s, int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int sum = 0, left = 0, right = 0;
8

9
        // By default, the minimum length is Max integer
10
        int result = Integer.MAX_VALUE;
11

12
        while (right < nums.length) {
13
            sum += nums[right];
14
            right++;
15

16
            // delete as many nums[left] as possible
17
            while (sum >= s) {
18
                result = Math.min(result, right - left);
19
                sum -= nums[left];
20
                left++;
21
            }
22
        }
23

24
        return result == Integer.MAX_VALUE ? 0 : result;
25
    }
26
}

展开收起

210. Course Schedule II#

https://leetcode.com/problems/course-schedule-ii/

在Course Schedule的基础上添加结果数组，每个dfs到达终点时表示当前最后选修的课程，这门课程应该放置于当前结果数组的末尾。

1
class Solution {
2
    boolean isCycle = false;
3
    int[] result;
4
    int resultIndex;
5

6
    public int[] findOrder(int numCourses, int[][] prerequisites) {
7
        result = new int[numCourses];
8
        resultIndex = numCourses - 1; // start from the last course
9

10
        List<List<Integer>> graph = new ArrayList<>();
11
        for (int i = 0; i < numCourses; i++) {
12
            graph.add(new ArrayList<Integer>());
13
        }
14

15
        // add all subsequent courses for each course
16
        for (int[] prerequisite : prerequisites) {
17
            graph.get( prerequisite[1] ).add( prerequisite[0] );
18
        }
19

20
        int[] courseStatus = new int[numCourses];
21
        for (int i = 0; i < numCourses; i++) {
22
            if (courseStatus[i] == 0) {
23
                dfs(courseStatus, i, graph);
24
            }
25
        }
26

27
        return isCycle ? new int[]{} : result;
28
    }
29

30
    // 0 unvisited, 1 visiting, 2 visited
31
    private void dfs(int[] courseStatus, int node, List<List<Integer>> graph) {
32
        courseStatus[node] = 1;
33

34
        for (int next : graph.get(node)) {
35
            if (courseStatus[next] == 0) {
36
                dfs(courseStatus, next, graph);
37
            }
38

39
            if (courseStatus[next] == 1) {
40
                isCycle = true;
41
            }
42
        }
43

44
        courseStatus[node] = 2;
45

46
        result[resultIndex] = node;
47
        resultIndex--;
48
    }
49
}

展开收起

211. Design Add and Search Words Data Structure#

https://leetcode.com/problems/design-add-and-search-words-data-structure/

借鉴Trie的思想，添加单词操作不变；搜索单词则略有变化，因为要处理.的情况。思路是使用index跟踪当前已遍历的长度，正常情况下保证子节点不空，并且下一个字符匹配即可；但如果遇到.时，由于这个字符能匹配任何字符，因此需要检查所有但非空子节点，判断之后是否能匹配。

1
class WordDictionary {
2

3
    public class TrieNode {
4
        public TrieNode() {}
5
        TrieNode[] children = new TrieNode[26];
6
        boolean isEnd = false;
7

8
        public boolean match(String word, int index) {
9
            if (index == word.length()) {
10
                return isEnd;
11
            }
12

13
            // check all not-null children
14
            if (word.charAt(index) == '.') {
15
                for (int i = 0 ; i < 26; i++) {
16
                    if (children[i] != null && children[i].match(word, index + 1)) {
17
                        return true;
18
                    }
19
                }
20

21
                return false;
22
            } else {
23
                return children[word.charAt(index) - 'a'] != null && children[word.charAt(index) - 'a'].match(word, index + 1);
24
            }
25
        }
26
    }
27

28
    private TrieNode root = new TrieNode();
29

30
    /** Initialize your data structure here. */
31
    public WordDictionary() {}
32

33
    /** Adds a word into the data structure. */
34
    public void addWord(String word) {
35
        TrieNode cur = root;
36
        for (char c : word.toCharArray()) {
37
            if (cur.children[c - 'a'] == null) {
38
                cur.children[c - 'a'] = new TrieNode();
39
            }
40

41
            cur = cur.children[c - 'a'];
42
        }
43

44
        cur.isEnd = true;
45
    }
46

47
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
48
    public boolean search(String word) {
49
        return root.match(word, 0);
50
    }
51
}

展开收起

212. Word Search II#

https://leetcode.com/problems/word-search-ii/

构造Prefix Tree，将输入的words中每一个单词存入每个TrieNode中，注意完成输入后，在最后一个字母的节点处将word属性设为当前单词；再使用DFS，如果遍历的过程中遇到某个TrieNode中的单词不为空，说明已经遍历了一个完整的单词，将其添加到结果中。

1
class Solution {
2
    public class TrieNode {
3
        TrieNode[] children = new TrieNode[26];
4
        String word;
5
    }
6

7
    public TrieNode buildTrie(String[] words) {
8
        TrieNode root = new TrieNode();
9

10
        for (String word : words) {
11
            TrieNode cur = root;
12
            for (char c : word.toCharArray()) {
13
                if (cur.children[c - 'a'] == null) {
14
                    cur.children[c - 'a'] = new TrieNode();
15
                }
16
                cur = cur.children[c - 'a'];
17
            }
18

19
            // only set cur.word when finishing inserting a word
20
            cur.word = word;
21
        }
22

23
        return root;
24
    }
25

26
    public List<String> findWords(char[][] board, String[] words) {
27
        List<String> result = new ArrayList<>();
28
        TrieNode root = buildTrie(words);
29

30
        for (int i = 0; i < board.length; i++) {
31
            for (int j = 0; j < board[0].length; j++) {
32
                dfs(board, i, j, root, result);
33
            }
34
        }
35

36
        return result;
37
    }
38

39
    public void dfs(char[][] board, int i, int j, TrieNode cur, List<String> result) {
40
        char c = board[i][j];
41
        if (c == '#' || cur.children[c - 'a'] == null) {
42
            return;
43
        }
44
        cur = cur.children[c - 'a'];
45

46
        // end of current word
47
        if (cur.word != null) {
48
            result.add(cur.word);
49

50
            // avoid repeat searching
51
            cur.word = null;
52
        }
53

54
        // temporarily mark visited character
55
        board[i][j] = '#';
56

57
        // try four adjacent grids
58
        if (i > 0) {
59
            dfs(board, i - 1, j, cur, result);
60
        }
61
        if (j > 0) {
62
            dfs(board, i, j - 1, cur, result);
63
        }
64
        if (i < board.length - 1) {
65
            dfs(board, i + 1, j, cur, result);
66
        }
67
        if (j < board[0].length - 1) {
68
            dfs(board, i, j + 1, cur, result);
69
        }
70

71
        board[i][j] = c;
72
    }
73
}

展开收起

213. House Robber II#

https://leetcode.com/problems/house-robber-ii/

为了避免圆环交接处相邻两户民居报警，只能重新划定范围，相当于沿用House Robber I的思路，进行比较：一次抢[0, nums.length - 2]的范围，另一次抢[1, nums.length - 1]的范围，选取收益大的那一次。

1
class Solution {
2
    private int helper(int[] nums, int low, int high) {
3

4
        // prev2: max profit without current number's prior number
5
        // prev: max profit between (1. without current number 2. prev2 + current number)
6
        int prev2 = 0, prev = 0;
7

8
        for (int i = low; i <= high; i++) {
9
            int temp = prev;
10
            prev = Math.max(prev, prev2 + nums[i]);
11
            prev2 = temp;
12
        }
13

14
        return prev;
15
    }
16

17
    public int rob(int[] nums) {
18
        if (nums == null || nums.length == 0) {
19
            return 0;
20
        } else if (nums.length == 1) {
21
            return nums[0];
22
        }
23

24
        return Math.max(helper(nums, 0, nums.length - 2), helper(nums, 1, nums.length - 1));
25
    }
26
}

展开收起

214. Shortest Palindrome#

https://leetcode.com/problems/shortest-palindrome/

显然，最直接的考虑是直接在s前添加s的逆，这样一定能得到回文串。但由于题目要求是最短但回文串，因此需要考虑的是，如何删减去粗浅思路的中间部分。换言之，如何找出中间的一部分“公共字符串”，能够用来构造回文串。例如，如果输入为s = aabba，则aa就是公共字符串：

1
原始构造：abbaa aabba
2
优化后构造： abb aa bba

为了寻找中间的字符串，使用两个指针分别从s的头尾开始遍历。如果头尾指针指向的字符相等，则头指针向后移动一位；而尾指针每一次循环都向前移动一位。这一过程中两个指针必然相遇，因此头指针至少会移动一次。在这种情况下，便能够根据头指针的位置，将s分成两个部分，其中一部分是后缀，另一部分进一步需要处理成为公共字符串，构成的公式是：后缀的倒序 + 待处理公共字符串 + 后缀。当然，倘若头指针直接移动到了s末尾，说明s已经是一个回文串了。

1
class Solution {
2
    public String shortestPalindrome(String s) {
3
        if (s.length() == 0 || s.length() == 1) {
4
            return s;
5
        }
6

7
        // try to divide the string into two parts, using head
8
        int head = 0;
9
        for (int tail = s.length() - 1; tail >= 0; tail--) {
10
            if (s.charAt(head) == s.charAt(tail)) {
11
                head++;
12
            }
13
        }
14

15
        // already a palindrome
16
        if (head == s.length()) {
17
            return s;
18
        }
19

20
        String suffix = s.substring(head);
21
        return new StringBuilder(suffix).reverse().toString() + shortestPalindrome(s.substring(0, head)) + suffix;
22
    }
23
}

展开收起

215. Kth Largest Element in an Array#

https://leetcode.com/problems/kth-largest-element-in-an-array/

使用快速选择算法，利用pivot元素为轴，交换双指针对应的数nums[left]和nums[right]，小于pivot的数放在pivot左侧，大于pivot的数放右侧。时间复杂度为O(n)。

1
class Solution {
2
    public int findKthLargest(int[] nums, int k) {
3
        if (nums == null || nums.length == 0) {
4
            return -1;
5
        }
6

7
        // kth largest is equal to (nums.length - k)th smallest
8
        return quickSelect(nums, 0, nums.length - 1, nums.length - k);
9
    }
10

11
    // quick select: kth smallest
12
    public int quickSelect(int[] nums, int begin, int end, int k) {
13
        if (begin == end) {
14
            return nums[begin];
15
        }
16
        if (begin > end) {
17
            return Integer.MAX_VALUE;
18
        }
19

20
        int pivot = nums[begin + (end - begin) / 2];
21
        int left = begin;
22
        int right = end;
23

24
        while (left <= right) {
25
            while (left <= right && nums[left] < pivot) {
26
                left++;
27
            }
28
            while (left <= right && nums[right] > pivot) {
29
                right--;
30
            }
31

32
            if (left <= right) {
33
                swap(nums, left, right);
34
                left++;
35
                right--;
36
            }
37
        }
38

39
        if (right >= k && right >= begin) {
40
            return quickSelect(nums, begin, right, k);
41
        } else if (left <= k && left <= end) {
42
            return quickSelect(nums, left, end, k);
43
        } else {
44
            return nums[k];
45
        }
46
    }
47

48
    private void swap(int[] A, int i, int j) {
49
        int temp = A[i];
50
        A[i] = A[j];
51
        A[j] = temp;
52
    }
53
}

展开收起

216. Combination Sum III#

https://leetcode.com/problems/combination-sum-iii/

套用此前总结的回溯问题模版即可，注意迭代时的变量含义。

1
class Solution {
2
    public List<List<Integer>> combinationSum3(int k, int n) {
3
        List< List<Integer> > result = new ArrayList<>();
4
        backtrack(result, new ArrayList<>(), k, n, 1);
5
        return result;
6
    }
7

8
    private void backtrack(List< List<Integer> > result, List<Integer> temp, int k, int n, int start) {
9
        if (temp.size() == k && n == 0) {
10
            result.add(new ArrayList<>(temp));
11
            return;
12
        }
13

14
        for (int i = start; i <= 9; i++) {
15
            temp.add(i);
16

17
            // need k numbers; remain sum is n - i; starting index is i + 1
18
            backtrack(result, temp, k, n - i, i + 1);
19
            temp.remove(temp.size() - 1);
20
        }
21
    }
22
}

展开收起

217. Contains Duplicate#

https://leetcode.com/problems/contains-duplicate/

向HashSet中添加元素，重复的数字无法被添加。

1
class Solution {
2
    public boolean containsDuplicate(int[] nums) {
3
        if (nums.length <= 1) {
4
            return false;
5
        }
6

7
        Set<Integer> set = new HashSet<Integer>();
8
        for (Integer num : nums) {
9
            if (!set.add(num)) {
10
                return true;
11
            }
12
        }
13

14
        return false;
15
    }
16
}

展开收起

218. The Skyline Problem#

https://leetcode.com/problems/the-skyline-problem/

把所有楼房的坐标与高度信息提取出来并排序，排序时按照先坐标（从左到右）后高度（从低到高）的顺序进行排列。注意提取时，可以将left edge的高度取个负数处理，这样做的目的是更好区分出left edge和right edge，方便之后的计算。

完成排序后，利用TreeMap的自动排序特性，以楼房高度为key，具有这个高度的楼房数量为value，把刚才提取出来的信息整理到TreeMap中。分情况讨论：

如果高度是负数，说明提取到的是left edge，意味着遇到了一栋新楼，直接把信息存进TreeMap中
如果高度为正，并且这个高度在TreeMap中的value是1，说明当前只有一栋楼是这个高度，并且此时我们已经遇到了其右边界。因此，我们需要把这个高度key移出TreeMap，这样子之后的轮廓打印中才能够正确打印出第二高的楼房高度
如果高度为正，并且这个高度在TreeMap中的value不止是1，说明不止一栋楼是这个高度，我们只是遇到了其中一栋楼的右边界，仍然还有其他的楼是这个高度。因此我们只需要修改TreeMap中这个高度key对应的value即可

完成TreeMap处理后，获取到TreeMap的最后一个key，也就是当前能被看到的最高的高度。这个高度与其对应的坐标点就是城市天际线中的轮廓点之一。需要注意，只有这一轮key发生了改变，才需要输出（不变的key意味着轮廓重合，不需要被打印出来）。

1
class Solution {
2
    public List<List<Integer>> getSkyline(int[][] buildings) {
3
        List<List<Integer>> result = new ArrayList();
4

5
        List<int[]> height = new ArrayList();
6
        for (int[] b : buildings) {
7
            height.add(new int[]{b[0], -b[2]});
8
            height.add(new int[]{b[1], b[2]});
9
        }
10

11
        // first sort by x coordinate, then sort by height
12
        Collections.sort(height, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
13

14
        // <height, num>
15
        TreeMap<Integer, Integer> bst = new TreeMap();
16
        bst.put(0, 1);
17
        int prev = 0;
18

19
        for (int[] h : height) {
20

21
            if (h[1] < 0) {
22
                // a new building is incoming
23
                bst.put(-h[1], bst.getOrDefault(-h[1], 0) + 1);
24
            } else if (bst.get(h[1]) == 1) {
25
                // current highest building reaches end, should output second highest building later
26
                bst.remove(h[1]);
27
            } else {
28
                bst.put(h[1], bst.get(h[1]) - 1);
29
            }
30

31
            // output highest new building
32
            int cur = bst.lastKey();
33
            if (cur != prev) {
34
                result.add(new ArrayList(Arrays.asList(h[0], cur)));
35
                prev = cur;
36
            }
37
        }
38

39
        return result;
40
    }
41
}

展开收起

219. Contains Duplicate II#

https://leetcode.com/problems/contains-duplicate-ii/

用一个HashMap存储当前数nums[i]和下标i。利用HashMap.put()方法的返回值，判断遇到相同nums[i]时下标之差为多少。

1
class Solution {
2
    public boolean containsNearbyDuplicate(int[] nums, int k) {
3
        Map<Integer, Integer> map = new HashMap<>();
4

5
        for (int i = 0; i < nums.length; i++) {
6
            // if not present, new entry, else the old entry will be updated
7
            Integer idx = map.put(nums[i], i);
8

9
            if (idx != null && Math.abs(idx - i) <= k) {
10
                return true;
11
            }
12
        }
13

14
        return false;
15
    }
16
}

展开收起

220. Contains Duplicate III#

https://leetcode.com/problems/contains-duplicate-iii/

由于题目提示问题可以在O(nlogk)的时间复杂度内解决，因此想到了二叉搜索树，而结合二叉搜索树与去重复性特点的数据结构正好是TreeSet。

构造一个TreeSet，利用两个TreeSet的函数floor()和ceiling()分别找出小于等于当前num的最大元素与集合中大于等于当前num的最小元素，以此便能判断差值是否在范围内。同时，注意到题目限定了常数k作为判定范围，实际上便是提示维持一个长度为k的窗口大小用于判断内部的重复性，因此循环次数超过k时，要将向前k个位置的元素从TreeSet中删除。

最后，题目中可能出现整数溢出，因此应该将TreeSet初始化为Long格式。

1
class Solution {
2
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
3
        if (nums == null || nums.length < 2) {
4
            return false;
5
        }
6

7
        TreeSet<Long> set = new TreeSet<>();
8
        for (int i = 0; i < nums.length; i++) {
9
            long num = (long)nums[i];
10

11
            // get upper bound and lower bound of current num
12
            // find if there is any element in this range
13
            Long floor = set.floor(num), ceiling = set.ceiling(num);
14
            if ((floor != null && num - floor <= t) || (ceiling != null && ceiling - num <= t)) {
15
                return true;
16
            }
17

18
            // add current num to set
19
            set.add(num);
20

21
            // delete k-th number backward
22
            if (i >= k) {
23
                set.remove((long)nums[i - k]);
24
            }
25
        }
26

27
        return false;
28
    }
29
}

展开收起

221. Maximal Square#

https://leetcode.com/problems/maximal-square/

使用动态规划，dp[i][j]代表在以[i, j]这一格为右下角的正方形边长。若这一格的值为1，那这个正方形的边长就是他的上，左，斜上的最小值边长+1，因为任何一边短缺都构成不了正方形。

1
class Solution {
2
    public int maximalSquare(char[][] matrix) {
3
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
4
            return 0;
5
        }
6

7
        int row = matrix.length, col = matrix[0].length;
8
        int[][] dp = new int[row + 1][col + 1];
9
        int result = 0;
10

11
        for (int i = 1; i <= row; i++) {
12
            for (int j = 1; j <= col; j++) {
13
                if (matrix[i-1][j-1] == '1') {
14
                    // minimum of up, left, upper left grids
15
                    dp[i][j] = Math.min(Math.min(dp[i-1][j-1], dp[i-1][j]), dp[i][j-1]) + 1;
16
                    result = Math.max(dp[i][j], result);
17
                }
18
            }
19
        }
20

21
        return result * result;
22
    }
23
}

展开收起

222. Count Complete Tree Nodes#

https://leetcode.com/problems/count-complete-tree-nodes/

对于每一个节点：

计算左子树的高度
计算右子树的高度
左右相同，直接利用完全二叉树的特性算出答案
左右不同，递归至下一层继续计算子节点的左右子树深度。注意最后+1（自身节点的数量）

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int countNodes(TreeNode root) {
18
        int leftDepth = getLeftDepth(root);
19
        int rightDepth = getRightDepth(root);
20

21
        if (leftDepth == rightDepth) {
22
            return (1 << leftDepth) - 1;
23
        }
24

25
        return 1 + countNodes(root.left) + countNodes(root.right);
26
    }
27

28
    private int getLeftDepth(TreeNode node) {
29
        int depth = 0;
30
        while (node != null) {
31
            node = node.left;
32
            depth++;
33
        }
34
        return depth;
35
    }
36

37
    private int getRightDepth(TreeNode node) {
38
        int depth = 0;
39
        while (node != null) {
40
            node = node.right;
41
            depth++;
42
        }
43
        return depth;
44
    }
45
}

展开收起

223. Rectangle Area#

https://leetcode.com/problems/rectangle-area/

核心在于求出重叠部分的面积。要出现重叠，两矩形左边的最大值一定会小于右边的最小值；同理，下边的最大值会小于上边的最小值。

1
class Solution {
2
    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
3
        if (bx1 > ax2 || bx2 < ax1) {
4
            return (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1);
5
        }
6

7
        int left = Math.max(ax1, bx1);
8
        int right = Math.min(ax2, bx2);
9
        int bottom = Math.max(ay1, by1);
10
        int top = Math.min(ay2, by2);
11

12
        int overlap = 0;
13
        if (right > left && top > bottom) {
14
            overlap = (right - left) * (top - bottom);
15
        }
16

17
        return (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - overlap;
18
    }
19
}

展开收起

224. Basic Calculator#

https://leetcode.com/problems/basic-calculator/

使用栈，遇到数字修改num；遇到加减号将数字累计到结果中，并修改符号；遇到左括号把当前符号数弹入栈；遇到右括号则弹出栈顶符号数。得到最终结果前，需要将栈中的num取出，结合对应的符号累加。

1
class Solution {
2
    public int calculate(String s) {
3
        if (s == null || s.length() == 0) {
4
            return 0;
5
        }
6

7
        Stack<Integer> stack = new Stack<Integer>();
8
        int result = 0, sign = 1, num = 0;
9

10
        stack.push(sign);
11
        for (int i = 0; i < s.length(); i++) {
12
            char c = s.charAt(i);
13

14
            if (c >= '0' && c <= '9') {
15
                num = num * 10 + c - '0';
16
            } else if (c == '+' || c == '-') {
17
                result += sign * num;
18
                sign = stack.peek() * (c == '+' ? 1 : -1);
19
                num = 0;
20
            } else if (c == '(') {
21
                stack.push(sign);
22
            } else if (c == ')') {
23
                stack.pop();
24
            }
25
        }
26

27
        result += sign * num;
28
        return result;
29
    }
30
}

展开收起

225. Implement Stack using Queues#

https://leetcode.com/problems/implement-stack-using-queues/

队列实现栈时，主要关注push()。Queue添加元素默认添加在尾部，但可以将前面的元素全部逐个弹出再逐个加入到末尾，形成一种循环机制，以此达到“添加在头部”的效果。

1
class MyStack {
2

3
    private Queue<Integer> queue = new ArrayDeque<>();
4

5
    /** Initialize your data structure here. */
6
    public MyStack() {}
7

8
    /** Push element x onto stack. */
9
    public void push(int x) {
10
        queue.offer(x);
11
        for (int i = 1; i < queue.size(); i++) {
12
            queue.offer(queue.poll());
13
        }
14
    }
15

16
    /** Removes the element on top of the stack and returns that element. */
17
    public int pop() {
18
        return queue.poll();
19
    }
20

21
    /** Get the top element. */
22
    public int top() {
23
        return queue.peek();
24
    }
25

26
    /** Returns whether the stack is empty. */
27
    public boolean empty() {
28
        return queue.isEmpty();
29
    }
30
}

展开收起

226. Invert Binary Tree#

https://leetcode.com/problems/invert-binary-tree/

对于当前节点，左子树递归调用右支作为参数的invertTree()，右子树调用左支作为参数的invertTree()。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public TreeNode invertTree(TreeNode root) {
18
        if (root == null) {
19
            return null;
20
        }
21

22
        TreeNode left = root.left, right = root.right;
23
        root.left = invertTree(right);
24
        root.right = invertTree(left);
25
        return root;
26
    }
27
}

展开收起

227. Basic Calculator II#

https://leetcode.com/problems/basic-calculator-ii/

仍然使用栈，但与Basic Calculator不同，此次不需要考虑正负号，因此直接根据相应的运算符号处理栈即可。

需要注意，遇到空格时直接跳过；在处理完栈之后，要及时更新符号op和操作数num。此外，为了不遗漏算式中的最后一个数，可以使用一个技巧，即在原始的字符串后加一个+号，这样使得最后一个数也能被推入栈中。最后累加栈中的所有数即可。

1
class Solution {
2
    public int calculate(String s) {
3
        if (s == null || s.length() == 0) {
4
            return 0;
5
        }
6

7
        Stack<Integer> stack = new Stack<>();
8

9
        // ensure that the last number can be pushed into the stack
10
        s += '+';
11

12
        // operand
13
        int num = 0;
14

15
        // operator
16
        char op = '+';
17

18
        for (int i = 0; i < s.length(); i++) {
19
            char c = s.charAt(i);
20

21
            if (c >= '0' && c <= '9') {
22
                num = num * 10 + c - '0';
23
                continue;
24
            }
25

26
            if (c == ' ') {
27
                continue;
28
            }
29

30
            if (op == '+') {
31
                stack.push(num);
32
            }
33
            if (op == '-') {
34
                stack.push(-num);
35
            }
36
            if (op == '*') {
37
                stack.push(stack.pop() * num);
38
            }
39
            if (op == '/') {
40
                stack.push(stack.pop() / num);
41
            }
42

43
            op = c;
44
            num = 0;
45
        }
46

47
        int result = 0;
48
        while (!stack.isEmpty()) {
49
            result += stack.pop();
50
        }
51

52
        return result;
53
    }
54
}

展开收起

228. Summary Ranges#

https://leetcode.com/problems/summary-ranges/

遍历数组，先记录当前的页码，之后向后搜索尽可能长的连续页码，直到下标无法继续移动为止。如果移动后下标指向的页码与当前页码不同，说明存在着连续页码；反之说明是单页。

1
class Solution {
2
    public List<String> summaryRanges(int[] nums) {
3
        List<String> result = new LinkedList<>();
4
        if (nums == null || nums.length == 0) {
5
            return result;
6
        }
7

8
        if (nums.length == 1) {
9
            result.add(nums[0] + "");
10
            return result;
11
        }
12

13
        for (int i = 0; i < nums.length; i++) {
14
            int temp = nums[i];
15

16
            // continuous pages
17
            while (i + 1 < nums.length && (nums[i+1] - nums[i] == 1)) {
18
                i++;
19
            }
20

21
            if (temp != nums[i]) {
22
                result.add(temp + "->" + nums[i]);
23
            } else {
24
                result.add(temp + "");
25
            }
26
        }
27

28
        return result;
29
    }
30
}

展开收起

229. Majority Element II#

https://leetcode.com/problems/majority-element-ii/

与Majority Element II思想近似，仍旧采用投票表决的思想。由于题目要求选出超过出现⌊ n/3 ⌋次的数，因此这样的数最多有两个，设定为candidate1和candidate2。

遍历数组时，遇到当前选出的candidate1和candidate2则次数+1；否则，次数各自-1（相当于当前数成对抵消了candidate1和candidate2）。如果原来的数次数都为0，且遇到了新的数，则candidate1或candidate2更换。第一次遍历数组后，可以最终投票表决出符合条件的数具体是多少，第二次遍历就只需统计这些数具体出现了几次。

1
class Solution {
2
    public List<Integer> majorityElement(int[] nums) {
3
        int count1 = 0, count2 = 0;
4
        Integer candidate1 = null, candidate2 = null;
5
        for (int num : nums) {
6
            if (candidate1 != null && candidate1 == num) {
7
                count1++;
8
            } else if (candidate2 != null && candidate2 == num) {
9
                count2++;
10
            } else if (count1 == 0) {
11
                // candidate1 has been updated
12
                candidate1 = num;
13
                count1++;
14
            } else if (count2 == 0) {
15
                // candidate2 has been updated
16
                candidate2 = num;
17
                count2++;
18
            } else {
19
                // reduce the portion of candidate1 and candidate2
20
                count1--;
21
                count2--;
22
            }
23
        }
24

25
        count1 = 0;
26
        count2 = 0;
27
        for (int num : nums) {
28
            if (candidate1 != null && candidate1 == num) {
29
                count1++;
30
            }
31
            if (candidate2 != null && candidate2 == num) {
32
                count2++;
33
            }
34
        }
35

36
        List<Integer> result = new ArrayList<>();
37
        if (count1 > nums.length/3) {
38
            result.add(candidate1);
39
        }
40
        if (count2 > nums.length/3) {
41
            result.add(candidate2);
42
        }
43

44
        return result;
45
    }
46
}

展开收起

230. Kth Smallest Element in a BST#

https://leetcode.com/problems/kth-smallest-element-in-a-bst/

沿用中序遍历思想，直接遍历至树的最左端，再逐渐向右遍历，直到次数为k即可。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private int count = 0;
18
    private boolean resultModified = false;
19
    private int result = Integer.MIN_VALUE;
20

21
    public int kthSmallest(TreeNode root, int k) {
22
        helper(root, k);
23
        return result;
24
    }
25

26
    private void helper(TreeNode node, int k) {
27
        if (node == null || resultModified) {
28
            return;
29
        }
30

31
        helper(node.left, k);
32

33
        count++;
34
        if (count == k) {
35
            result = node.val;
36
            resultModified = true;
37
            return;
38
        }
39

40
        helper(node.right, k);
41
    }
42
}

展开收起

231. Power of Two#

https://leetcode.com/problems/power-of-two/

二的次幂转换为二进制时，只有首位为1，其余都是0；利用这个特点，只需要判断n和n-1的与是否为0即可。

1
class Solution {
2
    public boolean isPowerOfTwo(int n) {
3
        return n > 0 && (n & (n - 1)) == 0;
4
    }
5
}

232. Implement Queue using Stacks#

https://leetcode.com/problems/implement-queue-using-stacks/

使用双栈实现队列，一进一出。大致思路是队列加入元素时统一推进入栈in；之后再一一弹出，进入出栈out，由此模拟元素先进先出的顺序。因此，查看队首元素时，将入栈的元素推入出栈，获取出栈的栈顶元素即为队首元素。

1
class MyQueue {
2

3
    Stack<Integer> in;
4
    Stack<Integer> out;
5

6
    /** Initialize your data structure here. */
7
    public MyQueue() {
8
        in = new Stack<Integer>();
9
        out = new Stack<Integer>();
10
    }
11

12
    /** Push element x to the back of queue. */
13
    public void push(int x) {
14
        in.push(x);
15
    }
16

17
    /** Removes the element from in front of queue and returns that element. */
18
    public int pop() {
19
        peek();
20
        return out.pop();
21
    }
22

23
    /** Get the front element. */
24
    public int peek() {
25
        // if out is empty, pop top element of in and push it into out
26
        if (out.isEmpty()) {
27
            while (!in.isEmpty()) out.push(in.pop());
28
        }
29

30
        return out.peek();
31
    }
32

33
    /** Returns whether the queue is empty. */
34
    public boolean empty() {
35
        return in.isEmpty() && out.isEmpty();
36
    }
37
}

展开收起

如果场景升级，要求实现一个线程安全版本双栈实现队列，只需要利用Java的synchronized函数，在push()和peek()时加锁即可：

1
class MyQueue {
2

3
    Object lock;
4
    Stack<Integer> in;
5
    Stack<Integer> out;
6

7
    /** Initialize your data structure here. */
8
    public MyQueue() {
9
        lock = new Object();
10
        in = new Stack<Integer>();
11
        out = new Stack<Integer>();
12
    }
13

14
    /** Push element x to the back of queue. */
15
    public void push(int x) {
16
        // must get lock to run the code inside synchronized
17
        synchronized(lock) {
18
            in.push(x);
19
        }
20
    }
21

22
    /** Removes the element from in front of queue and returns that element. */
23
    public int pop() {
24
        peek();
25
        return out.pop();
26
    }
27

28
    /** Get the front element. */
29
    public int peek() {
30
        // if out is empty, pop top element of in and push it into out
31
        if (out.isEmpty()) {
32
            synchronized(lock) {
33
                while (!in.isEmpty()) out.push(in.pop());
34
            }
35
        }
36
        return out.peek();
37
    }
38

39
    /** Returns whether the queue is empty. */
40
    public boolean empty() {
41
        return in.isEmpty() && out.isEmpty();
42
    }
43
}

展开收起

233. Number of Digit One#

https://leetcode.com/problems/number-of-digit-one/

纯数学推理题。观察，每10个数进行排列：

1
0, 1, 2, 3 ... 9 (1)
2

3
10, 11, 12, 13 ... 19 (1) + 10
4

5
20, 21, 22, 23 ... 29 (1)
6

7
...
8

9
90, 91, 92, 93 ... 99 (1)
10

11
100, 101, 102, 103 ... 109 (10 + 1)
12

13
110, 111, 112, 113 ... 119 (10 + 1) + 10
14

15
120, 121, 122, 123 ... 129 (10 + 1)
16

17
...
18

19
190, 191, 192, 193 ... 199 (10 + 1)

展开收起

最基础的情况下，每10个数里一定有1个数个位为1，每100个数里一定有10个数十位为1，每1000个数里一定有100个数百位为1…因此核心思想是用10的次幂k作为基底进行遍历。令r = n / k，则以上的分析将产生1的个数：

1
r / 10 * k

接着考虑特殊行，也就是10，11，12… 100，101，102…特殊行的特点在于十位/百位/…总有一个1。所以，采用取模的办法，令m = n % k，则在这一位上能够产生m + 1个1。即：

1
r % 10 == 1 ? m + 1 : 0

最后，某位大于等于2时，情况一致，直接添加在原始情况上即可。总和是：

1
(r + 8) / 10 * k + (r % 10 == 1 ? m + 1 : 0)

1
class Solution {
2
    public int countDigitOne(int n) {
3
        int result = 0;
4
        for (long k = 1; k <= n; k *= 10) {
5
            long r = n / k, m = n % k;
6
            result += (r + 8) / 10 * k + (r % 10 == 1 ? m + 1 : 0);
7
        }
8
        return result;
9
    }
10
}

234. Palindrome Linked List#

https://leetcode.com/problems/palindrome-linked-list/

使用快慢指针找到后半部分链表起点，并调转后半部分链表，再循环判断对称元素是否相等。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode() {}
7
 *     ListNode(int val) { this.val = val; }
8
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9
 * }
10
 */
11
class Solution {
12
    public boolean isPalindrome(ListNode head) {
13
        ListNode fast = head, slow = head;
14

15
        while (fast != null && fast.next != null) {
16
            slow = slow.next;
17
            fast = fast.next.next;
18
        }
19

20
        // odd length
21
        if (fast != null) {
22
            slow = slow.next;
23
        }
24

25
        // reverse second half of the list
26
        slow = reverse(slow);
27
        fast = head;
28

29
        // compare two halves
30
        while (slow != null) {
31
            if (slow.val != fast.val) {
32
                return false;
33
            }
34

35
            slow = slow.next;
36
            fast = fast.next;
37
        }
38

39
        return true;
40
    }
41

42
    private ListNode reverse(ListNode head) {
43
        ListNode prev = null;
44
        while (head != null) {
45
            ListNode next = head.next;
46
            head.next = prev;
47

48
            prev = head;
49
            head = next;
50
        }
51
        return prev;
52
    }
53
}

展开收起

235. Lowest Common Ancestor of a Binary Search Tree#

https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/

如果当前节点root的值root.val位于[p, q]内，说明root已经是p和q的最小公共祖先；否则，根据root和p.val与q.val的大小比较，调整搜索方向继续查找。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode(int x) { val = x; }
8
 * }
9
 */
10

11
class Solution {
12
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
13
        // root.val is not between p.val and q.val
14
        while ((root.val - p.val) * (root.val - q.val) > 0) {
15
            root = p.val < root.val ? root.left : root.right;
16
        }
17

18
        return root;
19
    }
20
}

展开收起

236. Lowest Common Ancestor of a Binary Tree#

https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/

如果某一个节点的左右子树里都能找到p或q，说明当前节点就是最小的公共祖先；否则，哪一边找不到，就说明这一边没有，去另一边的子树找。当然，如果两边都没有，说明路径不对，返回null退回上层。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode(int x) { val = x; }
8
 * }
9
 */
10
class Solution {
11
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
12
        if (root == null || root == p || root == q) {
13
            return root;
14
        }
15

16
        // whether can we find p or q in left & right subtrees
17
        TreeNode left = lowestCommonAncestor(root.left, p, q);
18
        TreeNode right = lowestCommonAncestor(root.right, p, q);
19

20
        // wrong path
21
        if (left == null && right == null) {
22
            return null;
23
        }
24

25
        // current node is LCA
26
        if (left != null && right != null) {
27
            return root;
28
        }
29

30
        // null in one subtree, find in the other
31
        return left == null ? right : left;
32
    }
33
}

展开收起

237. Delete Node in a Linked List#

https://leetcode.com/problems/delete-node-in-a-linked-list/

由于只给了一个node节点的引用，因此不知道链表的头在哪里，无法真正意义上删除node节点，只能将node的下一个节点的值赋值给node，再跳过node的下一个节点，起到了删除的效果。

1
/**
2
 * Definition for singly-linked list.
3
 * public class ListNode {
4
 *     int val;
5
 *     ListNode next;
6
 *     ListNode(int x) { val = x; }
7
 * }
8
 */
9
class Solution {
10
    public void deleteNode(ListNode node) {
11
        node.val = node.next.val;
12
        node.next = node.next.next;
13
    }
14
}

238. Product of Array Except Self#

https://leetcode.com/problems/product-of-array-except-self/

使用一个动态规划数组result，第一次从左到右循环，得到每个nums[i]左侧所有数的累乘结果，储存在result中；第二次从右到左循环，利用一个变量right乘以之前result中的结果，并让right乘以当前nums[i]，以此获得nums[i]右侧所有数的累乘结果。

1
class Solution {
2
    public int[] productExceptSelf(int[] nums) {
3
        int len = nums.length;
4
        int[] result = new int[len];
5
        result[0] = 1;
6

7
        // product of left part
8
        for (int i = 1; i < len; i++) {
9
            result[i] = result[i-1] * nums[i-1];
10
        }
11

12
        // product of right part
13
        int right = 1;
14
        for (int i = len - 1; i >= 0; i--) {
15
            result[i] *= right;
16
            right *= nums[i];
17
        }
18

19
        return result;
20
    }
21
}

展开收起

239. Sliding Window Maximum#

https://leetcode.com/problems/sliding-window-maximum/

使用一个LinkedList模拟双头队列，队列存储当前窗口内所有元素的下标。流程有三步：

关注[i - k + 1, i]的窗口，当某个元素在队列中且不在窗口内时，将其从队首弹出
从队列尾部开始，将所有对应小于nums[i]的下标丢弃。这是因为如果nums[x] < nums[i]且x < i，在当前窗口和之后的窗口里nums[x]都不可能成为最大值，因为nums[i]一定是更好的选择
将当前下标添加至队列，再将下标对应的值添加值最终的result数组

1
class Solution {
2
    public int[] maxSlidingWindow(int[] nums, int k) {
3
        if (nums == null || nums.length == 0 || nums.length < k) {
4
            return new int[] {};
5
        }
6

7
        int len = nums.length;
8
        int[] result = new int[len - k + 1];
9
        LinkedList<Integer> list = new LinkedList<>();
10

11
        for (int i = 0; i < len; i++) {
12
            // remove first element
13
            if (!list.isEmpty() && list.peek() < i - k + 1) {
14
                list.poll();
15
            }
16

17
            // remove unnecessary indices
18
            while (!list.isEmpty() && nums[i] >= nums[list.peekLast()]) {
19
                list.pollLast();
20
            }
21

22
            // new result
23
            list.offer(i);
24
            if (i - k + 1 >= 0) {
25
                result[i - k + 1] = nums[list.peek()];
26
            }
27
        }
28

29
        return result;
30
    }
31
}

展开收起

240. Search a 2D Matrix II#

https://leetcode.com/problems/search-a-2d-matrix-ii/

直接从第一行最右侧开始搜索，如果当前数比target小，则向左一列；当前数比target大，则向下一行。不断重复，若直到列或者行超出边界还没有找到target，就说明target不在数组中。

1
class Solution {
2
    public boolean searchMatrix(int[][] matrix, int target) {
3
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
4
            return false;
5
        }
6

7
        int row = 0, col = matrix[0].length - 1;
8

9
        // start from the upper right
10
        while (col >= 0 && row < matrix.length) {
11
            if (matrix[row][col] == target) {
12
                return true;
13
            } else if (matrix[row][col] < target) {
14
                row++;
15
            } else {
16
                col--;
17
            }
18
        }
19

20
        return false;
21
    }
22
}

展开收起

241. Different Ways to Add Parentheses#

https://leetcode.com/problems/different-ways-to-add-parentheses/

核心是使用分治，遍历输入字符串，当前字符为界将字符串分为左、右两个子字符串，根据具体的运算符算出临时结果。为了节省时间，可以使用map存储算过的结果。

1
class Solution {
2
    // <current input string, all possible results>
3
    private Map<String, List<Integer>> map = new HashMap<>();
4

5
    public List<Integer> diffWaysToCompute(String input) {
6
        // check history
7
        List<Integer> result = map.get(input);
8
        if (result != null) {
9
            return result;
10
        }
11
        result = new ArrayList<>();
12

13
        // only one digit left, put current result to map
14
        if (isDigit(input)) {
15
            result.add(Integer.parseInt(input));
16
            map.put(input, result);
17
            return result;
18
        }
19

20
        for (int i = 0; i < input.length(); i++) {
21
            char c = input.charAt(i);
22
            if (c == '+' || c == '-' || c == '*') {
23
                List<Integer> left = diffWaysToCompute(input.substring(0,i));
24
                List<Integer> right = diffWaysToCompute(input.substring(i+1));
25

26
                for (Integer il : left) {
27
                    for (Integer ir : right) {
28
                        if (c == '+') {
29
                            result.add(il + ir);
30
                        } else if (c == '-') {
31
                            result.add(il - ir);
32
                        } else if (c == '*') {
33
                            result.add(il * ir);
34
                        }
35
                    }
36
                }
37
            }
38
        }
39

40
        map.put(input, result);
41
        return result;
42
    }
43

44
    private boolean isDigit(String s) {
45
        for (Character c : s.toCharArray()) {
46
            if (c < '0' || c > '9') {
47
                return false;
48
            }
49
        }
50

51
        return true;
52
    }
53
}

展开收起

242. Valid Anagram#

https://leetcode.com/problems/valid-anagram/

人造一个map，存储s中每个字符出现的次数，再验证t中的每个字符出现的次数能否与之对应。

1
class Solution {
2
    public boolean isAnagram(String s, String t) {
3
        if (s.length() != t.length()) {
4
            return false;
5
        }
6
        int[] map = new int[256];
7

8
        // how many times each characters occur in s
9
        for (char c : s.toCharArray()) {
10
            map[c]++;
11
        }
12

13
        // check whether match occurrence in t
14
        for (char c : t.toCharArray()) {
15
            map[c]--;
16
            if (map[c] < 0) {
17
                return false;
18
            }
19
        }
20

21
        return true;
22
    }
23
}

展开收起

243. Shortest Word Distance#

https://leetcode.com/problems/shortest-word-distance/

遍历words中的每一个单词，如果当前的单词等于word1或者word2，则对应修改两个单词的下标index1和index2；当下标都大于0时，更新当前的下标间距最小值。

1
class Solution {
2
    public int shortestDistance(String[] words, String word1, String word2) {
3
        int result = Integer.MAX_VALUE;
4
        int index1 = -1, index2 = -1;
5

6
        for (int i = 0; i < words.length; i++) {
7
            // always update indices
8
            if (words[i].equals(word1)) {
9
                index1 = i;
10
            } else if (words[i].equals(word2)) {
11
                index2 = i;
12
            } else {
13
                continue;
14
            }
15

16
            if (index1 >= 0 && index2 >= 0) {
17
                result = Math.min(result, Math.abs(index1 - index2));
18
            }
19
        }
20

21
        return result;
22
    }
23
}

展开收起

244. Shortest Word Distance II#

https://leetcode.com/problems/shortest-word-distance-ii/

由于计算最短间距的函数可能被调用多次，因此直接的想法是将数组中每一个单词出现的下标都收录起来，整理成一个list。检查两个单词时，使用两个指针p1和p2分别遍历下标list，找到尽可能小的间距。

1
class WordDistance {
2

3
    // for each word, store its occurrence index
4
    HashMap<String, List<Integer>> map;
5

6
    public WordDistance(String[] words) {
7
        map = new HashMap();
8
        for (int i = 0; i < words.length; i++) {
9
            String currentWord = words[i];
10
            if (!map.containsKey(currentWord)) {
11
                map.put(currentWord, new ArrayList<>());
12
            }
13
            map.get(currentWord).add(i);
14
        }
15
    }
16

17
    public int shortest(String word1, String word2) {
18
        List<Integer> list1 = map.get(word1), list2 = map.get(word2);
19
        int result = Integer.MAX_VALUE;
20

21
        int p1 = 0, p2 = 0;
22
        while (p1 < list1.size() && p2 < list2.size()) {
23
            int index1 = list1.get(p1), index2 = list2.get(p2);
24

25
            // make two pointers as close as possible
26
            // shift the smaller index to its maximum value
27
            if (index1 > index2) {
28
                p2++;
29
            } else {
30
                p1++;
31
            }
32

33
            result = Math.min(result, Math.abs(index1 - index2));
34
        }
35
        return result;
36
    }
37
}

展开收起

245. Shortest Word Distance III#

https://leetcode.com/problems/shortest-word-distance-iii/

遍历循环。

1
class Solution {
2
    public int shortestWordDistance(String[] words, String word1, String word2) {
3
        int result = Integer.MAX_VALUE;
4
        int index1 = -1, index2 = -1;
5
        boolean isEqual = word1.equals(word2);
6

7
        for (int i = 0; i < words.length; i++) {
8
            if (words[i].equals(word1)) {
9
                index1 = i;
10
            } else if (words[i].equals(word2)) {
11
                index2 = i;
12
            } else {
13
                continue;
14
            }
15

16
            if (index1 >= 0 && index2 >= 0) {
17
                result = Math.min(result, Math.abs(index1 - index2));
18
            }
19

20
            // if word1 and word2 are equal, their indices should be set equally before next loop
21
            if (isEqual) {
22
                index2 = index1;
23
            }
24
        }
25
        return result;
26
    }
27
}

展开收起

246. Strobogrammatic Number#

https://leetcode.com/problems/strobogrammatic-number/

使用头尾指针标记num，不断移动指针，完整遍历num，判断每次头尾指针组成的数是否组成了一对strobogrammatic number pairs。

1
class Solution {
2
    public boolean isStrobogrammatic(String num) {
3
        char[] check = new char[10];
4
        // strobogrammatic number
5
        check[1] = '1';
6
        check[6] = '9';
7
        check[0] = '0';
8
        check[9] = '6';
9
        check[8] = '8';
10

11
        int low = 0, high = num.length() - 1;
12
        while (low <= high) {
13
            // must form strobogrammatic number pairs
14
            if (num.charAt(low) != check[num.charAt(high) - '0']) {
15
                return false;
16
            }
17

18
            low++;
19
            high--;
20
        }
21

22
        return true;
23
    }
24
}

展开收起

247. Strobogrammatic Number II#

https://leetcode.com/problems/strobogrammatic-number-ii/

调用递归，让当前字符数量不断减少2，以此能在首尾各自添加一个数字。添加的数字可以为11, 69, 96, 88；如果不是开头和结尾，还可以添加00。

1
class Solution {
2
    public List<String> findStrobogrammatic(int n) {
3
        return helper(n, n);
4
    }
5

6
    private List<String> helper(int current, int n) {
7
        if (current == 0) {
8
            return new ArrayList<String>(Arrays.asList(""));
9
        }
10
        if (current == 1) {
11
            return new ArrayList<String>(Arrays.asList("0", "1", "8"));
12
        }
13

14
        // reduce current digits count by 2 and add two new digits to head and tail
15
        List<String> list = helper(current - 2, n);
16

17
        List<String> result = new ArrayList<String>();
18
        for (int i = 0; i < list.size(); i++) {
19
            String s = list.get(i);
20
            if (current != n) {
21
                // 00 cannot be head and tail
22
                result.add("0" + s + "0");
23
            }
24
            result.add("1" + s + "1");
25
            result.add("6" + s + "9");
26
            result.add("9" + s + "6");
27
            result.add("8" + s + "8");
28
        }
29

30
        return result;
31
    }
32
}

展开收起

248. Strobogrammatic Number III#

https://leetcode.com/problems/strobogrammatic-number-iii/

使用DFS，提前列举好所有的strobogrammatic number pairs，之后使用头尾指针判断是否符合当前指针所指的两个数是否符合strobogrammatic规则。当头尾指针重合后，需要额外判断当前数是否超出了给定[low, high]的范围，如果在范围内才算做一个合法的数字。

1
class Solution {
2
    public int strobogrammaticInRange(String low, String high) {
3
        int n = low.length();
4
        while (n <= high.length()) {
5
            dfs(0, n - 1, new char[n], low, high);
6
            n++;
7
        }
8
        return result;
9
    }
10

11
    private char[][] converts = new char[][]{new char[]{'0' ,'0'}, new char[]{'1' ,'1'},
12
                                             new char[]{'6' ,'9'}, new char[]{'8' ,'8'}, new char[]{'9' ,'6'}};
13
    private int result = 0;
14

15
    private void dfs(int i, int j, char[] num, String low, String high) {
16
        if (i > j) {
17
            if (!isSmallerThan(num, low) && !isLargerThan(num, high)) {
18
                result++;
19
            }
20
            return;
21
        }
22

23
        // try two digits
24
        for (char[] convert : converts) {
25
            num[i] = convert[0];
26
            num[j] = convert[1];
27

28
            if (i == 0 && num.length > 1 && convert[0] == '0') {
29
                continue;
30
            }
31
            if (i == j && convert[0] != convert[1]) {
32
                continue;
33
            }
34
            dfs(i + 1, j - 1, num, low, high);
35
        }
36
    }
37

38
    private boolean isLargerThan(char[] num, String high) {
39
        if (num.length < high.length()) {
40
            return false;
41
        }
42
        int i = 0;
43
        while (i < high.length()) {
44
            if (num[i] == high.charAt(i)) {
45
                i++;
46
                continue;
47
            }
48

49
            return num[i] > high.charAt(i);
50
        }
51

52
        return false;
53
    }
54

55
    private boolean isSmallerThan(char[] num, String low) {
56
        if (num.length > low.length()) {
57
            return false;
58
        }
59

60
        int i = 0;
61
        while (i < low.length()) {
62
            if (num[i] == low.charAt(i)) {
63
                i++;
64
                continue;
65
            }
66

67
            return num[i] < low.charAt(i);
68
        }
69

70
        return false;
71
    }
72
}

展开收起

249. Group Shifted Strings#

https://leetcode.com/problems/group-shifted-strings/

对每一个输入字符串进行编辑，其他字母和首字母进行比较，如果其他字母的ASCII码比首字母小，需要补26作为循环，由此生成一个对应当前结构的key。再使用一个map，存储每个key对应的所有字符串，最后直接利用map.values()自动整理生成归类后的二维list。

1
class Solution {
2
    public List<List<String>> groupStrings(String[] strings) {
3
        Map<String, List<String> > map = new HashMap<>();
4

5
        for (String str : strings) {
6
            String key = getKey(str);
7
            if (map.containsKey(key)) {
8
                map.get(key).add(str);
9
            } else {
10
                List<String> temp = new ArrayList<>();
11
                temp.add(str);
12
                map.put(key, temp); // add new key
13
            }
14
        }
15

16
        // generate 2D list
17
        return new ArrayList<>(map.values());
18
    }
19

20
    private String getKey(String str) {
21
        StringBuilder key = new StringBuilder();
22
        int diff = str.charAt(0) - 'a';
23

24
        // if other character's ascii code is smaller than first character, complement 26 for rotation
25
        for (int i = 0; i < str.length(); i++) {
26
            int value = str.charAt(i) - 'a' < diff ? str.charAt(i) - 'a' - diff + 26
27
                                                   : str.charAt(i) - 'a' - diff;
28
            key.append((char)value);
29
        }
30

31
        return key.toString();
32
    }
33
}

展开收起

250. Count Univalue Subtrees#

https://leetcode.com/problems/count-univalue-subtrees/

使用后序遍历，在左右子树都是univalue树的前提下，判断当前节点和左、右节点是否一致。如果左、右任一节点存在且与当前节点不一样，就说明当前节点为根的树不是univalue；反之，univalue树的数量加1。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int countUnivalSubtrees(TreeNode root) {
18
        int[] result = new int[1]; // modify global value to get final result
19
        helper(root, result);
20
        return result[0];
21
    }
22

23
    private boolean helper(TreeNode node, int[] result) {
24
        if (node == null) {
25
            return true;
26
        }
27
        boolean left = helper(node.left, result);
28
        boolean right = helper(node.right, result);
29

30
        // both left and right subtrees are univalue trees, check subtrees
31
        if (left && right) {
32
            // current node's val must be same with left child and right child
33
            if ((node.left != null && node.val != node.left.val)
34
                || (node.right != null && node.val != node.right.val)) {
35
                return false;
36
            }
37
            result[0]++;
38
            return true;
39
        }
40

41
        // one subtree is not univalue tree, no more further check
42
        return false;
43
    }
44
}

展开收起

251. Flatten 2D Vector#

https://leetcode.com/problems/flatten-2d-vector/

使用一个二维数组temp，浅拷贝传入的数组。

检查是否存在下一个元素：

当前行没遍历到结尾，肯定还有下一个元素
当前行遍历到结尾，尝试跳转到下一行，检查行数是否越界。

获取下一个元素，移动相应二维数组下标即可。

1
class Vector2D {
2

3
    int[][] temp; // shallow copy input array
4
    int row = 0, col = 0;
5

6
    public Vector2D(int[][] v) {
7
        temp = v;
8
    }
9

10
    public int next() {
11
        // if there is next element, fetch it
12
        return hasNext() ? temp[row][col++] : -1;
13
    }
14

15
    public boolean hasNext() {
16
        // one row's end, jump to next row
17
        while (row < temp.length && col == temp[row].length) {
18
            row++;
19
            col = 0;
20
        }
21

22
        // whether go through all rows
23
        return row < temp.length;
24
    }
25
}

展开收起

252. Meeting Rooms#

https://leetcode.com/problems/meeting-rooms/

对每个子数组按照起始时间大小进行排序，之后检查是否有相邻会议的结束时间和起始时间重叠。

1
class Solution {
2
    public boolean canAttendMeetings(int[][] intervals) {
3
        if (intervals.length == 0 || intervals[0].length == 0) {
4
            return true;
5
        }
6

7
        Arrays.sort(intervals, (int[] a, int[] b) -> {
8
            return a[0] - b[0];
9
        });
10

11
        for (int i = 1; i < intervals.length; i++) {
12
            // overlap with previous interval
13
            if (intervals[i][0] < intervals[i - 1][1]) {
14
                return false;
15
            }
16
        }
17

18
        return true;
19
    }
20
}

展开收起

253. Meeting Rooms II#

https://leetcode.com/problems/meeting-rooms-ii/

将所有会议对开始时间和结束时间提取出来，分别整理成独立数组并排序。假设每开始一场会议都要占用一个房间，然而如果之前的一场会议已经结束，说明之前的这个房间可以被释放并挪用于当前的会议。因此，使用一个变量endIdx跟踪当前会议的结束情况，如果当前的会议的起始时间不小于之前最早开始的一场会议的结束时间，就不需要额外开一个新会议室。

1
class Solution {
2
    public int minMeetingRooms(int[][] intervals) {
3
        if (intervals == null || intervals.length == 0 || intervals[0].length == 0) {
4
            return 0;
5
        }
6
        int len = intervals.length;
7

8
        // fetch all start and end time, then sort
9
        int[] starts = new int[len];
10
        int[] ends = new int[len];
11
        for (int i = 0; i < len; i++) {
12
            starts[i] = intervals[i][0];
13
            ends[i] = intervals[i][1];
14
        }
15
        Arrays.sort(starts);
16
        Arrays.sort(ends);
17

18
        // use endIdx to track current ending meeting
19
        int result = 0, endIdx = 0;
20
        for (int i = 0; i < len; i++) {
21
            // assume each meeting needs a room first
22
            result++;
23

24
            // current start time is after one ending meeting, no need to arrange one room
25
            if (starts[i] >= ends[endIdx]) {
26
                result--;
27
                endIdx++;
28
            }
29
        }
30

31
        return result;
32
    }
33
}

展开收起

254. Factor Combinations#

https://leetcode.com/problems/factor-combinations/

本质上这题仍然是传统的backtrack问题。然而，技巧在于此题在下一轮dfs前进行加速，即：每一轮向临时数组添加时，i和n/i成对搭配，这样一来既能马上凑出一对combination，也可以节省时间，使得i的遍历只需要到达sqrt(i)即可。

1
class Solution {
2
    public List<List<Integer>> getFactors(int n) {
3
        List<List<Integer>> result = new ArrayList<List<Integer>>();
4
        backtrack(result, new ArrayList<>(), n, 2);
5
        return result;
6
    }
7

8
    private void backtrack(List<List<Integer>> result, List<Integer> temp, int n, int start) {
9
        // when n < 2, we must ensure we have more than 1 combination to get one result
10
        if (n < 2) {
11
            if (temp.size() > 1) {
12
                result.add(new ArrayList<>(temp));
13
            }
14
            return;
15
        }
16

17
        for (int i = start; i * i <= n; i++) {
18
            if (n % i == 0) {
19
                // add both i and n/i
20
                temp.add(i);
21
                temp.add(n / i);
22

23
                result.add(new ArrayList<>(temp));
24

25
                temp.remove(temp.size() - 1); // remove n/i
26
                backtrack(result, temp, n / i, i);
27
                temp.remove(temp.size() - 1); // remove i
28
            }
29
        }
30
    }
31
}

展开收起

255. Verify Preorder Sequence in Binary Search Tree#

https://leetcode.com/problems/verify-preorder-sequence-in-binary-search-tree/

模拟一个栈。假如遇到了比上一个栈顶值小的数，说明我们还在所有栈元素的左子树上，因此只需要把这个数也加入栈。然而，在此之前需要把所有更小的祖先值给踢出，因此我们遍历完之后需要跳转到右支了。设立弹出值为下界，之后遍历右支意味着不能遇到一个比下界更小的数，否则就是不合法的。

1
class Solution {
2
    public boolean verifyPreorder(int[] preorder) {
3
        // lower bound
4
        int low = Integer.MIN_VALUE, i = -1;
5

6
        for (int p : preorder) {
7
            // we cannot meet an element smaller than lower bound
8
            if (p < low) {
9
                return false;
10
            }
11

12
            // assume current p is root node, we need to find the furthest node preorder[i] < p
13
            // this indicates that we are still on the left subtree
14
            while (i >= 0 && p > preorder[i]) {
15
                low = preorder[i];
16
                i--;
17
            }
18

19
            // to right subtree
20
            i++;
21
            preorder[i] = p;
22
        }
23

24
        return true;
25
    }
26
}

展开收起

256. Paint House#

https://leetcode.com/problems/paint-house/

从第二行起直接修改输入的cost数组，cost[i][j]表示当前颜色成本加上之前使用另两种颜色刷房子的成本的最小值。

1
class Solution {
2
    public int minCost(int[][] costs) {
3
        if (costs == null || costs.length == 0) {
4
            return 0;
5
        }
6

7
        // current house's cost and two other houses' previous total cost
8
        for (int i = 1; i < costs.length; i++) {
9
            costs[i][0] += Math.min(costs[i-1][1], costs[i-1][2]);
10
            costs[i][1] += Math.min(costs[i-1][0], costs[i-1][2]);
11
            costs[i][2] += Math.min(costs[i-1][0], costs[i-1][1]);
12
        }
13

14
        int n = costs.length - 1;
15
        return Math.min(Math.min(costs[n][0], costs[n][1]), costs[n][2]);
16
    }
17
}

展开收起

257. Binary Tree Paths#

https://leetcode.com/problems/binary-tree-paths/

使用前序遍历到达叶节点，之后回溯遍历其他路径。

1
class Solution {
2
    public List<String> binaryTreePaths(TreeNode root) {
3
        List<Integer> list = new ArrayList<>();
4
        List<String> paths = new ArrayList<>();
5
        helper(root, list, paths);
6
        return paths;
7
    }
8

9
    private void helper(TreeNode root, List<Integer> list, List<String> paths) {
10
        if (root == null) {
11
            return;
12
        }
13

14
        // leaf node, add previous string and current value
15
        if (root.left == null && root.right == null) {
16
            StringBuilder sb = new StringBuilder();
17
            for (int element : list) {
18
                sb.append(element);
19
                sb.append("->");
20
            }
21
            sb.append(root.val);
22
            paths.add(sb.toString());
23
            return;
24
        }
25

26
        // backtrack
27
        list.add(root.val);
28
        helper(root.left, list, paths);
29
        helper(root.right, list, paths);
30
        list.remove(list.size() - 1);
31
    }
32
}

展开收起

258. Add Digits#

https://leetcode.com/problems/add-digits/

直接归纳总结公式。

1
class Solution {
2
    public int addDigits(int num) {
3
        return 1 + (num - 1) % 9;
4
    }
5
}

259. 3Sum Smaller#

https://leetcode.com/problems/3sum-smaller/

先排序，再使用三指针法，注意计数时，固定first和second，计算second和third之间的差值。

1
class Solution {
2
    public int threeSumSmaller(int[] nums, int target) {
3
        int result = 0;
4
        Arrays.sort(nums);
5

6
        int len = nums.length;
7
        for (int first = 0; first < len - 2; first++) {
8
            if (nums[first] * 3 >= target) {
9
                break;
10
            }
11

12
            int second = first + 1, third = len - 1;
13

14
            // fix first, range count in [second + 1, third]
15
            while (second < third) {
16
                if (nums[first] + nums[second] + nums[third] < target) {
17
                    result += third - second;
18
                    second++;
19
                } else {
20
                    third--;
21
                }
22
            }
23
        }
24

25
        return result;
26
    }
27
}

展开收起

260. Single Number III#

https://leetcode.com/problems/single-number-iii/

第一次遍历，与Single Number相同思想，找出两个single number的异或值。由于这两个数不同，因此异或的结果一定有一位是1（Set Bit)，任意保存一位即可。（例如，通过和负数取与，保留最后一位）

第二次遍历，将所有数分类，一类与异或数取与为0（不包含Set Bit），另一类为1（包含Set Bit），由于其他数一定能两两配对，因此最后分类后的异或结果就是两个single number。

1
class Solution {
2
    public int[] singleNumber(int[] nums) {
3
        if (nums == null || nums.length < 2) {
4
            return new int[] {};
5
        }
6

7
        // get xor of two single numbers, keep only the last set bit
8
        int xor = 0;
9
        for (int num : nums) {
10
            xor ^= num;
11
        }
12
        xor &= -xor;
13

14
        // use set bit to classify, each group's result is a single number
15
        int[] result = {0, 0};
16
        for (int num : nums) {
17
            if ((num & xor) == 0) {
18
                result[0] ^= num;
19
            } else {
20
                result[1] ^= num;
21
            }
22
        }
23
        return result;
24
    }
25
}

展开收起

261. Graph Valid Tree#

https://leetcode.com/problems/graph-valid-tree/

假定每个点是一个孤岛，使用union-find的思想，查找出每条边延伸下去最末端的孤岛是什么。如果末端相等，说明重合，即树中存在环，不合法；否则，更新当前的岛连接情况。

1
class Solution {
2
    public boolean validTree(int n, int[][] edges) {
3
        if (edges.length != n - 1) {
4
            return false;
5
        }
6

7
        // n nodes
8
        int[] nums = new int[n];
9
        Arrays.fill(nums, -1);
10

11
        for (int i = 0; i < edges.length; i++) {
12
            int x = find(nums, edges[i][0]);
13
            int y = find(nums, edges[i][1]);
14

15
            // furthest nodes are the same, so there must be a cycle
16
            if (x == y) {
17
                return false;
18
            }
19
            nums[x] = y;
20
        }
21

22
        return true;
23
    }
24

25
    // find the furthest node
26
    private int find(int[] nums, int i) {
27
        if (nums[i] == -1) {
28
            return i;
29
        }
30

31
        return find(nums, nums[i]);
32
    }
33
}

展开收起

262. Trips and Users#

https://leetcode.com/problems/trips-and-users/

拼接两张表，限制时间，用户账号状态作为筛选条件，选出所有取消的订单并除以总订单数。使用ROUND()函数保留两位小数。

1
SELECT request_at as Day, Round(Sum(If(status!="completed",1,0)) / count(status), 2) as "Cancellation Rate"
2
FROM trips
3
WHERE request_at BETWEEN "2013-10-01" AND "2013-10-03"
4
    AND client_id NOT IN (SELECT users_id FROM Users WHERE banned = "yes")
5
    AND driver_id NOT IN (SELECT users_id FROM Users WHERE banned = "yes")
6
GROUP BY request_at

263. Ugly Number#

https://leetcode.com/problems/ugly-number/

让num循环除2-5之间的数，判断最后结果是否为1。

1
class Solution {
2
    public boolean isUgly(int num) {
3
        if (num <= 0) {
4
            return false;
5
        }
6

7
        // keep divide by 2, then 3, then 5
8
        for (int i = 2; i < 6 && num > 0; i++) {
9
            while (num % i == 0) {
10
                num /= i;
11
            }
12
        }
13

14
        return num == 1;
15
    }
16
}

展开收起

264. Ugly Number II#

https://leetcode.com/problems/ugly-number-ii/

每个数实际上由因数和序数相乘得到，因此使用动态规划，直接按大小添加当前的ugly number，再根据其因数更新对应的序数即可。

1
class Solution {
2
    public int nthUglyNumber(int n) {
3
        int[] dp = new int[n];
4
        dp[0] = 1;
5

6
        int factor2 = 2, factor3 = 3, factor5 = 5;
7
        int index2 = 0, index3 = 0, index5 = 0;
8

9
        for (int i = 1; i < n; i++) {
10
            int min = Math.min(Math.min(factor2, factor3), factor5);
11

12
            // current ugly number
13
            dp[i] = min;
14

15
            // update last ugly number using 2/3/5 as factor, then increment corresponding index
16
            if (factor2 == min) {
17
                index2++;
18
                factor2 = 2 * dp[index2];
19
            }
20
            if (factor3 == min) {
21
                index3++;
22
                factor3 = 3 * dp[index3];
23
            }
24
            if (factor5 == min) {
25
                index5++;
26
                factor5 = 5*dp[index5];
27
            }
28
        }
29

30
        return dp[n - 1];
31
    }
32
}

展开收起

265. Paint House II#

https://leetcode.com/problems/paint-house-ii/

正常情况下，对于每一间房子的选择，只需要选出成本最低的即可。但由于相邻两间房子不能使用相同颜色，因此我们需要使用两个变量分别保存全局的第一小和第二小成本，并且额外使用一个变量index1记录上一间房最后使用的颜色。在当前的成本到总成本时需要观察，根据上一轮房子选择的情况，选择要累加的变量（min1st或者min2nd）。

1
class Solution {
2
    public int minCostII(int[][] costs) {
3
        if (costs.length == 0) {
4
            return 0;
5
        }
6

7
        // 1st-min cost, 2nd-min cost, maintain the index of min1st color cost of "last house"
8
        int min1st = 0, min2nd = 0, index1 = -1;
9

10
        for (int i = 0; i < costs.length; i++) {
11
            // temp value
12
            int m1 = Integer.MAX_VALUE, m2 = Integer.MAX_VALUE, idx = -1;
13

14
            for (int j = 0; j < costs[0].length; j++) {
15
                // adjacent houses cannot have same color
16
                int cost = costs[i][j] + (j != index1 ? min1st : min2nd);
17

18
                if (cost < m1) {
19
                    // cost < m1 < m2, update 1st-min, 2nd-min cost and index
20
                    m2 = m1;
21
                    m1 = cost;
22
                    idx = j;
23
                } else if (cost < m2) {
24
                    // m1 < cost < m2, update 2nd-min cost
25
                    m2 = cost;
26
                }
27
            }
28

29
            min1st = m1;
30
            min2nd = m2;
31
            index1 = idx;
32
        }
33

34
        return min1st;
35
    }
36
}

展开收起

266. Palindrome Permutation#

https://leetcode.com/problems/palindrome-permutation/

使用Set, 不断添加当前字符到Set中。如果已有这个字符，说明这两个相同字符可以组成一个pair而抵消；反之，作为一个新字符加入。遍历完之后，根据奇偶性讨论，Set中至多只能有1个字符。

1
class Solution {
2
    public boolean canPermutePalindrome(String s) {
3
        if (s == null || s.length() == 0) {
4
            return true;
5
        }
6

7
        Set<Character> set = new HashSet<>();
8
        for (char c : s.toCharArray()) {
9
            // one pair, remove
10
            if (set.contains(c)) {
11
                set.remove(c);
12
            } else {
13
                set.add(c);
14
            }
15
        }
16

17
        // odd or even
18
        return set.size() <= 1;
19
    }
20
}

展开收起

267. Palindrome Permutation II#

https://leetcode.com/problems/palindrome-permutation-ii/

先统计每个字符出现的次数，排除掉肯定不能组成palindromic permutation的情况。之后使用回溯算法，只要当前字符次数还有剩余，就将2个字符分配到当前字符串的首尾，并继续调用下一层构造函数。

1
class Solution {
2
    public List<String> generatePalindromes(String s) {
3
        // each character's count
4
        int[] count = new int[256];
5
        for (char c : s.toCharArray()) {
6
            count[c]++;
7
        }
8

9
        // odd character count
10
        int oddChars = 0;
11
        Character odd = null;
12
        for (int i = 0; i < count.length; i++) {
13
            if (count[i] % 2 == 1) {
14
                oddChars++;
15
                odd = (char)(i);
16
            }
17
        }
18

19
        // no palindromic permutations
20
        if (oddChars > 1) {
21
            return new ArrayList<>();
22
        }
23

24
        char[] local = new char[s.length()];
25

26
        // one odd char, must be in the middle of the string
27
        if (oddChars == 1) {
28
            local[local.length / 2] = odd;
29
            count[odd]--;
30
        }
31

32
        List<String> result = new ArrayList<>();
33
        backtrack(count, 0, local, result);
34
        return result;
35
    }
36

37
    private void backtrack(int[] count, int index, char[] local, List<String> result) {
38
        // base case
39
        if (index == local.length / 2) {
40
            result.add(new String(local));
41
            return;
42
        }
43

44
        // try all even number chars
45
        for (int i = 0; i < count.length; i++) {
46
            if (count[i] > 0) {
47
                // allocate (char)i to head and tail of current string
48
                local[index] = local[local.length - 1 - index] = (char)(i);
49

50
                count[i] -= 2;
51
                backtrack(count, index + 1, local, result);
52
                count[i] += 2;
53
            }
54
        }
55
    }
56
}

展开收起

268. Missing Number#

https://leetcode.com/problems/missing-number/

第一种方法，使用异或。每个数的下标与本身本应是一致的，因此二者异或结果是0。只有缺失的这个数，其本身将无法被异或填补。

例如以[0, 1, 2, 3, 4, 5, 6, 7, 9, 10]为例：

1
下标i：
2
0 1 2 3 4 5 6 7 8 9 ...
3
数值nums[i]：
4
0 1 2 3 4 5 6 7 9 10 ...

在最后补充异或nums.length，恰好能消除掉最后一个nums[i]，这样剩下的就是缺失的数字了。

1
class Solution {
2
    public int missingNumber(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int result = 0;
8
        for (int i = 0; i < nums.length; i++) {
9
            result = result ^ i ^ nums[i];
10
        }
11

12
        // nums.length is exactly the last nums[i]
13
        return result ^ nums.length;
14
    }
15
}

展开收起

第二种方法，因为缺失了一个数，导致数本身的和会大于等于下标之和。因此，令初始结果为最大数，累加所有的下标之和，减去所有数之和，最终会得到缺失的数。这种方法只能在不造成溢出的情况下使用。

1
class Solution {
2
    public int missingNumber(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int sum = nums.length;
8
        for (int i = 0; i < nums.length; i++) {
9
            sum += i - nums[i];
10
        }
11
        return sum;
12
    }
13
}

269. Alien Dictionary#

https://leetcode.com/problems/alien-dictionary/

构建二维邻接矩阵，按照相邻单词相同下标的字母顺序构建边，输入到邻接矩阵中；再使用DFS遍历邻接矩阵得到遍历顺序。

1
class Solution {
2
    private final int N = 26;
3

4
    public String alienOrder(String[] words) {
5
        // words[i+1:] order is unclear
6
        for (int i = 0; i < words.length - 1; i++) {
7
            if (words[i].length() > words[i+1].length() && words[i].startsWith(words[i+1])) {
8
                return "";
9
            }
10
        }
11

12
        // adjacency matrix
13
        boolean[][] adj = new boolean[N][N];
14
        int[] visited = new int[N];
15
        buildGraph(words, adj, visited);
16

17
        StringBuilder sb = new StringBuilder();
18
        for (int i = 0; i < N; i++) {
19
            if (visited[i] == 0 && !dfs(adj, visited, sb, i)) {
20
                return "";
21
            }
22
        }
23

24
        return sb.reverse().toString();
25
    }
26

27
    public void buildGraph(String[] words, boolean[][] adj, int[] visited) {
28
        // -1 = not existed
29
        Arrays.fill(visited, -1);
30

31
        for (int i = 0; i < words.length; i++) {
32
            for (char c : words[i].toCharArray()) {
33
                visited[c - 'a'] = 0;
34
            }
35

36
            if (i > 0) {
37
                // for characters of same indices, form an edge in matrix
38
                String w1 = words[i - 1], w2 = words[i];
39
                int len = Math.min(w1.length(), w2.length());
40

41
                for (int j = 0; j < len; j++) {
42
                    char c1 = w1.charAt(j), c2 = w2.charAt(j);
43
                    if (c1 != c2) {
44
                        adj[c1 - 'a'][c2 - 'a'] = true;
45
                        break;
46
                    }
47
                }
48
            }
49
        }
50
    }
51

52
    public boolean dfs(boolean[][] adj, int[] visited, StringBuilder sb, int i) {
53
        // 1 = visiting
54
        visited[i] = 1;
55

56
        for (int j = 0; j < N; j++) {
57
            // connected
58
            if (adj[i][j]) {
59
                // 1 => 1, cycle
60
                if (visited[j] == 1) {
61
                     return false;
62
                }
63

64
                // 0 = unvisited, and must need to find another unvisited node
65
                if (visited[j] == 0 && !dfs(adj, visited, sb, j)) {
66
                    return false;
67
                }
68
            }
69
        }
70

71
        // 2 = visited
72
        visited[i] = 2;
73
        sb.append((char) (i + 'a'));
74
        return true;
75
    }
76
}

展开收起

270. Closest Binary Search Tree Value#

https://leetcode.com/problems/closest-binary-search-tree-value/

存储一个最接近target的变量，再根据节点值的大小调整遍历的方向。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public int closestValue(TreeNode root, double target) {
18
        int result = root.val;
19

20
        while (root != null) {
21
            if (Math.abs(result - target) > Math.abs(root.val - target)) {
22
                result = root.val;
23
            }
24
            root = (root.val > target) ? root.left : root.right;
25
        }
26

27
        return result;
28
    }
29
}

展开收起

271. Encode and Decode Strings#

https://leetcode.com/problems/encode-and-decode-strings/

编码时，在输入的每一个字符串前加入当前字符串的长度，并用*号间隔。解码时根据长度截取*之后的子字符串。

1
public class Codec {
2

3
    // Encodes a list of strings to a single string.
4
    public String encode(List<String> strs) {
5
        StringBuilder sb = new StringBuilder();
6

7
        for (String s : strs) {
8
            // s.length() + '*' + s
9
            sb.append(s.length()).append('*');
10
            sb.append(s);
11
        }
12

13
        return sb.toString();
14
    }
15

16
    // Decodes a single string to a list of strings.
17
    public List<String> decode(String s) {
18
        int idx = 0;
19

20
        List<String> result = new ArrayList<>();
21
        while (idx < s.length()) {
22
            // first index of *
23
            int pos = s.indexOf('*', idx);
24
            int size = Integer.valueOf(s.substring(idx, pos));
25

26
            // next index of  *
27
            idx = pos + size + 1;
28
            result.add(s.substring(pos + 1, idx));
29
        }
30

31
        return result;
32
    }
33
}

展开收起

272. Closest Binary Search Tree Value II#

https://leetcode.com/problems/closest-binary-search-tree-value-ii/

使用一个LinkedList作为队列，使用中序遍历（保证遍历的元素值从小到大），当队列中的元素数量达到k时检查当前元素是否更加接近target，没有就直接返回，有的话将首个元素踢掉。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    public List<Integer> closestKValues(TreeNode root, double target, int k) {
18
        LinkedList<Integer> result = new LinkedList<>();
19
        helper(result, root, target, k);
20
        return result;
21
    }
22

23
    private void helper(LinkedList<Integer> result, TreeNode node, double target, int k) {
24
        if (node == null) {
25
            return;
26
        }
27

28
        // in-order traverse
29
        helper(result, node.left, target, k);
30

31
        // if already k elements in result, remove first element
32
        // since we use in-order element, we can ensure that first element is the smallest and has max difference with current
33
        if (result.size() == k) {
34
            if (Math.abs(target - node.val) < Math.abs(target - result.peekFirst())) {
35
                result.removeFirst();
36
            } else {
37
                return;
38
            }
39
        }
40

41
        result.add(node.val);
42
        helper(result, node.right, target, k);
43
    }
44
}

展开收起

273. Integer to English Words#

https://leetcode.com/problems/integer-to-english-words/

默写出0-20对应的英文单词，以及0-100中所有的整十数的英文单词。由于限定了输入的范围不会超过2147483647，因此需要考虑6组范围：

0 - 19，直接调用20以内的单词
20 - 99，十位数调用整十数，个位数调用0-20
100 - 999，分割后2位数和其余位数，用”Hundred”衔接
1,000 - 999,999，分割后3位数和其余位数，用”Thousand”衔接
1,000,000 - 999,999,999，分割后6位数和其余位数，用”Million”衔接
1,000,000,000，分割后9位数和其余位数，用”Billion”衔接

核心思路就是不断将大数变小，只直接处理小于100的数字，更大的数字按照相应单位进行拆分。

1
class Solution {
2
    private final String[] belowTwenty = new String[] {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
3
                                                       "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
4

5
    private final String[] tens = new String[] {"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
6

7
    public String numberToWords(int num) {
8
        return (num == 0) ? "Zero" : helper(num);
9
    }
10

11
    private String helper(int num) {
12
        String result = new String();
13

14
        if (num < 20) {
15
            result = belowTwenty[num];
16
        } else if (num < 100) {
17
            result = tens[num / 10] + " " + belowTwenty[num % 10];
18
        } else if (num < 1000) {
19
            result = helper(num / 100) + " Hundred " + helper(num % 100);
20
        } else if (num < 1000000) {
21
            result = helper(num / 1000) + " Thousand " + helper(num % 1000);
22
        } else if (num < 1000000000) {
23
            result = helper(num/1000000) + " Million " +  helper(num % 1000000);
24
        } else {
25
            result = helper(num/1000000000) + " Billion " + helper(num % 1000000000);
26
        }
27

28
        return result.trim();
29
    }
30
}

展开收起

274. H-Index#

https://leetcode.com/problems/h-index/

构造一个长度为总论文篇数 + 1的桶，每个桶的索引是论文的引用次数i，桶内存放着引用次数为i的论文篇数。

遍历所有论文，如果某篇论文引用次数超过总论文篇数，累加到最后一个桶；否则，按照次数索引累加相应的桶。完成后，从后向前遍历每个桶，并且累加桶里的值。如果累加值大于等于当前桶的索引，说明发现了h-index。

1
class Solution {
2
    public int hIndex(int[] citations) {
3
        if (citations == null || citations.length == 0) {
4
            return 0;
5
        }
6

7
        // total paper count
8
        int len = citations.length;
9

10
        // bucket[i] means count of paper with citation i
11
        int[] buckets = new int[len + 1];
12

13
        for (int c : citations) {
14
            // if one paper's citation exceeds total paper count, sum up to last bucket
15
            if (c >= len) {
16
                buckets[len]++;
17
            } else {
18
                buckets[c]++;
19
            }
20
        }
21

22
        // search backwards to find the largest h-index
23
        int count = 0;
24
        for (int i = len; i >= 0; i--) {
25
            count += buckets[i];
26
            if (count >= i) {
27
                return i;
28
            }
29
        }
30

31
        return 0;
32
    }
33
}

展开收起

275. H-Index II#

https://leetcode.com/problems/h-index-ii/

因为citations已经排好序了，所以直接使用二分搜索，如果mid索引的引用次数大于篇数，说明引用次数设定的过大，因此right取mid左侧；反之left取mid右侧。

1
class Solution {
2
    public int hIndex(int[] citations) {
3
        if (citations == null || citations.length == 0) {
4
            return 0;
5
        }
6

7
        int len = citations.length;
8
        int left = 0, right = len - 1;
9
        while (left <= right) {
10
            int mid = left + (right - left) / 2;
11

12
            // len - mid: have at least h citations
13
            if (citations[mid] >= (len - mid)) {
14
                right = mid - 1;
15
            } else {
16
                left = mid + 1;
17
            }
18
        }
19

20
        return len - left;
21
    }
22
}

展开收起

276. Paint Fence#

https://leetcode.com/problems/paint-fence/

考虑第n个post的染色数量，有两种情况：

与第n-1个不一致。任选和第n-1个post不同的颜色即可
与第n-1个一致，那么第n-1个必须和第n-2个post颜色不一致，问题转化为当前post与第n-2个不一致的问题

因此综合而言，如果使用动态规划，dp[i]依赖于dp[i-1]和dp[i-2]的值。不管是哪一种情况，都有k-1种其他颜色可选，因此总和就是(dp[i-1] + dp[i-2]) * (k-1)。

1
class Solution {
2
    public int numWays(int n, int k) {
3
        if (n == 0) {
4
            // no posts
5
            return 0;
6
        } else if (n == 1) {
7
            // one post and k colors
8
            return k;
9
        } else if (n == 2) {
10
            // two posts, each has k colors
11
            return k * k;
12
        }
13

14
        int[] dp = new int[n+1];
15
        dp[0] = 0;
16
        dp[1] = k;
17
        dp[2] = k * k;
18

19
        for (int i = 3; i <= n; i++) {
20
            dp[i] = (dp[i-1] + dp[i-2]) * (k-1);
21
        }
22
        return dp[n];
23
    }
24
}

展开收起

277. Find the Celebrity#

https://leetcode.com/problems/find-the-celebrity/

使用两次循环，第一次循环找出名人的候选，即如果candidate认识i，则把i换成新的candidate。第二次循环，再检查这个选出来的candidate是否认识号数在他之前的人。注意，第二次循环对于candidate是0的情况并不适用，因此需要额外讨论candidate为0的情况。

1
/* The knows API is defined in the parent class Relation.
2
      boolean knows(int a, int b); */
3

4
public class Solution extends Relation {
5
    public int findCelebrity(int n) {
6
        // only two people and they don't know about each other
7
        if (n == 2 && !knows(0, 1) && !knows(1, 0)) {
8
            return -1;
9
        }
10

11
        int candidate = 0;
12
        // find potential celebrity candidate
13
        for (int i = 1; i < n; i++) {
14
            if (knows(candidate, i)) {
15
                candidate = i;
16
            }
17
        }
18

19
        // additionally judge 0-th person
20
        if (candidate == 0) {
21
            for (int i = 1; i < n; i++) {
22
                if (!knows(i, candidate)) {
23
                    return -1;
24
                }
25
            }
26

27
            return 0;
28
        }
29

30
        // if this celebrity candidate knows someone,
31
        // or somebody doesn't know him, exclude him
32
        for (int i = 0; i < candidate; i++) {
33
            if (knows(candidate, i) || !knows(i, candidate)) {
34
                return -1;
35
            }
36
        }
37

38
        return candidate;
39
    }
40
}

展开收起

278. First Bad Version#

https://leetcode.com/problems/first-bad-version/

1
/* The isBadVersion API is defined in the parent class VersionControl.
2
      boolean isBadVersion(int version); */
3

4
public class Solution extends VersionControl {
5
    public int firstBadVersion(int n) {
6
        int left = 1, right = n;
7

8
        while (left < right) {
9
            int mid = left + (right - left) / 2;
10
            if (isBadVersion(mid) == false) {
11
                left = mid + 1;
12
            } else {
13
                right = mid;
14
            }
15
        }
16

17
        return left;
18
    }
19
}

展开收起

279. Perfect Squares#

https://leetcode.com/problems/perfect-squares/

使用动态规划思想，记录每个数中最少可用几个完全平方数表示。从1开始到sqrt(i)，尽可能地填入已知的最大完全平方数。

1
class Solution {
2
    public int numSquares(int n) {
3
        int[] dp = new int[n + 1];
4
        Arrays.fill(dp, Integer.MAX_VALUE);
5

6
        for (int i = 0; i * i <= n; i++) {
7
            dp[i * i] = 1;
8
        }
9

10
        for (int i = 1; i <= n; i++) {
11
            for (int j = 0; i + j * j <= n; j++) {
12
                dp[i + j * j] = Math.min(dp[i + j * j], dp[i] + 1);
13
            }
14
        }
15

16
        return dp[n];
17
    }
18
}

展开收起

280. Wiggle Sort#

https://leetcode.com/problems/wiggle-sort/

第一个数不动，之后的数按照下标奇偶，如果奇数下标的数比前一个数小，或是偶数下标的数比前一个数大，则交换当前数和前一个数。

1
class Solution {
2
    public void wiggleSort(int[] nums) {
3
        for (int i = 0; i < nums.length; i++) {
4

5
            if (i % 2 == 1 && nums[i-1] > nums[i]) {
6
                // odd index must be greater than previous one
7
                swap(nums, i-1, i);
8
            } else if (i > 0 && i % 2 == 0 && nums[i-1] < nums[i]) {
9
                // even index (except 0) must be samller than previous one
10
                swap(nums, i-1, i);
11
            }
12
        }
13
    }
14

15
    private void swap(int[] nums, int i, int j) {
16
        int temp = nums[i];
17
        nums[i] = nums[j];
18
        nums[j] = temp;
19
    }
20
}

展开收起

281. Zigzag Iterator#

https://leetcode.com/problems/zigzag-iterator/

将两个List的信息复制到全局变量中，同时引入两个指针变量用于标注当前遍历List的进度。必须时刻确保两个指针轮流前进，并且指针不能超出对应List的长度。

1
public class ZigzagIterator {
2

3
    int size1 = 0, size2 = 0;
4
    int ptr1 = 0, ptr2 = 0;
5
    List<Integer> v1, v2;
6

7
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
8
        size1 = v1.size();
9
        size2 = v2.size();
10
        this.v1 = v1;
11
        this.v2 = v2;
12
    }
13

14
    public int next() {
15
        int result = -1;
16

17
        // 'zigzagly' moving ptr1 and ptr2 forward
18
        if (ptr1 < ptr2 && ptr1 < size1) {
19
            result = v1.get(ptr1);
20
            ptr1++;
21
            return result;
22
        }
23
        if (ptr2 < ptr1 && ptr2 < size2) {
24
            result = v2.get(ptr2);
25
            ptr2++;
26
            return result;
27
        }
28

29
        // one of the pointers reach the end, only moving other pointers
30
        if (ptr1 < size1) {
31
            result = v1.get(ptr1);
32
            ptr1++;
33
            return result;
34
        }
35
        if (ptr2 < size2) {
36
            result = v2.get(ptr2);
37
            ptr2++;
38
            return result;
39
        }
40

41
        return result;
42
    }
43

44
    public boolean hasNext() {
45
        // v1 unfinished, or v2 unfinished
46
        return (ptr1 < size1 || ptr2 < size2);
47
    }
48
}

展开收起

282. Expression Add Operators#

https://leetcode.com/problems/expression-add-operators/

使用dfs，抄录num的每一位到exp中，再分别用三种符号dfs尝试是否满足条件。注意处理首位为0（跳过）以及整数溢出（使用long)的情况。

1
class Solution {
2
    private List<String> result;
3
    private char[] num;
4
    private char[] exp;
5

6
    public List<String> addOperators(String num, int target) {
7
        this.num = num.toCharArray();
8
        this.result = new ArrayList<>();
9
        this.exp = new char[num.length() * 2];
10
        dfs(0, 0, 0, 0, target);
11
        return result;
12
    }
13

14
    private void dfs(int pos, int len, long prev, long curr, int target) {
15
        // finish whole string
16
        if (pos == num.length) {
17
            if (curr == target) {
18
                // add current expression to result
19
                result.add(new String(exp, 0, len));
20
            }
21

22
            return;
23
        }
24

25
        // record current position of num and expression
26
        int s = pos, l = len;
27
        if (s != 0) {
28
            len++;
29
        }
30

31
        long n = 0;
32
        while (pos < num.length) {
33
            // first digit is 0, skipped
34
            if (num[s] == '0' && pos - s > 0) {
35
                break;
36
            }
37

38
            // calculation
39
            n = n * 10 + (int)(num[pos] - '0');
40
            if (n > Integer.MAX_VALUE) {
41
                break;
42
            }
43

44
            // copy current position of num to expression
45
            exp[len] = num[pos];
46
            len++;
47
            pos++;
48

49
            // at the start, no current value, go to dfs straightly
50
            if (s == 0) {
51
                dfs(pos, len, n, n, target);
52
                continue;
53
            }
54

55
            // try '+', '-', '*'
56
            exp[l] = '+';
57
            dfs(pos, len, n, curr + n, target);
58

59
            exp[l] = '-';
60
            dfs(pos, len, -n, curr - n, target);
61

62
            exp[l] = '*';
63
            dfs(pos, len, prev * n, curr - prev + prev * n, target);
64
        }
65
    }
66
}

展开收起

283. Move Zeroes#

https://leetcode.com/problems/move-zeroes/

遍历数组，将所有非0的数按顺序填到数组最前；之后的部分补0即可。

1
class Solution {
2
    public void moveZeroes(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return;
5
        }
6

7
        int count = 0;
8
        for (int i = 0; i < nums.length; i++) {
9
            if (nums[i] != 0) {
10
                nums[count] = nums[i];
11
                count++;
12
            }
13
        }
14

15
        for (int i = count; i < nums.length; i++) {
16
            nums[i] = 0;
17
        }
18
        return;
19
    }
20
}

展开收起

284. Peeking Iterator#

https://leetcode.com/problems/peeking-iterator/

构造函数里，需要先检查迭代器是否为空（含有下一个元素）。

使用isIterationFinished变量，记录目前迭代器是否访问完毕；在已访问完的情况下调用next()，需要抛出异常。

1
// Java Iterator interface reference:
2
// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
3

4
import java.util.NoSuchElementException;
5

6
class PeekingIterator implements Iterator<Integer> {
7

8
    Integer next;
9
    Iterator<Integer> iter;
10
    boolean isIterationFinished = false; // whether finished iterating current iterator
11

12
    public PeekingIterator(Iterator<Integer> iterator) {
13
        // initialize any member here.
14
        iter = iterator;
15

16
        // pre-set 'next' pointer and 'isIterationFinished' flag
17
        if (iter.hasNext()) {
18
            next = iter.next();
19
        } else {
20
            isIterationFinished = true;
21
        }
22
    }
23

24
    // Returns the next element in the iteration without advancing the iterator.
25
    public Integer peek() {
26
        return next;
27
    }
28

29
    // hasNext() and next() should behave the same as in the Iterator interface.
30
    // Override them if needed.
31
    @Override
32
    public Integer next() {
33
        if (isIterationFinished) {
34
            throw new NoSuchElementException();
35
        }
36
        Integer result = next;
37

38
        // need to set 'next' pointer and 'isIterationFinished' flag before return
39
        if (iter.hasNext()) {
40
            next = iter.next();
41
        } else {
42
            isIterationFinished = true;
43
        }
44

45
        return result;
46
    }
47

48
    @Override
49
    public boolean hasNext() {
50
        return !isIterationFinished;
51
    }
52
}

展开收起

285. Inorder Successor in BST#

https://leetcode.com/problems/inorder-successor-in-bst/

最近的继承者要么是p的右子树上的最小值，要么是p的父节点。

当root的值比p小时，不断递归调用root的右子，向右查找最近的successor；否则，调用root的左子进行判断，如果存在左子，root的左子肯定比root的小，但又比root的父节点大，因此返回root的左子；如果不存在左子，说明root本身就已经是以root为根的树上能获取到的最小节点（再小就需要返回上一级父节点），因此返回root本身。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode(int x) { val = x; }
8
 * }
9
 */
10
class Solution {
11
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
12
        if (root == null) {
13
            return null;
14
        }
15

16
        // start to search in left subtree
17
        if (root.val <= p.val) {
18
            return inorderSuccessor(root.right, p);
19
        } else {
20
            // may be the smallest node in left subtree, otherwise root itself
21
            TreeNode left = inorderSuccessor(root.left, p);
22
            return (left != null) ? left : root;
23
        }
24
    }
25
}

展开收起

286. Walls and Gates#

https://leetcode.com/problems/walls-and-gates/

DFS遍历数组，发现一个门时开始DFS，更新整个数组的值。DFS的过程中，迭代的深度即表示当前方格到门的距离。

1
class Solution {
2
    public void wallsAndGates(int[][] rooms) {
3
        if (rooms == null || rooms.length == 0 || rooms[0].length == 0) {
4
            return;
5
        }
6

7
        for (int i = 0; i < rooms.length; i++) {
8
            for (int j = 0; j < rooms[0].length; j++) {
9
                // start from a gate to update the whole matrix
10
                if (rooms[i][j] == 0) {
11
                    dfs(rooms, i, j, 0);
12
                }
13
            }
14
        }
15

16
        return;
17
    }
18

19
    private void dfs(int[][] rooms, int i, int j, int depth) {
20
        // set current depth of route
21
        rooms[i][j] = depth;
22

23
        if (i > 0 && rooms[i - 1][j] > depth + 1) {
24
            dfs(rooms, i - 1, j, depth + 1);
25
        }
26

27
        if (i < rooms.length - 1 && rooms[i + 1][j] > depth + 1) {
28
            dfs(rooms, i + 1, j, depth + 1);
29
        }
30

31
        if (j > 0 && rooms[i][j - 1] > depth + 1) {
32
            dfs(rooms, i, j - 1, depth + 1);
33
        }
34

35
        if (j < rooms[0].length - 1 && rooms[i][j + 1] > depth + 1) {
36
            dfs(rooms, i, j + 1, depth + 1);
37
        }
38
    }
39
}

展开收起

287. Find the Duplicate Number#

https://leetcode.com/problems/find-the-duplicate-number/

与此前的Linked List Cycle II思路相近，仍旧使用快慢指针，慢指针每次跳转一位，快指针每次跳转两位。经过相同次数跳转后，快慢指针将指向同一数字。这时，快指针已经比慢指针多完成了一个cycle的循环。从相遇点到cycle入口到距离恰好等于慢指针此前移动的次数：

因此，将慢指针放回起点，之后让两个指针等速跳转，慢指针重走一遍来时的路，快指针再走一遍cycle，相遇点就是环的入口，即重复的数字。

1
class Solution {
2
    public int findDuplicate(int[] nums) {
3
        int slow = 0, fast = 0;
4

5
        while (fast < nums.length && nums[fast] < nums.length) {
6
            slow = nums[slow];
7
            fast = nums[ nums[fast] ];
8

9
            if (slow == fast) {
10
                slow = 0;
11
                while (slow != fast) {
12
                    slow = nums[slow];
13
                    fast = nums[fast];
14
                }
15

16
                return slow;
17
            }
18
        }
19

20
        return -1;
21
    }
22
}

展开收起

288. Unique Word Abbreviation#

https://leetcode.com/problems/unique-word-abbreviation/

使用一个map，保存缩略词作为key，可能的unique word作为value。当发现一个新缩略词时，将其作为key，同时将这个单词本身作为value保存进map中；而一旦发现了第二个具有相缩略词的单词时，这个单词肯定不是unique word，因此将这个缩略词对应的value设为空，等待之后是否还有其他单词补入。判断是否为unique word时，只需要检查其对应缩略词key是否能获取得到value即可。

1
class ValidWordAbbr {
2

3
    // only save the abbr key and potential unique word as value
4
    Map<String, String> wordAbbr = new HashMap<>();
5

6
    public ValidWordAbbr(String[] dictionary) {
7
        for (String str : dictionary) {
8
            String abbr = getAbbreviation(str);
9

10
            if (!wordAbbr.containsKey(abbr)) {
11
                // a new key
12
                wordAbbr.put(abbr, str);
13
            }  else if (!wordAbbr.get(abbr).equals(str)) {
14
                // eliminate a pair of repeating words
15
                wordAbbr.put(abbr, "");
16
            }
17
        }
18
    }
19

20
    public boolean isUnique(String word) {
21
        String abbr = getAbbreviation(word);
22
        if (!wordAbbr.containsKey(abbr)) {
23
            return true;
24
        }
25

26
        return wordAbbr.get(abbr).equals(word);
27
    }
28

29
    private String getAbbreviation(String word) {
30
        int len = word.length();
31
        if (len < 3) {
32
            return word;
33
        }
34

35
        return word.charAt(0) + String.valueOf(len - 2) + word.charAt(len - 1);
36
    }
37
}

展开收起

289. Game of Life#

https://leetcode.com/problems/game-of-life/

使用两位状态码表示一个节点的状态：

1
[2nd bit, 1st bit] = [next state, current state]
2

3
- 00  dead (next) <- dead (current)
4
- 01  dead (next) <- live (current)
5
- 10  live (next) <- dead (current)
6
- 11  live (next) <- live (current)

在统计周围方格的情况时，只需要判断1st bit的情况（和1取与）；而决定一格是否生存，只需要修改2nd bit即可。只要2nd bit为1（对应状态2或3），右移后下一回合这一格就是生存的。

1
class Solution {
2
    public void gameOfLife(int[][] board) {
3
        if (board == null || board[0].length == 0) {
4
            return;
5
        }
6
        int row = board.length, col = board[0].length;
7

8
        for (int i = 0; i < row; i++) {
9
            for (int j = 0; j < col; j++) {
10
                int lives = countLives(board, row, col, i, j);
11
                if (board[i][j] == 1 && lives >= 2 && lives <= 3) {
12
                    // lives on to the next generation
13
                    board[i][j] = 3;
14
                }
15

16
                if (board[i][j] == 0 && lives == 3) {
17
                    // reproduction
18
                    board[i][j] = 2;
19
                }
20
            }
21
        }
22

23
        // shift to next state
24
        for (int i = 0; i < row; i++) {
25
            for (int j = 0; j < col; j++) {
26
                board[i][j] >>= 1;
27
            }
28
        }
29
    }
30

31
    private int countLives(int[][] board, int row, int col, int i, int j) {
32
        int lives = 0;
33

34
        // count how many alive cells in 3*3 grids, and reduce self cell
35
        for (int x = Math.max(i-1, 0); x <= Math.min(i+1, row-1); x++) {
36
            for (int y = Math.max(j-1, 0); y <= Math.min(j+1, col-1); y++) {
37
                lives += board[x][y] & 1;
38
            }
39
        }
40

41
        lives -= board[i][j] & 1;
42

43
        return lives;
44
    }
45
}

展开收起

290. Word Pattern#

https://leetcode.com/problems/word-pattern/

使用HashMap建立起<字母，下标>和<单词，下标>的对应，比较上一次字母、单词各自出现时对应的下标是否相等。注意两点：

map.put()返回插入前的value，可以直接用来比较，不需要再调用map.containsKey()
Java的autoboxing机制，即JVM会缓存-128 ~ 127之间的整数，此时这两个整数对象可以简单用==比较值。如果循环中的i声明为int类型，而恰好遇到了很长的测试用例使得i超出了这个范围，比较就失效了。（值相等也返回false)

1
class Solution {
2
    public boolean wordPattern(String pattern, String str) {
3
        char[] characters = pattern.toCharArray();
4
        String[] words = str.split(" ");
5

6
        // str and pattern must have same length
7
        if (characters.length != words.length) {
8
            return false;
9
        }
10

11
        Map map = new HashMap<>();
12
        for (Integer i = 0; i < characters.length; i++) {
13
            // map.put() returns the value before inserting
14
            if (map.put(characters[i], i) != map.put(words[i], i)) {
15
                return false;
16
            }
17
        }
18

19
        return true;
20
    }
21
}

展开收起

291. Word Pattern II#

https://leetcode.com/problems/word-pattern-ii/

使用回溯算法，用一个map保存pattern中每一个字母入口以及对应的字符串，再使用一个Set保存所有尝试过的字符串。逐个字母向前推进pattern和str，同时检查str中剩余的所有可能字符串，只要没有出现长度不合法或是模式不匹配，就dfs调用下一层检查。当pattern和str的指针同时达到结尾，说明匹配成功。

1
class Solution {
2
    public boolean wordPatternMatch(String pattern, String str) {
3
        if (pattern.length() == 0 && str.length() == 0) {
4
            return true;
5
        }
6
        if (pattern.length() > str.length()) {
7
            return false;
8
        }
9

10
        // string entry, string
11
        Map<Character, String> charToStr = new HashMap<>();
12
        Set<String> visited = new HashSet<>();
13

14
        return findPatternMatch(pattern, 0, str, 0, charToStr, visited);
15
    }
16

17
    private boolean findPatternMatch(String pattern, int pIndex, String str, int sIndex, Map<Character, String> charToStr, Set<String> visited) {
18
        // one reaches the end, the other should also reaches
19
        if (pIndex == pattern.length()) {
20
            return sIndex == str.length();
21
        }
22
        if (sIndex == str.length()) {
23
            return pIndex == pattern.length();
24
        }
25

26
        char c = pattern.charAt(pIndex);
27

28
        if (charToStr.containsKey(c)) {
29
            String cs = charToStr.get(c);
30
            if (cs.length() > str.length() - sIndex || !cs.equals(str.substring(sIndex, sIndex + cs.length()))) {
31
                return false;
32
            }
33
            return findPatternMatch(pattern, pIndex + 1, str, sIndex + cs.length(), charToStr, visited);
34
        }
35

36
        int sRemain = str.length() - sIndex;
37
        int pRemain = pattern.length() - pIndex - 1;
38

39
        // try different string length
40
        for (int len = 1; len <= sRemain - pRemain; len++) {
41
            String sub = str.substring(sIndex, sIndex + len);
42

43
            // skip visited string
44
            if (visited.contains(sub)) {
45
                continue;
46
            }
47

48
            charToStr.put(c, sub);
49
            visited.add(sub);
50

51
            // dfs, try next character in pattern
52
            if (findPatternMatch(pattern, pIndex + 1, str, sIndex + len, charToStr, visited)) {
53
                return true;
54
            }
55

56
            charToStr.remove(c);
57
            visited.remove(sub);
58
        }
59

60
        return false;
61
    }
62
}

展开收起

292. Nim Game#

https://leetcode.com/problems/nim-game/

如果石头个数是4的倍数，先手方拿任意x个，后方只需要拿4-x个，先手方必败。其余情况下，只要不是4的倍数，先手方拿一些石头使得剩余石头个数为4的倍数就能保证必胜。

1
class Solution {
2
    public boolean canWinNim(int n) {
3
        return n % 4 != 0;
4
    }
5
}

293. Flip Game#

https://leetcode.com/problems/flip-game/

将字符串转为chararray，循环遍历遇到连续两个+时，翻转到-，再构造字符串添加到结果中；之后这里两个字母翻转为+，继续循环。

1
class Solution {
2
    public List<String> generatePossibleNextMoves(String currentState) {
3
        List<String> result = new ArrayList<>();
4
        char[] arr = currentState.toCharArray();
5

6
        for (int i = 0; i < currentState.length() - 1; i++) {
7
            if (arr[i] == '+' && arr[i+1] == '+') {
8
                // flip
9
                arr[i] = '-';
10
                arr[i+1] = '-';
11

12
                // add result
13
                result.add(new String(arr));
14

15
                // restore
16
                arr[i] = '+';
17
                arr[i+1] = '+';
18
            }
19
        }
20

21
        return result;
22
    }
23
}

展开收起

294. Flip Game II#

https://leetcode.com/problems/flip-game-ii/

使用-分隔字符串，对每一个子字符串，分析其长度，如果其长度不为0且不是4的倍数+1，就说明对于这一组子字符串只要自己先手，就一定能让对方不能最终make move。因此添加这个长度到最终的set中。最终检查set中是否还存在元素，即可判断是否还有move。

1
class Solution {
2
    public boolean canWin(String s) {
3
        Set<Integer> set = new HashSet<>();
4

5
        for (String str : s.split("-")) {
6
            int curr = str.length();
7

8
            if (curr != 0 && curr % 4 != 1) {
9
                if (curr % 2 == 1) {
10
                    curr--;
11
                }
12

13
                if (set.contains(curr)) {
14
                    set.remove(curr);
15
                } else {
16
                    set.add(curr);
17
                }
18
            }
19
        }
20

21
        return set.size() != 0;
22
    }
23
}

展开收起

295. Find Median from Data Stream#

https://leetcode.com/problems/find-median-from-data-stream/

使用两个优先队列，一个存放较小的一半数，另一个存放较大的一半数。每次添加新num时，计算已有数据的中位数，决定num应该放到哪一半中，再调整平衡两个优先队列的个数。

1
class MedianFinder {
2

3
    PriorityQueue<Integer> smallHalf; // descending order
4
    PriorityQueue<Integer> largeHalf; // ascending order
5
    int totalCount = 0; // total element's count
6

7
    /** initialize your data structure here. */
8
    public MedianFinder() {
9
        smallHalf = new PriorityQueue<>((x, y) -> y - x);
10
        largeHalf  = new PriorityQueue<>();
11
    }
12

13
    public void addNum(int num) {
14
        // initial median to spearate smallHalf and largeHalf num
15
        double median = totalCount > 0 ? findMedian() : num;
16
        if (num < median) {
17
            smallHalf.add(num);
18
        } else {
19
            largeHalf.add(num);
20
        }
21

22
        // balance smallHalf and largeHalf
23
        if (smallHalf.size() > largeHalf.size() + 1) {
24
            largeHalf.add(smallHalf.poll());
25
        }
26
        if (smallHalf.size() + 1 < largeHalf.size()) {
27
            smallHalf.add(largeHalf.poll());
28
        }
29

30
        totalCount++;
31
    }
32

33
    // largest element in smallHalf & smallest element in largeHalf
34
    public double findMedian() {
35
        if (smallHalf.size() > largeHalf.size()) {
36
            return smallHalf.peek();
37
        }
38
        if (largeHalf.size() > smallHalf.size()) {
39
            return largeHalf.peek();
40
        }
41

42
        return (smallHalf.peek() + largeHalf.peek()) / 2.0;
43
    }
44
}

展开收起

296. Best Meeting Point#

https://leetcode.com/problems/best-meeting-point/

将每一行、每一列进行累加，得到两个1D的累加数组，分别记录每行与每列的和。之后对于每行或每列，用求和平衡法寻找到所有的行重心和列重心。

1
class Solution {
2
    public int minTotalDistance(int[][] grid) {
3
        int m = grid.length, n = grid[0].length;
4
        int[] rowSum = new int[n], colSum = new int[m];
5

6
        for (int i = 0; i < m; i++)
7
            for (int j = 0; j < n; j++) {
8
                rowSum[j] += grid[i][j];
9
                colSum[i] += grid[i][j];
10
            }
11

12
        return minDistance1D(rowSum) + minDistance1D(colSum);
13
    }
14

15
    public int minDistance1D(int[] vector) {
16
        int i = -1, j = vector.length;
17
        int distance = 0, left = 0, right = 0;
18

19
        // reach the middle sum point of each row and column
20
        while (i != j) {
21
            if (left < right) {
22
                distance += left;
23
                i++;
24
                left += vector[i];
25
            } else {
26
                distance += right;
27
                j--;
28
                right += vector[j];
29
            }
30
        }
31

32
        return distance;
33
    }
34
}

展开收起

297. Serialize and Deserialize Binary Tree#

https://leetcode.com/problems/serialize-and-deserialize-binary-tree/

串行化的过程比较容易，直接使用前序遍历的方法，使用一个StringBuilder不断添加节点的值即可，中间用逗号分隔。

解串行化复原的过程稍难，由于不允许使用静态变量，因此需要使用一个长度为1的动态数组用于储存当前的下标，仍然使用前序遍历。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode(int x) { val = x; }
8
 * }
9
 */
10
public class Codec {
11

12
    // Encodes a tree to a single string.
13
    public String serialize(TreeNode root) {
14
        StringBuilder sb = new StringBuilder();
15
        serializeHelper(root, sb);
16
        return sb.toString();
17
    }
18

19
    private void serializeHelper(TreeNode node, StringBuilder sb) {
20
        if (node == null) {
21
            sb.append("null,");
22
            return;
23
        }
24
        sb.append(node.val).append(",");
25
        serializeHelper(node.left, sb);
26
        serializeHelper(node.right, sb);
27
    }
28

29
    // Decodes your encoded data to tree.
30
    public TreeNode deserialize(String data) {
31
        String[] nodes = data.split(",");
32
        int[] index = new int[1];
33
        return deserializeHelper(nodes, index);
34
    }
35

36
    private TreeNode deserializeHelper(String[] nodes, int[] index) {
37
        if (nodes[index[0]].equals("null")) {
38
            index[0]++;
39
            return null;
40
        }
41
        TreeNode cur = new TreeNode(Integer.valueOf(nodes[index[0]]));
42
        index[0]++;
43
        cur.left = deserializeHelper(nodes, index);
44
        cur.right = deserializeHelper(nodes, index);
45
        return cur;
46
    }
47
}

展开收起

298. Binary Tree Longest Consecutive Sequence#

https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/

使用dfs，如果当前节点孩子的值增长了1，就在连续计数上增加1，反之重置结果。

1
/**
2
 * Definition for a binary tree node.
3
 * public class TreeNode {
4
 *     int val;
5
 *     TreeNode left;
6
 *     TreeNode right;
7
 *     TreeNode() {}
8
 *     TreeNode(int val) { this.val = val; }
9
 *     TreeNode(int val, TreeNode left, TreeNode right) {
10
 *         this.val = val;
11
 *         this.left = left;
12
 *         this.right = right;
13
 *     }
14
 * }
15
 */
16
class Solution {
17
    private int result;
18

19
    public int longestConsecutive(TreeNode root) {
20
        if (root == null) {
21
            return 0;
22
        }
23
        helper(root, 0, root.val);
24
        return result;
25
    }
26

27
    private void helper(TreeNode node, int tempCount, int value) {
28
        if (node == null) {
29
            return;
30
        }
31

32
        // if node's value is as expected, add 1 to count
33
        if (node.val == value) {
34
            tempCount++;
35
        } else {
36
            tempCount = 1;
37
        }
38

39
        // update result
40
        result = Math.max(result, tempCount);
41

42
        // next level's node value should increment by 1
43
        helper(node.left, tempCount, node.val + 1);
44
        helper(node.right, tempCount, node.val + 1);
45
    }
46
}

展开收起

299. Bulls and Cows#

https://leetcode.com/problems/bulls-and-cows/

一次遍历解决问题：使用numbers数组记录每个数字出现的次数。最理想的情况下，两个数字的对应位置数字相等，直接累加bull。

遍历secret时，numbers[i]增加；此时如果遇到了numbers[i]小于0的情况，说明这个数字已经在guess中出现过，但是位置不对，因此累加cow。同理，遍历guess时，numbers[i]减少；此时如果遇到了numbers[i]大于0的情况，也说明这个数字已经在secret中出现过且位置不对，累加cow。

1
class Solution {
2
    public String getHint(String secret, String guess) {
3
        int bulls = 0, cows = 0;
4
        int[] numbers = new int[10];
5
        for (int i = 0; i < secret.length(); i++) {
6
            if (secret.charAt(i) == guess.charAt(i)) {
7
                bulls++;
8
            } else {
9
                if (numbers[secret.charAt(i) - '0'] < 0) {
10
                    cows++;
11
                }
12
                numbers[secret.charAt(i) - '0']++;
13

14
                if (numbers[guess.charAt(i) - '0'] > 0) {
15
                    cows++;
16
                }
17
                numbers[guess.charAt(i) - '0']--;
18
            }
19
        }
20

21
        return bulls + "A" + cows + "B";
22
    }
23
}

展开收起

300. Longest Increasing Subsequence#

https://leetcode.com/problems/longest-increasing-subsequence/

使用一个tails数组，tails[i]记录当递增序列长度为i+1时，最小的序列尾的值。由此，可以确定出大于这个最小序列尾的数的个数，记为size。

例如，对于数列[4,5,6,3]，有：

1
len = 1   :      [4], [5], [6], [3]   => tails[0] = 3
2
len = 2   :      [4, 5], [5, 6]       => tails[1] = 5
3
len = 3   :      [4, 5, 6]            => tails[2] = 6

容易得知，tails是一个递增的数列。因此，每次加入一个数时就对tails使用一次二分查找，将这个数插入到tails中：

如果当前数比所有的tail都大，则添加在tails的末尾
如果当前数位于某个(tails[i-1], tails[i]]之间，更新tails[i]的值为当前数

在这一过程中，如果添加的位置正好是size，说明这个数肯定也是也在LIS中，因此size增加1。

1
class Solution {
2
    public int lengthOfLIS(int[] nums) {
3
        if (nums == null || nums.length == 0) {
4
            return 0;
5
        }
6

7
        int[] tails = new int[nums.length];
8
        int size = 0; // length of LIS
9

10
        for (int num : nums) {
11
            int left = 0, right = size;
12
            while (left < right) {
13
                int mid = left + (right - left) / 2;
14
                if (tails[mid] < num) {
15
                    left = mid + 1;
16
                } else {
17
                    right = mid;
18
                }
19
            }
20

21
            tails[left] = num;
22

23
            // update size
24
            if (left == size) {
25
                size++;
26
            }
27
        }
28

29
        return size;
30
    }
31
}

展开收起