2026年的第一个季度快要过去了。

胡乱地在各种软件里散落了些文字，今天放在这里祭奠。

写下的时间是由近到远。

如果能统计出每天会遇到的事，除了上班之外，还会遭遇那么多重复的事。事情一遍遍重复，对待这些事的反应也一遍遍重演，我们的情感在一遍遍宣泄，疲惫不堪，懊恼不已，却，还蕴含着一丝，乐此不疲。

想远离一切痛苦的我们，同时惧怕着万里无云。

• 酒！酒！酒！
• 傍晚的珠海跑进我的心里了。
• 艺术将人拉近，极端的科学将我们推远。
• 你写诗，文学创作，是为了讨好机器吗？
• 跟大家待在一起，让我自己变小了。
• 我还是在过一种幻觉的生活，总是不记得上一个月做的事，去过哪些地方，见过的那些人，总是没有太深的印象。日子就这样在过下去。
• 你会不断自己告诉自己，不再年轻。
• 前几年有人说我离生活太远。这几年主动离生活很近，心里依然觉得很远，心不在焉。
• 昨天算是宿醉，连续两天喝一瓶白葡萄酒，今天起床脑袋里好像放了一根木头，舌头一直在发麻，手脚控制力也下降了。

哲学和文学好像都不能再让我的心平静下来了。过去很多的内心深处的爱好，都失去了本来的意义。

我是行尸走肉。我在迷失。

• 你以为你踏实上班懂得越来越多了，其实懂得面越来越窄，反而对这个世界了解的越来越少了。
• 把我的心打开吧，给你们看，空无一物。
• 我并不觉得缺少什么，我并不为未来的物质焦虑，我对当下已然满意。
• 他们的改变太难。
• 新住的地方附近少了电影院，我便少看看了一些院线电影。
• 我怎么觉得就只有我想在社交网络上充满消极。为什么他们的社交网络只分享快乐，是大家的一种默契吗。
• 想去流浪。

我的内心浑浊，披着一层迷雾，扒不开，吹不散。丧失内核。混沌。我没有自我，即使有自我，任何问题，都不再能给出属于我这个人的解答，我活成了什么样子，批评自我，哀怨自我，又去每个方面肯定自我。迷幻的精神。谁都能批评，谁都必须尊敬。我是个病人。

• 旅行一两天只能够让你回到老地方安心生活一两天。
• 海明威说：巴黎是一席流动的盛宴。而上海就是我心中的巴黎，可我却不是海明威。至少目前还不是。
• 合肥路灯上站着的鸟儿，有想过飞去外地吗。
• 能够睡的越来越早，越来越虚无。

我现在好像没有什么烦恼，也没有什么希望。

• 没有过去，只有作品。
• 人就是拿来伤害的。
• 有些问题一直没有解决，得过且过生活到现在，思维无时无刻不在漂流，花很多时间在内心嘲笑自己。
• 大差不差的城市，还好有不同的故事。
• 日子是一天一天过吗，是一团一团的。
• 强迫自己和一些人待久了，都忘了自己可以有多酷了。
• 我的心被空无塞满，无法用任何爱填补，只有一层壳。
• 那个房间整洁的人，却可以随地吐口水。

四川让我痛苦。

• 既怕喧闹，又怕安静。
• 连可怜都没意识到，究竟是幸福还是更可怜。
• 有一种听到别人认真讨论，就想笑的轻蔑感。
• 俗不可耐
• 如果有一条抑郁，活着无欲望的狗。
• 浮华生活总是流于表面，但是确实相当带劲呀。
• 一个月有那么一两天断网，你会去咀嚼曾经的收获。
• 一个人开心，全世界光明。
• 我的生命力在减弱，在减弱…

厌恶生活的大巴车司机更厌恶生活一点之后，

我就踏入了一门新的菜系里。

属于这儿的，生活的滋味扑面而来，

不自觉用回忆这把筷子，挑出熟悉的一部分来品尝：

我尝到，停在港湾的船和泛在小河的舟在汇合。

我尝到，笑容的甜度和冲突的盐味混合在一块儿。

我尝到，那艘大船运输过的一道道完整的颜色。

我也能也会被接纳，我继续品尝。

味觉让我知道，如果在这里生活，

我也可以是，构成下一道霓虹里的一种。

被这艘姓名美丽的大船尽心运输。

没有什么想总结的。只想说一句话：对合肥，对目前的工作和同事，统统都厌倦了。

罗盘

从万缕缠绵中抽出预定的思念。
用指尖剥离花生的红衣。
松油意欲包裹的这一句：
“但是，他的性格有些怪异。”
作为琥珀成型的咒语。
由潮汐牵引至荫蔽，
满仓的松鼠表演焦急，
零碎的月光聚于夜的中心。
大地的炎症尽管熟悉，
罗盘岂有一天失灵？

第八宗

是一种诅咒，
需要一生克服的
从深山泥土中传递出的
一脉的诅咒：

盾牌防御了一次攻击，就扔掉
催发种子散发浓烈情感后，不播种
海边迎逆风启航，收帆，目睹搁浅的过程
滥用独一无二的连系，琢磨万人唾弃，暗含的
珍重

酒神不能诱发悲情或欢愉
爱神的天敌镇守在灵魂中

剩余的神佛在基因上雕刻：
是这一族罪过的第八宗。

扔春风

信封装着剑鞘，粘住一叶舟
锈蚀甘愿坠入，星河窟窿
梵高拎着黄红，填充平流层
清风只留我，一个时辰
留有余温的邮票，染黑双手
镜子是大地的眼眸，白里泛红
清道夫指着窗口说：
“可以在那儿，扔春风”

进化

在被一条鱼遗忘之际
海仍对它说：“勿忘平静”
曲折夺目的身姿
蓄势搅动地壳的神力
狰狞，鱼，锚定陆地
侍奉蓝天的飞禽
轻蔑地散播白羽
四脚的野兽们
守候膜拜阳的权力
哪只猿在月下
悄悄地直立
欲将星穹献给
爱恋的土地

心中鸟

吟唱摇篮曲的鸟儿
你还会留意——
叶间的青虫吗
你这自大的鸟儿
究竟在为什么歌唱呢
雨打风吹、寒冬酷暑
定要颤动胸脯幻化线谱
从地上荆棘到树的枝头
你分明连自己也弄不清楚
却将一切缝补在一块儿
引得无名的草丛
为了看你的模样
探向天空
引得我为你写下
连我自己也不清楚的
触动

一颗星

一种模式，在宇宙燃烧
一个星系，在银河筑巢

地球上有一种生命
用双眼观察到：
一颗星，正在闪耀

这颗星，如何知道：
他的夜空里，藏着一颗星
星上有无数的眼睛
在瞭望

翅膀

你好像很容易被赏赐一对翅膀，
海也预备生出波涛为你做向导。
有哪些心灵在对岸替你祈祷着：
太阳呀月亮呀，勿忘临摹土地之形状，
果实亦跌落在你开展的眉毛。
拂拭着，珍视着，你飞行的许可。
你好像感受到了，翅膀的心跳。

岩浆与海

岩浆被推着
从海底来到了海面
领悟上方另一种湛蓝
海在旁诉说，我在被伤害。
黑色的皮肤得以浮现。
炽热血脉蛰伏起来。

海被永远占据一块。

寺庙里的咖啡机

一台咖啡机，
在山顶的寺庙里。

“要不要来一杯有缘咖啡。”
师傅问我，“免费。”

我问师傅，“这个缘分，”
“能不能取名为dirty。”

师傅喃我，“执念太深。”
“众生皆苦，美式也行”，
我回。

师傅不再语。

缘分已尽，
我想。

幕布

好像没什么话想对自己说了
好像就失去了对情感的感悟
好像生命知晓了这一种平和
好像身体背着心灵掌握欢乐
好像在被谁俯视学不会融合

允许着自己怜悯我

我推我至人群
我拉我至自然

反复

阅读帮助巩固

随木头的脉搏起舞

我是我的一块幕布

光标在不会有人注意的地方闪烁，在向着只有我知道的方向移动。同我脑里想的事务一样，行为也在背着大家，做自己真正想做的事。瞒着周围的人，思考自己真正关注的事。

立冬了。

坦白说，我最近没有怎么靠近文学。

好像是触摸到了一种清晰的物质上的幸福：客观上并不算富足的我，嘴上虽然也总是在说钱不够，心里面其实没有觉得自己贫穷过，无论身上有多少钱，我其实都有一种满足感。

我目前感兴趣的物件，都能买到，那些周围的人都渴望买但是买不到的东西，我也都发自内心的不感兴趣。想去的地方，也都不必穷游，旅途中，想走便走，想留便留。听到我不管在哪儿，出行基本上都是打车，周围的人/旅行中认识的人，都说我生活地像个少爷。

等等，好像这样的描述，会让人觉得因为我都能负担，所以这般。可我内心清楚，如果不能负担旅行，那么我也就不向往旅行，会去寻找周围生活的美好。如果不能买更好的电子产品，我也不会困扰，因为我清楚工具的好坏并不会真正决定你想产出的内容的质量。初中上下学每天都要坐四趟公交车，我也没有一天觉得难受，公交车上挤满了人的那些日子，在当时或者是现在，我仍然觉得十分有趣。

让我自己给我的心态找个原由，我想是因为，这些都是基于我自己的选择，是这些自己的选择就只带来了这些物质，那么就应该满足于这些物质，这些物质就是你目前能得到的最好，想要新的物质，那么只管做出新的选择，否则你就是在自寻烦恼。可大家为什么不明白呢。

我觉得自己目前真正匮乏的，是属于自己的时间。安静的时间。做自己的时间。更多思考的时间。

立冬了。

都说身体自带一个闹钟，生物钟。我的钟和去年的这个时候一样，响起了病号铃。同样的感受，先是鼻子尽头一遇到空气就闹别扭，努力产出鼻涕，却始终无法成型。接着连一句话也说不完整，咳嗽之神总是在我说到关键之处提醒我谨言慎行。

深夜里，身体自觉地升温想杀死病菌，却先杀死了我的睡意。这股温度烧进了我的脑海，一块块尘封的记忆被炼成一幅幅镣铐，急欲重操旧刑折磨我。还好我终究是成长了一些，想起自己所在之地，自己提醒着自己，又是幻觉，我已经获得了全新的自由，已经不可能再像去年一样难过。

枕头被我垫高，缓解呼吸的障碍。空调在这个季节被我打开，调至18摄氏度，利用科技舒缓身与心的烧灼。

天亮，忘掉只睡了四个小时。带着终于能成型的鼻涕，和新的两个朋友，去吃一个星期前就约定好的非遗面馆。吃完，起意去爬山出出汗。两个朋友总是走在我前面，上面，回头看我，低头望我，满头大汗，气喘吁吁，他们笑我，他们等我，我很快乐，我在恢复。

登顶，只见一片雾霾。相机里的树木背后，呈现的是一片白，像是一张a4纸。我对朋友们说，现在看到的这一片白和我目前的人生一样，模糊不清。你知道这片白被驱散，就是五光十色。但是你目前就是只能看到这片白。朋友们调侃我又感慨起来了。

