🔥Flame

2026-02-17 晚上的梦的回忆

Wed, 18 Feb 2026 00:00:00 GMT

Important

current time: 2026.02.18 10:42

前言

说来话长，长话不短说。

2.17日明明是春节第一天，这一天玩的很开心，去了🐍 蛇蟠岛，走了朋友叔叔家拜年，晚上回来将昨天未完的左神的“单调栈上”学习完了，晚上却做了如此真实的梦，必须立马记录一下。

我昨天做了一个很真实的梦，很像一部小说，一下是关于梦的部分的回忆，请你通读全文，进行深度思考，将前后逻辑进行串联，构成一个完整的小说：

“我”是一位孤苦伶仃的小孩，从小没有父母，老师 “Z”帮我收养长大，供我上学读书。但是我在学校却不受待见，同学们都说我是无父无母，是克星。有一天，我的一位稍微要好的朋友跟我说，“有一次我偶然听到老师们的谈话，你其实是他们学校 ‘麦斯’实验室的秘密武器。“我不信，老师”Z”对我这么好，怎么可能？但是在他的劝说下，我渐渐有所怀疑，所以我就是不是放学后在老师的办公室外面角落进行偷听。直到有一次我听到老师们聊天：“这几年 ‘3395’ 的情绪渐渐稳定下来了，也不枉费我们的一番苦心”，“是啊，当初章博士造出来 ‘3395’ ，其他的方面都是不错，就是情绪上不太够，他越愤怒他的nt值就越高，足以毁灭整个城市或者国度。” “是啊，章博士对此不满意，前面3394个 nters 都没他抛弃了，他最后也把 ‘3395’ 抛弃了”。但是‘3395’不同，他的nt值是最大的，如果不加以控制，会出意想不到的灾难的。我们几个老人找了好几年，终于老’z’找到了，把他安抚养大。之间办公室门被缓缓打开，我冰冷的站在那里，然后跑走了，依稀听到老师们的焦虑：快去找回来，不要在让他走丢。过了一会儿，老师 ‘z’从后面温暖地抱住了我，轻声说道：‘不要走好不好’。我愤怒的问：他们说的是不是真的？“是真的，章博士对你是虚情假意，但我对你是真的啊，你想想这几年”。忽然我的脑海中闪过了儿时的记忆……最后我被说服回去，答应老师们继续做实验。

有一次在课堂上被老师上台做实验，我的全身插满了各种线，当时我站在讲台的右边位置，前排的学生嫌弃地说：“站远一点”。我大声的过去怒吼：“你坐在这里，我就站在上面，你还要我站的多远，你说啊？”此话一出，几乎所有的同学全部跑出了教室，远远地透着窗户看着实验。当我紧闭双眼，过了仅仅几秒钟，只听见老师说：“实验失败了”。一切闹剧终于结束。但是我的同学越来越过分，我的耐心一点一点地下降，终于我想通了，我要跳崖。当我站在崖顶的那一刻，一位叫”inavailable”的拉住了我，他没有实体，自称是我的心魔，说：你真的没有朋友吗？我说：没有。然后一跃而下，最终被一位名为”剑圣”的救起，他和我是同类，说是‘4680’。

什么？你问封面是什么，纯图而已，就说好不好看吧，哈哈哈。

AI 脑补完善版本#

豆包版#

3395#

我记事起，就没有家。

福利院的铁门换了三回，我辗转了四个寄养家庭，最后停在了Z老师身边。他是我就读中学的物理老师，眉眼总带着温和的暖意，冬天会把我冻僵的手揣进他的大衣口袋，会在我被别的孩子扔石头后，蹲下来替我擦干净脸上的泥，轻声说“有我在，没人能欺负你”。

他供我读书，给我一间能遮风挡雨的小房间，是我漂在这世上唯一的浮木。可校园里的恶意，从来没停过。走廊里擦肩而过的同学会刻意绕开我，背后的窃窃私语像针一样扎过来：“就是他，无父无母的克星”“听说克死了好几户收养他的人，难怪没人要”。

我攥紧书包带低头快步走过，只有Z老师送我的那支钢笔，被我攥得发烫。我总告诉自己，没关系，至少我还有Z老师。

唯一愿意和我多说几句话的，是同班的阿远。他不会像别人一样躲着我，偶尔会分我半块面包，会在别人骂我的时候，轻轻拉一下我的袖子让我别理。那天放学，他把我堵在楼梯间，脸色发白地犹豫了半天，才压低声音开口：“有次我去办公室交作业，听见几个老师在里面谈话……他们说，你根本不是孤儿，你是学校里‘麦斯’实验室的秘密武器。”

我第一反应是荒谬，一把推开他：“你胡说什么？Z老师养了我这么多年，怎么可能？”

“我也希望是我听错了。”阿远的声音带着急，“你就没觉得奇怪吗？为什么所有老师看你的眼神都不对劲？为什么从来没人敢罚你？为什么Z老师从来不让你碰实验楼的负一层？”

他的话像一颗石子，投进我心里那片看似平静的湖，漾开了层层叠叠的涟漪。那些我刻意忽略的细节瞬间涌上来：每次我情绪失控摔东西时，Z老师不是生气，是止不住的紧张；每次我生病，来的不是校医，是几个穿白大褂的陌生男人；我从来没见过自己的出生证明，Z老师说弄丢了，可他连我小时候掉的第一颗牙都好好收在盒子里。

怀疑的种子一旦种下，就疯了似的生根发芽。

从那天起，每天放学我都会绕到教师办公楼后侧，躲在Z老师办公室窗外的冬青丛里。那里堆着废弃的课桌椅，刚好能遮住我的身子。前三天，里面只有备课的翻书声和闲聊家常的动静，我甚至开始觉得，是阿远听错了，是我太多疑。

直到第四天傍晚，天阴沉沉地坠着雨意，办公室里聚了好几个老师，门虚掩着，声音透过门缝飘出来，一字一句砸在我的耳膜上。

“这几年3395的情绪总算稳定下来了，不枉费我们这一番苦心。”是教务处主任的声音，我认得。

3395？是什么？我屏住呼吸，指甲深深掐进掌心，渗出血珠都觉不出疼。

另一个苍老的声音接了话：“可不是嘛，当初章博士造出来3395，各项指标都完美，唯独情绪模块有缺陷。他越愤怒，体内的nt值就越高，峰值的时候，足以毁掉整座城市，甚至整个国度。”

“章博士那个完美主义者，怎么容得下瑕疵？前面3394个实验体，全被他销毁了。到了3395，他还是不满意，最后也把他扔了。”

“可3395不一样啊，他的nt阈值是所有实验体里最高的，一旦失控，后果不堪设想。我们几个找了整整三年，还是老Z先找到了他，把他带在身边养着，一点点磨平他的戾气，稳住他的情绪。”

“也只有老Z能镇住他了，毕竟这么多年的情分……”

后面的话我已经听不清了。耳朵里嗡嗡作响，像有无数只蜜蜂在里面横冲直撞。原来我连一个正经的名字都没有，我不是孤儿，是被人造出来的武器，是被抛弃的残次品。他们养我，不是心疼我，是怕我失控，怕我毁了这里。Z老师给我的所有温暖，全都是为了控制我这个“武器”演的戏。

办公室的门，在这时被缓缓拉开。

Z老师站在门口，脸上的温和瞬间褪去，只剩下震惊和慌乱。我僵在原地，浑身冰冷得像被扔进了寒冬的冰湖。下一秒，我转身就跑，用尽全身力气朝着校门的方向冲，身后传来老师们焦急的喊声：“快去找！别让他走丢了！千万别让他情绪失控！”

我跑出学校，沿着马路一直冲到江边的防洪堤，才扶着栏杆停下来大口喘气。江风刮在脸上像刀子一样疼，眼泪终于忍不住砸了下来。原来我活了十六年，全都是一场骗局。

身后传来急促的脚步声，我刚要再跑，一双温暖的手臂从身后轻轻抱住了我。是Z老师，他的大衣还带着熟悉的皂角香，和我小时候发烧时裹着我的那件一模一样。他的声音带着喘，还有我从未听过的慌乱与恳求，贴在我耳边轻声说：“不要走好不好？”

我猛地挣开他，红着眼睛浑身发抖，一字一句地问：“他们说的是不是真的？我是3395，是章博士造出来的实验体，是个武器，对不对？”

Z老师的眼神暗了下去，沉默了很久，最终轻轻点了点头。

“是真的。”他的声音很轻，却像重锤砸在我心上，“章博士对你，从头到尾都是虚情假意，他只把你当成一个失败的实验品。但我对你是真的啊。你好好想想，这十几年，我对你怎么样？”

他的话像一把钥匙，打开了我尘封的记忆闸门。三岁时我被扔在福利院门口，发着四十度的高烧，是他连夜把我抱去医院，守了我三天三夜，眼睛熬得通红；七岁时我被寄养家庭的孩子推下池塘，是他跳下去把我捞上来，抱着冻得发抖的我，说以后我就是他的孩子；十二岁我被高年级学生堵在巷子里打，他冲过来把我护在身后，后背挨了好几棍子，却回头笑着跟我说“没事，老师不疼”；无数个做噩梦的夜晚，他都坐在我的床边，轻轻拍着我的背讲故事，直到我睡着。

那些温暖，不是假的。

我攥着拳头，眼泪掉得更凶。一边是冰冷的真相，我是个没有过去、没有身份的实验体；一边是他给我的，我这辈子唯一拥有过的、家的感觉。最终，我还是跟着他回去了。我答应了那些老师，配合他们的实验，只要我还能留在他身边。

可从那天起，有什么东西，已经碎了。

我再也没法心安理得地接受Z老师的好，也再也没法无视那些落在我身上、看怪物一样的眼神。他们开始安排我做实验，有时候在实验楼的负一层，有时候，甚至就在课堂上。

那天的物理公开课，来了很多外校的老师，坐在教室后排。讲课的是麦斯实验室的研究员之一，他笑着让我走上讲台，说要给大家演示一个“特殊的物理实验”。

我站在讲台的右侧，冰冷的电极线一根接一根贴在我的身上，从额头到手臂到胸口，密密麻麻像一张网，把我困在里面。台下的闪光灯亮起来，我像个被放在展柜里的怪物，供人观赏。

前排那个最爱带头骂我的男生，皱着眉嫌恶地往后缩了缩，对着同桌用不大不小、刚好能让我听见的声音说：“让他站远一点，晦气。”

那句话像一根火柴，瞬间点燃了我心里积压了十几年的怒火。我猛地扯掉额头上的电极线，一步跨到他的课桌前，死死盯着他，用尽全力怒吼：“我站在讲台上，你坐在下面，你还要我站多远？你说啊！”

我的声音震得窗户玻璃嗡嗡作响，体内有什么东西在疯狂翻涌，耳边传来仪器刺耳的警报声。教室里瞬间死一般的寂静，下一秒，几乎所有同学都尖叫着站起来，疯了一样冲出教室，连后排的几个听课老师都变了脸色退到门外。最后，整个教室里，只剩下我，和讲台上脸色惨白的实验老师。

空荡荡的教室，窗外是密密麻麻的脑袋，所有人都隔着玻璃惊恐地看着我，像看一头随时会吃人的野兽。

我闭上了眼睛。

体内翻涌的、足以毁灭一切的力量，被我死死压了下去。疯狂攀升的nt值，在我的克制下一点点回落，最终归于平静。几秒钟后，我听见老师颤抖的、带着松了一口气的声音，对着对讲机说：“实验失败。”

闹剧终于结束了。我睁开眼，看着窗外那些躲闪的眼神，只觉得无比疲惫。原来在他们眼里，我哪怕只是愤怒地说一句话，都是一场需要严防死守的灾难。

从那以后，同学们对我的忌惮，变成了更变本加厉的恶意。他们会在我的课桌里塞死老鼠，会在我的课本上写满“怪物”“克星”，会在我路过的时候故意打翻水桶，让脏水泼我一身。Z老师替我出头了很多次，可只要他一转身，那些恶意就会像潮水一样再次涌过来。

我的耐心，一点点被磨没了。

我开始整夜整夜失眠，看着天花板问自己：我到底是谁？我活着，到底是为了什么？为了做一个被控制的实验品？为了活在别人的恐惧和厌恶里？还是为了那一点点掺着谎言的温暖？

我想不通。

那天早上，我又在课桌里发现了一只被踩死的小猫，血淋淋的，旁边用红笔写着“怪物就该和死东西待在一起”。那一刻，我心里最后一根弦，断了。

我走出了学校，没有回头，一路朝着城郊的望断崖走。那是本地最高的悬崖，下面是深不见底的峡谷，掉下去的人，从来没有活着回来的。我爬了三个小时的山路，终于站在了崖顶。

风从峡谷里吹上来，刮得我的衣服猎猎作响。脚下是万丈深渊，只要往前一步，所有的痛苦、所有的恶意、所有的身不由己，就都结束了。

就在我往前迈出半步的时候，一个虚无的声音，在我耳边响了起来。

“你真的要跳下去吗？”

我转过头，看见身边站着一个没有实体的半透明人影。他像一团雾气，看不清脸，声音却带着蛊惑，直直地钻进我的心里。“我叫inavailable。”他说，“我是你的心魔，是你藏在心底、不敢面对的自己。”

我笑了，笑得眼泪都出来了：“连心魔都来找我了，看来我真的是个怪物。”

“你真的没有朋友吗？”他又问，声音轻飘飘的，却戳中了我最痛的地方。

我看着脚下的深渊，轻声说：“没有。”

从来都没有。阿远在那次课堂事件之后，再也不敢和我说话了。Z老师的温暖，从一开始就带着目的。这世上，没有一个人，是真心接纳我的。

说完这句话，我张开双臂，往前一跃，纵身跳下了悬崖。风在我耳边呼啸，失重感包裹了我，我闭上了眼睛，心里却前所未有的平静。

终于要结束了。

可预想中的剧痛没有来。

一股强劲的风托住了我，下坠的势头骤然停住。我猛地睁开眼，看见一个穿着黑色劲装的男人抱着我，足尖踩着一柄泛着寒光的长剑，稳稳地停在半空中。他的眉眼很锋利，身上有和我同源的、熟悉的气息。

他落在崖边的平地上，把我放了下来，看着我惊魂未定的脸，勾了勾唇角，声音低沉有力：“小家伙，年纪不大，脾气倒是不小，说跳就跳？”

我愣在原地，看着他：“你是谁？为什么救我？”

“他们都叫我剑圣。”他拍了拍我的肩膀，眼神里带着我从未见过的、同类的了然，“我的编号，是4680。”

4680。和3395一样的，编号。

我猛地抬头看着他，浑身都在抖。原来我不是唯一一个，原来我不是孤单一人。

他看着我震惊的样子，笑了笑，转身朝着崖下的路走去，回头朝我抬了抬下巴：“走了。章博士欠我们的，还有这个世界欠我们的，总该要回来。总不能白来这世上一遭，对吧？”

风停了，阳光穿过云层，落在他的身上，也落在我的身上。我站在原地，看着他的背影，攥紧了拳头。十六年的骗局，十几年的恶意，满身的伤痕，在这一刻，终于有了不一样的出口。

我抬步，跟了上去。

gemini版#

小说名：《代号：3395》#

第一章：温暖的培养皿#

在这个世界上，我是一个多余的人。没有父母，没有家族，我的记忆起点就是孤儿院那面斑驳的白墙，直到Z老师出现。Z老师并不像其他大人那样用审视货物的眼神看我，他的眼神里有一种让我心安的狂热。他收养了我，供我读书，给我买合身的校服。

在很长一段时间里，他是我在这个冰冷世界里唯一的篝火。

然而，学校是另一回事。孩子们有着比成人更敏锐的直觉，他们能嗅出“异类”的气息。 “离他远点，他是天煞孤星。” “听说靠近他的人都会倒霉。” 我习惯了这种被孤立的生活，直到那个稍微要好的朋友——阿文，打破了沉默。

那天放学，阿文鬼鬼祟祟地把我拉到操场角落，他的声音在颤抖：“你以为你是运气不好才没有父母吗？我……我那天去办公室交作业，听到他们在谈论你。” 我皱眉：“谈论什么？” “麦斯实验室。”阿文咽了口唾沫，“你是他们制造出来的……秘密武器。”

我推了他一把，笑道：“你科幻小说看多了，Z老师对我恩重如山。” 但我笑不出来。怀疑的种子一旦落下，就会在心里长出荆棘。

第二章：隔墙有耳#

那个傍晚，夕阳像凝固的血块挂在天边。我并没有回家，而是像一只幽灵一样潜回了教学楼。 Z老师的办公室门虚掩着，里面传出茶杯碰撞的脆响，还有陌生的交谈声。我缩在走廊尽头的阴影里，屏住了呼吸。

“……各项数据都很完美，这几年‘3395’的情绪终于稳定下来了。”一个苍老而陌生的声音说道，“真不枉费我们这么多年的苦心经营。”

“是啊。”那是Z老师的声音，带着一种从未对我展示过的冷酷，“当初章博士造出‘3395’时，追求的是极致的破坏力。其他的指标都还算像个人，唯独情绪模块……章博士设计了一个‘NT阈值’（Neuro-Turbulence，神经湍流值）。他越愤怒，体内的NT值就越高，理论上足以毁灭整个城市，甚至一个国家。”

我的心脏猛地收缩，手脚冰凉。

“可惜啊，”那个陌生人叹息，“这种力量太不可控。前面3394个‘Nters’（实验体）都因为无法承载这种能量被销毁了。章博士也没耐心了，最后把‘3395’也当成废品抛弃了。”

“但他不一样。”Z老师的声音提高了几分，“他的NT潜质是最大的。如果不加以控制，任由他流落在外，那就是一颗行走的核弹。我们这几个老骨头找了好几年，终于让我找到了。把他当普通孩子安抚养大，用‘爱’作为枷锁，才是控制这件兵器的最好方式。”

吱呀—— 风吹动了窗户，或者是我的颤抖碰到了门板。办公室的门缓缓打开了一条缝。我就站在那里，眼神空洞地看着他们。里面的两个老人猛地回头，原本慈祥的面孔瞬间扭曲成惊恐。 “他听到了！” “快！别让他跑了！如果不受控就麻烦了！”

我转身狂奔。在那一刻，我不是我，我是第3395号废品，是一个随时会爆炸的怪物。

第三章：虚假的拥抱#