坐在一棵树下，就这样，闲聊一会儿，开一会儿玩笑。

下山，去往动物园。

上一次，还是小时候。

立冬了。

我最近买了一个动感单车，放在房间里。已经连续5天，下班后骑一个小时，消耗500大卡左右。

有一个女生说，要是我能够减15斤，她就给我报销动感单车。

所以，我就买了一个动感单车。

最近的我在过一种怎样的生活呢。

不过是三个月的时间，工作上做了不少项目，去了不少的地方，看了不少的电影和书籍，接触又分离不少的人。

短短的三个月，原来足够发生许多的事。从而想通：原来是这样，那些身患绝症的人，即便知道化疗的折磨，即便已被叮嘱（就算手术成功）生命只能延续一段时间。他们还是愿意继续。除了对死亡的恐惧，原来就这么一段时间，还有机会经历很多的事。

因为双休，朝九晚六，基本不用加班。这三个月去了：三亚、北京、重庆、合肥不少的酒吧/餐馆/景点/剧场。

这些活动都是去见人/和人一起去（可能是前些年太习惯一个人的自在），实际上都让我不是完全放松，即便是和熟人一同出游，在间隙我总是容易想过多和旅行无关的事。

我主动来看朋友们，他们看到我都很高兴。我当然也高兴，之余更多的是去看他们的这一行为的新奇体验。

去年以前，我都很少主动去另一个城市见见谁。

衷心感谢目前的这份工作给我的这些机会。毕竟今年目前为止，所有的机票都是公司给我买的。

感恩。

最近看过的电影：《落水狗》1992、《苏利文的旅行》1941、《巴顿·芬克》1991、《本杰明·巴顿奇事》2008、《日落大道》1950、《骗中骗》1973、《普通人》1980、《洛奇》1976、《犹在镜中》1961、《卡萨布兰卡》1942、《克莱默夫妇》1979、《唐人街》1974、《还有明天》2023、《没有过去的男人》2002、《一一》2000、《迁徙的鸟》2001、《奇爱博士》1964、《一个叫欧维的男人决定去死》2015、《彗星来的那一夜》2013、《海街日记》2015、《搏击俱乐部》1999、《喜宴》1993、《饮食男女》1994

最近看过的书：《窄门》、《冯雪科学减肥法》、《边喝边写》、《道德故事集》、《论生命之短暂》、《白夜》、《树上的男爵》、《伊万·伊利奇之死》、《海街日记》、《故事》、《一个孤独漫步者的遐想》、《美丽新世界》

可以知晓，我寻常工作日下班后除了打lolm、刷短视频之外，在做些什么。

可我想坦白，我的生活只是看起来“紧凑”，内在其实还是随意。

我会在备忘录时不时写一些自己的感受。大多数都悲观，不太能够给熟人看。

这段时间写过一条：

我现在好像没有什么烦恼，也没有什么希望。

我说给室友听，室友安慰我说：

那就是最好的状态。

再聊一点点工作上的吧。

对目前的全职工作，我很认可且认真，沉浸上班了七个月后，觉得之前，我对时间是否太不够尊重了。总认为一件事就是需要以一月/半年的单位去规划完成。实际上在社会机器里运转，分配到你头上的大量事的处理时间由不得你来决定。大部分的事儿都是突然开始，刚有些头绪时，还可能悄然结束。

一件件迅速地来，一件件惯性般地交付。偶然得空，想起来，来去不由得自己控制，中间五感发挥再尽兴，这种完成的成就感真的属于自己吗。

工资，是公司给我发的安慰剂。即便我认可目前的公司和项目，抗药性已在时不时地折磨我。

我实在应该多喝些酒、多写些文字。

毕竟这几个月已经刻苦学习了之前自认为还不够了解的那些技巧。

心与心

是有一种感觉，

填充在空气分子的间隙，

我应该是吸入过多，

寻求着窒息。

摸索着清醒。

沙漏在焦虑。

白夜还未醒。

流光已暂停。

谁活得怪异？

间隔那爱意！

物质生虚幻。

抽象渗具体。

蜉蝣问星辰。

心与心。

— 2025年06月05日写的无聊的诗

背景

上上周（2025-04-28），复读了整本小书。在去年的12月份，读完的第一遍。

从这本书我才开始察觉，斯多葛哲学，对我很有吸引力。

我曾经仅仅因为书名购买看过马可的《沉思录》、塞涅卡的《论生命之短暂》。

我曾经摘抄过叔本华的《人生的智慧》中的一句话：“使我们快乐或者忧伤的事物，不是那些客观、真实的事物，而是我们对这些事物的理解和把握。”，叔本华接着说：“这就是爱比克泰德所说的‘扰乱人们的不是客观事情，而是人们对客观事情的见解。’”

而马可、塞涅卡、爱比克泰德，都是斯多葛哲学的代表人物。

后来我终于读到了系统性讲述斯多葛哲学的《这个哲学家救了我》、《像哲学家一样生活》，这两本书提到了上面这些斯多葛哲学的代表人物们，我惊呼都有过接触。

甚至，在我好奇心驱使下看过的几本现代人讲述佛学的书中，也提到了斯多葛哲学和佛学有相近的地方。

斯多葛哲学在现代是一门十分实用的哲学。

感谢斯多葛哲学，最近这些年救我于水火。

第一部分：信奉爱比克泰德的智慧

1.3 斯多葛哲学入门

• 智慧
  • 区分什么是对我们真正有益或有害的知识。
• 勇气
  • 面临危险，或者宁愿遭受批评报复，也要采取合乎道德行动的倾向。
• 正义
  • 以公平的方式对待他人，以你希望他人对待你的方式对待他人，永远尊重他们作为人的尊严。
• 节制
  • 做事要有恰当的分寸，既不太少，也不太多。（平衡）

1.4 爱比克泰德哲学入门

• 控制二分法
  • 矛或箭射中某个点
• 斯多葛派实践三原则
  • 欲望（及厌恶）原则
  • 行动原则
  • 认同原则

控制二分法

第二部分：人生哲学指南

2.1 把事情弄清楚：学到最重要、最实用的智慧

其他一切都不完全取决于你，特别是你的身体、人际关系、事业、名誉和财富-本质上你可以影响它们，但结果取决于他人。

请记住，只有那些完全取决于你的东西，才真正属于你。其他一切都是从宇宙中暂借来的，宇宙可能会随时以任何收回。

这个建议非常重要：每当你对某事有强烈的欲望（或有强烈的厌恶，实际上是一回事）时，训练自己与欲望（或厌恶）的源头对话，并说：”你只是一个表象，可能根本不是你所描绘的那样！让我仔细看看到底是怎么回事。”然后对表象进行关键测试，问问你自己，这是否最终取决于你?

欲望（及厌恶）原则

2.2 欲望及厌恶训练：重新定位可能已被误导的欲望和厌恶

重新调整你的优先事项

你拼命渴望那根本不由你决定的事情，与此同时，却忘记了把精力投入到实际由你决定的事情上。

反复告诉自己，你的目的不是击中目标，而是尽你所有射出最好的一箭：不是为了获得晋升，而是为了成为最佳候选人；不是为了让别人爱你，而是全心全意成为一个最有爱的人。如果你能以这种方式重新引导你的注意力和欲望，你将会获得平静与快乐。

你自以为所拥有的一切就是你的吗

你自以为所拥有的一切其实都不是你的：你最喜欢的杯子，你的房子，你的工作，甚至你的伴侣或孩子。总有一天，你会以这样或那样的方式失去它们。你应该为此做好准备，同时清楚地知道，你要对这样的拥有心存感激。

如何应对可能发生的状况

对于你要做的每一件事，预估最有可能发生的情况，并提前预演你将如何面对。

困扰你的不是事情本身，而是你对事情的判断

困扰你的不是事情本身，而是你对事情的判断。看看周围，你会注意到人们对同样的事情有着完全不同的反应，也就是说他们对事情的判断不同。

智慧有三个阶段：

• 第一，愚者把自己对事物的判断归咎于他人；
• 第二，走向智慧的人不怪别人只怪自己；
• 第三，智者甚至都不会责怪自己。

立刻开始真正的生活

享受生活的乐趣，有时愉悦自己未尝不可。但你应该永远记住，航行在某一刻终会结束，不会永远持续下去。请为那一刻的来临做好准备，当你回首往事时，确保自己不会因为虚度了上岸时间而追悔莫及。

避免这种情况的最好方法，是常常问自己什么才是最重要的，并采取相应的行动。

事事如你所愿

要记住，你真正可以决定的，是全力以赴去实现自己的目标；同时也要记住，是否真正实现目标并不完全取决于你。在生活中，你有时会赢，有时会输，有时会以平局收场。

培养对外在事物的平静态度。当它们与你有益时，你要高兴并感激；反之，也不要恼怒。

你的意志永远是自由的

那些可能以某种方式限制你行动的东西，无法限制你的意志。这是自由的唯一意义，你的自由取决于你。

找到内在的能力

这是驾驭生活的良方。记住，对于发生在你身上的任何事情，你都可以找到内心的能力去应对。

比方说，你被情欲诱惑，你会找到节制力；如果你正经历痛苦，你会找到承受力；如果有人侮辱了你，你会用忍耐来对付那个砂锅。

时常练习你的能力，你就不会被生活的境遇击垮。

像旅人一样度过此生

你应该像暂住在客栈的旅人一样度过此生，永远不要认为任何东西真正属于你，它们只是你向宇宙暂借来的。

从小事开始练习保持内心平静

宁可少赚点钱、错过晋升机会或被轻视，你也不能失去平静和自我价值。

有一些事，不值得生气，经过你的智慧，你要判断出生气只会因为已经发生的事情而徒增对自己的伤害。

你能接受别人说你愚蠢吗

如果你想取得进步，你就要勇于接受别人依据外在事物而评判你愚蠢。不必设法用你的知识去打动他们，因为你真的没什么知识。

当追求外在分散了你的注意力时，你就很难在完善自己的判断方面取得进展。

只渴望由你决定的东西

悲伤完全是你的意念营造出来的。如果你奢望事情不是如此，只能说明你很愚蠢，因为你根本无力改变。

同样，如果你希望同事不要那么烦人，或者政客不要腐败，富人不要贪婪，你就是个傻瓜，因为那是他们的本性。总之，如果你希望人们都与众不同，那你就是傻瓜。

相反，如果你不想让自己的希望落空，那就训练自己只渴望由你决定的东西，也就是你自己的判断、意见和价值观。除此之外，别无他法。

如果你确实渴望一些不由你决定的东西，你就是把自己变成了他人或境遇的奴隶。

自由掌握在你的手中：只渴望由你决定的东西，只厌恶不能使你变得更好的东西。

一个关于如何生活的比喻

不要贪恋它们，拥有时就好好珍惜享受，失去时不要懊悔，因为这就是事物的本质。

事实有多可怕取决于个人的判断

你要时刻提醒并训练自己，平和应对逆境，牢记宇宙既不为你工作，也不与你作对。宇宙将永远运行下去，并且与你毫不相干。

然而，当你与他人互动时，不要漠视他们的苦恼或悲伤。实际上，他们只是需要你的安慰。但不要错误地认为，他们对外在事物的判断时必要的或正确的。

打好别人眼里的一手烂牌

你玩过扑克吗？生活就是这样。你不能决定拿到什么样的牌，这主要取决于充满随机性的运气。但无论如何最重要的是你如何采取策略打好手中的牌。如果你不是个好万家，即使有一手好牌，你也可能会输；如果你有能力，也可以打好别人眼里的一手烂牌。

不论什么样的命运，决定自己是否要全力以赴，也是衡量一个人优秀与否的标准。

不要迷信

不要迷信。不能用星座、纸牌、茶叶占卜或通灵术来预测你的未来。无论宇宙为你安排了什么，你都要做到尽力而为。所以，让一切顺其自然吧，你已做好准备。

获取自由的方法

只参加那些你确保能赢的比赛。唯一符合这种条件的比赛就是成为一个更好的人，别无其他。

那些由我们决定的才是真正好的东西，如果这是对的，那么你根本无须嫉妒或效仿。

你不应该渴望成名、有钱有势，而应该渴望自由。

让自己和别人的印象之间保持距离

你说，有人侮辱了你，这其实是说你允许他们侮辱你。他们的话只有在你自己认为是对你的侮辱时，才会变成侮辱。否则，只不过是愚人之言。

因此，尽量不要被表象迷惑，而是按下暂停键，让自己和别人的印象之间保持距离。通过这种方式，你会发现更容易保持理性，以及自我支配的能力。

时常冥想逆境

如果你这样做了，你就不太可能心存卑劣的想法，也会摆脱对任何事物的过渡渴求。

真心信奉哲学生活

如果你真心信奉哲学生活，请准备好迎接别人无情的嘲讽。他们会说你胡思乱想，或者说你自以为这样高人一等。

如果你按照自己的哲学行事，人们最终都会看见，会欣赏，甚至可能钦佩你，尽管这并不是你追求哲学生活方式的初衷。我的初衷是让自己平静，变得更好。

如果你只说不做，当然，你肯定会再次沦为笑柄。

当你感到名誉扫地时

名誉扫地是别人的想法，不是你能决定的。你所能决定的是：你是否做过不光彩的事？

• “但是我无法帮助家人和朋友。”
  • 谁告诉你这些事情是由你决定的？如果你自己都没有，肯定也无法给别人啊，所以你没有过错。
• “但我可以努力获得金钱和其他的物质资源，这样我就可以帮助我的家人与朋友。”
  • 你当然你可以，前提是保持你的尊严和正直。如果你能做到，那就尽力去做。但是，如果为了获得这些东西，你要舍弃真正对你有益的东西，那么你选择的道路将是最不明智的甚至是愚蠢的。
• “那么，我在社会上有什么地位呢？”
  • 只要能保持你的正直和美德即可。在你渴望为社会做出贡献时，如果失去了其中任何一个，你怎么能真正有用呢？

获得邀请是有代价的

无论谁获邀进入哪个晚宴或圈子，他都做了这样的事：阿谀奉承负责人，虚情假意地赞扬他们。所以你没被获邀，没有理由抱怨，你不愿意付出代价，还希望被接纳？

如果你不愿意付出，就不要到处酸溜溜地抱怨有人对你不公。这样既不合理又很愚蠢。你不是有自己的东西来代替邀请吗？因为你做到了这一点：保留自己的正直。

思考自己的反应

你应该认真思考，自己对他人所遇问题的反应以及处理方式。当你真正遇到类似问题时，这种未雨绸缪的思考就能指导你做出正确的回应。

重点是要平静地接受已经发生的事情，因为它的发生是自然的，而且你有能力决定如何回应。悲伤可以理解，绝望只会适得其反。

世界本来如此

世上没有什么是邪恶的，也没有什么是善良的。世界本来就如此。如何处理我们遇到的任何事情，由我们自己决定。

你的思想被人操作 你会感到不安吗

假设有人将你的身体随意丢给他人，你肯定会不高兴，不是吗？那么，为什么当别人操作你的思想，为所欲为时，你反而没有感到不安呢？

在确定目标前，衡量自己的本性和意向

在开始做某件事之前，你要仔细考虑它会涉及什么，以及为了顺利完成此事，什么是必要的。如果做不到这些，那么你必然会给很多事情开个头，结果却注定一事无成。（多消极想象，接受不好，全力以赴）

你必须在你的欲望和厌恶上下功夫，训练自己不要对别人生气，甚至与你的某些朋友和熟人保持距离，他们也许无益于你的训练。

这是一种取舍，你必须决定走哪条路。

只有你仔细考虑了以上所有，也只有到这时，你才能真正开始你的哲学之路。你会放弃很多，但你会获得自由和安宁。你将成为一位哲学家，而不只是一个凡夫俗子。

行动原则

2.3 行为训练：你将为公正对待他人做好准备

你是宇宙因果中微小但不可或缺的部分

你应该尽最大的努力专注于那些能够由自己决定的事情：审慎的判断经过深思熟虑后得出的观点和认可的价值观，而不是别的。否则，你会在自己不可控的事情上持续失败，并时常为自己不可控的事情而苦恼。

他们怨天尤人，就好像天气、市场或生活本身都取决于他们似的。

请记住：如果你理解了事物的本质，并将其融入自己的意识，便会懂得生活常常事与愿违。但请不要以为其他人也持有相同的认知。请按照他们期望的方式与他们和谐相处；要有同情心，不要因为他们认知中存在错误的表象而责备他们。

你必须决定自己是什么样的人

你必须决定自己是什么样的人，然后成为那个人。不管你是在众目睽睽的公共场合，还是在家里。否则，你会对自己造成双重伤害：你将是一个伪君子，而且由于表里不一，你将很难进步。

以下建议可以帮助你成为自己想成为的人：

• 不要说得太多，多花时间听别人说话。你应该训练自己花费两倍的时间去倾听。当你说话时，要准确简洁地表达自己。尽量减少闲聊，比如那些关于体育、名人或食物的话题。这种话题不会提高你（或他人）的水准。最重要的是，不要在背后议论别人，不管是指责或表扬，还是拿他们和别人比较。如果可能的话，试着把谈话引向有意义的主题。但也要记住：你永远可以选择保持沉默。
• 保持良好的幽默感，但不要笑得太多或太吵。你已不再是个孩子，要注意自己的尊严。
• 尽可能拒绝发誓。你需要保留对事物做出判断的选择权，而不是盲从他人随意强加给你的观点。
• 注意你结交的朋友。不要与那些无意完善自己的人交往。
• 不要沉溺于奢侈的享受。照顾好你的身体、健康和安全，尽量采取极简的生活方式。奢侈不仅没有必要，还极易使人堕落，让你远离美德。
• 假设他们告诉你，有人在你不知情的情况下批评你。预期为自己辩护，不如这么说：”哦，是的，但也是因为他不太了解，否则他会有更难听的话！”
• 当你去参加任何公共集会时，要记住保持自己的尊严，努力不让别人讨厌你。
• 当你在谈话时，注意不要过多地谈论自己。你真的并不像自己想象中那么迷人，别人对你也不感兴趣。
• 不要大声喧哗，也不要使用粗话。也许有人会无礼打断交谈。如果他这样做了，不要直接提出批评，但是你可以拒绝参加他们的行为。

欲觅有德之友，先做有德之人。

抵制表象，战胜欲望

每当你强烈感觉到，某种你本不该沉溺其中的快乐会对你有好处，这时候，你要慢下来，别着急。让自己与表象保持距离，让你的支配能力来仔细考虑。

尤其要思考，实际快乐的时间多么短暂，然后对比一下你遗憾的时间有多长。

此外，再想想，当你抵制了表象，战胜了欲望，并保持了你的美德，你将体验到一种更特别的、更高尚的快乐。

做你认为正确的事情

如果你认定做某件事是正确的，那就光明正大去做，即使别人并不赞成。他们的意见不由你决定。

但如果某件事情是错的，那就干脆不做，无论别人多想让你去做。他们的意见与你无关。

平衡自己与他人的需要

“现在是白天” 与 “现在是黑夜” 连成一句话，这句话就自相矛盾。

在生活中的许多其他事情上，也要时常明智地考虑，平衡自己与他人的需求。

选择角色

假设你决定扮演一个自己不适合，或无法胜任的角色，如果你是一名这样的演员，你就会毁了整部戏、观众、其他演员，还有你自己。

一定不要忽视本来非常适合你的事业。

切勿对思想的力量漫不经心

你总是很谨慎，不伤到自己的身体。为什么对你的思想的支配能力如此漫不经心？你怎么能容忍它被各种垃圾冒犯玷污？你应该保护它免受外部的侵扰，并尽可能使它从内部得到强化。

衡量尺度

你需要的是舒适耐用的鞋子。但是，一旦超过了这个标准，你就开始追求奢侈，变得毫无节制，你的脚将不再是鞋的衡量尺度。

对任何人的歧视都不合理

任何对他人的歧视都不合理，也不道德。

适可而止

所有都应适可而止。

你要把注意力聚焦于培养自己的支配能力上。作为一个人，良好的支配能力比其他一切都重要。

认同原则

2.4 好好思考的训练：提高对任何事的判断能力

如果有人说你坏话

有人坚持认为9的平方根是4，他错了吗？当然错了，但这会影响平方根运算的声誉吗？不会的，运算结果不会改变，反而出错的人看起来像个傻瓜。

同样，如果有人说你的坏话或对你不好，除非你自己接受，否则你不该是那个受折磨的人。

两个把手

任何东西都有两个把手。但这两个把手并不对称：一个拎起来更容易，另一个拎起来相对较难。

你可以抓住那个”更容易的把手”来应对家人或亲密朋友冒犯的这种表象，记住他们是你的家人或朋友，你们一起长大，共享许多回忆，他们爱你，你也爱他们。

难道你不觉得这样会让事情变得更容易，从长远来看会变得更好吗？

一些没有逻辑意义的世俗观念

你既不是金钱，也不是演讲本身。你是个有决定能力的人。对你的评价，或者自我评价，只取决于这些决定的好坏。

没有充足的信息就无法进行判断

记住，你的目标应该是对人和事做出最好的判断，如果没有充足的信息和深思熟虑就草率臆断，你绝不可能得到最好的判断。多数情况下，直接放弃判断，也不失为上策。

以哲学的方式生活

2.5 好好生活的训练：为实践生活的艺术做好准备

千万不要以为自己睿智、开明

千万不要以为自己睿智、开明。事实上，炫耀本身就标志着你既不睿智也不开明。比起目空一切、自以为是，请按照你学到的智慧行事吧，这样才会更加令人钦佩。

注意不要为了给人留下深刻印象，随口说一些自己都不理解的原则。