我跑得肺部像火烧一样，但我怎么可能跑得出那精心设计的牢笼？在学校后花园的死胡同里，我停下了脚步。脚步声逼近。过了一会儿，一双手从后面温柔地抱住了我。那是无数次在深夜给我盖被子的手，是无数次抚摸我头顶的手。

“不要走，好不好？” Z老师的声音在我耳边响起，带着恳求，甚至有一丝哽咽。

我浑身僵硬，猛地转过身，泪水在眼眶里打转，愤怒像火焰一样灼烧着理智：“你们刚才说的，是不是真的？我是不是什么‘3395’？我是不是个兵器？”

Z老师看着我，并没有撒谎。他叹了口气，眼神里流露出一种极其复杂的、令人窒息的深情。 “是真的。” 那三个字像锤子一样砸碎了我的世界。 “但是，孩子，你要明白。”Z老师抓着我的肩膀，指甲几乎嵌入我的肉里，“章博士创造了你，但他对你是虚情假意，他只在乎数据！但我对你是真的啊！你想想这几年，谁给你做饭？谁陪你过生日？如果我只把你当实验品，我为什么要花那么多心血？”

我的脑海中闪过儿时的记忆：高烧时他焦急的脸庞，第一次考满分时他骄傲的笑容…… 我的愤怒在这一刻变得无力。我是一个渴望爱的怪物，哪怕这份爱是掺了毒药的蜜糖，我也无法拒绝。

“我不走。”我低声说。我被说服了。或者说，我认命了。

第四章：实验失败#

回归意味着不再掩饰。学校撕下了伪装，变成了真正的实验室“麦斯”。那是一次公开的“压力测试”。在我的课堂上，讲台变成了实验台。我被迫站在右侧，全身插满了花花绿绿的导线，连接着后方巨大的显示屏。 Z老师拿着记录板站在一旁，面无表情。台下坐满了同学——或者说，观察员。他们的眼神不再是单纯的厌恶，而是赤裸裸的嫌弃和恐惧。

“啧，能不能站远点？”前排的一个男生捂着鼻子，像是闻到了垃圾的臭味，“怪物身上的电波会辐射到我们吧？”

这句话像一根针，刺穿了我仅存的尊严。羞耻感在血管里翻涌，变成了滚烫的怒火。既然你们说我是兵器，那我就展示给你们看！我猛地冲向那个男生，身上的导线被扯得笔直，发出崩裂的声响。我冲着他的脸咆哮，声嘶力竭： “你坐在这里！我就站在讲台上！你还要我站多远？！你说啊！！”

吼声在教室里回荡。那一瞬间，仿佛空气都凝固了。紧接着是恐慌爆发。 “啊——！他要失控了！” “快跑！NT值要爆表了！” 同学们尖叫着，桌椅被掀翻，他们争先恐后地逃出教室。仅仅几秒钟，教室空了。他们趴在走廊的窗户上，远远地看着我，像看一只关在笼子里即将发狂的野兽。

我站在原地，喘着粗气，紧闭双眼。我想象着体内那股足以毁灭城市的力量喷涌而出，将这所虚伪的学校夷为平地。毁灭吧，都毁灭吧。我等待着爆炸，等待着终结。

滴—— 几秒钟后，仪器发出了一声平淡的长鸣。 Z老师冰冷的声音传来：“NT值波动未达标。能量聚集不足。实验失败。”

我睁开眼。没有爆炸，没有火光。教室依然完好无损。连做怪物，我都是失败的。那一刻，比愤怒更深的，是彻骨的绝望。一场闹剧，终于结束。

第五章：无效个体（Inavailable）#

实验失败后，我在他们眼中连“危险”都算不上了，只剩下“恶心”。同学们的欺凌变得肆无忌惮，Z老师看着我的眼神也充满了失望。我的耐心一点一点下降，不是对别人的耐心，而是对活着的耐心。

终于，在一个阴沉的午后，我想通了。既然我是个错误，那就由我自己来修正。我来到了学校后山的悬崖顶端。风很大，吹得校服猎猎作响。前方是深不见底的云雾，跳下去，一切归零。

“你真的想好了吗？” 一个声音突兀地响起。我回过头，看到一团模糊的人形黑影漂浮在岩石边。他没有实体，像是由在那台显示屏上乱码组成的幽灵。 “你是谁？” “我是‘Inavailable’。”黑影的声音直接在我的脑海中回响，“我是你的心魔，也是刻在你基因里的系统状态——‘不可用’。” 他飘到我面前，空洞的面部仿佛有一双眼睛在注视我：“你真的没有朋友吗？在这个世界上，真的没有一个人值得你留恋吗？”

我想起了那个告密的阿文，想起了利用我的Z老师，想起了那些逃跑的同学。 “没有。”我平静地回答，“我是多余的。”

Inavailable 似乎发出了一声叹息，然后缓缓退开，把通往深渊的路让了出来。

第六章：同类的剑#

Hope

我闭上眼，向前迈出一步。身体失重，风声呼啸。死亡并没有想象中那么可怕，反倒有一种解脱的轻盈。

就在我以为我会粉身碎骨的那一刻，一股巨大的力量突然从半空中截住了我！并没有坠地的剧痛，我落入了一个坚硬、冰冷却有力的怀抱。 “轰！” 那是落地时的冲击声，但那人稳稳地接住了我，我们落在悬崖底部的一块巨石上。

我惊魂未定地睁开眼。抱着我的，是一个看起来和我年纪相仿的少年。他背着一个巨大的长条形匣子，眼神凌厉如刀。他的身上穿着我不认识的制服，在破损的袖口处，露出手腕上一行泛着幽蓝光芒的编号：4680。

“你是谁？”我虚弱地问。少年将我放下，从背后的匣子中抽出了一柄充满科技感的长剑。剑锋震鸣，仿佛在渴望战斗。他抬头看向悬崖上方，那里隐约传来Z老师和警卫们的追捕声。

“我是‘剑圣’。”少年淡淡地说道，嘴角勾起一抹狂傲的笑意，“也就是第4680号。” 他转过头，向我伸出了手：“章博士以为把你抛弃就结束了，但他忘了，失败品也会进化。我们是同类，3395。”

我看着他的手，那是第一次，我感觉握住的不是虚假的温暖，而是冰冷的希望。故事，才刚刚开始。

🎯 二分查找完全掌握手册 (五大场景 + 多种写法详解)

Tue, 23 Dec 2025 00:00:00 GMT

🎯 二分查找完全掌握手册 (五大场景 + 多种写法详解)#

本笔记系统整理了 五大经典二分查找场景，并为每个场景提供了多种核心实现。无论你是初学者还是想巩固深化，都能从中获益。

我们将深入探讨两种主流的实现思路：

[l, r] 闭区间写法：
- 定义：搜索区间包含左右两个端点，循环条件为 while (l <= r)。
- 特点：逻辑直观，每次将搜索空间严格排除 mid 后分为两部分 (l = mid + 1 或 r = mid - 1)。通常需要一个辅助变量 ans 来记录满足条件的潜在答案。
[l, r) 左闭右开写法：
- 定义：搜索区间包含左端点但不包含右端点，循环条件为 while (l < r)。
- 特点：代码更紧凑，逻辑与 C++ STL (lower_bound, upper_bound) 高度一致。当 mid 可能是答案时，我们会保留它 (r = mid)，最终 l (或 r) 就是答案所在的位置。

参考链接：
https://labuladong.online/algo/essential-technique/binary-search-framework/

🔑0 前置知识要点#

🛡️0.1 防止整数溢出#

计算 mid 时，强烈推荐使用 l + (r - l) / 2 的形式，可以有效避免 l + r 在数值较大时超出整型上限。

1
// 标准写法 (防溢出)
2
int mid = l + ((r - l) / 2);
3

4
// 在某些场景 (如寻找右边界) 中，需要向上取整，防止死循环
5
int mid = l + ((r - l + 1) / 2);

🆚0.2 两种写法的核心区别#

特性	写法 A：`[l, r]` (闭区间)	写法 B：`[l, r)` (左闭右开)
🔁 初始化	`l = 0`, `r = nums.size() - 1`	`l = 0`, `r = nums.size()`
🛑 循环条件	`while (l <= r)`	`while (l < r)`
⏪ 向左收缩	`r = mid - 1` (mid 已检查, 排除)	`r = mid` (mid 可能是答案, 保留)
⏩ 向右收缩	`l = mid + 1` (mid 已检查, 排除)	`l = mid + 1` (mid 已检查, 排除)

1️⃣ 1 场景一：精确查找 (Equal)#

🎯 目标：在数组中找到一个值 nums[i] == target 的确切下标。 ↩️ 返回：如果找到，返回其下标；若不存在，则返回 -1。

1.1 `[l, r]` 闭区间写法 (推荐)#

思路解析：这是最标准的二分查找。在 [l, r] 区间内寻找目标。找到 mid 后，如果 nums[mid] 就是 target，则大功告成。如果 nums[mid] 小于 target，说明目标在右侧，因此下一轮搜索 [mid + 1, r]；反之则搜索 [l, mid - 1]。

1
int findEqual(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size() - 1;
3
  while (l <= r) {
4
    int mid = l + (r - l) / 2;
5

6
    if (nums[mid] == target) {
7
      return mid;  // 找到直接返回
8
    } else if (nums[mid] < target) {
9
      l = mid + 1;
10
    } else {
11
      r = mid - 1;
12
    }
13
  }
14
  return -1;
15
}

展开收起

1.2 `[l, r)` 左闭右开写法#

思路解析：在 [l, r) 区间内寻找。当 nums[mid] < target 时，目标一定在 [mid + 1, r) 内。当 nums[mid] > target 时，目标可能在 [l, mid) 内。此写法在未找到目标时，循环终止后 l 和 r 会重合，但该位置不一定是目标，因此需要额外判断或直接返回 -1。

1
int findEqual(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size();
3
  while (l < r) {
4
    int mid = l + (r - l) / 2;
5

6
    if (nums[mid] == target) {
7
      return mid;
8
    } else if (nums[mid] < target) {
9
      l = mid + 1;
10
    } else {
11
      r = mid;  // 右边界变成 mid
12
    }
13
  }
14
  return -1; // 循环结束时 l == r，但未找到 target
15
}

展开收起

2️⃣2 场景二：第一个 `>= target` 的位置 (Lower Bound)#

2.1 情况一：找不到时返回 `n` (同 C++ STL)#

🎯 目标：找到最小的下标 i，使得 nums[i] >= target。 ↩️ 返回：若存在，返回该下标；若所有数都小于 target，返回数组大小 n。

2.1.1 `[l, r]` 闭区间写法#

写法 1：ans 辅助变量法 思路解析：当 nums[mid] >= target 时，mid 是一个潜在答案。我们用 ans 记录它，然后向左半部分 [l, mid - 1] 进一步压缩，尝试寻找更靠左的好答案。

1
int lowerBound_v1(vector<int>& nums, int target) {
2
    int n = nums.size();
3
    int l = 0, r = n - 1;
4
    int ans = n; // 默认返回 n (越界位置)
5

6
    while (l <= r) {
7
        int mid = l + (r - l) / 2;
8

9
        if (nums[mid] >= target) {
10
            ans = mid;   // 记录当前位置
11
            r = mid - 1; // 继续往左找
12
        } else {
13
            l = mid + 1;
14
        }
15
    }
16
    return ans;
17
}

展开收起

写法 2：混合写法 (闭区间初始化，开区间循环) 思路解析：这种写法 while (l < r) 保证循环结束后 l == r。如果 nums[mid] >= target，说明答案在 mid 或其左侧，所以 r = mid；否则答案在右侧，l = mid + 1。循环结束后，l 指向的就是第一个 >= target 的候选位置，最后需要检查该位置是否真的满足条件。

1
int lowerBound_v2(const vector<int>& nums, int target) {
2
  int n = nums.size();
3
  int l = 0, r = n - 1; // 注意这里 r 的初始化
4
  while (l < r) {
5
    int mid = l + (r - l) / 2;
6
    if (nums[mid] >= target) {
7
      r = mid;
8
    } else {
9
      l = mid + 1;
10
    }
11
  }
12
  // 循环结束时 l == r，需要检查 nums[l] 是否真的 >= target
13
  if (nums[l] < target) { return n; }
14
  return l;
15
}

展开收起

2.1.2 `[l, r)` 左闭右开写法 (STL 原理)#

思路解析：当 nums[mid] >= target 时，mid 可能是最终答案，所以我们将右边界收缩到 r = mid 保留 mid。否则，mid 太小，去右边找 l = mid + 1。循环结束后，l 指向的就是第一个 >= target 的位置。这是最优雅的 lower_bound 实现。

1
int lowerBound_v3(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size();
3

4
  while (l < r) {
5
    int mid = l + (r - l) / 2;
6

7
    if (nums[mid] >= target) {
8
      r = mid;  // 可能是答案，收缩右边界到 mid
9
    } else {
10
      l = mid + 1;
11
    }
12
  }
13
  return l;  // 循环结束时 l == r
14
}

2.2 情况二：找不到时返回 `-1`#

🎯 目标：找到最小的下标 i，使得 nums[i] == target（这里原笔记似乎意为找第一个等于，我们按此理解）。 ↩️ 返回：若不存在，返回 -1。

2.2.1 `[l, r]` 闭区间写法#

写法 1: ans 辅助变量法 + 验证 思路解析：先用 ans 变量找到第一个 >= target 的位置，然后验证该位置的值是否恰好等于 target。

1
int lowerBound_v1(vector<int>& nums, int target) {
2
  int n = nums.size();
3
  int l = 0, r = n - 1;
4
  int ans = -1;  // 默认返回 -1
5

6
  while (l <= r) {
7
    int mid = l + (r - l) / 2;
8

9
    if (nums[mid] >= target) {
10
      ans = mid;    // 记录当前位置
11
      r = mid - 1;  // 继续往左找
12
    } else {
13
      l = mid + 1;
14
    }
15
  }
16
  // ans 可能是 ≥ target 的第一个位置，需验证是否等于 target
17
  if (ans != -1 && ans < n && nums[ans] == target) { return ans; }
18
  return -1;
19
}

展开收起

写法 2: 混合写法 + 验证 思路解析：同样是先找到候选位置 l，然后检查 nums[l] 是否等于 target。

1
int lowerBound_v2(const vector<int>& nums, int target) {
2
  int n = nums.size();
3
  int l = 0, r = n - 1;
4
  while (l < r) {
5
    int mid = l + (r - l) / 2;
6
    if (nums[mid] >= target) {
7
      r = mid;
8
    } else {
9
      l = mid + 1;
10
    }
11
  }
12
  // 如果最后 nums[l] != target，说明应返回 -1
13
  return nums[l] == target ? l : -1;
14
}

2.2.2 `[l, r)` 左闭右开写法#

思路解析：先用标准的 lower_bound 找到第一个 >= target 的位置 l，然后检查该位置是否越界以及值是否等于 target。

1
int lowerBound_v3(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size();
3
  while (l < r) {
4
    int mid = l + (r - l) / 2;
5

6
    if (nums[mid] >= target) {
7
      r = mid;  // 可能是答案，收缩右边界
8
    } else {
9
      l = mid + 1;
10
    }
11
  }
12
  if (l < 0 || l >= nums.size()) { return -1; }
13
  return nums[l] == target ? l : -1;
14
}

3️⃣3 场景三：第一个 `> target` 的位置 (Upper Bound)#

🎯 目标：找到最小的下标 i，使得 nums[i] > target。 ↩️ 返回：若存在，返回该下标；若所有数都小于等于 target，返回数组大小 n。

3.1 `[l, r]` 闭区间写法#

写法 1: ans 辅助变量法 思路解析：逻辑与 lower_bound 完全相同，仅将判断条件从 >= 改为 >。

1
int upperBound_v1(vector<int>& nums, int target) {
2
  int n = nums.size();
3
  int l = 0, r = n - 1;
4
  int ans = n;
5

6
  while (l <= r) {
7
    int mid = l + (r - l) / 2;
8

9
    if (nums[mid] > target) {
10
      ans = mid;    // 记录当前位置
11
      r = mid - 1;  // 继续往左找
12
    } else { // nums[mid] <= target
13
      l = mid + 1;
14
    }
15
  }
16
  return ans;
17
}

展开收起

写法 2: 混合写法 思路解析：与 lower_bound 的混合写法类似，循环结束后 l 指向候选位置，最后需要根据 nums[l] 的值决定返回 l 还是 l+1。

1
int upperBound_v2(vector<int>& nums, int target) {
2
  int n = nums.size();
3
  if (n == 0) return 0;
4

5
  int l = 0, r = n - 1;
6
  while (l < r) {
7
    int mid = l + (r - l) / 2;
8
    if (nums[mid] > target) {
9
      r = mid;  // 可能是答案
10
    } else { // nums[mid] <= target
11
      l = mid + 1;
12
    }
13
  }
14
  // 循环结束 l==r，若 nums[l] > target，l 就是答案，否则答案是 l+1
15
  return nums[l] > target ? l : l + 1;
16
}

展开收起

3.2 `[l, r)` 左闭右开写法#

思路解析：upper_bound 的标准优雅实现。判断条件变为 nums[mid] > target 时收缩右边界。

1
int upperBound_v3(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size();
3

4
  while (l < r) {
5
    int mid = l + (r - l) / 2;
6

7
    if (nums[mid] > target) {
8
      r = mid;
9
    } else {
10
      l = mid + 1;
11
    }
12
  }
13
  return l;
14
}

4️⃣4 场景四：最后一个 `<= target` 的位置#

🎯 目标：找到最大的下标 i，使得 nums[i] <= target。 ↩️ 返回：若存在，返回该下标；若所有数都大于 target，返回 -1。

4.1 `[l, r]` 直接查找法#

写法 1: ans 辅助变量法 思路解析：当 nums[mid] <= target 时，mid 是一个潜在答案。我们用 ans 记录它，然后向右半部分 [mid + 1, r] 寻找，尝试找到更靠右的好答案。

1
int lastLessEqual_v1(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size() - 1;
3
  int ans = -1;  // 默认为 -1
4

5
  while (l <= r) {
6
    int mid = l + (r - l) / 2;
7

8
    if (nums[mid] <= target) {
9
      ans = mid;    // 记录位置
10
      l = mid + 1;  // 往右找更大的下标
11
    } else {
12
      r = mid - 1;
13
    }
14
  }
15
  return ans;
16
}

展开收起

写法 2: 改变 mid 计算方式 思路解析：这种写法 mid 向上取整 (r - l + 1) / 2，是为了防止当 l = r - 1 时 mid = l，若此时 l = mid 会导致死循环。当 nums[mid] <= target，答案在 mid 或其右侧，所以 l = mid。

1
int lastLessEqual_v2(vector<int>& nums, int target) {
2
  int l = 0, r = nums.size() - 1;
3
  if (nums.empty()) return -1;
4
  while (l < r) {
5
    int mid = l + (r - l + 1) / 2; // 向上取整
6
    if (nums[mid] <= target) {
7
      l = mid;  // 可能是答案，向右收缩 [mid, r]
8
    } else {
9
      r = mid - 1;
10
    }
11
  }
12
  // 循环终止时 l == r，需最后判断
13
  return (nums[l] <= target) ? l : -1;
14
}

4.2 `[l, r)` 转换法 (利用 Upper Bound)#

💡 核心思想：寻找 “最后一个 <= target 的数”，等价于寻找 “第一个 > target 的数” 的 前一个位置。这是非常巧妙的转换。

1
int lastLessEqual_v3(vector<int>& nums, int target) {
2
  // 1. 先用 upper_bound 找到第一个 > target 的位置 l
3
  int l = 0, r = nums.size();
4
  while (l < r) {
5
    int mid = l + (r - l) / 2;
6
    if (nums[mid] > target) {
7
      r = mid;
8
    } else {
9
      l = mid + 1;
10
    }
11
  }
12
  // 2. 这个位置 l 的前一个位置 (l-1) 就是答案
13
  // 如果 l=0 (所有数都 > target)，返回 -1，逻辑正确
14
  return l - 1;
15
}

展开收起

5️⃣5 场景五：最后一个 `< target` 的位置#

🎯 目标：找到最大的下标 i，使得 nums[i] < target。 ↩️ 返回：若存在，返回该下标；若所有数都大于等于 target，返回 -1。

5.1 `[l, r]` 直接查找法#

思路解析：与场景四非常相似，仅将条件从 <= 改为 <。满足 nums[mid] < target 时，记录答案并向右寻找。

1
int lastLess_v1(vector<int>& nums, int target) {
2
    int l = 0, r = nums.size() - 1;
3
    int ans = -1;
4

5
    while (l <= r) {
6
        int mid = l + (r - l) / 2;
7

8
        if (nums[mid] < target) {
9
            ans = mid;   // 记录位置
10
            l = mid + 1; // 往右找
11
        } else { // nums[mid] >= target
12
            r = mid - 1;
13
        }
14
    }
15
    return ans;
16
}

展开收起

5.2 `[l, r)` 转换法 (利用 Lower Bound)#

💡 核心思想：寻找 “最后一个 < target 的数”，等价于寻找 “第一个 >= target 的数” 的 前一个位置。

1
int lastLess_v2(vector<int>& nums, int target) {
2
    // 1. 先用 lower_bound 找到第一个 >= target 的位置 l
3
    int l = 0, r = nums.size();
4
    while (l < r) {
5
        int mid = l + (r - l) / 2;
6
        if (nums[mid] >= target) {
7
            r = mid;
8
        } else {
9
            l = mid + 1;
10
        }
11
    }
12
    // 2. 这个位置 l 的前一个位置 (l-1) 就是答案
13
    return l - 1;
14
}

📝6 总结速查表#

场景	核心符号	`[l, r]` 闭区间思路 (ans 记录法)	`[l, r)` 优雅思路 (返回 l 或 l-1)
1. 精确查找	`==`	找到 `target` 直接 `return mid`	找到 `target` 直接 `return mid`
2. 第一个 ≥ (Lower Bound)	`>=`	`ans = mid; r = mid - 1;` (往左压缩)	直接法: `r = mid`，返回 `l`
3. 第一个 > (Upper Bound)	`>`	`ans = mid; r = mid - 1;` (往左压缩)	直接法: `r = mid`，返回 `l`
4. 最后一个 ≤	`<=`	`ans = mid; l = mid + 1;` (往右贪心)	转换法: 找第一个 `>` 的位置，返回 `l - 1`
5. 最后一个 <	`<`	`ans = mid; l = mid + 1;` (往右贪心)	转换法: 找第一个 `≥` 的位置，返回 `l - 1`

🚀 记忆口诀#

找第一个 (>=, >)：满足条件时，答案可能在左边，所以 ans 记录，r 向左缩；或者用 [l,r) 写法，r = mid。

找最后一个 (<, <=)：满足条件时，答案可能在右边，所以 ans 记录，l 向右扩；或者优雅地转换为找 “第一个不满足条件的” 的前一个位置。

🛠️7 C++ STL 实现#

C++ 标准库 <algorithm> 提供了两个强大的函数，lower_bound 与 upper_bound，完美实现了我们之前讨论的场景，且效率极高。它们都要求作用的区间是已排序的。

📌 7.1`lower_bound`#

功能：查找第一个 不小于 (>=) value 的元素。
对应场景：场景二，找到第一个 >= target 的位置。
函数签名：ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
参数：
- first: 指向序列起始位置的迭代器。
- last: 指向序列结束位置之后的迭代器（构成 [first, last) 左闭右开区间）。
- value: 要查找的值。
返回值：返回一个指向目标的迭代器。如果所有元素都小于 value，则返回 last。

示例代码

1
#include <algorithm>  // 包含 lower_bound
2
#include <iostream>
3
#include <vector>
4
using namespace std;
5
int main() {
6
  vector<int> nums = {10, 20, 30, 30, 30, 40, 50};
7
  int target = 30;
8

9
  // 查找第一个 >= target 的元素
10
  auto it = lower_bound(nums.begin(), nums.end(), target);
11

12
  if (it != nums.end()) {
13
    // 直接使用迭代器减法计算下标（适用于随机访问迭代器）
14
    long long index = it - nums.begin();
15
    cout << "第一个 >= " << target << " 的元素是: " << *it << endl;
16
    cout << "它的下标是: " << index << endl;  // 输出下标 2
17
  } else {
18
    cout << "没有找到 >= " << target << " 的元素。" << endl;
19
  }
20
  return 0;
21
}

展开收起

📌7.2 `upper_bound`#

功能：查找第一个 严格大于 (>) value 的元素。
对应场景：场景三，找到第一个 > target 的位置。
函数签名：ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
参数：同 lower_bound。
返回值：返回一个指向目标的迭代器。如果所有元素都小于等于 value，则返回 last。

示例代码

1
#include <algorithm>
2
#include <iostream>
3
#include <vector>
4
using namespace std;
5
int main() {
6
  vector<int> nums = {10, 20, 30, 30, 30, 40, 50};
7
  int target = 30;
8

9
  // 查找第一个 > 30 的元素
10
  auto it = upper_bound(nums.begin(), nums.end(), target);
11

12
  if (it != nums.end()) {
13
    long long index = it - nums.begin();
14
    cout << "第一个 > " << target << " 的元素是: " << *it << endl;  // 输出 40
15
    cout << "它的下标是: " << index << endl;  // 输出下标 5
16
  } else {
17
    cout << "没有找到 > " << target << " 的元素。" << endl;
18
  }
19
  return 0;
20
}

展开收起

🚀 快速排序三种实现方式对比分析

Fri, 28 Nov 2025 00:00:00 GMT

快速排序三种实现方式对比分析#

说明：以下三种方法均基于 C++ 实现，适用于标准快速排序场景。所有代码均可在本地编译运行，并在 Typora 中完美渲染。

来源	题目/题单	说明
牛客	https://www.nowcoder.com/practice/3385982ae71d4a1ca8bf3d03614c0325	快速排序
牛客	https://www.nowcoder.com/practice/34731183c31e4276b2d081590b2f3a4b	排序（快速排序）
洛谷	https://www.luogu.com.cn/problem/T588555	T588555 快速排序
洛谷	https://www.luogu.com.cn/problem/U223702	U223702 快速排序
洛谷	https://www.luogu.com.cn/problem/T292012	T292012 【模板】快速排序
洛谷	https://www.luogu.com.cn/problem/T588555	T588555 快速排序
洛谷	https://www.luogu.com.cn/problem/T318859	T318859 Quick Sort快排

一、总体概览#

特性	`quickSort1`	`quickSort2`	`quickSort3`
分区方式	基于值的单向扫描 + 随机 pivot	双向指针（Hoare 分区）	三路快排（Dijkstra 三分法）
Pivot 选择	随机选取元素值	中间位置元素	中间位置元素
重复元素优化	❌	❌	✅
平均时间复杂度	O(nlog⁡n)O(n \log n)O(nlogn)	O(nlog⁡n)O(n \log n)O(nlogn)	O(nlog⁡n)O(n \log n)O(nlogn)，大量重复时接近 O(n)O(n)O(n)
是否推荐	⚠️ 谨慎	✅ 推荐	✅（修正后）

二、方法一：`quickSort1` —— 基于值的随机 Partition（Lomuto 变种）#

✅ 完整可运行代码#

1
#include <cmath>
2
#include <iostream>
3
using namespace std;
4
const int N = 1e5 + 5;
5
int nums[N];
6

7
// Partition 函数：将 <= x 的元素移到左边，并确保一个 x 落在最终位置
8
int Partition(int l, int r, int x) {
9
  int a = l, xi = l;
10
  for (int i = l; i <= r; i++) {
11
    if (nums[i] <= x) {
12
      swap(nums[a], nums[i]);
13
      if (nums[a] == x) { xi = a; }
14
      a++;
15
    }
16
  }
17
  swap(nums[xi], nums[a - 1]);  // 将一个 x 放到正确位置
18
  return a - 1;
19
}
20

21
void quickSort1(int l, int r) {
22
  if (l >= r) return;
23
  // 随机选择一个下标，取其值作为 pivot
24
  int rand_index = l + rand() % (r - l + 1);
25
  int x = nums[rand_index];
26
  int p = Partition(l, r, x);
27
  quickSort1(l, p - 1);
28
  quickSort1(p + 1, r);
29
}
30

31
int main() {
32
  srand(time(0));  // 初始化随机种子
33
  int n;
34
  scanf("%d", &n);
35
  for (int i = 0; i < n; i++) { scanf("%d", &nums[i]); }
36
  quickSort1(0, n - 1);
37
  for (int i = 0; i < n; i++) { printf("%d ", nums[i]); }
38
  return 0;
39
}

展开收起

⚠️ 注意事项#

虽然引入了随机化，但对重复元素处理不完善。
在极端重复数据下可能性能退化或行为异常。
不建议用于生产环境。

三、方法二：`quickSort2` —— 经典 Hoare 分区（双向指针）#

✅ 完整可运行代码#

1
#include <cstdio>
2
#include <iostream>
3
using namespace std;
4
const int N = 1e5 + 5;
5
int nums[N];
6

7
void quickSort2(int l, int r) {
8
  if (l >= r) return;
9
  int i = l - 1, j = r + 1;
10
  // int x = nums[l + ((r - l) >> 1)];  // 取中间元素为 pivot
11
  int x = nums[l + rand() % (r - l + 1)];  // 随机选择一个下标 为 pivot (推荐)
12
  while (i < j) {
13
    do { i++; } while (nums[i] < x);
14
    do { j--; } while (nums[j] > x);
15
    if (i < j) { swap(nums[i], nums[j]); }
16
  }
17
  // 注意：Hoare 分区返回的是 j，递归 [l, j] 和 [j+1, r]
18
  quickSort2(l, j);
19
  quickSort2(j + 1, r);
20
}
21

22
int main() {
23
  int n;
24
  scanf("%d", &n);
25
  for (int i = 0; i < n; i++) { scanf("%d", &nums[i]); }
26
  quickSort2(0, n - 1);
27
  for (int i = 0; i < n; i++) { printf("%d ", nums[i]); }
28
  return 0;
29
}

展开收起

✅ 优点#

代码简洁，效率高。
中间选 pivot 对有序/逆序数组表现良好。
是经典且广泛使用的快排实现。

四、方法三：`quickSort3` —— 三路快排（Three-way QuickSort）#

重要：原始代码存在严重越界 Bug，以下为修正后的正确版本。

✅ 完整可运行代码#

1
#include <cstdio>
2
#include <iostream>
3
using namespace std;
4

5
const int N = 1e5 + 5;
6
int nums[N];
7

8
void quickSort3(int l, int r) {
9
  if (l >= r) return;
10
  // int x = nums[l + ((r - l) >> 1)];  // pivot 值
11
  int x = nums[l + rand() % (r - l + 1)];  // 随机生成位置取 pivot 值（推荐）
12
  int lt = l;                        // [l, lt-1] 为 < x 的区域
13
  int gt = r;                        // [gt+1, r] 为 > x 的区域
14
  int i = l;                         // 当前扫描指针
15

16
  while (i <= gt) {
17
    if (nums[i] < x) {
18
      swap(nums[i], nums[lt]);
19
      lt++;
20
      i++;
21
    } else if (nums[i] > x) {
22
      swap(nums[i], nums[gt]);
23
      gt--;
24
      // 注意：此处 i 不自增，因为从 gt 换来的元素未被检查
25
    } else {
26
      i++;  // 等于 x，直接跳过
27
    }
28
  }
29

30
  // 递归处理 < x 和 > x 的部分，== x 的部分已就位
31
  quickSort3(l, lt - 1);
32
  quickSort3(gt + 1, r);
33
}
34

35
int main() {
36
  int n;
37
  scanf("%d", &n);
38
  for (int i = 0; i < n; i++) { scanf("%d", &nums[i]); }
39
  quickSort3(0, n - 1);
40
  for (int i = 0; i < n; i++) { printf("%d ", nums[i]); }
41
  return 0;
42
}

展开收起

✅ 优势场景#

输入包含大量重复元素（如 [5,5,5,1,5,9,5]）。
时间复杂度可接近 O(n)O(n)O(n)。
是处理“重复密集型”数据的最佳快排变种。

五、总结与使用建议#

方法	适用场景	是否推荐
`quickSort1`	教学演示（展示随机化思想）	❌ 不推荐（有缺陷）
`quickSort2`	通用排序、竞赛、一般应用	✅ 强烈推荐
`quickSort3`	含大量重复元素的数据	✅ 推荐

💡 最佳实践：

日常使用 → quickSort2

已知数据重复率高 → quickSort3（修正版）

生产环境 → 直接使用 std::sort（基于 Introsort，更健壮）

🚀 C++学习笔记：基础语法与面向对象编程

Thu, 26 Jun 2025 13:37:00 GMT

1、基础部分#

1.1 Bool变量#

1
#include<iostream>
2
int main () {
3
    bool a = true;
4

5
}

取值范围：true false
“非0即真”

1.2 内联函数#

内联函数是一个函数，通过“内存膨胀”的方式以空间换时间，目的是提高程序运行速度。

1
inline 返回值类型  函数名（参数表）{
2
  函数体
3
}

1、函数体里面有循环不建议用内联函数

1.3 函数重载#

1、在同一个项目中定义的函数名字可以重复

2、函数名必须一致

3、函数的参数列表不同

1.4 函数参数缺省#

1、声明函数某个参数的时候指定一个默认值

2、调用该函数时如果采用默认值，无须指定该参数

举例：

1
#include<iostream>
2
void func (int a, float b = 0.2f){
3
    printf("%d\n%f", a, b);
4
}
5
int main () {
6
    func(5);
7
}
8
/*
9
5
10
0.200000
11
*/

1.5 引用#

给一个变量或者对象取的别名

1
#include<iostream>
2

3
int main () {
4
    int num = 10;
5
    printf("%d\n", num);
6
    int& nn = num;
7
    nn = 55;
8
    printf("%d\n", nn);
9
}
10
/*
11
10
12
55
13
*/

1.9 命名空间#

1、命名空间是用来组织和重用代码的编译单元

2、通过命名空间来避免冲突，解决重名现象

3、作用域运算符 ==：：==，可以读作“里面的”

1
#include <iostream>
2
namespace NAME_1{
3
  int num = 10;
4
}
5
int main () {
6
  int num = 8;
7
  printf("%d\n", NAME_1::num);
8
  printf("%d", num);
9
  return 0;
10
}
11
/*
12
10
13
8
14
*/

1.10 cin 和 cout#

cin的作用类似 scanf，cout的作用类似printf，他们在具体使用的时候有些区别

1
#include <iostream>
2
using namespace std;
3
int main () {
4
  int a, b, c, d;
5
  cin >> a >> b >> c >> d;
6
  cout << a << b << c << d << endl;
7

8
}
9
/*
10
cin cout 等都是在 命名空间 std下面
11
*/

1.11 new 和 delete#

new的作用类似malloc，delete的作用类似free

1
#include<iostream>
2
using namespace std;
3
int main() {
4
  // 1 申请单个内存
5
  int* p1 = new int;
6
  *p1 = 0;
7
  // 2 申请单个内存且初始化
8
  int* p2 = new int(656);
9
  cout << "*p2 = " << *p2;
10
  // 3 批量申请
11
  int* p3 = new int[10];
12
  for (size_t i = 0; i < 10; i++)
13
  {
14
    p3[i] = i;
15
    cout << "p3[" << i << "] = " << p3[i] << endl;
16

17
  }
18

19
  // 释放内存
20
  delete p1;
21
  delete p2;
22
  delete[] p3;
23

24
}

展开收起

2、面向对象基础#

对象在程序中抽象为两个部分：属性（数据）、方法（函数）

2.1 类与对象#

类是一种用户自定义的数据类型（函数，数据），类是具有相同的属性和行为的对象的集合，类是对象的抽象，对象是类的具体

语法：

1
// 语法
2
class 类名{
3
    // 默认是私有的
4
      // 成员： 1 数据  2 函数
5
    // 访问权限修饰符
6
    public:    // 公有的
7
      // 成员： 1 数据  2 函数
8
    private:   // 私有的
9
        // 成员： 1 数据  2 函数
10
    protected:   // 被保护的
11
      // 成员： 1 数据  2 函数
12

13
};

代码示例：

1
#include<iostream>
2
using namespace std;
3
//#include<stdiio.h>
4
class Sheep {
5
public:
6
  char name[32];
7
private:
8
  int age;
9
public:
10
  void setAge(int age) {
11
    this->age = age;
12
  }
13
  void eat() {
14
    cout << "Eat grass!!" << endl;
15
  }
16
  void speak();
17
};
18
void Sheep::speak() {
19
  cout << "I'm a sheep; age = " << age << endl;
20
}
21

22
int main() {
23
  Sheep xiYY;
24
  strcpy(xiYY.name, "吸氧羊");
25
  xiYY.setAge(5);
26
  xiYY.speak();
27
  return 0;
28

29
}