践行生活艺术

践行生活艺术的人在审视自己时，既是为了寻求安慰，也是为了寻找伤害的根源。

要时刻提防自己的愚蠢行为，如同警惕准备随时攻击我们的潜伏的敌人。

智慧需要日复一日的练习

唯一值得骄傲的是你日复一日的练习。只有当你能真正实践这些戒律，而不只是阅读或谈论时，你才能称自己是一个认真实践生活艺术的人。这才是真正可以自豪的事！

行动起来，做该做的事情

你应该把注意力转移到自身以及自我的进步上，不要浪费时间去草率懒散，因循怠惰，或者找借口朝三暮四。

爱比克泰德部分语录

爱比克泰德的四条建议

• 如何断定一笔钱是不是好的？钱本身是不会告诉你的，只有用理性-这种能够运用表象的能力（才能做到）
• 无论何时，只要你认为外在的东西比自己的正直更重要，那么你就准备余生都为它们服务吧！
• 就我自己而言，我希望死亡降临时，完全专注于关照自己的品格，我希望自己品格平静安详、自由自在、无拘无束。
• 我们越重视自己无法掌控的事情，所能掌握的就越少。

第三部分 斯多葛哲学2.0

逻辑学+物理学=伦理学

哲学：

• 就像一个动物：逻辑学对应其骨骼和肌肉；伦理学对应其肉体；物理学对应其灵魂
• 就像一个鸡蛋：蛋壳是逻辑学；蛋白是伦理学；蛋黄是物理学
• 就像肥沃田地：逻辑学是环绕的栅栏；伦理学是庄稼；物理学是土壤或树木
• 或者是一个由理性包围并统治的城市

如果你对世界如何运转的理解是激进和错误的，就很难过好一生。

作者的观点：

• 主题1：不必漠视外在
• 主题2：不必刻意培养对他人损失的漠不关心
• 主题3: 顺应自然的生活
• 主题4: 不准确的科学还是形而上学
• 主题5: 上帝还是原子
• 主题6: 习俗既不普遍，也并非永恒
• 主题7: 社会正义

作词 : 裴育
作曲 : 华晨宇
编曲 : 郑楠
制作人 : 郑楠

我嚼着最贵的晚餐
可惜我无所谓应对这账单
左右逢源不是个好习惯
旁若无人要不要试试看
好不容易脱下天价的衣衫
不如说我卸下拖累的金砖
是人是鬼一眼就看的穿
不用非要学贵族的装扮

太多废话都无关感情
太多动作都始于环境
就像青春期的小孩会被大人酷刑
理由是 逼迫15岁的心灵
比成人要理性
那些道理我们从小就听
长大后不得不听命运的命
不是 道理多难履行
而是现实它太任性

多少人能看懂人心的空镜
只不过活着活着只活出了年龄
我攥着别人遥不可及的东西
一边自嘲一边冷眼那些肮脏的事情

如果真话
搅局假话不如闭嘴来的清静
鄙视那含蓄的交易
都像强心针样的陷阱

让人 无时无刻高速运转
该怎么保持清醒
趁你们还热爱浑水摸鱼的游戏
一本正经

披着羊皮创造你们的使命
当真的傻子乐此不疲在消耗着热情

装傻的戏子
你可赚到了吐沫飞溅的缓刑
怕被拆穿还没被拆穿
本就是你要的刺激

I’m boring 我只想一个人不说话
I’m boring 我只想一个人不用笑

我很想望着一闪一闪发光的星星
像其他同学一样唱着亮晶晶
可我的眼前饱满
来自虚伪世界的轰鸣
我还有很多事做很多歌听
可我就想窝在沙发做些无聊的点评

朋友
在醉酒后咒骂世界不公平
滑稽的排列组合让我想起了曾经
那时候爸妈总算分开的场景
和我高举成绩单强颜镇定的表情
老爸你揣着银子
到底是应酬还是旅行

闹吧
我总算找到适者生存的途径
总有人说的好听做起来像个逃兵
过河拆桥 真的好吗
但凡是活着就得习惯
这附带悬念的案情
我大脑都是各种嘴脸在抢镜

行吧
我看够了自私的目的 生硬的交情
我听够了善意的欺瞒 辩驳的矫情
所谓的个性 并非教养的不明
谁来解释下为什么好人卡那么流行
得到它 等于判定了人性

I’m boring 我只想一个人不说话
I’m boring 我只想一个人不用笑

我嚼着最贵的晚餐
可惜我无所谓应对这账单
左右逢源不是个好习惯
旁若无人要不要试试看

之感

2025年的第一篇文章，我总是不知道可以描述些什么，一拖再拖。除了懒癌之外，考虑到使用A4主题的人逐渐变多，总觉得过多暴露自己不成熟的小想法，并不是一件多么光彩的事。

可最终还是从躺了一天的床上，奔向洗手间洗了个澡，坐在了电脑前，敲下这些字。

是什么促使我做这些呢？我想就是上个月看的这本书《牧羊少年奇幻之旅》所说的，不要欺骗自己的心，学会去聆听自己的这颗心。我的这颗心了解我的灵魂，比我更能感知我想要做的事情。心总是被我忽略，所以心总是不安分，通过焦虑地、不规则地跳动，为我着急。必须学会倾听这颗心。

心了解所有事物，因为心来自世界之魂，并且总有一天会返回那里。

我还是喜欢文艺这件事。

去年阅读了40余本书籍（含十几本漫画），60余部影视。把一部分经典都读了，看了。

又了解了许多事，即使能深刻记住的不多。

我想今年看得更投入，看得更丰富，看得更多。

这件事不用谁逼我，我由衷地热爱。

摘抄

• 在那一带，他认识很多人，这正是他喜欢云游四方的原因，因为总能结交新朋友，而且不必天天跟他们低头不见抬头见。
• 当总是面对同样的面孔，像在神学院里那样，就会渐渐让那些人成为生活的一部分。而由于他们是你生活的一部分，当然就想改变你的生活。如果你不像他们所期望的那样，他们就会不高兴。因为，对于该怎样生活，所有人都有固定的观念。但是他们对于自己该怎样生活却一头雾水，就像那个给人解梦，却不会把梦变成现实的老妇人。
• “什么是世上最大的谎言？”“在人生的某个时候，我们失去了对自己生活的掌控，命运主宰了我们的人生。这就是世上最大的谎言。”
• 但是，当人与人交谈的时候，有些人说的话会让我们无所适从，不知该怎么把谈话继续下去。
• 天命就是你一直期望去做的事情。人一旦步入青年时期，就知道什么是自己的天命了。在人生的这个阶段，一切都那么明朗，没有做不到的事情。人们敢于梦想，期待完成他们一生中喜欢做的一切事情。但是，随着时光的流逝，一股神秘的力量开始企图证明，根本不可能实现天命。
• 那是表面看来有害无益的力量，但实际上它却在教你如何完成自己的天命，培养你的精神和毅力。因为在这个星球上，存在一个伟大的真理：不论你是谁，不论你做什么，当你渴望得到某样东西时，应当敢于去做，因为这愿望来自宇宙的灵魂。那就是你在世间的使命。
• 完成自己的天命师人类无可推辞的义务。万物皆为一物。当你想要某种东西时，整个宇宙会合力助你实现愿望。
• 那个卖爆米花的人小时候也总想出去游荡，但却选择了买一辆制作爆米花的机器，年复一年地攒钱。等到年老的时候，他将去非洲待上一个月。他从来就不明白，人们总有条件去实现自己的梦想。
• 如果东西还没到手，你就先许诺于人，那你就不会积极去争取了

• 有的时候最好让事情保持原样，想到这儿，男孩便没有开口。如果他说出来，这个卖爆米花的将一连三天考虑是否舍弃现有的一切，然而，他对推着小车卖爆米花早就习以为常了。

• 地中海东风越刮越猛。面对羊群和宝藏，我现在进退两难，男孩想。在已经习以为常的东西和意欲得到的东西之间，他必须做出抉择。

• 实际上，每天都一成不变，是因为人们已经失去了对美好事物的敏锐感觉。

• 我离开了我的父亲，我的母亲，还有家乡的城堡。他们都已经习惯了，我自己也习惯了。羊群没有我，也会习惯的。男孩想。

• 他意识到，他也可以像风一样自由。什么也不能阻止他，除了他自己。羊群、商人的女儿和安达卢西亚的大地，只不过是他在达成天命的途中留下的足迹。

• 第一次玩纸牌，多半会赢。这就是新手的运气。为什么？因为生活希望你去实现自己的天命。

• 你提出问题时永远要客观。

• 不要忘了万物皆为一物，不要忘了各种预兆的表现方式，不要忘了去完成你的天命。

• 幸福的秘密就在于，既要看到世上的奇珍异宝，又要永远不忘记勺里的那两滴油。

• 牧羊人喜欢四处游荡，但是永远不会忘记他的羊群。

• 他身旁那几只羊由于害怕新主人，一直骚动不安，频繁的变化刺激了它们的神经。它们想要的仅仅是水和食物。

• 我和别人没什么两样，总是以理想的眼光看待世界，以为事情会按理想的方式发展，而不会用现实的眼光看待世界，看不到事情真相。他想。

• 老人说过，问问题要清楚明白，因为宝石只对知道自己欲求的人起作用。

• 即便永远到不了金字塔，他也比任何一个他认识的牧羊人走得远。

• 他突然觉得，被骗之后，他可以像个倒霉的受害者一样看待世界，也可以像个寻宝的冒险家那样观察世界。

• 比如，要知道一个人是在接近还是远离其天命，只需观察一下他就行。

• “因为那些水晶脏了。而无论是你还是我，都需要清楚头脑里的坏念头。”

• 你与我不同，因为你希望实现你的梦想，而我只是想保有去麦加的梦想。

• 生活的河流是无法阻挡的。

• 但是你知道，我不会去麦加，就像你知道自己不会回去买羊一样。

• 男孩没有跟水晶店老板告别就走了。

• 一旦做出决定，实际上便坠入了一股巨大的洪流之中，这洪流会把人带到一个你做决定时从来没想到的地方去。

• 每当观看泱泱大海或熊熊烈焰的时候，他能一连几小时保持沉默，脑子里什么都不想，完全沉浸在自然的浩瀚和威力之中。

• 男孩明白了，预感就是灵魂飞快地投入生命的洪流当中，世上所有人的经历都在这洪流中联系在一起。我们因此能无所不知，无所不晓，因为一切均已命中注定。

• 书是不必要的负担，尽管男孩曾养成一种近乎迷信的观点：以书为友，开卷有益。

• 我们担心失去的，只是那些我们现在拥有的东西：我们的生命，或我们的作物。但是，当我们明白了生命的历程与世界的历程都是由同一只手写就的时候，这种担心就会消失。

• 不过你应该明白，在水晶店里，就连那些水晶杯都在为你的成功加油。

• 商队与沙漠讲同一种语言，所以沙漠允许商队通过。沙漠将检验商队走出的每一步，看看商队是否与它完全协调一致。如果协调一致，商队必将到达绿洲。