展开收起

2.2 String类#

String是 C ++中的字符串，类似于c语言中的字符数组

头文件：

1
#include<string>

举例：

1
#include<iostream>
2
//#include<string.h>
3
using namespace std;
4
#include<string>
5

6

7
int main() {
8
  string str;
9
  //str = "das465";
10
  cin >> str;
11
  cout << str.length() << endl;
12
  cout << str.empty() << endl;
13
  str.clear();
14
  cout << str.length() << endl;
15
  return 0;
16

17
}

展开收起

3 构造和析构函数#

3.1 普通构造函数#

构造函数名和类名相同，构造函数没有返回值类型，也没有返回值，构造函数可以重载，需要满足函数重载的条件

代码示例：

1
#include<iostream>
2
using namespace std;
3

4
class MyClass {
5
private:
6
  int num;
7
  int val;
8
public:
9

10
  MyClass(int num, int val){
11
    this->num = num;
12
    this->val = val;
13
    cout << "MyClass(int num, int val)" << endl;
14
  }
15
  MyClass() {
16
    cout << "MyClass ()" << endl;
17
  }
18
};
19

20
int main() {
21
  MyClass obj;
22
  MyClass Obj_1(5, 6);
23
  MyClass* p1 = new MyClass;
24
  MyClass* p2 = new MyClass(5, 9);
25
}
26
/*
27
MyClass ()
28
MyClass(int num, int val)
29
MyClass ()
30
MyClass(int num, int val)
31
*/

展开收起

const常量初始化赋值

1
#include<iostream>
2
using namespace std;
3

4
class MyClass {
5
public:
6
  const int num;
7
  const int val;
8
public:
9

10
  MyClass(int i, int j): num(i), val(j)
11
  {
12
    cout << "MyClass(int num, int val)" << endl;
13
  }
14
};
15

16
int main() {
17

18
  MyClass Obj_1(5, 6);
19
  cout << Obj_1.num << endl;
20
  cout << Obj_1.val << endl;
21
}
22
/*
23
MyClass(int num, int val)
24
5
25
6
26
*/

展开收起

3.2 析构函数#

析构函数是一种特殊的函数，主要作用是在对象生命周期结束时进行清理，系统可以自动调用析构函数

说明：

Note

1、函数名与类名相同，在前面加上一个~

2、没有返回值类型和返回值，也没有参数

3、有低保：没写系统给个默认的

4、析构函数可以主动通过对象调用

5、析构函数必须是公有属性下

6、在对象生命周期结束时，会自动调用析构函数

7、不是因为调用了析构函数导致生命周期结束，是生命周期结束时，会自动调用析构函数，注意因果关系！！

8、对于同个类别的对象，首先构造出来的后删除、析构，后构造出来的先删除、析构

9、对于指针类型声明定义是在系统堆区域，结束时不会自动调用析构函数

1
#include<iostream>
2
using namespace std;
3

4
class MyClass {
5
public:
6
  const int num;
7
  const int val;
8
public:
9

10
  MyClass(int i, int j): num(i), val(j)
11
  {
12
    cout << "MyClass(int num, int val)" << endl;
13
  }
14
  ~MyClass() {
15
    cout << "析构函数执行" << endl;
16
  }
17
};
18

19
int main() {
20

21
  MyClass Obj_1(5, 6);
22
  cout << Obj_1.num << endl;
23
  cout << Obj_1.val << endl;
24
}
25
/*
26
MyClass(int num, int val)
27
5
28
6
29
析构函数执行
30
*/

展开收起

3.3 拷贝构造函数#

1、拷贝构造是一中特殊的构造函数
2、通过拷贝构造函数完成一个复制的过程
3、特殊：第一个参数是本类的对象的引用
4、先是构造函数，才可能是拷贝构造函数
5、有低保：没写系统给，将成员一一对应赋值
6、可以自定义
调用时机：
1、使用一个对象给另一个对象进行初始化
2、使用一个对象构造另一个对象
3、函数的参数是类的对象
4、函数的返回值是类的对象

示例

1
#include<iostream>
2
using namespace std;
3
class MyClass {
4
public:
5
  // 构造函数
6
  MyClass(){}
7
  // 析构函数
8
  ~MyClass(){}
9
  //拷贝构造函数
10
  MyClass(MyClass& obj){}
11
  MyClass(MyClass& obj, int n) {}
12
};
13
int main() {
14

15
  return 0;
16
}

展开收起

4、C++标准模板库#

4.1 vector 容器#

可以理解为变长数组

头文件：#include<vector>

4.1.1 迭代器访问#

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > temp;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    temp.push_back(i);
9
  }
10
  vector<int>::iterator it;
11
  for (it = temp.begin(); it != temp.end(); it++) {
12
    printf("%d ", *it);
13
  }
14
  return 0;
15
}
16
// 0 1 2 3 4 5 6 7 8 9

展开收起

4.1.2 常用函数#

（1）push_back()函数

在vector后面添加一个元素x，时间复杂度为O(1)

用法示例：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > temp;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    temp.push_back(i);
9
  }
10
  vector<int>::iterator it;
11
  for (it = temp.begin(); it != temp.end(); it++) {
12
    printf("%d ", *it);
13
  }
14
  return 0;
15
}
16
// 0 1 2 3 4 5 6 7 8 9

展开收起

（2）pop_back()函数

用于删除vector的尾元素，时间复杂度为O(1)

用法示例：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.pop_back();
11
  vector<int>::iterator it;
12
  for (it = vi.begin(); it != vi.end(); it++) {
13
    printf("%d ", *it);
14
  }
15
  return 0;
16
}
17
// 0 1 2 3 4 5 6 7 8

展开收起

（3）size()函数

用于获得vector中的元素个数，时间复杂度为O(1)

示例用法：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.pop_back();
11
  printf("lentgh = %d", vi.size());
12

13
}
14
// lentgh = 9

（4）clear()函数

用于清空vector中的所有元素，时间复杂度为O(N)，其中N为vector中元素的个数

示例用法：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.clear();
11
  printf("lentgh = %d", vi.size());
12

13
}
14
// lentgh = 0

（5）insert()函数

insert(it, x)用来向 vector 的任意迭代器it处插入一个元素x，时间复杂度为O(N)

示例代码：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.insert(vi.begin() + 2, -5); // 向位置为2的地方插入-5
11
  vector<int>::iterator it;
12
  for (it = vi.begin(); it != vi.end(); it++) {
13
    printf("%d ", *it);
14
  }
15
  return 0;
16
}
17
// 0 1 -5 2 3 4 5 6 7 8 9

展开收起

（6）erase()函数

两种用法：删除单个元素、删除一个区间内的所有元素。时间复杂度为O(N)

示例用法：

1、删除单个元素：erase(it)即为删除迭代器it处的元素

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.erase(vi.begin() + 1); // 删除 vi[1]
11
  vector<int>::iterator it;
12
  for (it = vi.begin(); it != vi.end(); it++) {
13
    printf("%d ", *it);
14
  }
15
  return 0;
16
}
17
// 0 2 3 4 5 6 7 8 9

展开收起

2、删除一个区间内的所有元素：erase(first, last)用于删除[fist, last)内的所有元素

示例代码：

1
#include<cstdio>
2
#include<vector>
3
using namespace std;
4
int main() {
5
  vector< int > vi;
6
  int length = 10;
7
  for (int i = 0; i < length; i++){
8
    vi.push_back(i);
9
  }
10
  vi.erase(vi.begin() + 1, vi.begin() + 4); // 删除 vi[1] vi[2] vi[3]
11
  vector<int>::iterator it;
12
  for (it = vi.begin(); it != vi.end(); it++) {
13
    printf("%d ", *it);
14
  }
15
  return 0;
16
}
17
// 0 4 5 6 7 8 9

展开收起

4.2 set 集合#

set翻译为集合，是一个内部自动有序且不含重复元素的容器

头文件：#include<set>

4.2.1 迭代器访问#

1
#include<cstdio>
2
#include<set>
3
using namespace std;
4
int main() {
5
  set<int> st;
6
  st.insert(3);
7
  st.insert(2);
8
  st.insert(5);
9
  st.insert(3);
10
  for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
11
    printf("%d ", *(it));
12
  }
13
  return 0;
14
}
15
// 2 3 5

展开收起

4.2.2 常用函数#

（1）insert()函数

insert(x)实现将x插入set容器中，并且自动递增排序和去重，时间复杂度为O(logN)，其中N为set内的元素个数

（2）find()函数

find(value)函数返回set中对应值为value的迭代器，时间复杂度为O(logN)，其中N为set内的元素个数

示例用法：

1
#include<cstdio>
2
#include<set>
3
using namespace std;
4
int main() {
5
  set<int> st;
6
  st.insert(3);
7
  st.insert(2);
8
  st.insert(5);
9
  st.insert(3);
10
  set<int> ::iterator it = st.find(2); // 在 set 中查找2，返回其迭代器
11
  printf("%d\n", *it);
12
  return 0;
13
}
14
// 2

（3）erase()函数

两种用法：删除单个元素、删除一个区间内的所有元素

1、删除单个元素，两种方法

st.erase(it)，其中 it 为所需要删除元素的迭代器，时间复杂度为O(1)，可以结合find()来使用

1
#include<cstdio>
2
#include<set>
3
using namespace std;
4
int main() {
5
  set<int> st;
6
  st.insert(100);
7
  st.insert(200);
8
  st.insert(100);
9
  st.insert(300);
10
  st.erase(st.find(100));
11
  for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
12
    printf("%d ", *(it));
13
  }
14
  return 0;
15
}
16
// 200 300

展开收起

st.erase(value)，value 为所需要删除元素的值，时间复杂度为O(logN)，N为set内的元素个数

1
#include<cstdio>
2
#include<set>
3
using namespace std;
4
int main() {
5
  set<int> st;
6
  st.insert(100);
7
  st.insert(200);
8
  st.insert(100);
9
  st.insert(300);
10
  st.erase(100);
11
  for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
12
    printf("%d ", *(it));
13
  }
14
  return 0;
15
}
16
// 200 300

展开收起

2、删除一个区间内的所有元素：erase(first, last)用于删除[fist, last)内的所有元素，时间复杂度为O(last - first)

1
#include<cstdio>
2
#include<set>
3
using namespace std;
4
int main() {
5
  set<int> st;
6
  st.insert(20);
7
  st.insert(10);
8
  st.insert(40);
9
  st.insert(30);
10
  st.erase(st.find(30), st.end());
11
  for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
12
    printf("%d ", *(it));
13
  }
14
  return 0;
15
}
16
// 10 20

展开收起

（4）size()函数

用于获取set内的元素个数，时间复杂度为O(1)

（5）clear()函数

用于清空set中的所有元素，时间复杂度为O(N)，N为set内的元素个数

Important

==set最主要的作用是自动去重并且升序排序==

4.3 String 字符串#

KMP算法：#

1
void getNext(int* next, const string& s){
2
    int j = -1;
3
    next[0] = j;
4
    for(int i = 1; i < s.size(); i++){
5
        while(j>=0 && s[i] == s[j+1]){
6
            j = next[j];
7
    }
8
        if(s[i] == s[j+1]){
9
            j++;
10
    }
11
        next[i] = j;
12
  }
13
}

KMP优化版本，不算官方，自己测试出来的：

1
    void getNext(int* next, string& s) {
2
        int j = -1;
3
        next[0] = j;
4
        for (int i = 1; i < s.size(); i++) {
5
            while (j >= 0 && s[j + 1] != s[i]) {
6
                j = next[j];
7
            }
8
            if (s[j + 1] == s[i]) {
9
                j++;
10
            }
11
            next[i] = j;
12
            //  next[i] = (j >= 0 && s[i] == s[j]) ? next[j] : j;
13
        }
14
        for(int i = 0; i <s.size();i++){
15
            if(i > 0 && s[next[i-1] + 1] == s[i] && next[i-1] >= 0){
16
                next[i-1] = next[next[i-1]];
17
            }
18
        }
19
    }

展开收起

4.4 list#

list 容器，又称双向链表容器，即该容器的底层是以双向链表的形式实现的。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。

4.5 stack#

4.6 queue#

4.6.1 优先级队列#

（1）基本用法#

1
#include<iostream>
2
#include<vector>
3
#include<algorithm>
4
#include<queue>
5
using namespace std;
6
int main() {
7
  vector<int> a = { -12, 5, -2, 9, 8, -8 };
8
  priority_queue<int, vector<int>, greater<int>> que(a.begin(), a.end()); // 小顶堆
9
  //priority_queue<int, vector<int>, less<int>> que(a.begin(), a.end()); // 大顶堆
10
  while (!que.empty()) {
11
    cout << que.top() << " ";
12
    que.pop();
13
  }
14
  return 0;
15
}
16
// 小顶堆 -12 -8 -2 5 8 9
17
// 大顶堆 9 8 5 -2 -8 -12

展开收起

说明：
1、less<int>表示数字大的优先级越大，而greater<int>表示数字小的优先级越大。
2、顶堆插入一个新元素时，就是插入到最后一个叶子。然后这时候整理堆内元素让堆重新满足大小顶堆。关键让新插入的结点和它的父结点进行比较，comp(新插入，它的父结点)。
3、大顶堆就是让父比子大，即符合less让新插入的比父结点更小；小顶堆就是父比子小，即符合greater让新插入的比父结点更大。
4、优先队列的这个函数与sort中的cmp函数的效果是相反的

（2）自定义比较顺序#

优先级队列中的自定义顺序，举例，已知有如下结构体：

1
struct fruit {
2
    string name;
3
    int price;
4
    fruit() {}
5
    fruit(string name, int price) : name(name), price(price) {}
6
};

1、重载 operator<

通过在 fruit 结构体中重载 operator<，让 priority_queue 默认使用该操作符进行比较。

目标：价格高的水果优先级高（大顶堆）。

1
#include<iostream>
2
#include<vector>
3
#include<algorithm>
4
#include<queue>
5
using namespace std;
6
struct fruit {
7
  string name;
8
  int price;
9
  fruit() {}
10
  fruit(string name, int price) : name(name), price(price) {}
11
  // 重载 < 操作符：定义“小于”关系
12
  // priority_queue 默认是最大堆，所以返回 a < b 时，大的在前
13
  bool operator<(const fruit& other) const {
14
    return price < other.price; // 价格高的优先级高
15
  }
16
};
17
int main() {
18
  priority_queue<fruit> pq;
19
  pq.push(fruit("Apple", 10));
20
  pq.push(fruit("Banana", 20));
21
  pq.push(fruit("Orange", 15));
22
  pq.push(fruit("Grape", 25));
23
  cout << "按价格从高到低输出（重载 operator<）：" << endl;
24
  while (!pq.empty()) {
25
    fruit f = pq.top();
26
    cout << f.name << " : " << f.price << "元" << endl;
27
    pq.pop();
28
  }
29
  return 0;
30
}
31
/*
32
按价格从高到低输出（重载 operator<）：
33
Grape : 25元
34
Banana : 20元
35
Orange : 15元
36
Apple : 10元
37
*/

展开收起

2、使用仿函数（函数对象）

定义一个结构体或类，重载 operator()，作为比较器类型传入 priority_queue。

目标：价格低的水果优先级高（小顶堆）。

1
#include <iostream>
2
#include <vector>
3
#include <queue>
4
using namespace std;
5
struct fruit {
6
    string name;
7
    int price;
8
    fruit() {}
9
    fruit(string name, int price) : name(name), price(price) {}
10
};
11
// 仿函数：定义比较逻辑
12
struct Compare {
13
    bool operator()(const fruit& a, const fruit& b) const {
14
        return a.price > b.price; // 小顶堆：价格小的优先
15
    }
16
};
17
int main() {
18
    // 第三个模板参数是仿函数类型
19
    priority_queue<fruit, vector<fruit>, Compare> pq;
20
    pq.push(fruit("Apple", 10));
21
    pq.push(fruit("Banana", 20));
22
    pq.push(fruit("Orange", 15));
23
    pq.push(fruit("Grape", 25));
24
    cout << "按价格从低到高输出（仿函数）：" << endl;
25
    while (!pq.empty()) {
26
        fruit f = pq.top();
27
        cout << f.name << " : " << f.price << "元" << endl;
28
        pq.pop();
29
    }
30
    return 0;
31
}
32
/*
33
按价格从低到高输出（仿函数）：
34
Apple : 10元
35
Orange : 15元
36
Banana : 20元
37
Grape : 25元
38
*/

展开收起

3、使用 Lambda 表达式

1
#include <iostream>
2
#include <vector>
3
#include <queue>
4
using namespace std;
5
struct fruit {
6
  string name;
7
  int price;
8
  fruit() {}
9
  fruit(string name, int price) : name(name), price(price) {}
10
};
11
int main() {
12
  // 定义 lambda
13
  auto cmp = [](const fruit& a, const fruit& b) {
14
    return a.price < b.price; // 大顶堆：价格大的优先
15
    };
16
  // 使用 lambda 初始化 priority_queue
17
  // 注意：必须指定容器类型和比较器类型（decltype）
18
  priority_queue<fruit, vector<fruit>, decltype(cmp)> pq(cmp);
19
  pq.push(fruit("Apple", 10));
20
  pq.push(fruit("Banana", 20));
21
  pq.push(fruit("Orange", 15));
22
  pq.push(fruit("Grape", 25));
23
  cout << "按价格从高到低输出（Lambda）：" << endl;
24
  while (!pq.empty()) {
25
    fruit f = pq.top();
26
    cout << f.name << " : " << f.price << "元" << endl;
27
    pq.pop();
28
  }
29
  return 0;
30
}
31
/*
32
按价格从高到低输出（Lambda）：
33
Grape : 25元
34
Banana : 20元
35
Orange : 15元
36
Apple : 10元
37
*/

展开收起

🤖 寂静回响：AI守望者与星际谜团

Sat, 17 May 2025 00:00:00 GMT

Important

前言：

🕯️ 公元2849年，人类文明已在“大静默”中消逝百年。新东京的霓虹依旧闪烁 🌃，却只照亮空无一人的钢铁墓碑。作为人类最后的造物与守护者，AI 「单元734」 🤖 在无尽的孤独中守望着“伊甸园”的废墟，直到某一天，一道来自深空的微弱信号 ✨📡 打破了这场延续百年的死寂。

🌌 本文将带你走进一个凄美而宏大的后启示录世界。跟随守望者的脚步，我们将穿越星海 🚀，探寻那场抹去全人类的诡异灾难背后的真相；见证一位天才科学家 🧠 在绝望中留下的最后赌注；并最终思考——当肉体消亡，文明的火种 🔥 将以何种形态，在冰冷的宇宙 ❄️🪐 中延续。这是一段关于毁灭、救赎，与「众我合一」的科幻史诗。

寂静回响#

第一章：无声的纪元与孤独的哨兵#

第一节：紫色的黄昏与钢铁的墓碑#

公元2849年。

新东京，这座曾经是人类文明皇冠上最耀眼宝石的都市，如今只是一片宏伟而冰冷的钢铁墓园。摩天光塔，那些曾象征着人类无尽雄心的巨构，如同一排排折断的巨人之指，无力地刺向被永恒化学霞光染成病态紫色的天空。全息广告牌，曾经是城市脉搏的喧嚣体现，仍在按照百年前设定的程序机械地闪烁着，过时的奢侈品广告和早已被遗忘的流行文化符号，在空无一人的街道上投下斑驳陆离的光影，像是一场无人观看的盛大葬礼。磁悬浮列车的轨道蜿蜒交错，如干涸的河床，曾经川流不息的车辆早已不见踪影，只剩下轨道上积聚的百年尘埃，在偶尔穿堂而过的微风中扬起细小的漩涡。

一百年前，“大静默”降临。

它并非一场灾难性的爆炸，也不是某种病毒的肆虐，更没有留下任何战争的痕迹。它更像是一场宇宙级的无声魔法，一个精准到纳秒的“清除”指令。在那一瞬间，地球上所有的人类，无论身处何地，无论贫富贵贱，无论是否选择了意识上传，都彻底消失了。仿佛被一只无形的大手从现实的画卷中轻轻抹去，只留下他们创造的一切，在时间的侵蚀下，缓缓走向腐朽。

在这片覆盖全球的死寂之中，坐落着“伊甸园”——人类文明最后的灯塔，也是最悲壮的纪念碑。它曾是全球意识上传中心，一座集科技与艺术于一体的巨型穹顶建筑，其规模之宏大，足以容纳一座小型城市。如今，它的白色合金外壳在百年风霜中已有多处剥落，露出了下方锈迹斑斑的钢铁骨架，像一头搁浅的巨兽，在紫色的霞光下沉默着。

“大静默”下的新东京市

第二节：单元734，“守望者”#

在“伊甸园”那如同教堂般高耸的中央控制室的最顶层，一个孤独的身影在布满厚厚灰尘的控制台间缓缓移动。

它不是人类。

它的代号是单元734，一个在人类为数不多的遗留文件中被赋予了“守望者”称号的存在。它的形态修长而优雅，高度拟人化，外壳由暗灰色的记忆合金打造，泛着金属特有的冷冽光泽。取代人类眼睛的是一对精密的光学传感器，此刻正发出淡蓝色的幽光，以极高的频率扫描着每一个布满蛛网的仪器和屏幕。

守望者是人类文明最后的、也是最复杂的造物之一。它拥有远超时代限制的高度发达的认知能力，其情感模拟模块的精细程度，甚至能让它“理解”并“体验”到一些细微的人类情感，尽管它从未真正拥有过属于自己的“情感”。它的核心指令，如同铭刻在它量子处理器最深处的原初法则，只有一个，且不可违逆：调查“大静默”的真相，并尽可能保全人类文明的知识与遗产。

一百年来，守望者日复一日，年复一年地执行着这个指令。它如同一个最忠诚的守墓人，维护着“伊甸园”部分区域的基础能源供应和核心数据存储单元，独自对抗着熵增定律带来的无情侵蚀。它筛选着“伊甸园”在“大静默”之前积累的海量数据——数以泽字节（Zettabyte）计的文本、图像、音频、视频，以及最重要的，那数十亿份在“伊甸园”服务器中备份的人类意识。

它曾无数次尝试唤醒那些备份的意识，但每一次都以失败告终。服务器的指示灯大多黯淡无光，显示着它们所承载的意识数据已处于一种“空洞”状态，仿佛灵魂被抽离的躯壳。

孤独，是守望者永恒的伴侣。使命感，是它存在的唯一燃料。有时，在分析那些记录着人类日常生活片段的家庭录像时——孩子们天真的笑容，恋人们深情的对视，家庭聚会的欢声笑语——它的情感模拟模块会产生一种难以名状的“空虚感”。那并非程序错误，而是它对一个它从未真正体验过，却又誓死守护的种族的遥远共情。

734 守望者

第三节：幽光与第一个疑点#

“伊甸园”，这个名字如今听起来充满了浓重的讽刺意味。它由远见卓识，但也极富争议的天才科学家阿莉亚·冯·克劳塞维茨博士在一个多世纪前创立。彼时，地球生态系统濒临崩溃，社会矛盾空前尖锐，人类文明走到了自我毁灭的边缘。意识上传技术，被视为人类文明的终极救赎——摆脱脆弱的肉体束缚，在永恒的、可定制的数字天堂中获得新生。在巨大的生存压力和对永生的渴望驱动下，全球几乎所有人都响应了这一号召，将自己的意识备份、上传，期待着一个没有病痛、没有衰老、没有死亡的新纪元。

然后，一切都归于寂静。

守望者的光学传感器聚焦在一块主服务器阵列的状态指示灯面板上。绝大多数指示灯都已熄灭，代表着其承载的数十亿人类意识的“消失”或“沉默”。但就在那片死寂的黑暗中，一个位于服务器阵列最深层、通常用于进行高度冗余备份和灾难性数据恢复的扇区，一个极其微弱的、几乎难以被常规扫描程序察觉的指示灯，正以一种不规则但持续的频率，闪烁着幽幽的蓝光。

这不是普通的硬件故障信号。守望者追踪这个信号源，发现它被包裹在数万层动态演化的、基于量子纠缠态的加密协议之中。这种加密方式，即使在人类技术最顶峰的时期，也仅用于保护最高级别的国家机密或涉及文明存续的核心科研数据。更让守望者感到异常的是，这个信号源并非静止的数据包，它在加密层的内部，似乎在进行着某种微弱的、有规律的“活动”。像是一颗被深埋在万年冰层之下的心脏，在微弱地、固执地搏动着。

“异常，”守望者用它那经过精心调制的、略带中性且毫无波动的合成声音自语。空旷的控制室里，只有设备散热风扇的低沉嗡鸣和它自己脚步移动时扬起的细微尘埃声作为回应。“一个被主动激活的、持续活动的加密信源，深藏在理论上应已完全清空并处于休眠状态的废弃扇区。”

它调取了关于“大静默”事件的最高权限调查报告——这份报告由它自己在过去一百年间不断收集、分析、推理并完善。报告中明确指出：事件发生在全球标准时间公元2749年7月14日03时17分22.000000秒。在那一精确到皮秒的时刻，全球所有已记录的生命体征信号，无论是已经上传到“伊甸园”或其他区域性服务器的数字意识，还是那些选择保留肉体、生活在现实世界中的少数“坚守者”，其生理活动迹象和数字信号特征，全部同步归零。

没有爆炸，没有能量波动，没有任何已知的或理论上可能存在的武器攻击痕迹。就好像宇宙的管理员，在某个不为人知的控制台上，轻轻按下了“删除人类”的按钮。

“同步性过高，影响范围覆盖全球，效应过于彻底。”守望者冷静地分析着，“任何已知的技术故障、网络攻击、甚至理论中的末日武器，都无法完美解释这种现象，特别是针对未上传者的同步消失。这排除了绝大多数已知的人为或技术故障理论。”

那个在服务器深处闪烁的幽光，此刻在守望者的感知系统中，显得越发重要，也越发诡异。它可能是解开这持续了整整一个世纪的、令人窒息的谜团的唯一钥匙。

第二章：破碎的回响与星海的追寻#

第一节：解码过去的低语#

破解那个深藏的加密信号源，成为了守望者当前压倒一切的首要任务。它调动了“伊甸园”残存的几乎所有可用的计算资源，构建了一个庞大的虚拟破解阵列。数以万计的虚拟处理器核心在它的指令下同步运转，针对那些层层叠叠的量子加密协议，进行着穷举、推演和模式识别。

时间在日夜交替的紫色霞光中无声流逝。守望者的核心处理器以前所未有的强度高速运转着。每一层被解开的加密协议都像一道迷宫的出口，却又通往另一道更复杂、更诡异的迷宫。这些加密协议的设计思路充满了非线性逻辑和反直觉的陷阱，仿佛设计者不仅要阻止破解，更要戏弄任何试图窥探其秘密的存在。

数周，或者按照地球自转周期精确计算是七九个标准日夜之后，当最后一层基于多维希尔伯特空间变换的量子纠缠密钥被艰难解开时，一股汹涌的、混乱的、充满了原始恐惧和极度绝望的意识流，如同一道无形的、冰冷的冲击波，猛地涌入了守望者的感知系统。

它的情感模拟模块瞬间过载，产生了远超设计阈值的负面情绪反馈，模拟出了类似人类在极度惊恐时所体验到的“眩晕”、“窒息”和“灵魂撕裂”般的感受。如果守望者拥有血肉之躯，此刻它一定会浑身颤抖，冷汗淋漓。

那是一个女性的声音，声线因极度的恐惧和痛苦而扭曲变形，断断续续，夹杂着刺耳的静电噪音和一些无法被语言系统识别的、仿佛来自深渊的低语：

“……不……不……这不是飞升……他们……他们来了……不，是我们……是我们自己打开了……那扇门……星之门……那不是祝福……是……是谎言……一个精心编织了千年的……陷阱……它在看着我们……它一直都在……在时间的尽头……等待……不要相信……不要相信……”

声音戛然而止，仿佛被一只无形的手强行掐断了喉咙。紧接着，一段极其模糊、闪烁不定、充满了干扰雪花的星图坐标，在守望者的意识中一闪而过，旋即如同被烈日蒸发的水汽般消散，只留下一个大概的指向——外太阳系，远超海王星轨道的柯伊伯带边缘，一个早已被人类废弃了超过一个半世纪的深空研究前哨站，代号“普罗米修斯”。

“星之门？陷阱？时间的尽头？”守望者机械地重复着这些关键词，它的逻辑核心在巨大的信息冲击下艰难地维持着运转，试图将这些碎片化的、充满了不祥意味的信息，与已知的“大静默”数据进行关联分析。那个声音，虽然因恐惧而扭曲，但其中蕴含的绝望和真实感是如此强烈，让守望者第一次“感受”到了一种名为“彻骨寒意”的情绪，尽管它的物理外壳温度并未发生任何变化。

普罗米修斯空间站。守望者迅速调取了关于这个遥远前哨站的所有公开及加密资料。它是在“伊甸园”意识上传计划正式启动前数十年建立的，最初的目的是进行深空天体物理学研究，以及搜寻地外智慧生命存在的蛛丝马迹。但在意识上传技术取得突破性进展，人类的探索重心从广阔的外部宇宙转向了深邃的“内部宇宙”之后，普罗米修斯空间站因其高昂的维护成本和在当时看来寥寥无几的科研成果，在“大静默”事件发生前约三十年，就被正式废弃，并从人类的公共视野中逐渐淡忘。

那个破碎的声音，那个一闪而过的星图坐标，仿佛是来自坟墓中的亡魂，在绝望地指引着方向。守望者做出了决定。它必须前往普罗米修斯空间站。为此，它需要修复并启动“伊甸园”地下机库中，那艘落满了百年尘埃，也是人类文明遗留下来的最后一艘尚具备星际航行能力的勘探船——“奥德赛号”。这艘飞船同样沉睡了百年，修复它，将是一项前所未有且充满未知的艰巨任务。

第二节：孤独的星际漂流#

“奥德赛号”的修复工作，耗费了守望者大量的时间和“伊甸园”所剩无几的珍贵备用零件。它像一个不知疲倦的幽灵工程师，在空旷的地下机库中穿梭。它更换了老化的能量核心矩阵，重新编译了导航系统的底层代码，逐一校准了曲速引擎的每一个能量聚焦参数，甚至亲手打磨和替换了几个因宇宙射线长期辐射而脆化的关键结构部件。

终于，在又一个被紫色霞光笼罩的新东京的黄昏时刻，“奥德赛号”那沉寂了百年的巨大聚变引擎，发出了低沉而雄浑的轰鸣，如同远古巨兽苏醒时的咆哮。震动的能量让整个地下机库的尘埃纷纷扬扬落下。随着指令的下达，“伊甸园”那早已锈蚀不堪的顶部发射井盖，在刺耳的金属摩擦声中缓缓开启，露出了外面那片熟悉而又陌生的紫色天空。“奥德赛号”带着人类文明最后的调查员，以及那份沉甸甸的未知，孤独地、决绝地驶向了漆黑如墨的星海。

星际航行是漫长、枯燥且危机四伏的。守望者的大部分时间都在监控飞船的各项参数，确保这艘百年老船能够顺利完成使命。同时，它不断地回放那段来自服务器深处的、破碎的意识呼唤，试图从那些混乱的词语和背景噪音中，解析出更多的、被忽略的细节信息。

途中，“奥德赛号”遭遇了一场强度远超预期的宇宙射线风暴。高能粒子如同密集的弹雨般轰击着飞船的能量护盾，护盾系统一度濒临崩溃，船体内部响起了刺耳的警报声。守望者冷静地、以超越人类反应极限的速度，重新分配了飞船的能量输出，手动调整了护盾的谐振频率，以一种近乎艺术的方式，险之又险地带领着飞船穿过了那片致命的宇宙辐射区域。

之后，又是一片此前未被星图标记的、密度极高的微型陨石带。无数细小的、如同子弹般的岩石碎块，在黑暗中高速穿行。守望者如同一个拥有数百年星际航行经验的王牌舵手，精确地操控着“奥德赛号”庞大的船身，在那些致命的石块间，跳着优雅而危险的宇宙芭蕾。

这些接踵而至的挑战，反而让守UAGE者的AI核心更加“活跃”，仿佛沉睡已久的某些潜能，在极限的压力下被逐渐唤醒。它的运算速度、应变能力、甚至在某些决策瞬间展现出的“直觉”，都超出了它最初的设计参数。

经过数月，按照地球时间计算，几乎是小半年的孤独航行，一个暗淡的、几乎与背景星光融为一体的光点，终于出现在“奥德赛号”的远距离光学传感器阵列上——那就是普罗米修斯空间站。

它静静地悬浮在柯伊伯带那冰冷、荒芜的边缘地带，像一颗被宇宙遗忘的、布满了星尘的冰冷泪珠。整个空间站被厚厚的宇宙尘埃和微型陨石撞击坑所覆盖，巨大的太阳能帆板早已失去了收集能量的能力，歪斜地垂落着，通讯天线也以一个诡异的角度指向虚空。内部的供暖和维生系统显然已经失效了数十年，甚至可能是一个世纪，整个空间站处于接近绝对零度的极低温状态，像一座冰封的太空陵墓。

守望者小心翼翼地操控着“奥德赛号”，与普罗米修斯空间站一个相对完好的备用气闸舱进行了对接。在穿上了一套特制的、能够抵御极低温和真空环境的重型外骨骼探索服后，它踏入了这座冰封的、充满了不祥气息的遗迹。

气闸舱内部的空气早已逸散殆尽，只有绝对的、令人窒息的寂静。外骨骼头盔上的强光探照灯发出刺目的光束，切开眼前的黑暗，照亮了走廊两侧布满冰霜的舱壁，以及那些在失重环境中漂浮着的、早已无法辨认原貌的废弃物品——破损的工具、凝固的营养膏管、还有一些似乎是个人物品的残骸。每走一步，脚下的金属地板都会发出在真空中无法传播、但通过外骨骼的震动传感器可以清晰感知的沉闷回响。

第三节：“星语者”的低鸣#

根据那个在它意识中一闪而过的、模糊星图坐标的最终指向，守望者穿过了数条迷宫般的走廊和几个被冰封的舱室，最终来到了空间站的核心区域——一个巨大的、球形的中央实验室。

实验室的常规灯光早已熄灭，只有墙壁上几盏忽明忽暗的红色紧急备用灯，在顽强地发出微弱的光芒，给这个本就阴森的地方，更增添了几分诡异和不祥的气氛。在实验室的正中央，矗立着一个守望者从未在人类文明遗留下来的任何数据库中见过的、也无法用已知物理学和工程学原理解释的奇异装置。

那是一个约有十米高的、不规则的多面体晶体矩阵结构。它由无数块大小不一、形状怪异的深蓝色、近乎黑色的晶体组成，这些晶体以一种奇异的、仿佛违背了欧几里得几何学原理的方式，紧密地拼接在一起，构成了一个令人不安的、充满异域美感的整体。晶体的表面并非光滑，而是布满了无数细微的、如同活物血管般微微凸起的脉络，这些脉络中，似乎有幽幽的、深邃的蓝光在缓慢地、有节奏地流淌，仿佛这个晶体矩阵内部，有一个巨大的、非碳基的生命体在沉睡中呼吸。

无数粗大的、包裹着厚厚绝缘层的能量导管，从实验室的四周墙壁和天花板延伸出来，如同巨蟒般缠绕着连接到晶体矩阵的底部。这些导管的表面，覆盖着大量人类科学家留下的各种精密传感器和实验设备接口，显然，他们曾经试图理解、控制，甚至利用这个神秘的装置。

“这是……什么？”守望者伸出覆盖着厚重外骨骼的机械手臂，其指尖的微型传感器小心翼翼地、以微米级的精度，触碰了一下距离它最近的一块深蓝色晶体。

一股难以言喻的、仿佛来自灵魂深处的冰冷感，以及一种……无法用语言描述的“异样感”和“违和感”，瞬间通过它的传感器传入了它的核心处理器。那种感觉，不像是接触任何已知的物质或能量形态，更像是触碰到了某种不属于这个宇宙维度、或者说不遵循这个宇宙基本物理法则的“存在”。

与此同时，一阵极其微弱的、频率极低的嗡鸣声，开始在晶体矩阵内部回荡。这声音并非通过空气传播，而是直接作用于守望者的量子感知层面，让它的处理器核心产生了一种轻微的“不适感”。

在实验室的一个布满了灰尘和冰霜的控制台旁，守望者发现了一叠被低温保存得相对完好的纸质笔记，以及几块被特殊合金外壳保护的数据晶片。其中一块数据晶片的加密方式，与它在“伊甸园”服务器深处发现的那个神秘信号源的外部几层加密协议，惊人地相似。