• 这些事情都非常简单，简单得可以写在一块翡翠板上。

• 每个人都有自己的学习方式，他在心中反复对自己说。他的方式不属于我，我的方式也不属于他。但是我们俩都在追寻各自的天命，为此我尊重他。

• 因为我既不生活在过去，也不生活在未来，我只有现在，它才是我感兴趣的。如果你能永远停留在现在，那你将是最幸福的人。

• 有朝一日，这个清晨将成为一个回忆，仅此而已。但是现在，清晨是正在经历的这一刻，是那赶驼人所说的节日。

• 也许真主创造沙漠的目的，就是为了让人们见到椰枣树的时候能开心地笑，他想。

• 这些事情必须以这种方式传授，因为它们是由纯粹的生活构成的，而这种生活用图画和文字很难捕捉得到。

• 人们由于迷恋图画和文字，忘记了宇宙的语言。

• 离自己的梦想越近，事情就变得越困难。

• 因此，他不能莽撞行事，不能失去耐心。假如做不到这一点，最后他将看不到上帝在他前进的道路上布下的预兆。

• 不要失去耐心，男孩想，就像赶驼人所说的，该吃饭时吃饭，该走路时走路。

• 他明白了早在知道她的存在之前，他已经爱上了她，并且明白了凭他对少女的爱，就能找到世上所有的宝藏。

• “马克图布。”她最后说，“如果我是你天命的一部分，总有一天你会回来。”

• “作为沙漠中的女人，我为此而骄傲。希望我的男人像移动沙丘的风一样自由。也希望能在云彩中，动物身上和泉水里看到我的男人。”

• 实际上，并不是事物本身在暗示什么，而是观察事物的人发现了探究世界之魂的方法。

• 自从离开家乡，他每一天都过得很充实。

• 骑士继续说：“你必须热爱沙漠，但是绝不要完全相信沙漠。因为沙漠对所有人都是个考验：考验你迈出的每一步，杀死心猿意马的人。”

• “入口的东西并不邪恶。”炼金术师说，“邪恶的是从口里出来的东西。”

• 你的心到哪儿，你的宝藏就在哪儿。你必须找到你的宝藏，否则你在途中发现的一切便全都失去了意义。

• 你将是绿洲的顾问。第二年你会忘记那一批财宝。预兆开始不断地提示你这一点，而你则极力对那些预兆视而不见。第三年，预兆会继续向你提示你财宝和你的天命。促使你留在绿洲的原因，是你害怕自己再也不会回来。到这时，预兆将告诉你，你的财宝将永远被埋在地下了。第四年，预兆将会放弃你，因为你不再理会它们。

• 你讲永远不明白，爱情从来不会阻止一个男人去追寻天命。如果会阻止，一定因为那不是真正的爱情，不是用宇宙语言表达的爱情。

• “我是沙漠中的女人。”她说，将脸扭到一边，“但我毕竟是个女人。”

• 不一会儿，太阳便露出了笑脸。白天到来时，她将走出帐篷，去做多年来她一直做的事，然而一切都已改变。

• 如果你碰到的是用纯净物质制成的东西，它将永远不会腐朽，而你总有一天会回来。如果你碰到的仅仅是像行星爆炸那样一闪即逝的东西，那么返回的时候你将两手空空。不过你毕竟还是见到了爆炸时的光芒，仅凭这一点也值了。

• “要想学到本事，只有一种方式，”炼金术师回答说，“那就是行动。你需要学会的一切，这次旅行都教给你了。只缺少一样。”

• “他们一门心思追求黄金，寻求天命中的财宝，却不愿履行自己的天命。”炼金术师回答。

• “倾听你的声音。心了解所有事物，因为心来自世界之魂，并且总有一天会返回那里。”

• 但它永远平静不下来，即便男孩不和炼金术师讲话，心照样不会平静。

• 你永远不能让它沉默。即使你佯装不听它的话，它还是会在你的胸膛里，反复倾诉它对生活和世界的看法。

• 如果你对自己的心非常了解，它就永远打击不到你。因为你将了解它的梦想和愿望，并知道怎样应对。谁也不能逃避自己的心，所以最好倾听心在说什么。只有这样，你才永远不会遭受意外的打击。

• “你告诉它，害怕遭受痛苦比遭受痛苦本身还要糟糕。还要告诉它，没有一颗心在追求梦想的时候感到痛苦，因为追寻过程中的每一刻，都与上帝和永恒同在。”

• 人们把世界看作一个威胁，正因如此，世界才变成了一个威胁。

• 在梦想实现之前，世界之魂永远会对寻梦者途中所学到的一切进行检验。这是一个大多数人可能会放弃寻梦的时刻。

• 每个人的寻梦过程都是以‘新手的运气’为开端，又总是以‘对远征者的考验’收尾。

• 夜色之浓，莫过于黎明前的黑暗。

• 当巨大的财宝就在我们眼前时，我们却从来都察觉不到。你知道为什么吗？因为人们不相信财宝存在。

• 男孩和他的成了好朋友，彼此都不违背对方的意愿。

• “心只帮助那些追随天命的人。不过，更多的是帮助小孩、醉汉和老人。”

• 谁若干涉其他事物的天命，谁就永远发现不了自己的天命。

• 大海仍旧在这只贝壳里，因为这就是它的天命。大海永远不会离开贝壳，直到沙漠重新被海水淹没。

• “不要让他们察觉出你的恐惧。”炼金术师说，“他们都是勇敢的人，最鄙视胆小鬼。”

• “如果你必死无疑，它们对你又有什么用处呢？”炼金术师回答说，“你的钱救了你，还能多活三天。钱能用来推迟死期，这种事并不多见。”

• “你不要陷入绝望而不能自拔。”炼金术师用一种异常柔和的声音说道，“这样会使你无法和自己的心沟通。”

• “追寻天命的人，知道自己需要掌握的一切。只有一样东西令梦想无法成真，那就是担心失败。”

• “你将在追寻天命的过程中死去。这也比大多数普通人的死要好得多，因为他们根本不知道天命存在。但是，你不必担心，一般来说，死会使人更了解生。”

• 我离地球非常遥远，但从我所在的位置，我学会了爱。我知道，如果向地球再靠近一点，地球上的一切都将死去，世界之魂也将不复存在。所以我们才互相遥望，互相关爱。我给地球生命和温暖，地球给了我生存下去的理由。

• “我得到的报酬远胜于我的慷慨。”修士回答。“永远别再这么说。生活会听在耳内，下一次就会少给你。”

• 所有发生过一次的事，可能永远不会再发生，但所有发生过两次的事，肯定还会发生第三次。

• 说到底，月亮照耀的是沙漠的静寂和寻宝者们的足迹。

• 男孩在前去追寻天命的路途中，学会了必须要学的一切，也经历了梦想经历的一切。

• 无论何人，哪怕堆一辈子石头，也无法在自家后院堆起一座金字塔，他想。

• “如果你必死无疑，钱对你又有什么用处呢？钱能用来使人免于一死，这种事并不多见。”

• “不能。”他听见风对他说，“如果我事先告诉你，你就看不到金字塔了。它们很壮美，不是吗？”

• 生活对追随自己天命的人真的很慷慨，男孩想。

2024年是我到这个星球25年来，经历最丰富的一年。

该怎么去做一个描述呢。打开去年的总结，对2024的期待，只有一句话：“直面恐惧，继续焦虑。”

我想我无意识地做到了。

人生是否有注定的命运？在已发生的事情上寻找一定的因果，未发生的事情如何发展，或多或少取决于当下决策行动的每一步。发生与未发生，之间似乎有一样东西始终在起着作用。那么稍微抬高一点视野，依稀辨别出冥冥中的一条线联结了我们的过去和未来。

所以，如果你问我人生究竟是否命中注定？

我想这么回答你：“命运一定已经注定，可我同时坚信自己的力量能够克服被动的生命。我相信能够凭借这份意志违抗消极的影响。这份相信同样也是命中注定。待我真的实现那天，你们会相信我的命中注定。你们会相信我注定违抗，到达这里，创造这份命运。我的命运终被我注定，我也注定服从了命运。”

你问我如果最终实现不了呢？

那么我会反问你：“如果你真的相信命中注定，为何那么在乎注定的结局？如果你完全不相信命中注定，更不会在乎那个结局。更何况那个结局不过是所有生命都会经历的事情——死亡。而你死在了自己选择的路上。现在我想问你，死在自己选择的路上，闭眼沉眠那一刻，你会后悔吗？”

很久很久很久，没有写一点走心的东西了。

此时的我很失落，一颗真诚的心无处安放，思索真诚在我身上的真实含义，思索真诚给我带来的利与弊。

从最近的一些失败经验来看，真诚，呵呵，好像并不那么重要。

我得出一个结论：在这个破社会中的大部分场所，真诚并不是必杀技，而是自杀技。你就是得学会说谎，你就是得学会讨好，你就是得懂如何隐藏。社会当中，没人在乎你的真诚，只在乎你是否让他觉得，注意，只是让他，只是让他觉得，管用，就算是骗的也没关系。你就是得学会说别人想听的话，至于你到底是一个怎么样的人，他们嘴上说想了解，实际上也只想看到他们想看到的。注意，这就是最巧妙的地方，你只能透露他们在乎的方面，这就是他们眼中的诚实，尽管在你眼中归根到底仍然是一种欺骗。

不太想写明发生了什么事，思绪想到哪里就写到哪里吧。真诚，挺没劲的。

想到的第一件事，是关于付航在《喜剧之王单口季》夺冠。

他在脱口秀中传达出低落过往中曾蕴含的温暖，父爱母爱，朋友的爱，宠物的爱。

他向一起玩游戏的朋友抱怨：“兄弟，我人生之中烦恼已经太多了，我不想玩游戏，游戏里还那么多烦恼。“

他的朋友说：”兄弟，那不是你生活里的烦恼，那是你生活里的内容。“

付航：“是呀，要是人生一马平川，那还有什么意思呢！有什么意思！”

视频里的付航目光炯炯，在舞台上，他相信他说的话的力量。我能被付航感动，可是感动之余，留在我心里的是一条长长的走廊，一头黑暗，一头光明，过道两旁全是冷眼的目光，付航在迈步，低着头，从始至终，身体从小到大，低着头。

终于走完了这条长廊，他终于有资格挺直腰板，聚光灯下回头看，那些冷眼的目光开始仰视着他，同时也凝视下一个黑暗口垂头的年轻人。

什么都不会改变，人们几千年来就是这样。

听着理想主义过往感动欣喜欢乐，听完生活中继续充当冷眼者的角色。

总是这样，一面向往理想主义，一面恐惧理想主义，一面诋毁理想主义。

那到底要给这些担惊受怕的观众们说些什么呢。

好像没关系，还可以借此传达给和我一样被冷落过的人，就说这些内容吧，你们看看我呀，我相信我说的话。

还是有机会的，你们听听我说的话呀，他们虽然一直在冷眼，但是我们还是有机会从周围获得温暖的。