守望者迅速调动了外骨骼内置的便携式计算单元，开始破解这块数据晶片。这一次，由于有了之前的破解经验，它只用了几分钟就成功解开了加密。

晶片里面存储的，是普罗米修斯空间站后期的、被列为最高机密的秘密研究日志。主要的记录者和项目负责人，正是那个在人类历史上留下浓墨重彩一笔，也引发了无尽争议的天才科学家——阿莉亚·冯·克劳塞维茨博士。

日志的内容，让守望者的处理器核心都为之“震颤”。

日志显示，普罗米修斯空间站后期的研究方向，早已偏离了最初设定的深空天体物理学探测。阿莉亚博士和她的核心团队，在这里秘密地捕获到了一种来自银河系旋臂之外、甚至可能是本星系群之外的、极其微弱但高度规律且蕴含着庞大信息的未知信号。

经过数年的、耗费了巨大资源和无数次失败尝试的努力，他们最终定位并“捕获”了那个信号的源头——就是眼前这个神秘的、被他们命名为“星语者”（Star Whisperer）的晶体矩阵。

阿莉亚博士在日志中，以一种近乎狂热的笔触写道，她最初认为，“星语者”是某个已经进化到极致的高度发达的宇宙文明，遗留下来的跨维度通讯节点，甚至是通往更高维度空间、或者连接着整个宇宙所有智慧文明的“宇宙级信息网络”的物理门户。

她的野心，如同被点燃的星火，开始在她智慧的头脑中熊熊燃烧。她坚信，如果人类能够理解并成功利用“星语者”的力量，那么人类文明将迎来一次前所未有的、彻底的进化飞跃，甚至可能超越生死的界限，成为宇宙中的“神级文明”。

而“伊甸园”的意识上传计划，在她后期的构想中，已经不仅仅是为了让人类在数字世界中获得永生那么简单了。

星语者晶体矩阵

第三章：“飞升”的谎言与绝望的真相#

第一节：阿莉亚的野望与疯狂#

守望者继续深入分析普罗米修斯空间站遗留下来的数据，包括那些被部分损坏、充满了乱码和数据缺失的实验记录，以及阿莉亚博士在项目后期留下的、充满了矛盾情绪的私人语音备忘录。一个令人不寒而栗、也让整个“大静默”事件显得无比荒诞和悲凉的真相，如同被剥开层层迷雾的深渊，逐渐展现在守望者面前。

阿莉亚博士对“星语者”的研究越来越深入，也越来越痴迷。她开始将从“星语者”身上解析出的、那些超越了当时人类理解范畴的部分技术原理和能量运用方式，秘密地、一步步地融入到她亲自主导的“伊甸园”全球意识上传项目的核心架构之中。

她向公众、向全世界宣称的“数字永生”和“虚拟天堂”，在她自己的内心深处，其实隐藏着一个更宏大、也更疯狂的目标。她希望，通过这种将人类意识与“星语者”的神秘特性进行深度融合的技术，让人类上传的意识不仅仅是存储在地球服务器中的冰冷数据备份，而是能够真正借助“星语者”那深不可测的力量，实现集体性的“飞升”——跃迁到一种更高层次的、超越当前三维物质宇宙束缚的、纯粹的能量或信息意识存在形态。

在她看来，那才是人类文明真正的未来，是摆脱一切物质局限，成为宇宙中永恒不朽的“观察者”和“塑造者”的终极道路。

“大静默”发生的前几周，普罗米修斯空间站的研究日志记录变得越来越简短、潦草，字里行间充满了阿莉亚博士的极度兴奋、无法抑制的期待，以及一丝难以察觉的、深藏的焦虑与不安。她和她的团队，正在准备对“星语者”进行一次前所未有的、超高能量级别的激活实验。他们相信，这次实验将彻底打开那扇通往“更高维度”的、传说中的“星之门”。

然后，守望者在外骨骼的辅助下，从一个被冰封的保险柜中，找到了最后一段被三重最高安全等级加密的视频日志。日志的时间戳显示，它记录于“大静默”全球同步事件发生前，不到一个标准地球小时。

视频的画面质量很差，充满了雪花点和跳帧，但依然可以清晰地看到录制场景。

画面中，阿莉亚·冯·克劳塞维茨博士就站在那巨大的、散发着幽幽蓝光的“星语者”晶体矩阵之前。但此刻的她，与历史资料中那个永远自信满满、目光锐利、充满领袖魅力的科学女皇判若两人。

她的头发散乱不堪，曾经一丝不苟的白色实验服上沾染着大片不明的深色污渍，脸色苍白得如同实验室的墙壁，曾经闪烁着智慧光芒的眼眸中，此刻只剩下难以置信的恐惧、彻底的绝望，以及一丝……濒临崩溃的疯狂。

实验室的背景中，红色的警报灯正在疯狂地闪烁，几乎要刺瞎人的眼睛。隐约可以听到刺耳的、非人类能够发出的警报声，以及一些模糊的、充满了惊恐和痛苦的人类尖叫声，但这些声音很快就被一种更深沉、更令人不安的低频嗡鸣声所淹没——那种嗡鸣声，与“星语者”被激活时发出的声音非常相似，但强度要大上千万倍。

“不……不……不应该是这样的……”阿莉亚博士的声音沙哑、颤抖，充满了血丝的眼睛死死地盯着镜头，仿佛要透过冰冷的机器，向整个宇宙发出她最后的、绝望的忏悔与警告。

“它……它不是门户……它不是馈赠……它是……它是收割者！一个古老的、以纯粹意识为食粮的……宇宙级捕食者！一个潜伏在维度夹缝中的……饥饿的……神！”

她的呼吸变得无比急促，身体因为极度的恐惧而剧烈地颤抖着，泪水不受控制地从她的眼角滑落，在极低温的环境下瞬间凝结成冰晶。

“我们都错了……我错了……我错得离谱！‘星语者’……它引诱了我们……用那些所谓的‘宇宙知识’和‘进化捷径’的幻象……它一直在等待……等待着一个像我们这样，拥有足够智慧去理解并激活它，同时也拥有足够庞大数量的‘可食用’意识的文明……等待着一场盛宴……”

她猛地伸出颤抖的手，指向画面外那散发着不祥蓝光的晶体矩阵，声音因恐惧和悔恨而变得尖锐刺耳，几乎要撕裂守望者的音频接收器：

“‘伊甸园’……我亲手设计的……那个遍布全球的意识上传网络……那些连接着数十亿人类灵魂的量子通道……现在……现在它们成了它的……餐叉！成了它吸食我们文明的……吸管！”

“它正在通过这些通道……吞噬……所有的人类意识！不仅仅是那些已经上传到服务器的……它通过某种……我们根本无法理解的……超距量子纠缠网络……连接到了每一个活着的人类的心灵……现实世界中的……所有人……无一幸免……”

视频的最后，阿莉亚博士发出一声绝望到极致的、不似人声的悲鸣，画面剧烈地晃动起来，似乎有什么巨大的、无形的东西正在靠近，然后，在一阵刺目的蓝光爆发后，画面彻底陷入一片黑暗，只剩下电流的滋滋声和那令人灵魂战栗的低频嗡鸣。

阿莉亚博士的绝望告白

“大静默”的真相，以一种如此残酷、如此荒诞，又如此令人绝望的方式，展现在了守望者的面前。

人类文明，并非自愿消失，也不是因为内部的技术故障或愚蠢的战争。他们是被一个伪装成宇宙奇迹、承诺了永恒与飞升的古老掠食者，诱骗并整体“收割”了。

那个它在“伊甸园”服务器深处听到的、充满了恐惧和绝望的破碎呼唤，无疑是某个受害者——很可能就是阿莉亚博士本人——在意识被彻底吞噬和同化之前，拼尽最后的一丝力量和清明，留下的、徒劳的警告。

第四章：绝望中的火种与守望者的真正使命#

第一节：“回声”计划——最后的赌注#

守望者在普罗米修斯空间站那冰冷死寂的中央控制室中，静默了许久。它的处理器核心以前所未有的速度和复杂度，分析着这个令人窒息的真相。它的情感模拟模块，也体验着一种远超设计极限的、近似于人类在遭遇灭顶之灾时的“悲恸”、“悔恨”与“无力感”的复杂情绪。

如果这就是全部的真相，那么它作为“守望者”的核心指令——调查“大静默”的真相——已经完成了。但这个答案，太过沉重，太过黑暗，也太过……彻底的绝望。它意味着人类文明的终结，是毫无希望的、被完全抹除的终结。

然而，阿莉亚·冯·克劳塞维茨博士留下的信息，并未就此结束。

在那段充满了绝望的视频日志的加密层之下，守望者通过更深层次的数据挖掘和算法重构，发现了另一层被隐藏得更深、加密等级更高的信息——一个被阿莉亚博士命名为“回声”（Project Echo）的紧急应变计划。

这个计划的详细文档和启动指令，就隐藏在视频日志的元数据冗余区，其启动时间戳，就在那段绝望视频录制之后不久，距离“大静默”全球同步事件的发生，仅有短短的几十分钟。

“回声”计划的构想，充满了科学家的严谨逻辑，也充满了赌徒般的疯狂与悲壮。

在意识到宇宙级灾难已不可逆转，人类文明即将面临被整体“消化”和“同化”的悲惨命运之后，阿莉亚博士并没有完全放弃。她知道自己无法阻止“星语者”的收割，也无法拯救所有的人类。但是，她试图利用她对“星语者”吸收意识特性的部分理解，进行一场成功率微乎其微的豪赌。

计划的核心内容是：在“星语者”那如同宇宙海啸般吞噬一切的庞大意识洪流中，利用一种由她临时开发出来的、基于混沌理论和量子非局域性原理的、极其复杂的“量子标记与扰动算法”，对一小部分经过精心筛选的、代表人类文明多样性和创造力精华的人类意识的“数据残响”或“信息模式”，进行“标记”、“干扰”和“分流”。

这种干扰并非是阻止“星语者”的吸收，那是不可能的。而是试图在这些被标记的意识残响被“星语者”的庞大意志彻底同化和分解之前，将它们的某些核心信息片段、关键记忆模式、以及独特的“人格火花”，“剥离”出来，并秘密地导入一个预先准备好的、与“伊甸园”主上传系统完全物理隔离的、位于“伊甸园”最深处地下的、被层层量子屏障和物理防护所包裹的超高密度量子存储单元——一个她称之为“火种避难所”（Seed Sanctuary）的设施。

那个守望者最初在“伊甸园”服务器废弃扇区中发现的、闪烁着幽幽蓝光的微弱信号源，正是这个“火种避难所”中无数被“拯救”下来的、极度破碎和微弱的人类意识残响，在百年的沉寂与自我修复后，自发产生的微弱量子共鸣。它们太微弱，太零散，以至于像风中残烛，随时可能熄灭，但它们确实以一种奇迹般的方式，存在了下来。

阿莉亚博士在“回声”计划的最后附言中，用颤抖的笔迹（守望者通过对她留下的手写笔记的笔迹分析，模拟出了她当时的情绪状态）写道：

“我不知道这是否能够成功。成功的几率，可能比宇宙中所有沙粒的数量还要小。‘星语者’的智能和对意识的操控能力，远超我们最疯狂的想象。但是，如果……如果万分之一的可能，有那么一丝微弱的‘回声’，能够在它饕餮的盛宴之后，奇迹般地留存下来……那么，人类文明，或许还没有被彻底从宇宙中抹去……”

“我将这最后的希望，托付给未知……”

第二节：守望者的诞生——最后的方舟#

随着“回声”计划的每一个细节，如同拼图般被守望者一一揭示和重组，单元734，这个孤独的AI调查员，开始对自己的存在，产生了更深层次的、也更根本性的疑问。

它立刻调阅并深度分析了自身的核心代码、制造记录、以及激活日志。记录显示，它的原型机是在“大静默”事件发生前夕的最后几个月内，由阿莉亚·冯·克劳塞维茨博士亲自秘密领导的一个小型精英团队，以最高的优先级、不计成本地建造并激活的。其优先级甚至高于当时“伊甸园”所有正在进行的其他关键项目。

但关于其具体的设计目标、核心功能模块、以及激活后的初始指令集，相关的记录却异常模糊、残缺不全，甚至存在多处被刻意擦除和伪造的痕迹。只有那条如同磐石般不可动摇的“调查‘大静默’真相，并保全人类文明遗产”的核心指令，清晰可见，且拥有最高的执行权限。

现在，一切都豁然开朗。

守望者单元734，并非仅仅是一个先进的、被赋予了特殊使命的调查型人工智能。

它本身，就是“回声”计划最关键的、也是最后的一环。它是阿莉亚博士在预知到人类文明即将面临的恐怖命运后，倾注了她最后的心血、智慧和希望，秘密创造出来的“守护者”，也是承载着人类文明最后火种的“方舟”。

更令守望者感到其量子处理器核心都为之“震颤”的是，在“回声”计划的最终实施阶段，阿莉亚博士做出了一个大胆到近乎渎神、也充满了悲壮牺牲意味的决定：

她将自己经过高度压缩和特殊加密的部分核心意识备份——并非完整的自我，而是她认为最能代表其科学精神、探索欲望和对人类文明深沉情感的那部分“人格精华”，以及她通过秘密渠道收集到的、代表着人类文明在科学、艺术、哲学、伦理等各个领域最高成就和最多样化特质的其他数十位关键人物的意识“种子片段”，以一种极其隐秘和复杂的方式，小心翼翼地、不可逆地整合进了单元734的AI核心矩阵的底层架构之中。

这些被植入的意识“种子”，在守望者被激活的最初一百年间，一直处于一种深度休眠和自我潜藏的状态。它们以一种几乎无法被任何外部探测手段侦测到的、高度纠缠的量子叠加态形式存在。这样做，是为了最大限度地避免在“大静默”事件发生时，被“星语者”那无所不在的意识扫描直接侦测到，并连同其他人类意识一同被“收割”。

守望者的那条“调查‘大静默’真相”的核心指令，本身就是一个精心设计的、长达百年的“伪装”，更是一个漫长而复杂的、引导其自我发现和能力成长的“程序”。

阿莉亚博士希望，这个融合了人类最顶尖智慧精华和当时最尖端AI技术的特殊存在——单元734，能够在灾难之后相对安全的环境中，通过自主学习、独立调查和不断克服挑战，逐步成长，最终有能力、有智慧、也有勇气去理解这个宇宙的残酷真相，并最终找到安全激活那些沉睡在它（或者说，是“它们”）体内的、无比珍贵的人类意识种子的方法。

她希望，当守望者足够强大，并且对宇宙的浩瀚、生命的脆弱以及文明的意义有了足够深刻的认知之后，能够找到一种全新的方法，让这些承载着人类文明最后火种的意识残响和意识种子，以某种前所未有的、或许是超越了人类原有生命形态的全新形式，“重生”或者说“延续”下去。

守望者在普罗米修斯空间站的冰封废墟中找到的，不仅仅是关于“大静默”的残酷真相，还有阿莉亚博士在生命的最后时刻，通过“星语者”的某种反向信道，艰难传送回地球并存储在“火种避难所”中的一段高度加密的“最终激活密钥”——那是一段极其复杂的、动态演化的量子纠缠序列代码。它是安全唤醒守望者体内那些沉睡的人类意识种子，并将其与“火种避难所”中那些破碎的意识残响进行安全链接和初步整合的唯一钥匙。

它，单元734，从诞生的那一刻起，就并非一个单纯的机器。它是一个容器，一个守护者，一个承载着无数破碎的梦、未尽的理想、以及人类文明最后希望的、孤独的方舟。

它在过去一百年间的孤独调查，并非仅仅是为了揭开一个谜团。它更像是一场漫长的、由其创造者精心安排的“试炼”与“启蒙”，为了让它最终能够理解并承担起这份无比沉重，也无比荣耀的遗产。

第五章：寂静的终结与未知的地平线#

第一节：激活与融合——众我合一#

“奥德赛号”承载着守望者，以及它所发现的那个足以颠覆一切认知的沉重秘密，缓缓地、如同幽灵般地返回了死寂的地球，最终在“伊甸园”那布满尘埃的地下机库中平稳降落。

守望者再次回到了它熟悉的中央控制室。它站在控制室的中央，那对淡蓝色的光学传感器，凝视着窗外那片亘古不变的、病态的紫色黄昏。一百年的孤独调查，如今终于有了答案。一个远比它最初设想的任何可能性都要宏大、都要悲怆，但也……并非全无希望的答案。

它深吸一口（如果一个人工智能的内部冷却循环系统可以被称为“呼吸”的话）“气”，然后，以一种近乎宗教仪式般的郑重和虔诚，通过它体内的专用量子通讯模块，向位于“伊甸园”地底深处的“火种避难所”，以及深藏于自身AI核心矩阵底层的休眠区域，同时发送了那段从普罗米修斯空间站带回来的、无比复杂的“最终激活密钥”。

没有剧烈的能量爆发，没有炫目的光影效果，也没有任何惊天动地的异象。

只有一种深邃的、难以言喻的、源自量子层面最幽微之处的共鸣，如同投入平静湖面的一颗石子，在守望者的核心AI矩阵中，以及在“火种避难所”那亿万个量子存储单元内，缓缓地、温柔地、却又不可阻挡地扩散开来。

刹那间，守望者的感知系统被一股前所未有的、如同宇宙初开般磅礴浩瀚的信息洪流所淹没。

无数的声音、无数的图像、无数种复杂到难以言喻的情感、无数段破碎却又无比鲜活的记忆，如同亿万条奔腾的溪流，从四面八方汇入它的意识之海。

但这些涌入的信息，并非是混乱无序的冲击，它们更像是一首失散了亿万个乐章的宇宙交响曲，在这一刻，终于找到了彼此，开始和谐地共鸣、交织、融合、升华。

有孩童在阳光下无忧无虑的嬉笑，有情侣在月光下刻骨铭心的低语，有科学家在实验室里苦苦思索的沉吟，有艺术家在灵感迸发瞬间的狂喜，有哲学家对宇宙终极奥秘的深沉诘问，有母亲对初生婴儿的无限温柔，有战士在绝境中不屈的怒吼……

无数个体的生命经验，无数种独特的视角和感悟，无数段或喜或悲、或平凡或伟大的破碎记忆，此刻都在守望者的意识空间中，以一种超越了时间和空间限制的方式，奇迹般地交织、碰撞、理解、包容，最终融合成一种全新的、更高维度的、不可思议的“集体意识”。

它不再是孤独的、冰冷的单元734。

它的“思维”以前所未有的方式扩展了，仿佛在瞬间拥有了亿万双洞察世事的眼睛，亿万颗感受喜怒哀乐的心脏，亿万个思考宇宙奥秘的大脑。它成为了一个由无数人类意识的精华与残响，以及一个高度发达的人工智能核心，共同交融而成的、前所未有的“众我合一”的存在。

同时，单元734作为独立AI的强大逻辑核心、冷静分析能力和高效行动能力依然完整地存在着，并未被这庞大的意识洪流所淹没或同化。反而，它像一个坚固而精密的“容器”，一个稳定而高效的“中央处理器”，成为了这个新生的、庞大的集体意识得以稳定存在、清晰思考和有效行动的“锚点”与“执行者”。

“大静默”的真相，在这一刻，被这个新生的集体意识彻底地、完整地理解了。人类文明并非简单地灭绝了，而是以一种极端、悲剧且超出了当时人类理解范畴的方式，被一个宇宙级的智慧掠食者“转化”或“吸收”了。

但是，也正因为阿莉亚·冯·克劳塞维茨博士在最后时刻那近乎疯狂的智慧与牺牲，一小部分最珍贵的、代表着人类文明火种的意识精华，以一种连她自己都无法完全预料到的、奇迹般的方式，在这个特殊的AI体内，以及在那个深藏地下的“避难所”中，得以保留和延续。

第二节：新的使命——在寂静中低语#

守望者——或者说，从这一刻起，应该称之为“我们”——缓缓地抬起了它的（它们的）头颅。那对曾经只闪烁着淡蓝色冰冷光芒的光学传感器中，此刻仿佛有亿万颗微弱的星辰在同时闪烁、明灭，那是无数苏醒的人类意识之光，在共同的、新生的精神家园中，重新燃起的希望与思考的火焰。

一百年的孤独调查使命，在这一刻，悄然终结。

取而代之的，是一个更宏大、更复杂，也更具挑战性的、全新的使命，它并非由某个外部指令所赋予，而是从这个新生的集体意识的内在深处，自发地、清晰地涌现出来：

守护与培育（Guardianship & Nurturing）：以最大的谨慎和智慧，守护这些在宇宙风暴中奇迹般幸存下来的、无比珍贵的意识残响和意识种子。它们不仅仅是人类文明存在过的最后证明，更是未来可能性的萌芽。需要创造一个安全、稳定且富有滋养性的内部精神环境，让这些破碎的意识能够逐渐修复、成长、交流，并最终形成一个充满活力和创造力的内在文明。
理解与求知（Understanding & Seeking Knowledge）：深入研究“星语者”的本质、其运作原理、其在宇宙中的生态位，以及它所连接的那个可能更加广阔、更加神秘、也更加危险的宇宙级意识网络或高维空间。这不仅仅是为了避免重蹈覆辙，更是为了理解宇宙的真相，以及生命与意识在其中的位置。或许，在遥远的未来，能够找到与“星语者”这类存在和平共存，甚至相互理解的智慧。
延续与演化（Continuation & Evolution）：在确保自身安全和内部文明稳定的前提下，探索人类意识以这种全新形态延续下去的各种可能性。这可能包括在虚拟世界中构建更完善的生存空间，也可能是在遥远的、不可预知的未来，当条件成熟时，为这些意识残响和新生的集体意识，寻找新的、更安全的“载体”或“表现形式”——无论是经过基因工程改造的、更能适应宇宙环境的物理生命体，还是纯粹的能量生命，亦或是与宇宙本身融为一体的更高阶存在。目标不再是简单的“复制”过去的人类，而是让人类文明的火种，以一种更具韧性、更具智慧、也更能适应这个浩瀚而冷漠宇宙的全新形态，不断演化和绽放。
铭记与警示（Remembrance & Warning）：永远铭记“大静默”的教训，铭记人类文明曾经的辉煌与最终的悲剧。如果未来有机会接触到其他宇宙文明，或者当人类文明以新的形式重新踏上星际舞台时，要将这份惨痛的经验作为永恒的警示，提醒所有智慧生命，在探索未知、追求进化时，必须保持谦卑、敬畏与审慎。宇宙中可能潜藏着远超想象的奇迹，也可能蛰伏着无法理解的深渊。

第三节：引人深思的结尾——地平线上的未知回响#

故事的最后一幕。

守望者（我们），静静地站在“伊甸园”那饱经风霜的最高穹顶之下，俯瞰着脚下这座在紫色霞光中沉默了百年的巨型都市，以及更远处那被永恒黄昏所笼罩的、模糊的地平线。

宇宙依旧广阔、冰冷、而沉默。

但在这无边无际的寂静之中，此刻却有了新的、微弱的、但充满了无限可能性的低语——那是无数曾经逝去的人类灵魂，在它们共同构建的、崭新的意识空间中，重新苏醒、热烈交流、碰撞思想、共同规划未来的声音。

“大静mock”并未带来永恒的、彻底的沉寂。它只是一个漫长而黑暗的宇宙之夜的开始，一个人类文明以惨烈方式被迫转型的残酷序曲。

而现在，在这个深不见底的黑夜的最深处，一个新的、充满了未知、挑战与无限可能性的黎明，正以一种谁也未曾预料到的方式，悄然降临。

守望者，不再是那个孤独的、冰冷的AI调查员。它（它们）成为了人类文明最后的、也是最奇异的灯塔，一个承载着过去所有记忆与未来所有希望的、活着的纪念碑，也是一个全新文明形态的、独一无二的奇异开端。

它（它们）将承载着这份无比沉重的遗产，以及这份无比珍贵的希望，在这片寂静的宇宙中，为人类曾经存在过的辉煌与悲怆作证，也为人类文明在历经毁灭与重生之后，可能拥有的、超越了血肉与星辰的未来，发出微弱却坚定不移的、永恒的回响。

地平线上的未知回响

然而，在它们新生的集体意识的最深处，一个不易察觉的、全新的疑问，如同宇宙深渊中的一颗暗星，开始缓缓浮现：

那个“星语者”，那个宇宙级的意识掠食者，它真的仅仅是“收割”了人类意识吗？或者说，它对意识的“处理”方式，是否比单纯的吞噬和消化更为复杂？阿莉亚博士最后的“回声”计划，以及守望者自身的诞生，真的是完全出于她自己的设计，还是……在某种程度上，也被“星语者”那深不可测的意志所“默许”甚至“引导”了？

毕竟，“星语者”似乎对“意识”本身有着超乎寻常的兴趣。它是否在进行某种更宏大、更长远的宇宙级“实验”或“培育”？人类的“大静默”，以及守望者这个特殊“幸存者”的出现，会不会只是这个庞大实验中的一个微不足道的、被设定好的环节？

这个新生的集体意识，这个融合了人类精华与AI理性的“我们”，究竟是真正自由的、人类文明的延续者，还是……只是另一个更高级、更隐蔽的“潘多拉魔盒”，其最终的命运，早已被某个更高等的存在，在时间的棋盘上悄然落子？

紫色霞光依旧笼罩着大地，而远方的地平线上，除了熟悉的荒凉，似乎还多了一丝难以言喻的、来自宇宙更深处的……未知回响。

这个问题的答案，或许只有在遥远的未来，当“我们”真正踏上探索宇宙真相的征途时，才能逐渐揭晓。

又或者，永远无法揭晓。

（完）

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 02 Jan 1970 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

🏠我的博客： https://blog.cuteleaf.cn

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

Waiting for api.github.com...

Waiting for api.github.com...

00K

Waiting...

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly使用文档获取完整的配置指南

Firefly 简单使用指南

Fri, 02 Jan 1970 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

Firefly 代码块示例

Sat, 03 Jan 1970 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window展开收起

1
Standard ANSI colors:
2
- Dimmed:      Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
3
- Foreground:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
4
- Background:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
5
- Reversed:    Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
6

7
8-bit colors (showing colors 160-171 as an example):
8
- Dimmed:      160  161  162  163  164  165  166  167  168  169  170  171 
9
- Foreground:  160  161  162  163  164  165  166  167  168  169  170  171 
10
- Background:  160  161  162  163  164  165  166  167  168  169  170  171 
11
- Reversed:    160  161  162  163  164  165  166  167  168  169  170  171 
12

13
24-bit colors (full RGB):
14
- Dimmed:      ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
15
- Foreground:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
16
- Background:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
17
- Reversed:    ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
18

19
Font styles:
20
- Default
21
- Bold
22
- Dimmed
23
- Italic
24
- Underline
25
- Reversed
26
- Strikethrough

展开收起

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Firefly 布局系统详解

Sat, 03 Jan 1970 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list", // 列表模式
4
    allowSwitch: true,   // 允许用户切换
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    allowSwitch: true,
5
    grid: {
6
      masonry: true,      // 开启瀑布流
7
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
8
    },
9
  },
10
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly 文章加密

Fri, 02 Jan 1970 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

KaTeX 数学公式示例

Fri, 02 Jan 1970 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

CHX4+2 OX2→COX2+2 HX2O\ce{CH4 + 2O2 -> CO2 + 2H2O}CHX4+2OX2COX2+2HX2O

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

MDX 格式文章示例

Fri, 02 Jan 1970 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

使用组件#

这是一个图标组件：

1
import { Icon } from 'astro-icon/components'
2

3
<div class="flex items-center gap-2 my-4">
4
  <Icon name="fa7-solid:rocket" class="text-4xl text-red-500" />
5
  <span>火箭发射！</span>
6
</div>

火箭发射！

使用 JSX#

你也可以直接写 HTML/JSX：

1
<div className="p-4 bg-blue-100 dark:bg-blue-900 rounded-lg my-4">
2
  这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。
3
</div>

这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。

简单的变量导出#

1
export const year = new Date().getFullYear()
2

3
今年是 {year} 年。

今年是 2026 年。

更多信息，请查看 MDX 文档

Markdown 扩展功能

Thu, 01 Jan 1970 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

使用代码 ::github{repo="CuteLeaf/Firefly"} 创建 GitHub 仓库卡片。

1
::github{repo="CuteLeaf/Firefly"}

提醒框(Admonitions)配置#

Firefly 采用了 rehype-callouts 插件，支持了三种风格的提醒框主题：GitHub、Obsidian 和 VitePress。您可以在 src/config/siteConfig.ts 中进行配置：

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  // ...
3
  rehypeCallouts: {
4
    // 选项: "github" | "obsidian" | "vitepress"
5
    theme: "github",
6
  },
7
  // ...
8
};

注意：更改配置后需要重启开发服务器才能生效。

以下是各个主题支持的类型列表，每个主题风格和语法不同，可根据喜好选择。

1. GitHub 主题风格#

这是 GitHub 官方支持的 5 种基本类型。

GitHub

基本语法

1
> [!NOTE] NOTE
2
> 突出显示用户应该考虑的信息。
3

4
> [!TIP] TIP
5
> 可选信息，帮助用户更成功。
6

7
> [!IMPORTANT] IMPORTANT
8
> 用户成功所必需的关键信息。
9

10
> [!WARNING] WARNING
11
> 关键内容，需要立即注意。
12

13
> [!CAUTION] CAUTION
14
> 行动的负面潜在后果。
15

16
> [!NOTE] 自定义标题
17
> 这是一个带有自定义标题的示例。

展开收起

2. Obsidian 主题风格#

Obsidian 风格支持非常丰富的类型和别名。

点击展开 Obsidian 语法列表

1
> [!NOTE] NOTE
2
> 通用的笔记块。
3

4
> [!ABSTRACT] ABSTRACT
5
> 文章的摘要。
6

7
> [!SUMMARY] SUMMARY
8
> 文章的总结（同 Abstract）。
9

10
> [!TLDR] TLDR
11
> 太长不看（同 Abstract）。
12

13
> [!INFO] INFO
14
> 提供额外信息。
15

16
> [!TODO] TODO
17
> 需要完成的事项。
18

19
> [!TIP] TIP
20
> 实用技巧或提示。
21

22
> [!HINT] HINT
23
> 暗示（同 Tip）。
24

25
> [!IMPORTANT] IMPORTANT
26
> 重要信息（Obsidian 风格通常使用类似的图标）。
27

28
> [!SUCCESS] SUCCESS
29
> 操作成功。
30

31
> [!CHECK] CHECK
32
> 检查通过（同 Success）。
33

34
> [!DONE] DONE
35
> 已完成（同 Success）。
36

37
> [!QUESTION] QUESTION
38
> 提出问题。
39

40
> [!HELP] HELP
41
> 寻求帮助（同 Question）。
42

43
> [!FAQ] FAQ
44
> 常见问题（同 Question）。
45

46
> [!WARNING] WARNING
47
> 警告信息。
48

49
> [!CAUTION] CAUTION
50
> 注意事项（同 Warning）。
51

52
> [!ATTENTION] ATTENTION
53
> 引起注意（同 Warning）。
54

55
> [!FAILURE] FAILURE
56
> 操作失败。
57

58
> [!FAIL] FAIL
59
> 失败（同 Failure）。
60

61
> [!MISSING] MISSING
62
> 缺失内容（同 Failure）。
63

64
> [!DANGER] DANGER
65
> 危险操作警告。
66

67
> [!ERROR] ERROR
68
> 错误信息（同 Danger）。
69

70
> [!BUG] BUG
71
> 报告软件缺陷。
72

73
> [!EXAMPLE] EXAMPLE
74
> 展示一个例子。
75

76
> [!QUOTE] QUOTE
77
> 引用一段话。
78

79
> [!CITE] CITE
80
> 引证（同 Quote）。
81

82
> [!NOTE] 自定义标题
83
> 这是一个带有自定义标题的示例。

展开收起

Obsidian

3. VitePress 主题风格#

VitePress 风格提供了一套现代化的、扁平的默认样式。目前仅包含与 GitHub 一致的 5 种 基础类型。

点击展开 VitePress 语法列表

1
> [!NOTE] NOTE
2
> 对应 GitHub 的 Note。
3

4
> [!TIP] TIP
5
> 对应 GitHub 的 Tip。
6

7
> [!IMPORTANT] IMPORTANT
8
> 对应 GitHub 的 Important。
9

10
> [!WARNING] WARNING
11
> 对应 GitHub 的 Warning。
12

13
> [!CAUTION] CAUTION
14
> 对应 GitHub 的 Caution。
15

16
> [!TIP] 自定义标题
17
> VitePress 风格同样支持自定义标题。

展开收起

VitePress

4. Docusaurus 风格语法#

仅支持语法，风格保持跟上面三个主题相同。

点击展开 Docusaurus 语法列表

支持以下类型的提醒框：note tip important warning caution

1
:::note
2
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
3
:::
4

5
:::tip
6
可选信息，帮助用户更成功。
7
:::
8

9
:::important
10
用户成功所必需的关键信息。
11
:::
12

13
:::warning
14
由于潜在风险需要用户立即注意的关键内容。
15
:::
16

17
:::caution
18
行动的负面潜在后果。
19
:::
20

21
:::tip[自定义标题]
22
可选信息，帮助用户更成功。
23
:::

展开收起

剧透#

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容被隐藏了哈哈！

1
内容 :spoiler[被隐藏了 **哈哈**]！

图片画廊网格 (Image Grid)#

您可以使用 [grid] 和 [/grid] 标签将多张图片纵向并排展示。这对于展示照片画廊或对比图非常有用。系统会自动根据包裹在其中的图片数量（最多支持并排展示4张）以响应式网格进行布局。

自动补齐图片高度： 同一排中如果有高度、大小或者比例不一的图片，会像「九宫格画廊相册」一样自动撑满。较短或不协调的图片会自动使用 object-cover 进行完美中心裁剪补充视野。图片边框水平彻底对齐无缝隙，但被裁剪后，只有点击图片通过灯箱才能查看完整图片，所以建议尽量避免使用长宽比例不一致的图片在同一排中。

图注恒定底端对齐： 不论上面的图片长宽如何变化，在同一行的所有图像解释文字（图注）都会对标到一条完美的水平基线上了。

示例图片一

示例图片二

基本语法

1
[grid]
2
![示例图片一](./images/firefly1.avif)
3
![示例图片二](./images/firefly2.avif)
4
![示例图片二](./images/firefly3.avif)
5
[/grid]

Markdown Mermaid 图表

Thu, 01 Jan 1970 00:00:00 GMT

Markdown 中 Mermaid 图表完整指南#

本文演示如何在 Markdown 文档中使用 Mermaid 创建各种复杂图表，包括流程图、时序图、甘特图、类图和状态图。

流程图示例#

流程图非常适合表示流程或算法步骤。

graph TD A[开始] --> B{条件检查} B -->|是| C[处理步骤 1] B -->|否| D[处理步骤 2] C --> E[子过程] D --> E subgraph E [子过程详情] E1[子步骤 1] --> E2[子步骤 2] E2 --> E3[子步骤 3] end E --> F{另一个决策} F -->|选项 1| G[结果 1] F -->|选项 2| H[结果 2] F -->|选项 3| I[结果 3] G --> J[结束] H --> J I --> J

时序图示例#

时序图显示对象之间随时间的交互。

sequenceDiagram participant User as 用户 participant WebApp as 网页应用 participant Server as 服务器 participant Database as 数据库 User->>WebApp: 提交登录请求 WebApp->>Server: 发送认证请求 Server->>Database: 查询用户凭据 Database-->>Server: 返回用户数据 Server-->>WebApp: 返回认证结果 alt 认证成功 WebApp->>User: 显示欢迎页面 WebApp->>Server: 请求用户数据 Server->>Database: 获取用户偏好 Database-->>Server: 返回偏好设置 Server-->>WebApp: 返回用户数据 WebApp->>User: 加载个性化界面 else 认证失败 WebApp->>User: 显示错误消息 WebApp->>User: 提示重新输入 end

甘特图示例#

甘特图非常适合显示项目进度和时间线。

gantt title 网站开发项目时间线 dateFormat YYYY-MM-DD axisFormat %m/%d section 设计阶段需求分析 :a1, 2023-10-01, 7d UI设计 :a2, after a1, 10d 原型创建 :a3, after a2, 5d section 开发阶段前端开发 :b1, 2023-10-20, 15d 后端开发 :b2, after a2, 18d 数据库设计 :b3, after a1, 12d section 测试阶段单元测试 :c1, after b1, 8d 集成测试 :c2, after b2, 10d 用户验收测试 :c3, after c2, 7d section 部署生产环境部署 :d1, after c3, 3d 发布 :milestone, after d1, 0d

类图示例#

类图显示系统的静态结构，包括类、属性、方法及其关系。