我们一起让自己快乐吧。

想到的第二件事，是关于我和《那不勒斯四部曲》2019年至2024年的结束。

正是在昨天，我看完了《我的天才女友》第四季最终季的最后一集。

毫不夸张，我觉得自己的二十多岁是被《那不勒斯四部曲》影响、雕琢、打磨、抛光。

在大概2019年某个夜晚大学宿舍床上，我在被窝里想找一部外语片看，无意看了《我的天才女友》第一季第一集。意大利那不勒斯及故事从此留在我的心灵中。

第一季看完，就迎来了2020年疫情之下找实习的日子。我在家一边找实习、准备面试、进行面试，同时在看《我的天才女友》第二季。

看完第二季，就去找到原著《那不勒斯四部曲》，继续一边面试，一边了解那不勒斯。在我看完4本原著过后不久，我就拿到了阿里的实习机会。我现在还记得，阿里的第五轮面试，面试官问我最近看了什么书，我向他细致地描述了《那不勒斯四部曲》的故事。

操，写到这里，写不下去了。

我此时因为最近的经历很难过，很难过，很难过。

《那不勒斯四部曲》有两个女主人公，莉拉和埃莲娜。

莉拉一生都在试图看破街区的真相，做自己认为正确的事。我可以说她是一个理想主义者，她一直被大家认为具有意想不到的力量，敢于做很多不敢想的事情，始终关心整个那不勒斯的人们，可她最后选择了消失。

埃莲娜一直被莉拉影响，性格更偏向顺从，得益于稍好的家庭氛围支持和莉拉的友谊，离开了那不勒斯成为文学小说家，同样一生也在经历并迷失并克服并找回那不勒斯留下的粗俗。

我想说莉拉。我想，前些年我真正从莉拉身上学到的只有两个字：“消失”。

能去做自己认为正确的事，且是善良的事，好像是我们每个人的追求，可为什么实际生活中，处处是他妈的阻挠。太难了，太难了，太难了。莉拉，不是吗。你已经足够努力了，可真正认识到你的好的人们，总是后知后觉，一开始甚至还那么那么少的认可，可你依然在取得成果过后善待所有人。

最后呢，你不还是选择消失了吗。

所有积极的努力，最后还是导致了自己的消失是吗。

好像，还是不如学着变得更自私一点。

咱们就别那么真诚了好吗。

没人在乎。

我们的真诚，是会吓到他们的。

河流

我心中有一片海洋，
义无反顾流向河流。
如炬目光捉摸不透，
声嘶力竭流向河流。

尘世最为盲目狂热，
肃穆庄重神性相赠。
海洋不曾驻足领受，
海洋不曾为谁停留。

人们赞美落空，激起
崇拜的波涛喧嚣更甚。

“河流！河流！河流！”
有人说，听见海洋重复嘶吼。
有人说，海洋力图吞并河流。
没有人说，海洋曾经是河流。

我心中有一片海洋，
一生只顾呢喃河流。

浮屠殉道，
妄念执拗。
万物在唱。

夜

音符，在旋转
在鼓动，窃喜
土壤吞噬花丛
灰白塞满江海
如梦易逝地
享受虚无

威胁病态的定义
挥舞谎言的旗帜
踏上遗弃的节奏
奋起为折磨正名
如痴如醉地
享受后退

听从夜引导身体

很容易看到一对
一双无力的援手
给予薄弱的支撑

和寂静融为一体

在虚无中，享受后退
在后退中，享受虚无

尽情奔向、尽兴歌唱

夜在弥漫、夜的豪迈
夜的凶猛 、夜在狂笑

痛快

湛蓝在向大地压下来

紫罗兰在房间里凋谢
一股尸身的香味

我踩在沙上，不被了解
在海边，或沙漠

浮现于暧昧中的爱情
跟随季节变更的婚姻

清醒的诗人，早已想通
浓烈，是一种恶臭

无旁人的景色
去做些不被允许的事
是自然的，是自由的

痛苦混合快乐，病态又壮硕
滴酒未沾，反驳前一秒自我
这种状态是好的、是糟糕的、
是痛快的、是痛快的

衣服要干净
精神，不必须
是痛快的

黄月

黄月借云层朦胧
笑我浑浊不堪

下一片令牌：
头抬起来
心低下去

许久

夜不发一言
星亦沉默
黄月生气
我倒欢喜

• 小林coding
• 沉默王二-操作系统
• 沉默王二-linus

基本的Linux命令

• ls: 查看目录列表
• touch: 新建文件
• cp: 复制文件
• mv: 移动文件

Mysql

• 小林coding
• 15道精选MySQL索引面试题
• 沉默王二

面试题收集

执行一条 select 语句，期间发生了什么？

MySQL 一行记录是怎么存储的？

什么是索引？

索引的分类有哪些？

什么时候需要/不需要创建索引?

有什么优化索引的方法？

InnoDB 是如何存储数据的？

B+树是如何进行查询的？

聚簇索引和二级索引

为什么MySQL采用B+树作为索引？

MySQL单表不要超过2000W行，靠谱吗？

索引失效有哪些？

MySQL使用like “%x”,索引一定会失效吗？

count(*)和count(1)有什么区别？哪个性能最好？

事务有哪些特性？

并行事务会引发什么问题？

事务的隔离级别有哪些？

ReadView 在MVCC里如何工作的？

可重复读是如何工作的？

读提交是如何工作的？

MySQL 可重复读隔离级别，完全解决幻读了吗？

MySQL有哪些锁？

MySQL是怎么加锁的？

update没加索引会锁全表？

MySQL记录锁+间隙锁可以防止删除操作而导致的幻读吗？

MySQL死锁了，怎么办？

MySQL日志：undo log、redo log、binlog 有什么用？

• 沉默王二-分布式
• 沉默王二-微服务

RokectMQ

• 沉默王二

Kafka

• 40道精选Kafka面试题

Redis

• 小林coding
• 沉默王二

面试题收集

什么是Redis?

Redis 和 Memcached 有什么区别？

为什么用 Redis 作为 MySQL 的缓存？

Redis 数据类型以及使用场景分别是什么？

五种常见的 Redis 数据类型是怎么实现？

Redis 是单线程吗？

Redis 单线程模式是怎样的？

Redis 采用单线程为什么还这么快？

Redis 6.0 之前为什么使用单线程？

Redis 6.0 之后为什么引入了多线程？

Redis 如何实现数据不丢失？

AOF 日志是如何实现的？

RDB 快照是如何实现的呢？

为什么会有混合持久化？

Redis 如何实现服务高可用？

集群脑裂导致数据丢失怎么办？

Redis 使用的过期删除策略是什么？

Redis 持久化时，对过期键会如何处理的？

Redis 主从模式中，对过期键会如何处理？

Redis 内存满了，会发生什么？

Redis 内存淘汰策略有哪些？

LRU 算法和 LFU 算法有什么区别？

如何避免缓存雪崩、缓存击穿、缓存穿透？

如何设计一个缓存策略，可以动态缓存热点数据呢？

说说常见的缓存更新策略？

如何保证缓存和数据库数据的一致性？

Redis 如何实现延迟队列？

Redis 的大 key 如何处理？

Redis 管道有什么用？

Redis 事务支持回滚吗？

如何用 Redis 实现分布式锁的？

主从复制是怎么实现的？

为什么要有哨兵？

• 小林coding
• 沉默王二

• 小林coding
• 沉默王二

• 小林coding
• 沉默王二

• 小林coding
• 沉默王二

• 小林coding
• 沉默王二

• 小林coding
• 沉默王二

[TOC]

• 题目来源：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台
• 代码来源：刷了多遍所有题目后，参考各种题解，由本人根据自己的java编码习惯,系统化不断优化编码风格而来，整体编码风格成一个体系：比方说变量命名尽量见名知意，每道题的代码结构有相似性、注释丰富、链表题目几乎都会首先新建一个头节点、回溯模版、滑动窗口模版、dfs上下左右的技巧、二分法的技巧…
• 好处：利于java选手系统刷题，因为所有的代码思维是在一个空间内的，你一看就知道是一个人写的，零散地看每个题目不同人写的题解，风格往往差异很多，新手理解起来会走弯路。

链表

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

• intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
• listA - 第一个链表
• listB - 第二个链表
• skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
• skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

1
2
3
4
5
6

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

1
2
3
4
5

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

1
2
3
4
5

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 1 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 基本原理是 两个指针都一步一步走，到底了，就从另一指针 接着走
        // 这样实际上 两条指针的 长度 都一样 都为 a+b+c
        // 那么一定会相遇，最后相遇的节点即是交点
        if(headA == null || headB == null) return null;
        ListNode tempA = headA;
        ListNode tempB = headB;
        while(tempA != tempB) {
            tempA = tempA == null ? headB : tempA.next;
            tempB = tempB == null ? headA : tempB.next;
        }
        return tempA;
    }
}

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

1
2

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

1
2

输入：head = [1,2]
输出：[2,1]

示例 3：

1
2

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode newHead = head;
        head = head.next;
        newHead.next = null;
        while(head != null) {
            ListNode temp = head;
            head = head.next;
            temp.next = newHead;
            newHead = temp;
        }
        return newHead;
    }
}

234. 回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

1
2

输入：head = [1,2,2,1]
输出：true

示例 2：

1
2

输入：head = [1,2]
输出：false

提示：

• 链表中节点数目在范围[1, 105] 内
• 0 <= Node.val <= 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        // O(1)空间复杂度的话
        // 先利用快慢指针 找到中点
        // 接着 把中点往后的链表翻转
        // 最后和表头比较挨个比较即可
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next;
            fast = fast.next;
        }
        // 这个时候slow就是中点
        slow.next = reverse(slow.next);
        slow = slow.next;
        while(slow != null) {
            if(slow.val != head.val) {
                return false;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;
    }

    private ListNode reverse(ListNode head) {

        ListNode pre = null;
        while(head != null) {
            ListNode temp = head;
            head = head.next;
            temp.next = pre;
            pre = temp;
        }
        return pre;
    }
}

141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

1
2
3

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

1
2
3

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

1
2
3

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

• 链表中节点的数目范围是 [0, 104]
• -105 <= Node.val <= 105
• pos 为 -1 或者链表中的一个 有效索引 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        // 保证一定至少有两个节点
        if(head == null || head.next == null) return  false;
        ListNode newHead = new ListNode(0, head);
        // 慢指针先走一步
        ListNode slow = newHead.next;
        // 快指针先走两步
        ListNode fast = newHead.next.next;

        while(fast != slow) {
            slow = slow.next;
            fast = fast.next;
            if(fast == null) return false;
            fast = fast.next;
            if(fast == null) return false;
        }
        return true;
        
    }
}

142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

1
2
3

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

1
2
3

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