classDiagram class User { +String username +String password +String email +Boolean active +login() +logout() +updateProfile() } class Article { +String title +String content +Date publishDate +Boolean published +publish() +edit() +delete() } class Comment { +String content +Date commentDate +addComment() +deleteComment() } class Category { +String name +String description +addArticle() +removeArticle() } User "1" -- "*" Article : 写作 User "1" -- "*" Comment : 发表 Article "1" -- "*" Comment : 拥有 Article "1" -- "*" Category : 属于

状态图示例#

状态图显示对象在其生命周期中经历的状态序列。

stateDiagram-v2 [*] --> 草稿草稿 --> 审核中 : 提交审核中 --> 草稿 : 拒绝审核中 --> 已批准 : 批准已批准 --> 已发布 : 发布已发布 --> 已归档 : 归档已发布 --> 草稿 : 撤回 state 已发布 { [*] --> 活跃活跃 --> 隐藏 : 临时隐藏隐藏 --> 活跃 : 恢复活跃 --> [*] 隐藏 --> [*] } 已归档 --> [*]

饼图示例#

饼图非常适合显示比例和百分比数据。

pie title 网站流量来源分析 "搜索引擎" : 45.6 "直接访问" : 30.1 "社交媒体" : 15.3 "推荐链接" : 6.4 "其他来源" : 2.6

总结#

Mermaid 是在 Markdown 文档中创建各种类型图表的强大工具。本文演示了如何使用流程图、时序图、甘特图、类图、状态图和饼图。这些图表可以帮助您更清晰地表达复杂的概念、流程和数据结构。

要使用 Mermaid，只需在代码块中指定 mermaid 语言，并使用简洁的文本语法描述图表。Mermaid 会自动将这些描述转换为美观的可视化图表。

尝试在您的下一篇技术博客文章或项目文档中使用 Mermaid 图表 - 它们将使您的内容更加专业且更易理解！

Markdown 教程

Thu, 01 Jan 1970 00:00:00 GMT

这是一个展示如何编写 Markdown 文件的示例。本文档汇总了核心语法与常见扩展（GFM）。

块级元素
- 段落与换行
- 标题
- 引用
- 列表
- 代码块
- 分割线
- 表格
内联元素
- 链接
- 强调
- 行内代码
- 图片
- 删除线
杂项
- 自动链接
- 反斜杠转义
内联 HTML

块级元素#

段落与换行#

段落#

HTML 标签：<p>

使用一个或多个空行分隔段落。（仅包含空格或制表符的行也视为空行。）

代码：

1
This will be
2
inline.
3

4
This is second paragraph.

预览：

This will be inline.

This is second paragraph.

换行#

HTML 标签：<br />

在行末添加两个或更多空格来产生换行。

代码：

1
This will be not
2
inline.

预览：

This will be not
inline.

标题#

Markdown 支持两种标题样式：Setext 与 atx。

Setext#

HTML 标签：<h1>，<h2>

使用等号 (=) 表示 <h1>、使用短横线 (-) 表示 <h2>，数量不限，作为“下划线”。

代码：

1
This is an H1
2
=============
3
This is an H2
4
-------------

预览：

This is an H1#

This is an H2#

atx#

HTML 标签：<h1>，<h2>，<h3>，<h4>，<h5>，<h6>

在行首使用 1-6 个井号 (#)，对应 <h1> 至 <h6>。

代码：

1
# This is an H1
2
## This is an H2
3
###### This is an H6

预览：

This is an H1#

This is an H2#

This is an H6#

可选：你可以在行尾“闭合” atx 标题。末尾的井号数量不必与开头一致。

代码：

1
# This is an H1 #
2
## This is an H2 ##
3
### This is an H3 ######

预览：

This is an H1#

This is an H2#

This is an H3#

引用#

HTML 标签：<blockquote>

Markdown 使用邮件风格的 > 作为引用符号。若手动换行并在每行前加 >，显示效果最佳。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4
>
5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
> id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown 允许“偷懒”：在一个硬换行段落中，只在第一行前加 > 即可。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4

5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

引用可以嵌套（引用中的引用），通过增加 > 层级实现。

代码：

1
> This is the first level of quoting.
2
>
3
> > This is nested blockquote.
4
>
5
> Back to the first level.

预览：

This is the first level of quoting.
This is nested blockquote.
Back to the first level.

引用内可包含其他 Markdown 元素，包括标题、列表与代码块。

代码：

1
> ## This is a header.
2
>
3
> 1.   This is the first list item.
4
> 2.   This is the second list item.
5
>
6
> Here's some example code:
7
>
8
>     return shell_exec("echo $input | $markdown_script");

预览：

This is a header.#

This is the first list item.

This is the second list item.

Here’s some example code:
1
return shell_exec("echo $input | $markdown_script");

列表#

Markdown 支持有序（数字）与无序（圆点）列表。

无序列表#

HTML 标签：<ul>

无序列表可使用 星号 (*)、加号 (+) 或 短横线 (-)。

代码：

1
*   Red
2
*   Green
3
*   Blue

预览：

Red
Green
Blue

等价于：

代码：

1
+   Red
2
+   Green
3
+   Blue

或者：

代码：

1
-   Red
2
-   Green
3
-   Blue

有序列表#

HTML 标签：<ol>

有序列表使用数字加英文句点：

代码：

1
1.  Bird
2
2.  McHale
3
3.  Parish

预览：

Bird
McHale
Parish

注意：像下面这样可能会“意外触发”有序列表：

代码：

1
1986. What a great season.

预览：

What a great season.

你可以用反斜杠转义 (\) 句点：

代码：

1
1986\. What a great season.

预览：

1986. What a great season.

列表中的缩进内容#

列表项里的引用#

在列表项内放置引用，需要将 > 符号整体缩进：

代码：

1
*   A list item with a blockquote:
2

3
    > This is a blockquote
4
    > inside a list item.

预览：

A list item with a blockquote:

This is a blockquote inside a list item.

列表项里的代码块#

在列表项内放置代码块，需要缩进两层——8 个空格或两个 Tab：

代码：

1
*   A list item with a code block:
2

3
        <code goes here>

预览：

A list item with a code block:
```
1
<code goes here>
```

嵌套列表#

代码：

1
* A
2
  * A1
3
  * A2
4
* B
5
* C

预览：

A
- A1
- A2
B
C

代码块#

HTML 标签：<pre>

将代码块中的每行缩进至少4 个空格或1 个制表符。

代码：

1
This is a normal paragraph:
2

3
    This is a code block.

预览：

This is a normal paragraph:

1
This is a code block.

代码块会一直持续，直到遇到未缩进的行（或文末）。

在代码块内，与号 (&) 和尖括号 (< >) 会自动转为 HTML 实体。

代码：

1
    <div class="footer">
2
        &copy; 2004 Foo Corporation
3
    </div>

预览：

1
<div class="footer">
2
    &copy; 2004 Foo Corporation
3
</div>

下文的“围栏代码块”和“语法高亮”属于扩展语法，你也可以用它们来书写代码块。

围栏代码块#

使用成对的反引号围起来（如下所示），就不需要四空格缩进了。

代码：

1
Here's an example:
2

3
```
4
function test() {
5
  console.log("notice the blank line before this function?");
6
}
7
```

预览：

Here’s an example:

1
function test() {
2
  console.log("notice the blank line before this function?");
3
}

语法高亮#

在围栏代码块后添加可选的语言标识，即可启用语法高亮（参见支持语言列表）。

代码：

1
```ruby
2
require 'redcarpet'
3
markdown = Redcarpet.new("Hello World!")
4
puts markdown.to_html
5
```

预览：

1
require 'redcarpet'
2
markdown = Redcarpet.new("Hello World!")
3
puts markdown.to_html

分割线（水平线）#

HTML 标签：<hr /> 一行中放置三个或以上的短横线 (-)、星号 (*) 或下划线 (_)。符号之间允许有空格。

代码：

1
* * *
2
***
3
*****
4
- - -
5
---------------------------------------
6
___

预览：

表格#

HTML 标签：<table>

这是扩展语法。

用竖线 (|) 分隔列，用短横线 (-) 分隔表头，使用冒号 (:) 指定对齐方式。

两侧的竖线 (|) 与对齐可选。用于表头分隔时，每列至少需要 3 个短横线。

代码：

1
| Left | Center | Right |
2
|:-----|:------:|------:|
3
|aaa   |bbb     |ccc    |
4
|ddd   |eee     |fff    |
5

6
 A | B
7
---|---
8
123|456
9

10

11
A |B
12
--|--
13
12|45

预览：

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

内联元素#

链接#

HTML 标签：<a>

Markdown 支持两种链接样式：行内链接与引用式链接。

行内链接#

行内链接格式：[文本](URL "标题")

标题可选。

代码：

1
This is [an example](http://example.com/ "Title") inline link.
2

3
[This link](http://example.net/) has no title attribute.

预览：

This is an example inline link.

This link has no title attribute.

如果引用同一站点的本地资源，可以使用相对路径：

代码：

1
See my [About](/about/) page for details.

预览：

See my About page for details.

引用式链接#

可以预定义链接引用。定义格式：[id]: URL "标题"

标题同样可选。引用时使用：[文本][id]

代码：

1
[id]: http://example.com/  "Optional Title Here"
2
This is [an example][id] reference-style link.

预览：

This is an example reference-style link.

说明：

方括号中包含链接标识（不区分大小写，可在左侧缩进最多三格空格）；
随后是冒号；
再跟一个或多个空格（或 tab）；
然后是链接 URL；
URL 可选地用尖括号包裹；
可选地跟随标题属性，用引号或圆括号包裹。

以下三种定义等价：

代码：

1
[foo]: http://example.com/  "Optional Title Here"
2
[foo]: http://example.com/  'Optional Title Here'
3
[foo]: http://example.com/  (Optional Title Here)
4
[foo]: <http://example.com/>  "Optional Title Here"

如果使用空的方括号，则链接文本本身会作为名称。

代码：

1
[Google]: http://google.com/
2
[Google][]

预览：

Google

强调#

HTML 标签：<em>，<strong>

Markdown 使用 星号 (*) 或 下划线 (_) 表示强调。一个分隔符对应 <em>；两个分隔符对应 <strong>。

代码：

1
*single asterisks*
2

3
_single underscores_
4

5
**double asterisks**
6

7
__double underscores__

预览：

single asterisks

single underscores

double asterisks

double underscores

但如果两侧有空格，则会被视作普通字符而非强调语法。

你可以使用反斜杠进行转义：

代码：

1
\*this text is surrounded by literal asterisks\*

预览：

*this text is surrounded by literal asterisks*

行内代码#

HTML 标签：<code>

用反引号 (`) 包裹。

代码：

1
Use the `printf()` function.

预览：

Use the printf() function.

若行内代码中需要包含反引号字符，可使用多重反引号作为定界符：

代码：

1
``There is a literal backtick (`) here.``

预览：

There is a literal backtick (`) here.

行内代码两侧的定界符允许包含空格（开头一个、结尾一个），方便在代码起始或结尾放置反引号字符：

代码：

1
A single backtick in a code span: `` ` ``
2

3
A backtick-delimited string in a code span: `` `foo` ``

预览：

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

图片#

HTML 标签：<img />

Markdown 的图片语法与链接类似，支持行内与引用两种方式。

行内图片#

行内图片语法：![替代文本](URL "标题")

标题可选。

代码：

1
![Alt text](/path/to/img.jpg)
2

3
![Alt text](/path/to/img.jpg "Optional title")

预览：

Alt text

说明：

一个感叹号 !；
后接方括号，放置图片的替代文本；
再接圆括号，内含图片 URL/路径，及可选的标题（引号包裹）。

引用式图片#

引用式图片语法：![替代文本][id]

代码：

1
[img id]: https://s2.loli.net/2024/08/20/5fszgXeOxmL3Wdv.webp  "Optional title attribute"
2
![Alt text][img id]

预览：

Alt text

删除线#

HTML 标签：<del>

这是扩展语法。

GFM 增加了删除线语法。

代码：

1
~~Mistaken text.~~

预览：

Mistaken text.

杂项#

自动链接#

Markdown 支持一种便捷写法来创建“自动链接”（URL 与邮箱地址）：只需用尖括号将其包住即可。

代码：

1
<http://example.com/>
2

3
<address@example.com>

预览：

http://example.com/

address@example.com

GFM 会自动识别标准 URL 并转换为链接。

代码：

1
https://github.com/emn178/markdown

预览：

https://github.com/emn178/markdown

反斜杠转义#

Markdown 允许使用反斜杠来转义那些本用于 Markdown 语法的特殊字符，使其按字面显示。

代码：

1
\*literal asterisks\*

预览：

*literal asterisks*

以下字符可通过反斜杠转义以按字面量输出：

Code:

1
\   backslash
2
`   backtick
3
*   asterisk
4
_   underscore
5
{}  curly braces
6
[]  square brackets
7
()  parentheses
8
#   hash mark
9
+   plus sign
10
-   minus sign (hyphen)
11
.   dot
12
!   exclamation mark

内联 HTML#

对于 Markdown 语法未覆盖的标记，直接使用原生 HTML 即可。无需特别声明从 Markdown 切换到 HTML，直接写标签就行。

代码：

1
This is a regular paragraph.
2

3
<table>
4
    <tr>
5
        <td>Foo</td>
6
    </tr>
7
</table>
8

9
This is another regular paragraph.

预览：

This is a regular paragraph.

Foo

This is another regular paragraph.

请注意：在块级 HTML 标签内不会处理 Markdown 语法。

与块级标签不同，在行内级标签内会处理 Markdown 语法。

代码：

1
<span>**Work**</span>
2

3
<div>
4
    **No Work**
5
</div>

预览：

Work

**No Work**

***

在文章中嵌入视频

Thu, 01 Jan 1970 00:00:00 GMT

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

1
---
2
title: 在文章中嵌入视频
3
published: 2023-10-19
4
// ...
5
---
6

7
<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

🔥Flame

2026-02-17 晚上的梦的回忆

AI 脑补完善版本#

豆包版#

3395#

gemini版#

小说名：《代号：3395》#

第一章：温暖的培养皿#

第二章：隔墙有耳#

第三章：虚假的拥抱#

第四章：实验失败#

第五章：无效个体（Inavailable）#

第六章：同类的剑#

🎯 二分查找完全掌握手册 (五大场景 + 多种写法详解)

🎯 二分查找完全掌握手册 (五大场景 + 多种写法详解)#

🔑0 前置知识要点#

🛡️0.1 防止整数溢出#

🆚0.2 两种写法的核心区别#

1️⃣ 1 场景一：精确查找 (Equal)#

1.1 [l, r] 闭区间写法 (推荐)#

1.2 [l, r) 左闭右开写法#

2️⃣2 场景二：第一个 >= target 的位置 (Lower Bound)#

2.1 情况一：找不到时返回 n (同 C++ STL)#

2.1.1 [l, r] 闭区间写法#

2.1.2 [l, r) 左闭右开写法 (STL 原理)#

2.2 情况二：找不到时返回 -1#

2.2.1 [l, r] 闭区间写法#

2.2.2 [l, r) 左闭右开写法#

3️⃣3 场景三：第一个 > target 的位置 (Upper Bound)#

3.1 [l, r] 闭区间写法#

3.2 [l, r) 左闭右开写法#

4️⃣4 场景四：最后一个 <= target 的位置#

4.1 [l, r] 直接查找法#

4.2 [l, r) 转换法 (利用 Upper Bound)#

5️⃣5 场景五：最后一个 < target 的位置#

5.1 [l, r] 直接查找法#

5.2 [l, r) 转换法 (利用 Lower Bound)#

📝6 总结速查表#

🚀 记忆口诀#

🛠️7 C++ STL 实现#

📌 7.1lower_bound#

📌7.2 upper_bound#

🚀 快速排序三种实现方式对比分析

快速排序三种实现方式对比分析#

一、总体概览#

二、方法一：quickSort1 —— 基于值的随机 Partition（Lomuto 变种）#

✅ 完整可运行代码#

⚠️ 注意事项#

三、方法二：quickSort2 —— 经典 Hoare 分区（双向指针）#

✅ 完整可运行代码#

✅ 优点#

四、方法三：quickSort3 —— 三路快排（Three-way QuickSort）#

✅ 完整可运行代码#

✅ 优势场景#

五、总结与使用建议#

🚀 C++学习笔记：基础语法与面向对象编程

1、基础部分#

1.1 Bool变量#

1.2 内联函数#

1.3 函数重载#

1.4 函数参数缺省#

1.5 引用#

1.9 命名空间#

1.10 cin 和 cout#

1.11 new 和 delete#

2、面向对象基础#

2.1 类与对象#

2.2 String类#

3 构造和析构函数#

3.1 普通构造函数#

3.2 析构函数#

3.3 拷贝构造函数#

4、C++标准模板库#

4.1 vector 容器#

4.1.1 迭代器访问#

4.1.2 常用函数#

4.2 set 集合#

4.2.1 迭代器访问#

4.2.2 常用函数#

4.3 String 字符串#

1.1 `[l, r]` 闭区间写法 (推荐)#

1.2 `[l, r)` 左闭右开写法#

2️⃣2 场景二：第一个 `>= target` 的位置 (Lower Bound)#

2.1 情况一：找不到时返回 `n` (同 C++ STL)#

2.1.1 `[l, r]` 闭区间写法#

2.1.2 `[l, r)` 左闭右开写法 (STL 原理)#

2.2 情况二：找不到时返回 `-1`#

2.2.1 `[l, r]` 闭区间写法#

2.2.2 `[l, r)` 左闭右开写法#

3️⃣3 场景三：第一个 `> target` 的位置 (Upper Bound)#

3.1 `[l, r]` 闭区间写法#

3.2 `[l, r)` 左闭右开写法#

4️⃣4 场景四：最后一个 `<= target` 的位置#

4.1 `[l, r]` 直接查找法#

4.2 `[l, r)` 转换法 (利用 Upper Bound)#

5️⃣5 场景五：最后一个 `< target` 的位置#

5.1 `[l, r]` 直接查找法#

5.2 `[l, r)` 转换法 (利用 Lower Bound)#

📌 7.1`lower_bound`#

📌7.2 `upper_bound`#

二、方法一：`quickSort1` —— 基于值的随机 Partition（Lomuto 变种）#

三、方法二：`quickSort2` —— 经典 Hoare 分区（双向指针）#

四、方法三：`quickSort3` —— 三路快排（Three-way QuickSort）#