1
2
3

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null) return null;
        ListNode newHead = new ListNode(0, head);

        // 找环的话，先都行动一次
        ListNode slow = newHead.next;
        ListNode fast = newHead.next.next;

        while(slow != fast) {
            slow = slow.next;
            fast = fast.next;
            if(fast == null) return null;
            fast = fast.next;
            if(fast == null) return null;
        }
        // 直接放在头结点
        fast = newHead;
        while(slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

1
2

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

1
2

输入：l1 = [], l2 = []
输出：[]

示例 3：

1
2

输入：l1 = [], l2 = [0]
输出：[0]

提示：

• 两个链表的节点数目范围是 [0, 50]
• -100 <= Node.val <= 100
• l1 和 l2 均按 非递减顺序 排列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null) return list2;
        if(list2 == null) return list1;
        if(list1.val < list2.val) {
            list1.next = mergeTwoLists(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists(list1, list2.next);
            return list2;
        }
    }
}

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

1
2
3

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

1
2

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

1
2

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) {
            ListNode templ1 = l1;
            while (l1.val >= 10) {
                if(l1.next == null) {
                    l1.next = new ListNode(1);
                } else {
                    l1.next.val++;
                }
                l1.val -= 10;
                l1 = l1.next;
            }
            return templ1;
        }



        l1.val = l1.val + l2.val;
        if(l1.val >= 10)  {
            if(l1.next == null) {
                l1.next = new ListNode(1);
            } else {
                l1.next.val++;
            }
            l1.val -= 10;
        }
        l1.next = addTwoNumbers(l1.next, l2.next);
        return l1;
    }
}

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

1
2

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

1
2

输入：head = [1], n = 1
输出：[]

示例 3：

1
2

输入：head = [1,2], n = 1
输出：[1]

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode newHead = new ListNode();
        newHead.next = head;

        ListNode first = newHead;
        ListNode second = newHead;
        while(n-- > 0) {
            second = second.next;
        }
        while(second.next != null) {
            second = second.next;
            first = first.next;
        }
        first.next = first.next.next;
        return newHead.next;
    }
}

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

1
2

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

1
2

输入：head = []
输出：[]

示例 3：

1
2

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        
        ListNode first = head;
        head = head.next;
        first.next = null;

        ListNode second = head;
        head = head.next;
        second.next = null;

        second.next = first;

        first.next = swapPairs(head);
        
        return second;

    }
}

25. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

1
2

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：

1
2

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：

• 链表中的节点数目为 n
• 1 <= k <= n <= 5000
• 0 <= Node.val <= 1000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null || k == 1) return head;
        
        ListNode newHead = new ListNode();
        ListNode tail = newHead;
        ListNode left = head;
        
        while(left != null) {
            ListNode tempHead = new ListNode(0, left);
            ListNode slow = tempHead;
            ListNode fast = tempHead;
            int count = 0;
            while(count < k) {
                fast = fast.next;
                if(fast == null) break;
                count++;
            }
            if(count < k) break;
            left = fast.next;
            fast.next = null;
            tail.next = reverse(slow.next);
            tail = slow.next;
            tail.next = null;
        }
        tail.next = left;
        return newHead.next;
    }

    private ListNode reverse(ListNode head) {
        ListNode newHead = head;
        head = head.next;
        newHead.next = null;
        while(head != null) {
            ListNode tempHead = head;
            head = head.next;
            tempHead.next = newHead;
            newHead = tempHead;
        }
        return newHead;
    }
}

138. 随机链表的复制

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

• val：一个表示 Node.val 的整数。
• random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1：

1
2

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

1
2

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

1
2

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

提示：

• 0 <= n <= 1000
• -104 <= Node.val <= 104
• Node.random 为 null 或指向链表中的节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    public Node copyRandomList(Node head) {
        if(head == null) return null;
        HashMap<Node, Node> hashMap = new HashMap<>();
        Node tempHead = head;
        while(tempHead != null) {
            hashMap.put(tempHead, new Node(tempHead.val));
            tempHead = tempHead.next;
        }
        tempHead = head;
        while(tempHead != null) {
            hashMap.get(tempHead).next = hashMap.get(tempHead.next);
            hashMap.get(tempHead).random = hashMap.get(tempHead.random);
            tempHead = tempHead.next;
        }
        return hashMap.get(head);
    }
}

148. 排序链表

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

示例 1：

1
2

输入：head = [4,2,1,3]
输出：[1,2,3,4]

示例 2：

1
2

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

示例 3：

1
2

输入：head = []
输出：[]

提示：

• 链表中节点的数目在范围 [0, 5 * 104] 内
• -105 <= Node.val <= 105

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {

    // 记住找中心节点和合并方法，都弄一个头结点就比较稳
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) return head;
        
        ListNode left = head;
        ListNode middleNode = getMiddle(left);
        ListNode right = middleNode.next;
        middleNode.next = null;
        
        left = sortList(left);
        right = sortList(right);
        ListNode result = merge(left, right);
        return result;
    }

    private ListNode getMiddle(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode newHead = new ListNode(-1, head);
        ListNode slow = newHead.next;
        ListNode fast = newHead.next.next;
        
        while(fast.next != null) {
            slow = slow.next;
            fast = fast.next;
            if(fast.next == null) break;
            fast = fast.next;
        }
        return slow;
    }

    private ListNode merge(ListNode l1, ListNode l2) {
        // 两个方法都要新弄一个头结点
        ListNode tempHead = new ListNode();
        ListNode tail = tempHead;
        while(l1 != null && l2 != null) {
            if(l1.val < l2.val) {
                tail.next = l1;
                l1 = l1.next;
            } else {
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;
        }
        tail.next = l1 == null ? l2 : l1;
        return tempHead.next;
    }

}

23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

1
2
3
4
5
6
7
8
9
10

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

1
2

输入：lists = []
输出：[]

示例 3：

1
2

输入：lists = [[]]
输出：[]

提示：

• k == lists.length
• 0 <= k <= 10^4
• 0 <= lists[i].length <= 500
• -10^4 <= lists[i][j] <= 10^4
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10^4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {

        if(lists == null || lists.length < 1) return null;
        ListNode newHead = new ListNode();
        ListNode tail = newHead;

        // 引入输入有可能很恶心，比如 [[], [1]], 所以先找到合理的长度
        int count = 0;
        for(ListNode list : lists) {
            if(list != null) count++;
        }
        while(count > 0) {
            ListNode tempNode = new ListNode(Integer.MAX_VALUE);
            int tempIndex = -1;
            for(int i = 0; i < lists.length; i++) {
                ListNode tempList = lists[i];
                if(tempList == null) continue;
                if(tempList.val < tempNode.val) {
                    tempNode = tempList;
                    tempIndex = i;
                }
            }
            tail.next = tempNode;
            lists[tempIndex] = lists[tempIndex].next;
            if(lists[tempIndex] == null) {
                count--;
            }
            tail = tail.next;
            tail.next = null;

        } 
        return newHead.next;
    }
}

146. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：

• 1 <= capacity <= 3000
• 0 <= key <= 10000
• 0 <= value <= 105
• 最多调用 2 * 105 次 get 和 put

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

import java.util.HashMap;

class LRUCache {
    // 原理就是利用 hashMap 做缓存，再用 带前后指针的链表
    // 访问过/放入过，就立马把该元素放到头部
    // 超过长度就移除末尾的那个元素
    // 小技巧：使用头结点和尾结点
    private HashMap<Integer, LinkNode> cache = new HashMap<>();
    private LinkNode head;
    private LinkNode tail;
    // 当前大小
    private int size;
    // 总的容量
    private int capacity;


    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;

        // 伪头结点 尾结点
        this.head = new LinkNode();
        this.tail = new LinkNode();
        this.head.next = tail;
        this.tail.pre = head;
    }
    
    public int get(int key) {
        LinkNode node = this.cache.get(key);
        if(node == null) {
            return -1;
        }
        // 被访问了，就放到头部
        moveToHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        LinkNode node = this.cache.get(key);
        if(node == null) {
            node = new LinkNode(key, value);
            this.cache.put(key, node);
            addToHead(node);
            ++size;
            if(size > capacity) {
                LinkNode temp = removeTail();
                cache.remove(temp.key);
                --size;
            }
        } else {
            node.value = value;
            moveToHead(node);
        }
    }

    private LinkNode removeTail() {
        LinkNode node = this.tail.pre;
        removeNode(node);
        return node;
    }

    private void removeNode(LinkNode node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    private void addToHead(LinkNode node) {
        node.next = this.head.next;
        node.pre = this.head;
        this.head.next.pre = node;
        this.head.next = node;
    }

    private void moveToHead(LinkNode node) {
        removeNode(node);
        addToHead(node);
    }

    class LinkNode {
        int key;
        int value;

        LinkNode pre;
        LinkNode next;
        public LinkNode() {}
        public LinkNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

技巧

287. 寻找重复数

给定一个包含n + 1个整数的数组 nums ，其数字都在[1, n]范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设nums只有 一个重复的整数 ，返回这个重复的数 。

你设计的解决方案必须 不修改数组nums且只用常量级O(1)的额外空间。

示例 1：

输入：nums = [1,3,4,2,2]

输出：2

示例 2：

输入：nums = [3,1,3,4,2]

输出：3

示例 3 :

输入：nums = [3,3,3,3,3]

输出：3

提示：

• 1 <= n <= 105
• nums.length == n + 1
• 1 <= nums[i] <= n
• nums 中只有一个整数出现两次或多次，其余整数均只出现一次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.util.Arrays;

class Solution {
    public int findDuplicate(int[] nums) {
        // 往循环链表想
        int slow = nums[0];
        int fast = nums[slow];

        while(slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
            fast = nums[fast];
        }
        // 确认有环后，是把快指针放在开头，然后两个都一步一步走
        fast = 0;
        while(slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return fast;
    }
}

1. 往循环链表联想
2. 根据访问熟悉顺序可以发现，这个访问顺序是一条循环链表，且这条循环链表循环的部分第一个节点，即是我们要找的重复的数
3. 慢指针一开始就放在第一个真正节点，算作走了一步，快指针一开始就放在第二个真正节点，算作走了两步，然后快慢指针按照自己的节奏走
4. 那么找到循环链表的循环部分的第一个节点的步骤：
   1. 快慢指针确认有环（这道题必定有环）
   2. 将快指针放到头结点（不要放在第一个真正节点了，这样做代表多走了一步），慢指针不动放在上一步确认有环的停留位置
   3. 快慢指针皆一步一步走，相同即为所求点

75.颜色分类

给定一个包含红色、白色和蓝色、共n个元素的数组nums，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

我们使用整数0、1和2分别表示红色、白色和蓝色。

必须在不使用库内置的 sort 函数的情况下解决这个问题。

示例 1：

输入：nums = [2,0,2,1,1,0]

输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]

输出：[0,1,2]

提示：

• n == nums.length
• 1 <= n <= 300
• nums[i] 为 0、1 或 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import java.util.Arrays;

class Solution {
    public void sortColors(int[] nums) {
        int[] data = new int[3];
        Arrays.stream(nums).forEach(num -> {data[num]++;});
        int index = 0;
        for(int i = 0; i < 3; i++) {
            for(int j = 0; j < data[i]; j++) {
                nums[index++] = i;
            }
        }
    }
}

学习下stream流简便写法吧

31.下一个排列

整数数组的一个排列就是将其所有成员以序列或线性顺序排列。

• 例如，arr =[1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。

整数数组的下一个排列是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的下一个排列就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

• 例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
• 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
• 而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。

给你一个整数数组nums，找出nums的下一个排列。

必须原地算法修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3]

输出：[1,3,2]

示例 2：

输入：nums = [3,2,1]

输出：[1,2,3]

示例 3：

输入：nums = [1,1,5]

输出：[1,5,1]

提示：

• 1 <= nums.length <= 100

• 0 <= nums[i] <= 100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Solution {
    // 举例如：12354 需要得到下一个排列是 12435
    // 分以下三步 
    // 1.从尾到头，找到第一个升序相邻对 position 和 position+1 , 即 12354 找到 3 和 5
    // 2.从position位置到尾，找到第一个大于position的数来交换，即 3 和 4 交换，12354 变为  12453
    // 3.从position+1 位置到尾，进行排序，使得剩余的尾部从小到大，达到最小状态，即排序 53 后 12453 变为  12435
    public void nextPermutation(int[] nums) {
        if(nums == null || nums.length == 1) return;
        int position = -1;
        // 第一步找到position
        for(int i = nums.length - 2; i >= 0; i--) {
            if(nums[i] < nums[i+1]) {
                position = i;
                break;
            }
        }
        if(position == -1) {
            // 说明一直是降序
            Arrays.sort(nums);
            return;
        }
        // 第二步找到尾部第一个大于nums[position]的数交换
        for(int i = nums.length - 1; i > position; i--) {
            if(nums[i] > nums[position]) {
                int temp = nums[i];
                nums[i] = nums[position];
                nums[position] = temp;
                break;
            }
        }
        // 第三步，排序 postion + 1 到尾部
      // 这里编码的时候出过错，得排序 position + 1 的位置，写快了，容易忘了是position下一个位置
        Arrays.sort(nums, position + 1, nums.length);
    }
}

核心的思路就是：下一个排列，意味着尽量在尾部找更好，找到该变换的位置，接着找到这个位置代表的数往后面第一个大的数交换，随后排序这个位置往后的部分即可以达到题目所求。

1. 第一步从尾部往前找到第一个升序相邻对
   1. 有这样的升序相邻对，意味着，这样才能通过变化，找到更大的数，如果找不到，就说明就是个降序数，下一个排列就是从小到大
   2. 第一个：因为我们找的是下一个排列，所以越靠近尾部越好
   3. 相邻对：因为判断相邻就能表示尾部可以变化来达到题意，至于到底交换哪个更大的数，到第二步去完成。
2. 第二步找到尾部第一个大于nums[position]的数，从尾部往前循环第一个大的数就是，这是因为在第一步找的就是第一个升序相邻对，这个标准意味着，从尾部往前循环的话，不会出现这个第一个大的数在中间的情况。
3. 第三步 只需要排序 剩余的尾部，达到下一个排序的要求

136.只出现一次的数字

给你一个非空整数数组nums，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

示例 1 ：

输入：nums = [2,2,1]

输出：1

示例 2 ：

输入：nums = [4,1,2,1,2]

输出：4

示例 3 ：

输入：nums = [1]

输出：1

提示：

• 1 <= nums.length <= 3 * 104
• -3 * 104 <= nums[i] <= 3 * 104
• 除了某个元素只出现一次以外，其余每个元素均出现两次。

1
2
3
4
5
6
7

class Solution {
    public int singleNumber(int[] nums) {
        int result = 0;
        for(int num : nums) result ^= num;
        return result;
    }
}

169. 多数元素

给定一个大小为n的数组nums，返回其中的多数元素。多数元素是指在数组中出现次数大于⌊n/2⌋的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：nums = [3,2,3]

输出：3示例 2：

输入：nums = [2,2,1,1,1,2,2]

输出：2

提示：

• n == nums.length
• 1 <= n <= 5 * 104
• 109 <= nums[i] <= 109

hashMap解法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import java.util.HashMap;

class Solution {
    public int majorityElement(int[] nums) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            if(hashMap.containsKey(nums[i])) {
                hashMap.put(nums[i], hashMap.get(nums[i]) + 1);
                if(hashMap.get(nums[i]) > nums.length / 2) {
                    return nums[i];
                }
            } else {
                hashMap.put(nums[i], 1);
            }
        }
        return nums[0];
    }
}

进阶：摩尔投票解法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
    // 通常可以用hashMap，学习下空间复杂度O(1)的摩尔投票
    public int majorityElement(int[] nums) {
        int mayNum = 0, votes = 0;
        for(int num : nums) {
            // 每一轮循环都会去判断votes是否等于0
            // 等于0意味着可以这是新选择一个mayNum
            if(votes == 0) mayNum = num;
            // 找众数，只有mayNum才去+1，否则都-1
            votes += (num == mayNum ? 1 : -1);
            // 不断地重新判断mayNum
        }
        return mayNum;
    }
}

多维动态规划

62.不同路径

一个机器人位于一个m x n网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7

输出：28

示例 2：

输入：m = 3, n = 2

输出：3

解释：

从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3

输出：28

示例 4：

输入：m = 3, n = 3

输出：6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution {
    public int uniquePaths(int m, int n) {
        int rows = m;
        int cols = n;
        int[][] dp = new int[rows][cols];
        for(int row = 0; row < rows; row++) {
            for(int col = 0; col < cols; col++) {
                if(row == 0 || col == 0) {
                    dp[row][col] = 1;
                } else {
                    dp[row][col] = dp[row-1][col] + dp[row][col-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
}

64. 最小路径和

给定一个包含非负整数的 mxn 网格grid，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]

输出：7

解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：

输入：grid = [[1,2,3],[4,5,6]]

输出：12

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 200
• 0 <= grid[i][j] <= 200

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Solution {
    public int minPathSum(int[][] grid) {

        int rows = grid.length;
        int cols = grid[0].length;
        int[][] dp = new int[rows][cols];

        for(int row = 0; row < rows; row++) {
            for(int col = 0; col < cols; col++) {
                if(row == 0 && col == 0) {
                    dp[row][col] = grid[row][col];
                } else if(row == 0 || col == 0) {
                    if(row == 0) {
                        dp[row][col] = dp[row][col-1] + grid[row][col];
                    } else {
                        dp[row][col] = dp[row-1][col] + grid[row][col];
                    }
                } else {
                    dp[row][col] = Math.min(dp[row-1][col], dp[row][col-1]);
                    dp[row][col] += grid[row][col];
                }
            }
        }
        return dp[rows-1][cols-1];
    }
}

5.最长回文子串

给你一个字符串 s，找到 s 中最长的 回文子串。

示例 1：

输入：s = “babad”

输出：“bab”

解释：“aba” 同样是符合题意的答案。

示例 2：

输入：s = “cbbd”

输出：“bb”

提示：

• 1 <= s.length <= 1000
• s 仅由数字和英文字母组成

中心扩散解法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Solution {
    public String longestPalindrome(String s) {

        String result = "";
        for(int i = 0; i < s.length(); i++) {
            // 以单个为中心的回文串，计算长度
            String tempResult = get(s, i, i);
            if(i < s.length() - 1 && s.charAt(i) == s.charAt(i+1)) {
                // 如果是成对为中心的回文串，去计算长度
                String tempResult1 = get(s, i, i + 1);
                tempResult = tempResult.length() > tempResult1.length() ? tempResult : tempResult1;
            }

            if(tempResult.length() > result.length()) {
                result = tempResult;
            }
        }
        return result;
    }

    private String get(String s, int left, int right) {
   
        while(left - 1 >= 0 && right + 1 < s.length()) {
            if(s.charAt(left - 1) != s.charAt(right + 1)) {
                break;
            }
            left--;
            right++;
        }
        return s.substring(left, right + 1);
    }
}

dp解法

学习下动态规划解决方法

boolean dp[l][r] 表示字符串从 i 到 j 这段是否为回文。试想如果 dp[l][r]=true，我们要判断 dp[l-1][r+1] 是否为回文。只需要判断字符串在(l-1)和（r+1)两个位置是否为相同的字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public String longestPalindrome(String s) {
        if (s == null || s.length() < 2) {
            return s;
        }
        int strLen = s.length();
        int maxStart = 0;  //最长回文串的起点
        int maxEnd = 0;    //最长回文串的终点
        int maxLen = 1;  //最长回文串的长度

        boolean[][] dp = new boolean[strLen][strLen];

        for (int r = 1; r < strLen; r++) {
            for (int l = 0; l < r; l++) {
                if (s.charAt(l) == s.charAt(r) && (r - l <= 2 || dp[l + 1][r - 1])) {
                    dp[l][r] = true;
                    if (r - l + 1 > maxLen) {
                        maxLen = r - l + 1;
                        maxStart = l;
                        maxEnd = r;

                    }
                }

            }

        }
        return s.substring(maxStart, maxEnd + 1);

    }

1143. 最长公共子序列

给定两个字符串text1和text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。

一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，”ace” 是”abcde”的子序列，但 “aec” 不是”abcde” 的子序列。

两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = “abcde”, text2 = “ace”

输出：3

解释：最长公共子序列是 “ace” ，它的长度为 3 。

示例 2：

输入：text1 = “abc”, text2 = “abc”

输出：3

解释：最长公共子序列是 “abc” ，它的长度为 3 。

示例 3：

输入：text1 = “abc”, text2 = “def”

输出：0

解释：两个字符串没有公共子序列，返回 0 。

提示：

• 1 <= text1.length, text2.length <= 1000
• text1 和 text2 仅由小写英文字符组成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Solution {

    public int longestCommonSubsequence(String text1, String text2) {

        // 使用二维数组来表示，dp[i][j] 表示 到第一个字符串 的第i个位置 到第二个字符串 的 第j个位置的 匹配情况
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];

        for(int i = 1; i <= text1.length(); i++) {
            for(int j = 1; j <= text2.length(); j++) {
                if(text1.charAt(i-1) == text2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }


}

72.编辑距离

给你两个单词word1和 word2， 请返回将 word1转换成word2所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

• 插入一个字符
• 删除一个字符
• 替换一个字符

示例 1：

输入：word1 = “horse”, word2 = “ros”

输出：3

解释：

horse -> rorse (将 ‘h’ 替换为 ‘r’)

rorse -> rose (删除 ‘r’)

rose -> ros (删除 ‘e’)

示例 2：

输入：word1 = “intention”, word2 = “execution”

输出：5

解释：

intention -> inention (删除 ‘t’)

inention -> enention (将 ‘i’ 替换为 ‘e’)

enention -> exention (将 ‘n’ 替换为 ‘x’)

exention -> exection (将 ‘n’ 替换为 ‘c’)

exection -> execution (插入 ‘u’)

提示：

• 0 <= word1.length, word2.length <= 500
• word1 和 word2 由小写英文字母组成