酷酷的算法

蓝莓程序岛

欢迎关注我的微信公众号：蓝莓程序岛

我想帮助 1666 个学习计算机的小伙伴变得更好 ~

作者：蓝莓

本站地址：https://blueberry-universe.cn/

感谢你能来，我们一起加油呀 ~

本站内容

优秀博客推荐

小林coding 图解网络、图解系统、图解MySQL、图解Redis、Java 后端面试题
小菜学编程学Python、其他杂七杂八的
木鸟杂记一个学习分布式系统的论坛
JavaGuide Java 面试可参考

优秀图书推荐

在这里推荐的这些书有一部分是我看过的，还有些是我没看过但是打算看的。这些图书应该都是非常经典的学习资料了，希望对你有帮助。

1、操作系统

《程序员的自我修养 - 链接、装载和库》
《操作系统真象还原》
《深入理解计算机系统》

2、Java

Java 编程

《Head First Java》新手入门
《Java 核心技术卷1 基础知识》新手入门
《Java8 实战》 Java8 的新特性讲的最全最仔细的
《Effective Java》大量的 Java 编程实践 Java 之父推荐

虚拟机

《深入理解 Java 虚拟机》进阶

并发编程

《Java并发编程实战》系统全面的介绍了Java的并发，如何设计支持并发的数据结构，以及如何编写正确的并发程序
《实战Java高并发程序设计》比上一本更新，容易读

设计模式

《Head First 设计模式》

工具类

《Maven 实战》

性能优化

《Java性能权威指南》

单元测试

《有效的单元测试》

并发编程补充

《Java多线程编程核心技术》实战
《Java并发编程艺术》理论

个人修养

《重构：改善既有代码的设计》
《代码整洁之道》
《程序员的职业素养》

3、数据库

MySQL

《MySQL必知必会》入门
《高性能MySQL》进阶
《MySQL技术内幕：InnoDB储存引擎》 MySQL 底层

Redis

《Redis 实战》本书深入浅出地介绍了Redis的5种数据类型，并通过多个实用示例展示了Redis的用法，讲述了Redis的优化方法以及扩展方法。
《Redis设计与实现》 Redis 内部深入剖析

4、Kafka

《Kafka权威指南》入门
《深入理解Kafka：核心设计与实践原理》进阶
《Apache Kafka实战》进阶
《Kafka技术内幕》进阶

5、Spring

Spring

《Spring实战》 Redis 底层原理
《精通Spring 4.x ――企业应用开发实战》

Spring Boot

《SpringBoot实战》
《JavaEE开发的颠覆者：Spring Boot实战》
《SpringBoot揭秘：快速构建微服务体系》

6、操作系统

从零实现系列

《操作系统真象还原》看过，作者讲的比较幽默一些，语言平易近人
《30天自制操作系统》没看过，听说这也是一本很不错的书

拓展类的小书

《Linux 是怎样工作的》
《程序是怎样跑起来的》
《计算机是怎样跑起来的》
《网络是怎样连接的》

Linux 内核

《深入Linux内核架构》
《Linux 内核设计的艺术》
《Linux 内核完全剖析》讲的是早期的内核代码

分布式系统学习之路

图解分布式共识算法 Raft（领导者选举）

一起刷力扣

基础

如何写出正确的代码 ✅

1、数组

入门

三路快排

对撞指针

滑动窗口

2、查找表

set && map 入门

set && map 练习

查找表问题

键值选择

滑动窗口 + 查找表

二分搜索树的顺序性

0220 存在重复元素 III ✅

3、链表

入门

虚拟头结点的使用

双指针

4、栈，队列，优先队列

栈

队列

广度优先搜索

优先队列

5、二叉树

基础

递归终止条件

递归问题的定义

二分搜索树

6、递归和回溯

基础

排列

组合

二维平面的回溯

0079 单词搜索

floodfill

练习

7、动态规划

基础

重叠子问题

状态定义和状态转移

背包问题

最长上升子序列 LIS（Longest Increasing Subsequence）

最长公共子序列 LCS （Lonogest Common Sequence）

1143 最长公共子序列

8、贪心算法

待分类

0752 Open-The-Lock

操作系统学习之路

优雅的编程语言 Python

蓝莓的胡思乱想

思考的维度和付费意识

计算机网络学习之路

彻底搞懂虚拟网络搭建

图解分布式共识算法 Raft（领导者选举）

你好啊，我是蓝莓，在这篇文章中我们来聊聊 Raft ~

为什么要使用分布式技术呢？

在互联网上每天产生的数据量是非常大的，甚至我们在使用软件的过程中，每一次按钮的点击和屏幕的滑动都会被记录下来形成日志。对于这些大量的数据进行存储是一个问题，进行分析也是一个问题。因此分布式技术的出现就是因为：当一台机器干不动的时候，联合众多机器一起干，分布式也不是凭空产生的，都是随着实际问题的产生而产生的。因此如何让众多的机器能够协调成为一个整体就成为了一个重要的问题。

Raft 算法论文

原文传送门：https://ramcloud.atlassian.net/wiki/download/attachments/6586375/raft.pdf

中文翻译版：https://github.com/maemual/raft-zh_cn

目标：

Raft：关于 Raft 的基本认识
Leader Election：领导者选举的具体过程
RPC：使用到的两种 RPC 的论文原图

1 Raft

既然我们知道了，Raft 所要解决的问题就是协调一组机器作为一个整体进行工作。那么 Raft 是要做什么呢？回想一下现实生活中的例子，一个部门的人一起来完成同一件事情，那么这个部门肯定是有一个 老大 的，这个老大做的事情就是对下面的人发号施令，老大让他们干什么，他们就干什么。如果有一天这个老大突然生病了，估计要请上那么一两个月的假来养病，这时候这个部门没有 老大 了，那可怎么办，比较简单的方法当然是从这个部门里面选择一个人作为新的老大咯继续对下面的人发号施令了呀。

Raft 共识算法将达成共识这件事情拆分成为了三个部分：

Leader Election 领导者选举（主要来讲如何选老大）
Log Replication 日志复制（如何发号施令）
Safety 安全性（为保证算法能够正确运行，对前两者的补充）

在这篇文章中，我们只说领导者选举这个部分

2 Leader Election

在 Raft 中选举领导是基于投票的，我们就假设这个部门一共有三个人，我们来看看这三个人是如何根据一套规则选择出一个 Leader 并且维护领导者权威的。

三种状态

在 Raft 算法中，每个 Raft 节点都处于三种状态中的一个，分别为：

Leader 领导者
Candidate 候选人
Follower 追随者

记录状态使用的字段

在本篇文章中，我们只说领导者选举，所以我们只使用到了这几个字段来记录状态：

currentTerm：Raft 节点当前所处的任期
votedFor：Raft 节点在这一次任期中把票投给了谁

在 Raft 论文中的原图如下所示：

每个 Raft 节点都有一个倒计时的时钟，你可以为这个倒计时的时钟指定一个倒计时的下限和上限，假设我们指定下限为 300ms 和上限为 400ms ，如果这组人中是有 Leader 的，比如我们约定好，如果谁当选了 Leader 就每隔 150ms 就发送一次心跳消息，这样可以通知其他的 Raft 节点这组机器里面是有 Leader 的，从而告诉他们不用毛遂自荐了。

其实发送心跳的消息只要能在每个节点的时钟超时之前收到就可以了，这样就不会发生一直有人要竞选的尴尬局面。之所以我们要让时钟处于 300ms 到 400ms 之间随机选一个数，这是因为，如果大家都是使用同一个时间进行倒计时，那么大家大概率在同一时间超时，大家同时发起选举，每个人都给自己投一票，这样下去可能永远不会有人收到半数以上的投票，因为一轮选举中（就是每个任期中）每个人都只能投一票出去，除非进入到下一轮选举才能够再次投票。随机化的倒计时方法可以很好的避免这种尴尬局面的产生，让大家不在同一时间超时就不会同时发起选举了。

有领导吗

在一组计算机刚刚启动的时候是没有 Leader 的，这时候每个节点都在等待时钟超时，如果自己的时钟一旦超时，就主动发起选举，我们可以发现，大雄的倒计时剩余的时间最短，所以一定是大雄率先发起选举。

大雄到时间了

这时候大雄已经超时了

大雄发送要票请求

大雄首先将自己推荐为候选人 Candidate，然后将自己的 CurrentTerm 在原来的基础上增加 1。这说明大雄发现，在上一个任期中一直没有 Leader 通知我领导人的存在，所以我要主动进入到下一轮的选举中进行选举。

大雄做的事情：

将自己的任期 CurrentTerm 加 1
将自己的 Role 从 Follower 转换为 Candidate 并给自己投上一票
用小本本记录自己已经获得的选票数量，现在大雄的 votes 记录为 1，每当 votes 的值增加一次的时候，他就算一算自己的选票数量是不是超过了总数的一半，一旦超过一半，大雄就把自己从 Candidate 转变为 Leader 成为真正的领导人

在实现中大雄通过 RPC 向其他人发送 RequestVote RPC 请求进行要票

被要票的人做的事情：

首先看看要票人的任期是不是比自己小：如果要票人的任期比自己小，那就直接拒绝给他投票，并且告诉他自己的任期是什么，当要票人收到回复后一旦发现自己的任期已经落后了，要票人就会直接从 Candidate 变为 Follower 并且重置自己的时钟以及对齐任期
如果要票人的任期大于自己：那被要票的人就将自己的任期提升，保持最高的任期，说明被要票的人应该注意到，现在已经进入了更新的一轮的选举过程了，这时候被要票的人就拥有了在新一轮选举中的投票权，直接同意投票给要票人即可
如果要票人的任期等于自己：那这时候被要票的人就看看自己是不是已经投过票了，如果被要票的人还没有投过票那就直接同意投给要票人即可，如果被要票的人投过票了就直接拒绝即可

关于第 3 点：如果被要票的人投过票了，还可以检查一下这个票是不是投给当前正在向自己要票的这个人，因为在网络环境中很有可能被要票人的 RPC 回复消息丢失的情况，所以要票人没有收到回复，不太确定是拒绝了自己还是同意了自己，所以这时候要票人可以再次发送一次要票请求进行尝试

静香支持大雄

我们可以发现，静香所处的条件是：要票人的任期大于自己，因此静香做如下的事情：

静香的 CurrentTerm 和大雄的 Term 对齐，更新为 1
静香投票给大雄，使用 VotedFor 从 -1 修改为大雄，其中 -1 在本文中代表没有投票给任何人的意思
重置倒计时时钟：一旦同意投票给大雄，意味着静香认可了大雄，所以答应大雄在一段时间内不会再次发起选举，所以要将自己的时钟重置

大雄做的事情：

每次大雄收到一票后都要检查一下自己的 votes 是不是超过总节点数的一半了，一旦超过一半就可以直接从 Candidate 变身为 Leader 了

大雄需要检查投票是否成功，如果投票成功直接给自己的 votes 增加 1，然后看看是不是能够变成 Leader
如果投票没有成功，那就要检查一下被要票人的任期，如果被要票人的任期小于等于自己，那么就说明被要票人已经投给别人票了，在这一次选举中不能给当前这个要票人进行投票了，如果被要票人的任期大于自己，那说明要票人的任期落后了，要票人应该从 Candidate 变为 Follower 并且重置自己的时钟，同时将自己的任期和这个更新的任期对齐

显然在这里大雄所做的事情应该是属于第 1 种情况

静香苦等，多啦a梦奋笔疾书

当静香投票成功后，静香就开始等待心跳，所谓的心跳就是一个 RPC ，在论文中起的名字叫做 AppendEntries

Leader 需要通过这样的方式来告诉所有人，当前是有 Leader 的，每次你们收到我的心跳消息后，你们都要重置自己的时钟

哆啦a梦支持大雄

这时候大雄收到了哆啦a梦的投票，不过已经没有什么用处了，大雄收到是没有问题的，我们需要在实现的过程中增加这一步的边界条件判断，如果已经是 Leader 了，收到后续的选票后要看看对方是同意了还是不同意，具体的事情和刚才收到静香的投票的时候是一样的：

大雄需要检查投票是否成功，如果投票成功直接给自己的 votes 增加 1，然后看看是不是能够变成 Leader，如果自己已经是 Leader 了，那就不用再变咯
如果投票没有成功，那就要检查一下被要票人的任期，如果被要票人的任期小于等于自己，那么就说明被要票人已经投给别人票了，在这一次选举中不能给当前这个要票人进行投票了，如果被要票人的任期大于自己，那说明要票人的任期落后了，要票人应该从 Leader 变为 Follower 并且重置自己的时钟，同时将自己的任期和这个更新的任期对齐

来自大雄的心跳

这时候，大雄要宣布自己的主动，那就是使用 AppendEntries RPC 向所有下属发送消息，证明领导人是存在的，告诉他们，你们不用发起选举了啊，都听我的号令

响应 Leader 的心跳

每次收到 Leader 的心跳后，他们 Follower 都要做这样的事情：

如果自己的任期比当前的 Leader 小，那就对齐自己的任期，并且把 VotedFor 修改为 -1 ，记住，VotedFor 只有在自己的任期增加的时候才可以修改为 -1，因为只有来到更新的一轮中，自己才能重新获得新的一次投票权
如果自己的任期和当前的 Leader 相等，那么自己直接回复 Leader 并说，我已经收到你的心跳了，而且重置了自己的时钟，这代表中 Follower 认可了 Leader 的权威，并且答应在一段时间内不会再次发起选举
如果自己的任期大于当前的 Leader，那也很简单，只需要回复当前的 Leader 说，我的任期都已经比你高了，你不能再继续当 Leader 了，你赶紧和我的任期对齐之后变成 Follower 吧

大雄不干了！产生宕机的罪魁祸首

在现实世界中，每个节点都是有可能出现问题的，比如大雄去睡觉了，这时候大雄肯定不会在梦中继续向其他节点发送心跳消息了，过一会儿如果大家没有收到心跳，率先超时的那个节点就会率先发起新一轮的选举，你可以发现，分布式系统是允许某个节点出现问题的，即使它宕机了，也还是能继续运行下去

可见，下一次就是哆啦a梦率先发起选举了

多啦a梦超时，开始竞选

重复刚才的过程，哆啦a梦增加自己的任期等一系列工作，发送要票请求给其他人

静香投票给哆啦

虽然哆啦a梦并不会收到大雄的回复，由于这是一个3节点的集群，所以只要哆啦a梦能拿到2票，就可以成功当选 Leader

收到哆啦a梦的心跳

这时候，哆啦a梦开始发送心跳维护自己的权威

回复多啦a梦的心跳

哆啦a梦收到静香的响应

3 RPC

我们在本文中提到了两个 RPC，对照一下这些 RPC 中出现的字段，我们就很好理解是如何完成图中所说的那些事情了

RequestVote
AppendEntries

RequestVote

AppendEntries

002-N-Queens

这篇文章讨论下 LeetCode 上边儿的 51 号问题： N 皇后 (N Queens)

1 问题描述：

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

任意两个皇后不能处于同行、同列或者斜线直线上。

此问题要求给出所有合法的皇后摆放方式。

举个例子

可见上图，任意两个皇后之间都不在同一行上，也不在同一列上，也不在斜线上。所谓斜线就是像五子棋那样的斜线，而在 N 皇后的摆放规则中是不允许这样的。

这个例子是当 n 等于 4 的时候，这是一个 4 行 4 列的棋盘，并且这时候你拥有 4 个棋子，这 4 个棋子的摆放方式要符合刚才的三个不。

当你的程序输入的值为 n 的时候希望你给所有的摆放方式的解。

2 解题思路

对于这样的问题，最直接的想法就是穷举所有的可能性。也就是说，你可以尝试所有的摆放方式，

当然，你可以按照一定的顺序把你手中的 n 个棋子全都摆好之后你再看一下当前的摆放方式是否符合要求。

另外，你也可以在按照一定的次序摆放的过程中顺便检查当前落下这颗棋子之后，此时的局面是不是就已经不符合 N 皇后的要求了呐？如果这时候就已经不符合要求了，那么你就可以尝试下一种摆放方式了，因为当前已经不符合，再继续摆下去也没有意义了。

那么在这里，我才用第二种方式，就是在摆放的过程中就边摆放边验证。

举个例子

这里我一行一行地来摆放棋子，并且每一行都从第 0 号格子开始依次尝试到第 n-1 号格子。因为要求不同行，所以每行至多一个棋子。

假设：

我们先摆放了第 0 号行的第 0 个位置一颗棋子，

接着摆放第 1 号行的第 0 个位置一颗棋子，

这时候我们就已经没有必要去尝试摆放第 2 号行了，因为此时已经不合法了。因为我们摆放的那两颗棋子位于了同一列上，那么这时候应该直接跳过第 1 号行的那种摆放方式而继续去尝试接下来的一种摆放方式。

那么这时候撤销第 1 号行摆放的棋子，然后尝试 1 号行且 1 号列的摆放方式，这时候你会发现，当前摆放位置的左上角的格子存在棋子，所以不合法。

再撤销刚才的棋子，这次尝试 1 号行且 2 号列的位置摆放棋子，现在你会发现，已经没有冲突了，那么这时候就可以在第 2 号行尝试所有的位置摆放棋子了，若冲突则换下一个位置尝试，直到所有的行都摆放上了棋子，这时候我们就得到了一个合法的摆放方式了！

相信你理解了~

那么，如何验证合法性？

每当我们摆放一颗棋子之后，我们就已经检查当前摆放的位置的左上角方向上所有的格子是否存在棋子，检查当前位置的右上角方向上的所有格子是否存在棋子，最后检查一下当前位置的正上方的所有格子是否存在棋子。

那么为什么不用检查左下角方向上的所有格子、右下角方向上的所有格子、正下方的位置上所有的格子呐？答案就是：因为我们是一行一行的摆放呀，所以下边的行都还没有摆放棋子呀，所有也就用不着检查了呀！那么又为什么不用检查当前行上是否存在其他的棋子呐？因为我们每次只在一行上摆放一个棋子呀！从一开始就避免了在行方向上出现不合法的情况了。

3 代码实现 C++

LeetCode 给的代码

class Solution {
public:
    vector> solveNQueens(int n) {
        
    }
};

LeetCode 希望我们返回一个 vector> 类型的数据，这个类型的数据中每一个 vector 记录了一个棋盘的样子。

vector 相当于一个二位数组，

vector> 相当于一个三位数组，

意会一下，相信你理解了 ~

算法思想

整个算法的实现其实就是一个穷举的过程，属于 回溯算法。

穷举的逻辑

你会发现，我在此添加了两个函数，分别是 backtrack 和 isValid；

另外还有一个变量 res；

其中 res 的类型和 solveNQueens 函数的返回值类型一样，也就是说，我们使用 res 来记录所有合法的棋盘的样子，每穷举到一个合法的棋盘的时候，我们就添加到 res 中去。

backtrack 回溯

我们先来关注 backtrack 函数的逻辑

其他地方的代码都不要看，只看 backtrack 函数的代码以及它的注释

class Solution {
public:
    vector> res;

    vector> solveNQueens(int n) {

        vector board(n, string(n, '.'));
        backtrack(board, 0);

        return res;
    }

    // 用于判断当我们在 row 号行 col 号列
    // 摆放一个棋子的时候，检查当前摆放是否合法
    bool isValid(vector& board, int row, int col){

    }

    // backtrack 函数的定义
    // 在棋盘 board 中对 row 号行进行棋子的摆放
    void backtrack(vector& board, int row){
        if(row >= board.size()){
            // 应注意到 board.size() 的大小刚好是等于 n 的
            // n 是棋盘的长宽
            // 若 row 等于 n 说明我们正在对第 n 号行摆放棋子
            // 而我们的行号从 0 开始编号
            // 那也就说明了我们已经摆放完成了 n 个棋子
            // 能够递归到这一层，说明之前的选择都是合法的
            // 则当前 board 纳入到 res 中
            res.push_back(board);
            return;
        }

        // 对于每一层都可以进行这样的选择
        for(int col = 0; col < board.size(); ++col){
            // 做出选择前，对该情况判断是否合法
            // 若不合法则直接跳过
            if(!isValid(board, row, col)) continue;

            // 做出对当前行的选择
            // 并放入到 board 中
            board[row][col] = 'Q';

            // 对下一行进行选择
            backtrack(board, row+1);

            // 撤销当前行的选择
            // 进行下一轮的循环，重新对当前行选择
            board[row][col] = '.';
        }
    }

};

好啦！在你认真意会了 backtrack 函数之后，相信你已经懂了它的逻辑。

关键问题是，现在 isValid 函数的逻辑还没有写，那么接下来我们重点关注一下 isValid 函数的逻辑。

isValid

我在这里为了节约篇幅，单独把 isValid 函数给拿出来；

// 用于判断当我们在 row 号行 col 号列
// 摆放一个棋子的时候，检查当前摆放是否合法
bool isValid(vector& board, int row, int col){
        // 因为是自上而下一行一行摆放皇后
        // 所以在当前行的下方不存在皇后
        // 则只需要检查此行上方的方向即可

        // 1 检查左上方所有格子;注意对数组下标是否越界进行检查
        for(int i = row-1, j = col-1; i >= 0 && j >= 0; --i, --j){
            if(board[i][j] == 'Q')
                return false;
        }

        // 2 检查正上方所有格子;注意对数组下标是否越界进行检查
        for(int i = row-1; i >= 0 ; --i){
            if(board[i][col] == 'Q')
                return false;
        }

        // 3 检查右上方所有格子;注意对数组下标是否越界进行检查
        for(int i = row-1, j = col+1; i >= 0 && j < board.size(); --i, ++j){
            if(board[i][j] == 'Q')
                return false;
        }
		
    	// 若以上三种情况都合法，则返回 true 
        return true;

}

solveNQueens

最后重点关注下 solveNQueens 函数

vector> solveNQueens(int n) {

    vector board(n, string(n, '.'));
    backtrack(board, 0);

    return res;
}

这个函数就是，首先初始化一下最一开始的棋盘，因为还没有摆放任何的棋子，所以此时的棋盘的每一个位置都应该初始化为符号 . 一个点。

接着，我们看 backtrack 函数的定义：

在棋盘 board 中对 row 号行进行棋子的摆放

因为我们的行号从 0 开始，所以我们调用 backtrack 函数的时候应该先从第 0 号行开始，接着后边的工作，它都会自动进行下去了。

完整代码

// n 行 n 列， 其中 . 代表空，Q 代表皇后
// 任意两个皇后都不能同行、同列、同对角线 
// -> 共六个方向
// 输出所有合法的解
// 返回一个 vector> 类型的数据
class Solution {
public:
    vector> res;

    vector> solveNQueens(int n) {

        vector board(n, string(n, '.'));
        backtrack(board, 0);

        return res;
    }

    bool isValid(vector& board, int row, int col){
        // 因为是自上而下一行一行摆放皇后
        // 所以在当前行的下方不存在皇后
        // 则只需要检查此行上方的方向即可

        // 1 检查左上方
        for(int i = row-1, j = col-1; i >= 0 && j >= 0; --i, --j){
            if(board[i][j] == 'Q')
                return false;
        }

        // 2 检查正上方
        for(int i = row-1; i >= 0 ; --i){
            if(board[i][col] == 'Q')
                return false;
        }

        // 3 检查右上方
        for(int i = row-1, j = col+1; i >= 0 && j < board.size(); --i, ++j){
            if(board[i][j] == 'Q')
                return false;
        }

        return true;

    }

    void backtrack(vector& board, int row){
        if(row >= board.size()){
            // 能够递归到这一层，说明之前的选择都是合法的
            // 则当前 board 纳入到 res 中
            res.push_back(board);
            return;
        }

        // 对于每一层都可以进行这样的选择
        for(int col = 0; col < board.size(); ++col){
            // 做出选择前，对该情况判断是否合法
            // 若不合法则直接跳过
            if(!isValid(board, row, col)) continue;

            // 做出对当前行的选择
            // 并放入到 board 中
            board[row][col] = 'Q';

            // 对下一行进行选择
            backtrack(board, row+1);

            // 撤销当前行的选择
            // 进行下一轮的循环，重新对当前行选择
            board[row][col] = '.';
        }
    }

};

003-Minimum-Depth-of-Binary-Tree

这篇文章谈论下二分搜索树的 广度优先遍历 也叫 层次遍历 还有个英文名字叫 BFS (Breadth First Search) 就是广度优先搜索。

在 LeetCode 上边儿有一个对应的问题是 111 号问题：二叉树的最小深度。

1 题目描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

其实就是距离根节点最近的那个叶子节点所处的那一层的深度。

举个例子

最小深度的定义

这是一颗二叉树，那么这棵树对应的最小高度是多少呢？

答案是 2，你可以发现在第二层 [9, 20] 这两个节点就已经出现了叶子节点，所以节点 9 所在层的深度就是这个二叉树的最小深度。

什么是层次遍历

顾名思义，对于树而言，层次遍历就是一层一层的按照自上而下且自左向右的顺序访问每一个节点，这也被成为树的广度优先遍历。

对于上图而言，它的层次遍历的结果就是如下的节点访问顺序

[3, 9, 20, 15, 7]

解题思路：如何寻找最小深度

对于 9 号节点来说，用层次遍历就可以找到这个节点了，只要我们在遍历的过程中一边遍历一遍判断当前节点是否是叶子节点。这样，当我们第一次判断成功，也就是说，第一次寻找到的叶子节点所在的那一层的深度就是最终的答案了。这时，整个算法也就结束了。

如何判断是否是叶子节点

判断一个节点是否是叶子节点就等价于判断此节点是否满足左孩子和有孩子同时为空。

2 层次遍历代码实现思路

初始状态

层次遍历的过程需要一个队列作为辅助的数据结构，在以下的图中，我使用一个箭头代表队列的对头方向，初始情况下队列是空的。

如何访问节点

访问到的第一个节点，当然是位于二叉树的第一层的节点，而第一层也仅有一个节点。

但我们并不是直接访问它，为了代码的统一性，我们每次访问一个节点的时候都要从队列的队头取出一个节点然后访问它，并且在访问这个队头节点后还要把它的左孩子和右孩子依次入队。

1 访问第 1 层的节点

先让根节点入队，其中我用绿色箭头指向队列的头节点。接着，如果我们直接访问队头节点并且让此节点出队的话，那么后边就不知道该访问谁了，那么你发现了嘛，下一层的节点刚好就是队头节点的左孩子和右孩子，此时，当我们访问队头节点的时候顺便让它的左孩子和右孩子入队即可。

就像这样子：

并且这时候也可以放心地把头节点从队列中删除掉，然后头节点就变成了节点 9。

到这里思考一个问题

如果有一个需求，你想一行一行地把这些节点输出你该怎么办呢？如果按照刚才的策略进行的话，你每次都从队头取一个节点出来，可是你并不知道当前你取的这个队头的节点到底是位于树中的第几层呀？

其实：当你在访问第一个节点之前，队列的长度就是你即将访问的那一层的节点的数量，那么这时候你就可以在访问这一层之前使用一个变量记下这一层的节点数量，当你访问过这么多的节点后让输出换行。并且这时候你访问完了一层的节点，而且每访问一个节点那么它的左孩子和右孩子也会入队，所以此时队列中放满了下一层的节点，也就是说，这时候的队列的长度又成为了下一层节点的数量。如此，我们就知道了如何一层一层的输出每一层的节点了。

2 访问第 2 层的节点

现在队头指针已经指向了节点 9，那么还是刚才的过程，访问节点 9 并且将节点 9 的非空的孩子入队，而现在你可以发现，它的左孩子和有孩子都为空，所以不用入队任何节点。

这时，把节点 9 从队列中去除，接着访问新的队头节点：

依然是按照刚才的套路，访问节点 20 再将节点 20 的左孩子和右孩子入队。

3 访问第 3 层节点

访问节点 15

访问节点 7

结束

当我们访问完成所有的节点后，你会发现队列也变成了空。所以，判断层次遍历是否完成的条件就是判断队列是为空。若队列为空则遍历结束。

3 代码实现 C++

LeetCode 给出的代码

// 节点的定义
struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode() : val(0), left(nullptr), right(nullptr) {}
      TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
      TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };


// Solution 在这里写算法的实现 
class Solution {
public:
    int minDepth(TreeNode* root) {
        
    }
};

对于 LeetCode 上边的这道题而言，并不需要遍历整个二叉树，而仅仅是找到第一个叶子节点的时候算法就可以结束了。因为我们是一层一层遍历的，所以访问到的第一个叶子节点所在的层一定是距离根节点最近的那一层，也就是题目中所叙述的那一层的最小深度。

完整代码

下边的代码只有一个函数，你可以对照这刚才所示的图片以及注释来理解这段代码。

class Solution {
public:
    int minDepth(TreeNode* root) {
        // 若根节点不存在则 depth 为 0 
        // 直接返回 0 即可
        if(root == nullptr) return 0;
        
        queue q;
        
        // 把根节点入队，让代码统一
        q.push(root);
        
        // 题目希望我们给出最小深度的值，
        // 所以需要一个变量记录最小深度的值是什么
        // depth 存储的是当前正在遍历的
        // 那一层的深度
        // 因为首先遍历的是根节点
        // 根节点为第 1 层
        // 则 depth 应初始化为 1
        int depth = 1;
        
        // 队列不为空则说明遍历没有结束
        while(!q.empty()) {
            // 在还没有开始遍历一层的时候
            // 队列 q 中存储了即将遍历的那一层的节点
            // 所以 q.size() 就是即将遍历的这一层的节点数量
            // 记录当前层的节点个数 sz
            int sz = q.size();
            
            
            // 一次 for 循环的完整执行
            // 就是完成了二叉树的一层的遍历
            for(int i = 0; i < sz; ++i){
                TreeNode* cur = q.front();
                q.pop();

                // 目标是找到第一个层次遍历中
                // 所遇到的那个叶子节点
                // 此时直接返回 depth
                if(cur->left == nullptr && cur->right == nullptr)
                    return depth;


                // 添加 cur 的相邻节点到队列中
                // 对于二叉树而言就是添加其不为空的孩子节点
                if(cur->left != nullptr)
                    q.push(cur->left);
                if(cur->right != nullptr)
                    q.push(cur->right);
            }

            // 此时完成了整个的 for 循环
            // 维护 depth 变量的定义
            // 继续遍历下一层的节点
            depth += 1;
        }

        // 对于这个题目来说
        // 它并不会执行
        // 因为一定可以在 while 循环中找到叶子节点
        // 但我不这么写， LeetCode 编译出错
        // 说存在没有返回值的情况
        // 尽管这个 return 语句没用
        // 为什么要减去 1 呢？
        // 因为每遍历完成一层后就会为 depth 加上 1
        // 而加上 1 后正准备要去遍历新的一层，
        // 但是已经遍历结束，所以新的一层并不存在则要减去 1
        return depth-1;
    }
};

0752-Open-The-Lock

这篇文章讨论一个关于 BFS 应用的题目，LeetCode 上边儿的 752 号问题：打开转盘锁（0752-Open-The-Lock）

1 题目描述

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。

锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。

列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

示例

输入：deadends = ["0201","0101","0102","1212","2002"], target = "0202" 输出：6 解释：可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的，因为当拨动到 "0102" 时这个锁就会被锁定。

那么先来理解下题目的意思，程序的输入是两个内容，一个是 **deadends ** 另外一个是 **target **

那么拨轮锁是什么东西呢，你可以脑补一下你行李箱上的那个锁子，可以拨动那个轮子然后转换成不同的数字。我简单画了一张图，可以参考下：

画图水平有限，只能画成这个样子了，绿色表示的是第几号波轮，再看绿色的圈圈中的数值就是指当前转到的密码是什么。如上图就是 0000

现在向上拨动 0 号波轮，那么这时候对应的密码就从 0000 变成了 1000

deadends 是什么意思？

在 **deadends ** 中存放了一组密码，指的就是在你拨动拨轮的过程中不能够在拨动的过程中拨出任意一个 **deadends ** 中存在的密码。

当前的 target = "0202", 按照正常情况来说，我们先把 0 号拨轮拨成 0，然后把 1 号拨轮拨成 2 再把 2 号拨轮拨成 0，最后 3 号拨轮拨成 2。我们也就打开密码锁了，但是在 deadends 中有一项是 0201，如果前三个已经拨成了 020 而在你拨动最后一个轮子的时候如果你向上拨动，你会先触发 0201 然后再触发 0202。那么相信你也理解了 deadends 的作用了，最后，题目要求我们寻找的是最少的拨动次数，只要单个拨轮的数字产生一次变化就视为拨动了一次。

题目的拨轮的初始状态为 0000

2 解题思路

从题目，可以知道，要求：求得的值是一个最少的拨动次数。那么，广度优先搜索求解的就是最少的次数，我们可以从状态 0000 出发，然后遍历所有的密码状态，当然，我们要按照一定的顺序来遍历所有的密码，这个顺序就是按照广度优先的顺序遍历。其实，所有的密码状态可以被我们抽象称为数据结构中的 图结构。

为了简单，这里我直接说重要的地方，如果不太好理解，那么可以参考下边的这篇文章，先把这篇文章搞懂后，相信接下来的内容会更加好理解。

传送门

BFS-求解二叉树的最小深度

到底是什么意思？举个例子

拨动次序，从第 0 号拨轮开始依次拨动到第 3 号拨轮，每个拨轮的拨动方向有上下两种选择。那么也就意味着每一个密码状态节点共有 8 个相邻节点，因为我们可以从一个密码状态通过 8 种不同的操作得到另外一个密码状态。如果你学习过图结构，是不是忽然就能够理解了呢？

按照广度优先的策略，每次我们从队列中取一个节点出来访问它，并且把它的相邻节点插入到队尾。然后接着循环刚才的过程就好了。

注意一个问题

假如当前我们访问到的密码节点是 0001，这时候我们选择把 3 号拨轮，向上拨动那么节点 0002 就会插入到队列，我们迟早也会访问到节点 0002。

那么思考一下，如果我们现在访问到的节点是 0003 ，这时候把第 3 号拨轮向下拨动就变成了 0002 节点，这时候 0002 节点也会插入到队尾。

这就产生了一个问题，我们会形成一个死循环，因为被访问过的状态再今后还会访问，这样会一直持续下去。有没有什么好方法，来解决这个问题呢？那就是，可以对每一个访问过的状态标记一下，当我们要把一个密码状态插入到队尾之前就先判断一下当前这个状态是不是已经被放进过队列中了，如果已经放进过了，那么我们直接跳过当前状态即可。在后边的程序中，我会使用一个布尔类型的数组来完成这件事情，当然你也可以选择使用哈希表或者字典等等都可以。但是使用数组的画，或许会更加高效，因为数组对于元素是随机访问的而若使用其他的数据结构还需要先查找再访问。

我简单化了一张图，可以参过来理解：

其实整个求解过程就是图的广度优先遍历，每个节点都会有 8 个相邻的节点，我只画出了很小的一部分，

顺便再来理解一下题目中的 deadends

假设在 deadends 中有一个密码状态是 0008，而且现在的 target = 0007。

其实它想表达的意思就是我们不能够通过节点 0008 来访问节点 0007

初始化注意的问题

那么我们又如何来判断是否能够通过一个节点访问到另外一个节点呢，在刚才我们提到了一个布尔类型的数组，只要我们在程序开始运行之前，我们就在布尔类型的数组中标记这个节点是不能够加入队列的，那么我们的程序自然也就不会访问到 0008 这个节点了。

3 代码实现 C++

LeetCode 给出的代码

class Solution {
public:
    int openLock(vector& deadends, string target) {

    }
};

在文章最下边我给出了完整的代码，你可以对照文章末尾的完整代码和这里的部分片段来结合起来理解，而在这里我会拆解每一个部分详细阐述：

布尔类型的数组

因为共有 4 个拨轮，每个拨轮又有 10 种状态（0~9），所以用这样的一个数组刚好可以记录某一个密码状态是否被访问过。

比如 visited[1][2][3][4] 就是表示说，密码状态 1234 时已经被加入到过队列了吗？当我们要加入 1234 这个状态到队列之前，我们先判断这个条件是否是 false。

visited[1][2][3][4] == true 表明已经已经被加入过了

visited[1][2][3][4] == false 表明没有被加入过

// 用于标记某个节点是否被访问过
bool visited[10][10][10][10];

isVisited 函数

为了方便，我把对一个密码状态是否被访问过的这个操作封装成了一个函数。

在程序中使用字符串对象来存储一个密码状态，由于数组下标需要整型，所以要先把每个字符转换成对应的整型最后直接返回这个结果就好了。

    bool isVisted(string s) {
        unsigned int s0 = s[0] - '0';
        unsigned int s1 = s[1] - '0';
        unsigned int s2 = s[2] - '0';
        unsigned int s3 = s[3] - '0';
        
        return visited[s0][s1][s2][s3];
    }

visite 函数

每当我们把一个密码状态放入队列后，放了防止下次重复放入相同的密码状态，所以需要在 visited 数组种标记一下，那么，我把这个标记的功能封装在了 visite 函数中，非常简单。

    void visite(string s) {
        unsigned int s0 = s[0] - '0';
        unsigned int s1 = s[1] - '0';
        unsigned int s2 = s[2] - '0';
        unsigned int s3 = s[3] - '0';

        // cout << "visite : " << s << endl;

        visited[s0][s1][s2][s3] = true;
    }

plusOne 函数

当我们对密码状态 s 的第 j 号拨轮向上拨动一次那么就会产生一个新的密码状态，我把这个功能放在了 plusOne 函数中，这个函数会以字符串的形式返回拨动后的新的密码状态的字符串格式。

    // s[j] 向上拨动一次
    string plusOne(string s, int j) {
        if(s[j] == '9')
            s[j] = '0';
        else
            s[j] += 1;

        return s;
    }

minusOne 函数

当我们对密码状态 s 的第 j 号拨轮向下拨动一次那么就会产生一个新的密码状态，我把这个功能放在了 minusOne 函数中，这个函数会以字符串的形式返回拨动后的新的密码状态的字符串格式。

    // s[j] 向下拨动一次
    string minusOne(string s, int j) {
        if(s[j] == '0')
            s[j] = '9';
        else
            s[j] -= 1;

        return s;
    }

最后就只剩下 openLock 的核心逻辑了，那么可以直接在完整代码中结合其他的部分和代码中的注释来理解最后的逻辑。

完整代码

#include 
#include 
#include 
#include 
using namespace std;


class Solution {
public:

    // 用于标记某个节点是否被访问过
    bool visited[10][10][10][10];

    void visite(string s) {
        unsigned int s0 = s[0] - '0';
        unsigned int s1 = s[1] - '0';
        unsigned int s2 = s[2] - '0';
        unsigned int s3 = s[3] - '0';

        visited[s0][s1][s2][s3] = true;
    }

    bool isVisted(string s) {
        unsigned int s0 = s[0] - '0';
        unsigned int s1 = s[1] - '0';
        unsigned int s2 = s[2] - '0';
        unsigned int s3 = s[3] - '0';
        
        return visited[s0][s1][s2][s3];
    }

    // s[j] 向上拨动一次
    string plusOne(string s, int j) {
        if(s[j] == '9')
            s[j] = '0';
        else
            s[j] += 1;

        return s;
    }

    // s[j] 向下拨动一次
    string minusOne(string s, int j) {
        if(s[j] == '0')
            s[j] = '9';
        else
            s[j] -= 1;

        return s;
    }

    int openLock(vector& deadends, string target) {
        // 每个节点的相邻节点有 8 个
    
        // 初始化为每个节点都没有访问过
        // 数组整个都初始化为 0 就代表了是 false
        memset(visited, 0, sizeof(visited));

        // 在 visited 中初始化不可达的顶点
        // 遍历 deadends 中的每一个密码状态
        // 把这些节点都标记为已经入队过
        // 其实就是在说，这些结果不能够再被访问了
        // 因为 BFS 每次都是从队列中取一个节点来访问
        // 不能够入队就代表了不会从队列中被访问
        for(auto s : deadends) {
            visite(s);
        }

        // 极端情况的考虑
        // 如果 deadends 中存在 0000
        // 又由于我们密码锁的初始状态就是 0000
        // 所以我们无法从 0000 访问到任何节点
        // 则程序返回 -1 表示无解
        if(isVisted(string("0000")))
            return -1;
            
        // step 记录的是
        // 当前正在遍历的这些节点
        // 从 0000 状态开始
        // 最少需要拨动几次才能够触达
        // 初始化为拨动 0 次
        // 因为 0000 状态不需要拨动
        // 0000 状态就是最初始的状态
        int step = 0;

        // 用 start 字符串记录初始状态 0000
        string start = "0000";
        
        // BFS 用到的辅助队列 q
        queue q;

        // 让初始状态入队
        q.push(start);

        // 并且标记该状态已经入队过了
        visite(start);

        // 队列不为空则 BFS 未结束
        while(!q.empty()) {
            // 通过 size 可以知道当前遍历的那一层有多少个节点
            // 每遍历完成 size 个节点后
            // step 就应该增加 1 
            int sz = q.size();

            for(int i = 0 ; i < sz ; ++i) {
                // 从队头取一个节点出来
                string cur = q.front();
                // 并且删除队头节点
                q.pop();

                // 判断是否是目标 target
                if(cur == target)
                    return step;

                // BFS 的套路
                // 添加相邻节点
                // 只不过这里的相邻节点需要自己来构建
                // 共有 4 个拨轮
                // 每个拨轮可以向上或向下两种拨动方式
                for(int j = 0 ; j < 4 ; ++j) {
                    string plus_cur = plusOne(cur, j);
                    // 入队之前要保证此节点没有被入队过
                    if(!isVisted(plus_cur)) {
                        q.push(plus_cur);
                        // 入队后标记此节点已经入队过了
                        visite(plus_cur);
                    }

                    string minus_cur = minusOne(cur, j);
                    // 入队之前要保证此节点没有被入队过
                    if(!isVisted(minus_cur)) {
                        q.push(minus_cur);
                        // 入队后标记此节点已经入队过了
                        visite(minus_cur);
                    }
                }

            }

            // 维护 step 变量
            step += 1;
        }

        // 整个 BFS 结束后还没有找到解
        // 则不可达
        return -1;
    }
};




int main() {

    vector deadends = {
        "0000"
    };

    string target = "8888";
    
    Solution solution;
    int res = solution.openLock(deadends, target);

    cout << "res : " << res << endl;


    return 0;
}

0416 分割等和子集

哈喽 ~

你好啊，我是蓝莓 ~

416 LeetCode

1 暴力搜索

理解题目是要把给定的 nums 数组中的元素拆分成集合 A 和集合 B，使得 sum(A) 等于 sum(B)，也就是 sum(A) = sum(B) = sum(nums)/2 。

记 sum(nums) / 2 = C

最简单的方法就是遍历所有的子集，从中挑出一个满足要求的集合，那么剩下的另外一半元素也一定就是满足要求的另外一个集合了。

2 动态规划

这个题目可以用 0-1 背包 的思路解决，因为本质就是从中寻找出一组数值，然后看看这些数值能不能刚好装满容量 C 。

那么 dp 数组要如何设置呢？

bool dp[nums.size()][C+1]

nums.size() 是数值的个数
取 C+1 是因为下标从 0 到 C 这么多种容量的情况

dp[i][j] 表示考虑 [0...i] 这些数值，且容量为 j 时，能否有一个数值的子集求和后刚好等于 C。

我们要求的结果就是 dp[nums.size()-1][C]，它代表了考虑所有的元素，并且容量为 C 的时候，能否从所有的元素中找到一个子集使得该集合的元素和等于 C。

当 dp[i][j] = true 说明考虑 [0...i] 这些编号的数值且容量为 j 的时候刚好可以装满容量 j，也就是说可以从 [0...i] 这些编号的数值中找到一个子集，使得该子集的数值和等于 j。
当 dp[i][j] = true 说明考虑 [0...i] 这些编号的数值且容量为 j 的时候不能装满容量 j。

那么dp[i][j] 的值取决于什么呢？

对于 第i号 数值可以选择要或不要

选择要那么就要判断一下容量 j 能否装入 第i号 数值。如果可以装入，这时候还剩下的容量为 j-nums[i]，再考察一下 dp[i-1][j-nums[i]] 的情况，如果 dp[i-1][j-nums[i]] = true 则 dp[i][j] = true 。 dp[i-1][j-nums[i]] = true 表达的意思是：当我装进去 第i号 数值后，那么考虑上前边的那些数值，也就是编号为 [0...i-1] 的这些数值并且使用剩下来的 j-nums[i] 这么大的容量能否被前 [0...i-1] 这些编号的数值装满。如果不能的话，就是说，虽然把 第i号 数值装进去了，同时也消耗了 nums[i] 这么大的容量，但是剩下的空间并不能被 [0...i-1] 这些编号的数值的子集装满，这样同样不符合题目要求，所以 dp[i][j] 的值一方面取决于 dp[i-1][j-nums[i]] 的值。
如果选择不要那么 dp[i][j] = dp[i-1][j]，这个应该很好理解，如果你不要 第i号 数值，那么此时的结果其实和 dp[i-1][j] 是一样的。不要 第i号 数值的话，问题就变成了：考虑一下 [0...i-1] 这些编号的数值能否找到一个子集，并且这个子集的数值和能否刚好等于 j。

最终

dp[i][j]

= dp[i-1][j-nums[i]] || dp[i-1][j]

只要，要或不要两种决策方案种有一个方案是可以使得背包的容量被装满的，那么 dp[i][j] 就可以满足被装满的要求。

总结一下

只要两种方案中有一个可以满足要求 dp[i][j] = true
两种方案都不满足要求 dp[i][j] =false

你可以发现更新 第i号 行需要 第 i-1 号 行的数据作为支撑

处理特殊行和列

当背包的容量为 0 的时候，一定存在一个子集可以把背包装满，只要我们什么数值都不选就好了呀，这个子集就是空集呀。所以 dp 数组的第 0 列也就是容量为 0 的那一列的值都为 true。

因为更新 第i号 行的数据需要 第 i-1 号 行的数据作为支持，所以我们先专门计算出 第0号 行的值。在计算 0 列的时候，已经计算出了 dp[0][0] 的值，所以只需要计算 dp[0][1...C] 的值就可以了。这些值中只有那个容量刚好等于 nums[0] 的位置才能被刚好装满，其余的位置都是不能被装满的。

那么特殊行的处理代码就很简单了：

// 容量为 0 的时候都能装满 ==> 可以都不装
for(int i = 0 ; i < nums.size() ; ++i)
  dp[i][0] = true;

// 当容量 >= 1 的时候只有 dp[0][nums[0]] 能装满
// 其他位置都装不满
for(int j = 1 ; j <= C ; ++j)
  dp[0][j] = false;

// dp[0][nums[0]] 能装满
if(nums[0] <= C) dp[0][nums[0]] = true;

dp 数组更新

接下来，就是其他行的数值更新了。其他行的每个位置的值都可以根据上一行的结果推算出来

我们只需要更新 dp[1...nums.size()-1][1...C] 这些值即可，也就是排除了第 0 行和第 0 列。

for(int i = 1 ; i < nums.size() ; ++i) {
  for(int j = 1 ; j <= C ; ++j) {
    // 容量不足以装入 i 号元素
		// 那么只能选择不装 i 号元素了
    if(nums[i] > j)
      dp[i][j] = dp[i-1][j];
    else {
      // 容量 j 能装入第 i 号元素
      // 结果取 装入 i 号 或 不装入 i 号元素
			// 只要其中一个方案成功即可
      dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];
    }
  }
}

3 完整代码

class Solution {
public:
    bool canPartition(vector& nums) {
        int sum = 0;
        for(int num : nums)
            sum += num;

        // sum 是奇数的时候是不可能分割的
        if(sum % 2 != 0) return false;

        // [0...nums.size()-1] 数值
        // [0...C] 容量
        int C = sum / 2;
        // dp[i][j] 考虑 [0...i] 数值且容量为 j 时能否装满
        bool dp[nums.size()][C+1];

        // 容量为 0 的时候都能装满 ==> 可以都不装
        for(int i = 0 ; i < nums.size() ; ++i)
            dp[i][0] = true;

        // 当容量 >= 1 的时候只有 dp[0][nums[0]] 能装满
        // 其他位置都装不满
        for(int j = 1 ; j <= C ; ++j)
            dp[0][j] = false;

        // dp[0][nums[0]] 能装满
        if(nums[0] <= C) dp[0][nums[0]] = true;


        for(int i = 1 ; i < nums.size() ; ++i) {
            for(int j = 1 ; j <= C ; ++j) {
                // 容量不足以装入 i 号元素
                // 先减去了第 i 号元素所需要的空间
                // 然后才去装其他的元素的
                if(nums[i] > j)
                    dp[i][j] = dp[i-1][j];
                else {
                    // 容量 j 能装入第 i 号元素
                    // 结果取 装入 i 号 或 不装入 i 号元素
                    // 两者中能够正好装满的那个结果
                    // 不装入 i 号元素的时候是 j-0
                    // 装入 i 号元素的时候是 j-nums[i]
                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];
                }
            }
        }

        return dp[nums.size()-1][C];
    }
};

0416-状态压缩

哈喽 ~

你好啊 ~ 我是蓝莓 ~

LeetCode 416 （状态压缩）

在上一篇文章中，提到了怎么使用动态规划的方法来解决这个问题，但其实还能够进一步对改问题做优化。

在更新 dp 数组的时候，更新 第i号 行的值需要使用到 第i-1号 行的数据才可以，而更新完成 第i号 行后，就不会再次用到 第i-1号 行的数据了，所以并不需要存储那么多的值，我们可以把二维的 dp 数组压缩成一维的 dp 数组。

定义 dp 数组

bool dp[C]

修改状态转移方程

在之前的状态转移方程式这样的：

dp[i][j]

= dp[i-1][j-nums[i]] || dp[i-1][j]

使用了一维的 dp 数组后：

dp[j] = dp[j-nums[i]] || dp[j]

你仔细想想，相信这个式子是非常好理解的 ~ 等号右边的 dp[j] 可以理解为旧的 dp[j]，它就相当于 dp[i-1][j]。等号左边的 dp[j] 是新一轮的 dp[j] 其实就相当于 dp[i][j]，但是为什么能够直接把新的 dp[j] 放在旧的 dp[j] 的位置呢？因为旧的 dp[j] 的值最后一次使用就是在计算新的 dp[j] 的时候，而此后再也不会被用到了。

这里所说到的最后一次使用是按照新的计算顺序而言的，下边就会说明新的计算顺序是怎样的。

如何更新 dp 数组

在更新一维 dp 数组的时候就不能像二维那样的顺序来更新了，因为新的 dp[j] 的值取决于旧的dp[j] 和 dp[j-nums[i]] 如果更新 dp 数组是按照从左到右进行更新的话，计算靠右的值需要用到左边的值，而左边是先被更新的，所以就已经被覆盖了。

那么很简单的，我们只需要按照从右到左的顺序进行计算并且更新一维的 dp 数组就可以了

到这里思考一下，为什么这种优化方式叫做 状态压缩 呢，相信聪明的你也看出来了，dp 数组占用的空间少了很多，少存了很多的中间状态的值。少了就是压缩了嘛 ~

完整版代码

class Solution {
public:
    bool canPartition(vector& nums) {
        int sum = 0;
        for(int num : nums)
            sum += num;

        // sum 是奇数的时候是不可能分割的
        if(sum % 2 != 0) return false;

        // [0...nums.size()-1] 数值
        // [0...C] 容量
        int C = sum / 2;

        // 容量 [0...C]
        int dp[C+1];

        // 处理仅考虑 0 号元素的情况
        dp[0] = true; // 选择不装 0 号元素可装满
        for(int j = 1 ; j <= C ; ++j)
            dp[j] = false;
        // 该位置可装满
        if(nums[0] <= C) dp[nums[0]] = true;

        for(int i = 1 ; i < nums.size() ; ++i) {
            for(int j = C ; j >= 0 ; --j) {
                // 没办法装入 i 号元素的时候
                // dp[j] 的值不变
                if(j >= nums[i]) {
                    dp[j] = dp[j] || dp[j-nums[i]];
                }
            }
        }

        return dp[C];
    }

};

如何写出正确的代码

你好啊，我是蓝莓。

在这片文章中，通过二分查找来聊一聊如何写出正确的代码。

什么二分查找？

二分查找的思想不难理解，在一个有序数组中，我们要寻找 target，我们直接将该数组一分为二，直接去对比中间位置的那个值是不是我们要找的值。

如果该数组正中间的值 v刚刚好就是我们要找的值的话，那么皆大欢喜，我们已经找到了这个值所在数组中的位置了。
如果我们要找的值 target > v 那么我们就直接丢弃数组左边的那部分值，直接去数组的右边进行搜索。
如果我们要找的值 target < v 那么我们就直接丢弃数组的右边的那部分值，直接去数组的左边进行搜索。

我们只需要不断的重复刚才的过程，如果 target 存在于该数组中的话，我们一定是能查找到的，如果这个值不在数组中的话，随着我们搜索的推进，我们可搜索的范围会越来越小，直到没有内容可以搜索，这时候就说明 target 不存在于该数组中。

循环不变量

有一个很专业的名词叫 循环不变量，虽然某些变量的值是一直在改变的，但是这个变量的定义是一直保持不变的，那么我们来看看二分搜索中的循环不变量是什么？

在这里，我定义一个函数 binarySearch 并且传递三个参数

arr 这是我们要搜索的数组
arr 数组中包含 n 个元素，也就是 arr[0] 到 arr[n-1] 都是可以读取到的
target 是我们要搜索的目标值，判断 arr 中是否包含 target

// 在包含 n 个元素的数组 arr 中寻找目标值 target 的下标
int binarySearch(const int* arr, int n, int target) {
    // 在区间 [l...r] 这个区间内寻找 target
    int l = 0, r = n-1;

    // 在没有找到并且 [l...r] 区间内仍然是有元素的情况下继续查找
    while( l <= r ) {
        int mid = (l+r) / 2;
        if( arr[mid] == target ) {
            return mid;
        } else if( target > arr[mid] ) {
            l = mid+1;
        } else {
            // target < arr[mid]
            r = mid-1;
        }
    }

    return -1;  // 如果循环都结束了，说明还是没有找到，那么返回 -1 代表失败
}

接着让我们一点一点的来看：

这里的 l 和 r 分别代表我们要搜索的位于 arr 数组中的氛围，我们要在区间 [l...r] 这个范围内寻找 target；这里的 l 和 r 就是我们要维护的循环不变量，因为我们始终要在 [l...r] 这样一个闭区间内寻找 target

    // 在区间 [l...r] 这个区间内寻找 target
    int l = 0, r = n-1;

循环进行的条件：

什么情况下，循环要继续进行下去呢？那就是，我们依然没有寻找到 target 并且 [l...r] 这个区间内依然是有元素的，这种情况就要让循环继续下去。即使当 l 等于 r 的时候，[l...r] 这个区间内依然是拥有一个元素的，所以，我们依然还是可以继续让循环进行下去的，因此循环的条件应该是 l <= r

    // 在没有找到并且 [l...r] 区间内仍然是有元素的情况下继续查找
	while( l <= r ) {

    }

接着，我们就来看循环内部的语句了，在本轮循环中共有三种情况，首先我们先计算出 [l...r] 这个范围内正中间的下标是什么，得到 mid，随后这三种情况分别是：

arr[mid] 就是我们要找的 target
我们要找的 target 比 arr[mid] 还要大一些，这时候我们可以寻找右边的那部分
我们要找的 target 比 arr[mid] 还要小一些，这时候我们可以寻找左边的那部分

后面的那两种情况，我们只需要简单的通过修改 l或r 的值就可以了，通过修改搜索区间的索引来维持这件事情。

在修改搜索区间的时候，你可以发现，我们都跳过了 mid 这个位置，也就是说，如果当前的 arr[mid] 不是我们要找的那个值，在下一次的搜索区间中将不会包含 mid 这个下标了，这里也恰到好处的维护了 [l...r] 这个区间就是我们将要搜索的范围这样一个循环不变量。就是说：l 和 r 这两个变量的值虽然在改变，但是它们的定义始终不变。

    while( l <= r ) {
        int mid = (l+r) / 2;
        if( arr[mid] == target ) {
            return mid;  // 如果找到了就直接返回
        } else if( target > arr[mid] ) {
            l = mid+1;
        } else {
            // target < arr[mid]
            r = mid-1;
        }
    }

测试

我们通过写一个简单的代码，来测试一下我们的算法

int main() {

    const int n = 1000000;
    int* arr = new int[n];

    // 生成一个包含 n 个元素的完全有序的数组 arr
    for(int i = 0; i < n; i++) {
        arr[i] = i;
    }

    // 对 arr 中的每一次元素都进行查找
    clock_t start_time = clock();
    for(int i = 0; i < n; i++) {
        assert(i == binarySearch(arr, n, i));
    }
    clock_t end_time = clock();

    // 计算查找 n 次所需要的时间
    cout << "Time: " << double(end_time - start_time) / CLOCKS_PER_SEC << endl;
    cout << "done!" << endl;
    return 0;
}

运行结果：

在包含 100w 个元素的数组中进行 100w 次二分查找，在我的计算机上共使用了 0.08秒的时间；

完整代码

本文采用了 C++

#include 
#include 
#include 
using namespace std;

// 在包含 n 个元素的数组 arr 中寻找目标值 target 的下标
int binarySearch(const int* arr, int n, int target) {
    // 在区间 [l...r] 这个区间内寻找 target
    int l = 0, r = n-1;

    // 在没有找到并且 [l...r] 区间内仍然是有元素的情况下继续查找
    while( l <= r ) {
        int mid = (l+r) / 2;
        if( arr[mid] == target ) {
            return mid;
        } else if( target > arr[mid] ) {
            l = mid+1;
        } else {
            // target < arr[mid]
            r = mid-1;
        }
    }

    return -1;
}

int main() {

    const int n = 1000000;
    int* arr = new int[n];

    // 生成一个包含 n 个元素的完全有序的数组 arr
    for(int i = 0; i < n; i++) {
        arr[i] = i;
    }

    // 对 arr 中的每一次元素都进行查找
    clock_t start_time = clock();
    for(int i = 0; i < n; i++) {
        assert(i == binarySearch(arr, n, i));
    }
    clock_t end_time = clock();

    // 计算查找 n 次所需要的时间
    cout << "Time: " << double(end_time - start_time) / CLOCKS_PER_SEC << endl;
    cout << "done!" << endl;
    return 0;
}

0283 移动零

题目描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
提示:

1 <= nums.length <= 104

-231 <= nums[i] <= 231 - 1

代码:
class Solution {
public:
    void moveZeroes(vector& nums) {
        
    }
};

方法一

思路

方法一和题目的要求不太符合，题目说了：在不复制数组的情况下原地完成，咱们先使用一个更简单的方法来实现

把所有的非零元素从 nums 里面拿出来放在 nonZeroNums 中，然后再把 nonZeroNums 中的元素放回 nums，nums 的其他元素赋值为 0

代码实现

class Solution {
public:
    void moveZeroes(vector& nums) {
        vector nonZeroNums;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            if( nums[i] != 0 )
                nonZeroNums.push_back( nums[i] );
        }

        for( int i = 0 ; i < nonZeroNums.size() ; i++ ) {
            nums[i] = nonZeroNums[i];
        }

        for( int i = nonZeroNums.size() ; i < nums.size() ; i++ ) {
            nums[i] = 0;
        }
    }
};

方法二

思路

维护一个区间，我们规定 nums 数组的 [0...r) 表示的是非零元素的部分，在算法初始化的时候 r 的值等于 0，所以这样一个左闭右开的区间再算法一开始表达的是一个空区间的意思。
使用一个索引 i 从 0 开始遍历整个 nums 数组，如果 i 遇到的这个位置的元素是非零元素，那么就把这个元素放在 r 索引的位置，然后再让 r 索引向右移动一个位置，扩大非零元素的区间（因为我们向非零元素的区间添加了一个非零元素，当然就要扩大啦），你可以发现 r 这个索引指向的始终是下一次我们发现非零元素的时候要放的位置。
最后，我们全都遍历完了，我们就要把 nums 数组从 r 一直到最后的全部元素赋值为 0

代码实现

class Solution {
public:
    void moveZeroes(vector& nums) {
        // [0...r) 是非零元素的区间
        // [0...0) 表示空区间

        int r = 0;
        for( int i = 0 ; i < nums.size() ; i++ ) {
            if( nums[i] != 0 ) {
                nums[r++] = nums[i];
            }
        }

        for( int i = r ; i < nums.size() ; i++ ) {
            nums[i] = 0;
        }
    }
};

方法三

思路

在方法二中你可能会发现，最后赋值 0 的过程有些多余，所以我们还可以改一下，写成方法三的样子，我们直接在遍历非零元素的时候就把 0 给赋值上去，要注意 r 和 i 如果指向的是同一个元素的话，我们是不能赋值为 0 的，不然我们就把非零元素给覆盖掉了

代码实现

class Solution {
public:
    void moveZeroes(vector& nums) {
        // [0...r) 是非零元素的区间
        // [0...0) 表示空区间

        int r = 0;
        for( int i = 0 ; i < nums.size() ; i++ ) {
            if( nums[i] != 0 ) {
                nums[r] = nums[i];
                if( r != i) {
                    nums[i] = 0;
                }
                r++;
            }
        }
    }
};

0027 移动元素

你好啊，我是蓝莓，今天是每日一题的第 2 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/remove-element/description/

题目描述

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：

0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

实现

思路

这个题目和「每日一题」力扣 283 移动零使用的方法是类似的，我们都是维护一个一开始为空的区间，然后在不断的扫描数组同时维护好我们定义的那个最终答案的区间。

维护 nums 数组的区间 [0...k) 为不等于 val 元素的区间
由于区间 [0...k) 装的是不等于 val 的值，所以在算法开始前，我们应该让 k 的值为 0 这样就表示我们在算法开始之前，这个区间内不包含任何元素，每当我们发现一个不等于 val 元素的值后就把这个值和索引 k 所在的值进行交换并让 k 向右移动一个位置
在代码实现中有一点是判断 i 和 k 是否相同，如果 i 等于 k 的话，那么我们就没有必要让 nums[i] 和 nums[k] 的值进行交换了，我们只需要让 k 向右移动一个位置就可以让这个元素放进我们维护的区间里面了

Python 代码实现

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        # 维护区间 [0...k) 为非 val 元素的区间
        # 初始化 k 为 0 则 [0...0) 代表为一个空区间
        k = 0

        # 遍历 nums 列表
        for i in range(len(nums)):
            if nums[i] != val:
                if i != k:
                    nums[k], nums[i] = nums[i], nums[k]
                k += 1

        return k

C++ 代码实现

class Solution {
public:
    int removeElement(vector& nums, int val) {
        // [0...k) 区间维护不等于 val 的元素
        int k = 0;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            if( nums[i] != val ) {
                if( k != i ) {
                    swap(nums[k], nums[i]);
                } 
                k++;
            }
        }

        return k;
    }
};

Java 代码实现

class Solution {
    public int removeElement(int[] nums, int val) {
        int k = 0;

        for( int i = 0 ; i < nums.length ; i++ ) {
            if( nums[i] != val ) {
                if( i != k ) {
                    int temp = nums[i];
                    nums[i] = nums[k];
                    nums[k] = temp;
                }
                k++;
            }
        }

        return k;
    }
}

0026 删除有序数组中的重复项

你好啊，我是蓝莓，今天是每日一题的第 3 天。

我的博客：https://blueberry-universe.cn/lc/index.html

力扣题目：https://leetcode.cn/problems/remove-duplicates-from-sorted-array/description/

题目描述

给你一个 非严格递增排列 的数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 非严格递增 排列

实现

思路

同样的，这个题目和之前写过的两个题目的解决方法是一样的，这两个题目的链接如下：

「每日一题」力扣 283 移动零

「每日一题」力扣 27 移动元素

维护 nums[0...k) 为不重复的元素所在区间
索引 k 在算法初始时应赋值为 0 ；代表算法开始前， nums[0...k) 是一个空区间
由于 nums 数组是一个非严格的递增序列（当出现相邻元素的时候，这段区间就是所谓的非严格递增了，同时也告诉我们，重复的元素在 nums 数组中都是相邻的），所以使用索引 i 遍历整个 nums 数组，每当我们发现 i 遍历到的元素和 nums[0...k) 这个区间的最后一个元素不相等的时候就说明我们找到了一个新的不重复的元素，这时候我们只需要把这个新的元素纳入到 nums[0...k) 这个区间就可以了
nums[0...k) 区间的最后一个元素其实就是 nums[k-1] 这个元素
需要注意的是：如果 nums[0...k) 这个区间一开始为空的话，也就是说 k = 0，那么 nums[k-1] 就是 nums[-1] 了，这显然是越界的。因此，除了在 nums[i] != nums[k-1] 的时候可以在区间中纳入一个新的不重复元素外，还可以在 k = 0 的时候在我们维护的区间中纳入一个新的元素，这时候，你可以选择直接让 k 增加 1，或者你也可以在代码中保持统一写成 nums[k] = nums[i] 的形式（这就相当于自己赋值给了自己嘛），然后再让 k 增加 1，其实都是一样的。
根据题目描述中的测试方式来看，这个题目只需要将不重复的元素放在 nums 数组的左侧就可以了，并不需要我们清除那些重复的元素，所以我们可以不对 nums 数组的大小进行调整

Python 代码实现

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        k = 0
        for i in range(len(nums)):
            if k == 0 or nums[i] != nums[k-1]:
                nums[k] = nums[i]
                k += 1
        
        return k

C++ 代码实现

class Solution {
public:
    int removeDuplicates(vector& nums) {
        // 维护 nums[0...k) 装在不重复的元素所在区间

        int k = 0;
        for( int i = 0 ; i < nums.size() ; i++ ) {
            if( k == 0 || nums[i] != nums[k-1] ) {
                nums[k++] = nums[i];
            }
        }
        return k;
    }
};

Java 代码实现

class Solution {
    public int removeDuplicates(int[] nums) {
        int k = 0;

        for( int i = 0 ; i < nums.length ; i++ ) {
            if( k == 0 || nums[i] != nums[k-1] ) {
                nums[k++] = nums[i];
            }
        }

        return k;
    }
}

Golang 代码实现

func removeDuplicates(nums []int) int {
    k := 0;

    for i := 0 ; i < len(nums) ; i++ {
        if k == 0 || nums[i] != nums[k-1] {
            nums[k] = nums[i];
            k += 1;
        }
    }

    return k;
}

0080 删除有序数组中的重复项 II

你好啊，我是蓝莓，今天是每日一题的第 4 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii/description/

题目描述

给你一个有序数组 nums ，请你** 原地** 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,1,2,3,3]
输出：7, nums = [0,0,1,1,2,3,3]
解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列

实现

思路

这个题目和以下三个题目的思路是差不多的，链接如下：

「每日一题」力扣 283 移动零

「每日一题」力扣 27 移动元素

「每日一题」力扣 26 删除有序数组中的重复项

nums[0...k) 区间为这个题目的结果，这个区间中允许每个数值最多出现 2 次，超过 2 次的是不会出现在这个区间中的
k 的初始值依然为 0，这代表在算法开始之前，nums[0...k)` 这个区间是一个空区间
用索引 i 遍历 nums 数组，每当我们发现一个数值实在 nums[0...k) 区间中出现的次数不超过 2 次的，我们就把这个元素纳入到 nums[0...k) 区间中 -最后一个问题就是：我们如何判断当前遍历到的元素 nums[i] 在当前的区间 nums[0...k) 中出现的次数是小于 2 次的？因为题目给出的数组 nums 的元素是按照从小到大的顺序排序好的，所以如果是连续出现的数值，必然被我们纳入到 nums[0...k) 区间中也是连续的，所以我们可以直接判断：是不是 nums[k-2] != nums[i]。如果是不是 nums[k-2] != nums[i] 是成立的，那么我们就可以把当前这个元素纳入到 nums[0...k) 区间中了。nums[k-2] 代表的就是这个区间中的倒数第二个元素，当我们发现 nums[i] 和倒数第一个元素相等是没关系的，因为在我们维护的区间中每个元素最多可以出现两次，可是一旦这个元素和倒数第二个元素相等，那就不行了。
越界处理：由于当 k == 0 或者 k == 1 的时候 nums[k-2] 的访问是越界的，然而这个题目又允许每个元素最多可以出现两次，所以当当 k == 0 或者 k == 1 的时候直接无脑将 nums[i] 纳入到我们维护的区间即可。

Python 代码实现

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 维护 nums[0...k) 区间为出现小于等于 2 次的元素
        k = 0

        for i in range(len(nums)):
            # 只要 nums[i] 不等于 nums[0...k) 区间中的倒数第2个元素即可
            if k == 0 or k == 1 or nums[i] != nums[k-2]:
                nums[k] = nums[i]
                k += 1

        return k

C++ 代码实现

class Solution {
public:
    int removeDuplicates(vector& nums) {
        // 维护 nums[0...k) 区间为出现小于等于 2 次的元素
        int k = 0;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            // 只要 nums[i] 不等于 nums[0...k) 区间中的倒数第2个元素即可
            if( k == 0 || k == 1 || nums[i] != nums[k-2]) {
                nums[k++] = nums[i];
            }
        }

        return k;
    }
};

Java 代码实现

class Solution {
    public int removeDuplicates(int[] nums) {
        // 维护 nums[0...k) 区间为出现小于等于 2 次的元素
        int k = 0;

        for( int i = 0 ; i < nums.length ; i++ ) {
            // 只要 nums[i] 不等于 nums[0...k) 区间中的倒数第2个元素即可
            if( k == 0 || k == 1 || nums[i] != nums[k-2] ) {
                nums[k++] = nums[i];
            }
        }

        return k;
    }
}

Golang 代码实现

func removeDuplicates(nums []int) int {
    // 维护 nums[0...k) 区间为出现小于等于 2 次的元素
    k := 0

    for i := 0 ; i < len(nums) ; i++ {
        // 只要 nums[i] 不等于 nums[0...k) 区间中的倒数第2个元素即可
        if k == 0 || k == 1 || nums[i] != nums[k-2] {
            nums[k] = nums[i]
            k += 1
        }
    }

    return k;
}

0075 颜色分类

你好啊，我是蓝莓，今天是每日一题的第 5 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/sort-colors/description/

题目描述

给定一个包含红色、白色和蓝色、共 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

进阶：

你能想出一个仅使用常数空间的一趟扫描算法吗？

方法一

思路

第一种方法，我们可以使用计数排序的思路
遍历 nums 数组，统计出 0, 1, 2 三个数值出现的次数分别是多少
然后按照统计出的出现的次数，依次填回到 nums 数组中即可

Python 代码实现

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 使用 counter 记录 0 1 2 分别出现的次数
        counter = [0, 0, 0]

        # 统计 0 1 2 出现的次数
        for num in nums:
            counter[num] += 1

        i = 0
        for num in range(len(counter)):
            for _ in range(counter[num]):
                nums[i] = num
                i += 1

C++ 代码实现

class Solution {
public:
    void sortColors(vector& nums) {
        // 使用 counter 记录 0 1 2 分别出现的次数
        vector counter(3, 0);
		
        // 统计 0 1 2 出现的次数
        for( int i = 0 ; i < nums.size() ; i++ ) {
            counter[nums[i]]++;
        }
		
        // 记录当前填充到了 nums 数组的位置
        int i = 0;
        // num 从 0 取到 2
        for( int num = 0 ; num < counter.size() ; num++ ) {
            // 填充 counter[num] 次 num 数值
            for( int sz = 0 ; sz < counter[num] ; sz++ ) {
                // 每次填充一个数值之后就让 i 向后移动一下
                nums[i++] = num;
            }
        }
    }
};

Java 代码实现

class Solution {
    public void sortColors(int[] nums) {
        // 使用 counter 记录 0 1 2 分别出现的次数
        int[] counter = new int[3];
		
        // 统计 0 1 2 出现的次数
        for( int i = 0 ; i < nums.length ; i++ ) {
            counter[nums[i]]++;
        }

        int i = 0;  // 记录当前填充到了 nums 数组的位置
        for( int num = 0 ; num < counter.length ; num++ ) {
            // 填充 counter[num] 次 num 数值
            for( int sz = 0 ; sz < counter[num] ; sz++ ) {
                // 每次填充一个数值之后就让 i 向后移动一下
                nums[i++] = num;
            }
        }
    }
}

Golang 代码实现

func sortColors(nums []int)  {
    counter := [3]int{0, 0, 0};

    for _, num := range nums {
        counter[num] ++;
    }

    i := 0;
    for num, sz := range counter {
        for k := 0 ; k < sz ; k++ {
            nums[i] = num;
            i += 1;
        }
    }
}

方法二

思路

第二种方法就是使用 快速排序 的三路快排中的 partition 步骤来实现
partition 这一步做了什么？在快速排序中，我们首先会选择一个值 v ，然后把小于 v 的值全部放在数组的左侧，等于 v 的值放在数组的中间，大于 v 的值放在数组的右侧；观察这个题目，其实也是需要将所有的数组分成三个部分，每个部分装载了不同的值，分别是 0 1 2
那么，我们维护三个区间就可以了，每个区间装载不同的值
小于 v 的区间定义为：nums[0...i) ，这里 i 的初始值为 0
等于 v 的区间定义为：nums[i...j) ，这里 j 的初始值为 0
大于 v 的区间定义为：nums(k...n-1] ，这里的 k 初始化为 n-1； n 代表数组长度
使用索引 cur 遍历 nums 数组，每当我们遇到不同的值的时候，我们就将它放在不同的区间中，并对这三个区间进行维护即可

nums[cur] 小于 v 的时候

当我们遇到的 nums[cur] 小于 v 的时候，数据可能是这样的。

你可以发现，我们怎么才能让 num[0...i) 的区间扩大呢？显然我们这时候没办法扩大，一旦扩大，我们的数据就会覆盖掉 nums[i...j) 这个区间里面的数据，所以我们可以让 nums[i...j) 这个区间的第一个元素放到 j 所在的位置，其实就相当于移走了最开头的元素放到了 nums[i...j) 这个区间的尾巴上，然后为了维护 nums[i...j) 这个区间的定义，我们需要让 j 的值增加 1；好巧不巧，这个时候 cur 的值是等于 j 的值的，所以我们直接交换 nums[i] 和 nums[j] 的值就可以了，然后我们分别让 i, j, cur 的值分别都增加 1 即可，随后就变成了下面这样子。

思考一下，j 和 cur 是不是会一直保持着指向同一个元素呢？答案是：会的，他们两个在这个过程中会一直指向同一个元素。

到目前为止我们看到的是没有遇到 nums[cur] > v 的情况，那么我们接着看。

nums[cur] > v 的时候

如果我们碰到了当前的值 nums[cur] 是大于 v 的，那么我们只需要让 nums[cur] 和 nums[k] 的值进行交换，然后只让索引 k 向左移动一下就可以了；为什么所以 cur 不需要移动？这是因为，nums[k] 这个值本来是我们没有访问过的，所以相当于经过交换后， nums[cur] 正是我们可以访问的下一个元素。

假设数据一开始是这样的：

这时候我们交换 nums[cur] 和 nums[k]

nums[cur] == v 的时候

当 nums[cur] 和 v 相等的时候，我们需要把这个值放在 nums[i...j) 这个区间中，这也太容易了，我们只需要让 j, cur 向右移动一下就可以了，这里就不做图演示了。

算法什么时候停止？

根据我们的定义，nums(k...n-1] 区间代表的是大于 v 的那部分，由于左侧是开区间，所以 nums[k] 是可以被继续访问的，那么就是说，当 cur > k 的时候算法结束，注意 cur 等于 k 的时候还是需要继续的。

从上述的分析过程可以发现 cur 的值是等于 j 的，所以在代码实现中我去掉了 cur 索引

Python 代码实现

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        self.partition(nums, 1)

    def partition(self, nums: List[int], v: int) -> None:
        i = 0
        j = 0
        k = len(nums) - 1

        while j <= k:
            if nums[j] < v:
                nums[i], nums[j] = nums[j], nums[i]
                i += 1
                j += 1
            elif nums[j] > v:
                nums[j], nums[k] = nums[k], nums[j]
                k -= 1
            else:
                j += 1

C++ 代码实现

class Solution {
public:
    void sortColors(vector& nums) {
       partition(nums, 1);
    }

    void partition(vector& nums, int v) {
        // 维护 nums[0...i) 为小于 v 的数值所在区间
        // 维护 nums[i...j) 为等于 v 的数值所在区间
        // 维护 nums(k...n-1] 为大于 v 的数值所在区间

        int i = 0;
        int j = 0;
        int k = nums.size() - 1;

        while( j <= k ) {
            if( nums[j] < v ) {
                // 从 nums[i...j) 区间中 为 nums[0...i) 区间让出一个位置
                swap(nums[i++], nums[j++]);
            } else if( nums[j] > v ) {
                // nums[cur] > v
                swap(nums[k--], nums[j]);
            } else {
                j++;
            }
        }
    }
};

Java 代码实现

class Solution {
    public void sortColors(int[] nums) {
        partition(nums, 1);
    }

    public void partition(int[] nums, int v) {
        int i = 0;
        int j = 0;
        int k = nums.length - 1;

        while( j <= k ) {
            if( nums[j] < v ) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                i++;
                j++;
            } else if( nums[j] > v ) {
                int temp = nums[j];
                nums[j] = nums[k];
                nums[k] = temp;
                k--;
            } else {
                j++;
            }
        }
    }
}

Golang 代码实现

func sortColors(nums []int)  {
    partition(nums, 1);
}

func partition(nums []int, v int) {
    i := 0
    j := 0
    k := len(nums) - 1

    for j <= k {
        if nums[j] < v {
            nums[i], nums[j] = nums[j], nums[i]
            i++;
            j++;
        } else if nums[j] > v {
            nums[j], nums[k] = nums[k], nums[j]
            k--;
        } else {
            j++;
        }
    }
}

0088 合并两个有序数组

你好啊，我是蓝莓，今天是每日一题的第 6 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/merge-sorted-array/

题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

**注意：**最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109

**进阶：**你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

实现

思路

这个题目是将两个有序的数组合并成一个数组，所以我们直接采用归并排序的思路即可
归并排序中的 merge 操作做了什么？
在归并排序中，通常情况下对两个有序的数组进行归并，我们分别使用 i 和 j 两个索引指向两个数组的开头元素。然后每次选择 i 和 j 索引指向的较小的元素依次放在最终的结果中。比如我们选择了 i 索引所指向的元素，那么我们就让 i 索引向右移动一个位置，继续重复刚才的过程即可。
需要注意的是，由于是对两个数组进行归并，非常有可能其中一个数组的元素已经遍历完了，但是另一个数组的元素还没有遍历完，所以剩下的另一个数组的元素就直接无脑的依次堆叠在最终的结果中即可。
因为题目要求的是我们把最后归并完成的结果放在 nums1 数组中，所以在代码实现的最后需要把我们的结果复制进去。
在执行归并的过程中，我们使用 i 索引遍历 nums1 数组；i 的初始值为 0，并且小于数组长度 m
我们使用 j 索引遍历 nums2 数组，j 的初始值为 0，并且小于数组长度 n
定义一个 res 数组用来存放最后的结果，它的长度为 nums1 的长度加上 nums2 的长度，也就是 m+n
使用 cur 索引遍历 res 数组，res 的初始值为 0
代码中需要注意的一个点是：在归并的时候，我们需要先判断是不是有一个数组已经遍历完了？如果都没有遍历完，我们才能比较大小，一旦有一个数组遍历完了，那么执行比较大小的操作就会越界，所以在 while 循环中我把比较大小的那一步放在了后面，而把判断数组遍历是否结束的步骤放在了前面。

Python 代码实现

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        i = 0
        j = 0

        res = []

        while i < m or j < n:
            if i >= m:
                # nums1 数组已经全部遍历结束 && nums2 数组还没有结束
                res.append(nums2[j])
                j += 1
            elif j >= n:
                # nums2 数组已经全部遍历结束 && nums1 数组还没有结束
                res.append(nums1[i])
                i += 1
            elif nums1[i] < nums2[j]:
                # nums1[i] 的元素较小 选择 nums1[i]
                res.append(nums1[i])
                i += 1
            else:
                res.append(nums2[j])
                j += 1

        nums1[:] = res[:]

C++ 代码实现

class Solution {
public:
    void merge(vector& nums1, int m, vector& nums2, int n) {
        int i = 0;
        int j = 0;
        
        int cur = 0;
        vector res(m+n, 0);

        while( i < m || j < n ) {
            if( i >= m ) {
                // nums1 数组已经全部遍历结束 && nums2 数组还没有结束
                res[cur++] = nums2[j++];
            } else if( j >= n ) {
                // nums2 数组已经全部遍历结束 && nums1 数组还没有结束
                res[cur++] = nums1[i++];
            } else if( nums1[i] < nums2[j]) {
                // nums1[i] 的元素较小 选择 nums1[i] 
                res[cur++] = nums1[i++];
            } else {
                // nums1[i] > nums2[j]
                res[cur++] = nums2[j++];
            }
        }

        cur = 0;
        while( cur < nums1.size() ) {
            nums1[cur] = res[cur];
            cur++;
        }
    }
};

Java 代码实现

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = 0;
        int j = 0;
        
        int cur = 0;
        int[] res = new int[m+n];

        while( i < m || j < n ) {
            if( i >= m ) {
                // nums1 数组已经全部遍历结束 && nums2 数组还没有结束
                res[cur++] = nums2[j++];
            } else if( j >= n ) {
                // nums2 数组已经全部遍历结束 && nums1 数组还没有结束
                res[cur++] = nums1[i++];
            } else if( nums1[i] < nums2[j]) {
                // nums1[i] 的元素较小 选择 nums1[i] 
                res[cur++] = nums1[i++];
            } else {
                // nums1[i] > nums2[j]
                res[cur++] = nums2[j++];
            }
        }

        cur = 0;
        while( cur < nums1.length ) {
            nums1[cur] = res[cur];
            cur++;
        }
    }
}

Golang 代码

func merge(nums1 []int, m int, nums2 []int, n int)  {
    i := 0;
    j := 0;

    cur := 0;
    res := make([]int, m+n);

    for i < m || j < n {
        if i >= m  {
            // nums1 数组已经全部遍历结束 && nums2 数组还没有结束
            res[cur] = nums2[j];
            j++;
        } else if j >= n {
            // nums2 数组已经全部遍历结束 && nums1 数组还没有结束
            res[cur] = nums1[i];
            i++;
        } else if nums1[i] < nums2[j] {
            // nums1[i] 的元素较小 选择 nums1[i] 
            res[cur] = nums1[i];
            i++;
        } else {
            // nums1[i] > nums2[j]
            res[cur] = nums2[j];
            j++;
        }

        cur++;
    }

    copy(nums1, res);
}

0215 数组中的第k个最大的元素

你好啊，我是蓝莓，今天是每日一题的第 7 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/kth-largest-element-in-an-array/description/

题目描述

给定整数数组 nums 和整数 k，请返回数组中第 **k** 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

提示：

1 <= k <= nums.length <= 105
-104 <= nums[i] <= 104

实现

思路

最简单的思路应该是将整个 nums 数组进行排序，然后计算出第 k 大的元素所在的位置，就可以求解出结果了
另一种思路，我们可以使用 快速排序 + 分治 的方法实现
回忆快速排序中 partition 的操作需要传入一个 nums 数组以及一个数值 v ，我们会根据 v 的值将所有小于它的放在左边，大于它的放在右边，等于v 的值放在中间。也就是说中间的这部分值是已经完成排序的，如果中间这部分的某个元素的小标刚好就是我们要找的第 k 大的元素的下标，那么算法就已经结束了
如果我们要找的元素的下标在中间这部分元素的右侧，那么我们只需要对右侧的部分再继续使用 partition 操作即可，接着只需要重复上面的过程
如果我们要找的元素的下标在中间这部分元素的左侧，那么我们只需要对左侧的这部分元素再继续使用 partition 操作即可，接着继续重复上述操作
如果我们一旦找到了指定元素就直接返回就可以了
这里的 partition 操作的过程可参考这篇文章「每日一题」力扣 75 颜色分类，我只是在 partition 操作返回的时候，返回了中间那部分的区间，其他的都是一模一样的抄了过来

Python 代码实现

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        l = 0
        r = len(nums) - 1
        # 第 k 大的元素所在 nums 数组中的位置 (按照从小到大的顺序摆放)
        p = len(nums) - k

        while l <= r:
            pivot = random.choice(nums[l:r+1])  # 在 nums 中随机选取一个数值
            first, second = self.partition(nums, pivot, l, r)
            if first <= p and second >= p:
                # 如果 p 落在 interval 表示的中间部分的区间里
                # 说明第 k 大的元素已经被放在了正确的位置
                return nums[p]
            elif first > p:
                # 说明应该在左边继续寻找
                r = first - 1
            else:
                # interval.second < p
                # 说明应该在右边继续寻找
                l = second + 1

    def partition(self, nums: List[int], v: int, l: int, r: int) -> Tuple:
        i = l
        j = l
        k = r

        while j <= k:
            if nums[j] < v:
                nums[i], nums[j] = nums[j], nums[i]
                i += 1
                j += 1
            elif nums[j] > v:
                nums[j], nums[k] = nums[k], nums[j]
                k -= 1
            else:
                j += 1

        # 返回区别 nums[i, j-1] 代表等于数值 v 的区间
        return i, j-1

C++ 代码实现

class Solution {
public:
    int findKthLargest(vector& nums, int k) {
        int l = 0;
        int r = nums.size() - 1;
        // 第 k 大的元素所在 nums 数组中的位置 (按照从小到大的顺序摆放)
        int p = nums.size() - k;

        srand(time(nullptr)); // 使用当前时间初始化随机种子

        while( l <= r ) {
            int select = l + rand() % (r - l + 1); // 生成 [l, r] 的随机整数
            pair interval = partition(nums, nums[select], l, r);
            if( interval.first <= p && interval.second >= p ) {
                // 如果 p 落在 interval 表示的中间部分的区间里
                // 说明第 k 大的元素已经被放在了正确的位置
                return nums[p];
            } else if( interval.first > p ) {
                // 说明应该在左边继续寻找
                r = interval.first - 1;
            } else {
                // interval.second < p
                // 说明应该在右边继续寻找
                l = interval.second + 1;
            }
        }

        return -1;
    }

    pair partition(vector& nums, int v, int l, int r) {
        // 维护 nums[l...i) 为小于 v 的数值所在区间
        // 维护 nums[l...j) 为等于 v 的数值所在区间
        // 维护 nums(k...r] 为大于 v 的数值所在区间

        int i = l;
        int j = l;
        int k = r;

        while( j <= k ) {
            if( nums[j] < v ) {
                // 从 nums[i...j) 区间中 为 nums[0...i) 区间让出一个位置
                swap(nums[i++], nums[j++]);
            } else if( nums[j] > v ) {
                // nums[cur] > v
                swap(nums[k--], nums[j]);
            } else {
                j++;
            }
        }

        // 返回区别 nums[i, j-1] 代表等于数值 v 的区间
        return make_pair(i, j-1);
    }
};

Java 代码实现

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int l = 0;
        int r = nums.length - 1;
        // 第 k 大的元素所在 nums 数组中的位置 (按照从小到大的顺序摆放)
        int p = nums.length - k;

        Random random = new Random();

        while( l <= r ) {
            int select = random.nextInt(r - l + 1) + l; // 生成 [l, r] 的随机整数
            int[] interval = partition(nums, nums[select], l, r);
            if( interval[0] <= p && interval[1] >= p ) {
                // 如果 p 落在 interval 表示的中间部分的区间里
                // 说明第 k 大的元素已经被放在了正确的位置
                return nums[p];
            } else if( interval[0] > p ) {
                // 说明应该在左边继续寻找
                r = interval[0] - 1;
            } else {
                // interval[1] < p
                // 说明应该在右边继续寻找
                l = interval[1] + 1;
            }
        }

        return -1;
    }

     public int[] partition(int[] nums, int v, int l, int r) {
        int i = l;
        int j = l;
        int k = r;

        while( j <= k ) {
            if( nums[j] < v ) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                i++;
                j++;
            } else if( nums[j] > v ) {
                int temp = nums[j];
                nums[j] = nums[k];
                nums[k] = temp;
                k--;
            } else {
                j++;
            }
        }
         
		// 返回区别 nums[i, j-1] 代表等于数值 v 的区间
        return new int[]{i, j-1};
    }
}

Golang 代码实现

func findKthLargest(nums []int, k int) int {
	l := 0
	r := len(nums) - 1
	// 第 k 大的元素所在 nums 数组中的位置 (按照从小到大的顺序摆放)
	p := len(nums) - k

	rand.Seed(time.Now().UnixNano()) // 使用当前时间初始化随机种子

	for l <= r {
		selectIndex := rand.Intn(r-l+1) + l // 生成 [l, r] 的随机整数
		first, second := partition(nums, nums[selectIndex], l, r)
		if first <= p && second >= p {
			// 如果 p 落在 [first, second] 区间内
			// 说明第 k 大的元素已经被放在了正确的位置
			return nums[p]
		} else if first > p {
			// 说明应该在左边继续寻找
			r = first - 1
		} else {
			// second < p
			// 说明应该在右边继续寻找
			l = second + 1
		}
	}

	return -1
}

// partition 函数，将 nums[l:r] 数组划分为小于、等于和大于基准值的部分
func partition(nums []int, v, l, r int) (int, int) {
	i := l
	j := l
	k := r

	for j <= k {
		if nums[j] < v {
			nums[i], nums[j] = nums[j], nums[i]
			i++
			j++
		} else if nums[j] > v {
			nums[j], nums[k] = nums[k], nums[j]
			k--
		} else {
			j++
		}
	}

	// 返回 [i, j-1]，即等于数值 v 的区间
	return i, j - 1
}

0167 两数之和 II - 输入有序数组

你好啊，我是蓝莓，今天是每日一题的第 8 天。

题目清单非常重要，每个题目都是经过分类的，可以有针对性的使用这些题目进行练习，可以看看。

题目清单：点我

引用力扣题目：点我

题目描述

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非递减顺序 排列
-1000 <= target <= 1000
仅存在一个有效答案

实现

思路

这个题目开始会有四个使用双指针的题目
对于这个题目来说，最容易想到的暴力解法就是使用两层循环，遍历所有的两个数值为一对的组合
对于组合来说相信并不陌生，最简单的代码实现可能是下面这样子的

// 寻找组合的两层循环

for( int i = 0 ; i < len(numbers) ; i++ ) {
    for( int j = i+1 ; j < len(numbers) ; j++ ) {
        // 在这里写对于每一对的要进行判断的逻辑
        // 你可以在这里判断 numbers[i] 和 numbers[j] 相加后的结果是否满足 target
        // 并做一些必要的处理
    }
}

你可以很容易的发现，这里的 i 是永远小于 j 的，这样可以保证我们不会寻找出重复的组合
对于经典的两层循环的代码可能是下面这样的

// 经典的两层循环
for( int i = 0 ; i < len(numbers) ; i++ ) {
	for( int j = 0 ; j < len(numbers) ; j++ ) {
		// 在这里写对于每一对的要进行判断的逻辑
        // 你可以在这里判断 numbers[i] 和 numbers[j] 相加后的结果是否满足 target
        // 并做一些必要的处理
	}
}

经典的两层循环 和 寻找组合的两层循环 有什么区别？区别就在于 经典的两层循环 会寻找出重复的情况，比如对于一对组合 numbers[5] 和 numbers[10] ，我们可以让 i 和 j 分别等于 5 和 10 这就会出现重复的情况了。所以防止不出现重复的情况，我们应该使用 寻找组合的两层循环 这种写法，这种写法既不会出现 i 等于 j 的情况，也不会出现重复的情况
虽然说我们使用了 寻找组合的两层循环 可以降低很多不必要的操作，但是它依然是 O(N^2) 的时间复杂度
对于这个题目，我们要设计一个在 O(N) 的时间复杂度就可以完成的算法。双指针是什么？
我们设置索引 i 并设置初始值为 0
我们设置索引 j 并设置初始值为 len(numbers) - 1 也就是让 j 指向数组中的最后一个元素
我们检查 numbers[i] + numbers[j] 的值是不是等于 target 的值，如果相等的话，就说明我们找到了，如果不相等的话，只有可能出现两种情况。
第一种情况：numbers[i] + numbers[j] 的值大于 target，这种情况下可以选择让 j 的索引向左移动一下。因为数组是从小到大排序的，所以让 j 向左移动可以减小 numbers[i] + numbers[j] 的值。为什么我们不让 i 向右移动？因为如果让 i 向右移动势必会让 numbers[i] + numbers[j] 的值增大。也就是说：我们可以排除掉所有固定 j 的情况下， i < j 的情况下 numbers[i] + numbers[j] 的值了。通过这种方法，我们进一步缩小了搜索的空间。
第二种情况：numbers[i] + numbers[j] 的值小于 target，这种情况下可以选择让 i 的索引向右移动一下。这样，numbers[i] + numbers[j] 就会增大一些。同理，我们思考一下，为什么这种情况下不能让 j 来向左移动？因为在固定 i 的情况下，所有 j > i 情况下的 numbers[i] + numbers[j] 的值都只会比当前的值更小。
相比于使用 寻找组合的两层循环 来说，在数组有序的情况下使用双指针可以让我们进一步的减小搜索空间。
在力扣上有一个题解很不错，使用了图解的方式对：为什么双指针不会漏掉一些情况的问题，进行了讲解。
题解链接：点我

Python 代码实现

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i = 0
        j = len(numbers) - 1

        while i < j:
            if numbers[i] + numbers[j] == target:
                return i+1, j+1
            elif numbers[i] + numbers[j] > target:
                j -= 1
            else:
                i += 1

        return 0, 0

C++ 代码实现

class Solution {
public:
    vector twoSum(vector& numbers, int target) {
        int i = 0;
        int j = numbers.size() - 1;

        while( i < j ) {
            if( numbers[i] + numbers[j] == target ) {
                return vector({i+1, j+1});
            } else if( numbers[i] + numbers[j] > target ) {
                j--;
            } else {
                // numbers[i] + numbers[j] < target
                i++;
            }
        }

        return vector({0, 0});
    }
};

Java 代码实现

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i = 0;
        int j = numbers.length - 1;

        while( i < j ) {
            if( numbers[i] + numbers[j] == target ) {
                return new int[]{i+1, j+1};
            }  else if( numbers[i] + numbers[j] > target ) {
                j -= 1;
            } else {
                // numbers[i] + numbers[j] < target 
                i += 1;
            }
        }

        return new int[]{0, 0};
    }
}

Golang 代码实现

func twoSum(numbers []int, target int) []int {
    i := 0
    j := len(numbers) - 1

    for i < j {
        if numbers[i] + numbers[j] == target {
            return []int{i+1, j+1}
        } else if numbers[i] + numbers[j] > target {
            j--
        } else {
            i++
        }
    }

    return []int{0, 0}
}

0125 验证回文串

你好啊，我是蓝莓，今天是每日一题的第 9 天。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/valid-palindrome/description/

题目描述

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

示例 1：

输入: s = "A man, a plan, a canal: Panama"
输出：true
解释："amanaplanacanalpanama" 是回文串。

示例 2：

输入：s = "race a car"
输出：false
解释："raceacar" 不是回文串。

示例 3：

输入：s = " "
输出：true
解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
由于空字符串正着反着读都一样，所以是回文串。

提示：

1 <= s.length <= 2 * 105
s 仅由可打印的 ASCII 字符组成

实现

这个题目是使用双指针的方法来实现，类似的还有这篇文章「每日一题」力扣 167 两数之和 II - 输入有序数组
使用索引 i 从字符串的左侧开始遍历，使用索引 j 从字符串的右侧开始遍历
将s[i] 和 s[j]先转换为小写字母后，判断是不是相等，如果不相等的话说明不满足，返回 false 即可
但是在移动索引 i 和 j 的过程中要记得每次做完是否相等的判断后，还需要跳过那些不满足大小写字母和数字的字符；为了判断当前字符是是大小写字母或者数字，我做了一个函数 isValidChar 来判断

Python 代码实现

class Solution:
    def isValidChar(self, c: str) -> bool:
        return ('A' <= c <= 'Z') or ('a' <= c <= 'z') or ('0' <= c <= '9')

    def isPalindrome(self, s: str) -> bool:
        i, j = 0, len(s) - 1

        while i <= j and not self.isValidChar(s[i]):
            i += 1
        while i <= j and not self.isValidChar(s[j]):
            j -= 1

        while i <= j:
            if s[i].lower() != s[j].lower():
                return False
            i += 1
            j -= 1
            while i <= j and not self.isValidChar(s[i]):
                i += 1
            while i <= j and not self.isValidChar(s[j]):
                j -= 1

        return True

C++ 代码实现

class Solution {
public:
    bool isValidChar(char c) {
        if( (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || ( c >= '0' && c <= '9') ) {
            return true;
        }

        return false;
    }

    bool isPalindrome(string s) {
        int i = 0;
        int j = s.size() - 1;
        
        while( i <= j && !isValidChar(s[i]) ) i++;
        while( i <= j && !isValidChar(s[j]) ) j--;

        while( i <= j ) {
            if( tolower(s[i]) != tolower(s[j]) ) return false;

            i++;
            j--;

            while( i <= j && !isValidChar(s[i]) ) i++;
            while( i <= j && !isValidChar(s[j]) ) j--;
        }

        return true;
    }
};

Java 代码实现

class Solution {
    private boolean isValidChar(char c) {
        return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
    }

    public boolean isPalindrome(String s) {
        int i = 0, j = s.length() - 1;

        while (i <= j && !isValidChar(s.charAt(i))) {
            i++;
        }
        while (i <= j && !isValidChar(s.charAt(j))) {
            j--;
        }

        while (i <= j) {
            if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(j))) {
                return false;
            }
            i++;
            j--;
            while (i <= j && !isValidChar(s.charAt(i))) {
                i++;
            }
            while (i <= j && !isValidChar(s.charAt(j))) {
                j--;
            }
        }

        return true;
    }
}

Golang 代码实现

func isValidChar(c rune) bool {
    return unicode.IsLetter(c) || unicode.IsDigit(c)
}

func isPalindrome(s string) bool {
    i, j := 0, len(s)-1

    for i <= j {
        for i <= j && !isValidChar(rune(s[i])) {
            i++
        }
        for i <= j && !isValidChar(rune(s[j])) {
            j--
        }
        if i <= j {
            if unicode.ToLower(rune(s[i])) != unicode.ToLower(rune(s[j])) {
                return false
            }
            i++
            j--
        }
    }

    return true
}

0345 反转字符串中的元音字母

你好啊，我是蓝莓，今天是每日一题的第 10 天。

从明天开始，题解的文章就只在我的博客更新啦，暂时不会把每个题目的题解都更新在公众号了。

如果你对刷力扣的题目感兴趣，欢迎你添加我的微信，我拉你进群一起刷题。添加微信的方法是在我的微信公众号下方点击 联系我 可以收到我的微信二维码。

题目清单就是我的博客对应的力扣题目的地址啦。

题目清单：https://blueberry-universe.cn/lc/index.html

引用力扣题目：https://leetcode.cn/problems/reverse-vowels-of-a-string/description/

题目描述

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。

元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。

示例 1：

**输入：**s = "IceCreAm"

输出："AceCreIm"

解释：

s 中的元音是 ['I', 'e', 'e', 'A']。反转这些元音，s 变为 "AceCreIm".

示例 2：

**输入：**s = "leetcode"

输出："leotcede"

提示：

1 <= s.length <= 3 * 105
s 由 可打印的 ASCII 字符组成

实现

思路

这个题目仍然是使用双指针，同样使用双指针的题目还有以下两篇文章

「每日一题」力扣 167 两数之和 II - 输入有序数组

「每日一题」力扣 125 验证回文串

使用索引 i 从左侧开始遍历，它的初始值为 0
使用索引 j 从右侧开始遍历，它的初始值为 n-1；这里的 n 代表字符串的长度
交换 i 和 j 所指向的元音字母的位置，然后再让两个索引继续跳转到下一个原因字母即可
使用 isVowelLetter 函数来判断当前字符是否是元音字母

Python 代码实现

class Solution:
    def reverseVowels(self, s: str) -> str:

        def is_vowel_letter(letter: str) -> bool:
            letter = letter.lower()
            return letter in {'a', 'e', 'i', 'o', 'u'}
        
        s = list(s)
        i, j = 0, len(s) - 1

        while i < j and not is_vowel_letter(s[i]):
            i += 1
        while i < j and not is_vowel_letter(s[j]):
            j -= 1
        
        while i < j:
            s[i], s[j] = s[j], s[i]
            i += 1
            j -= 1
            
            while i < j and not is_vowel_letter(s[i]):
                i += 1
            while i < j and not is_vowel_letter(s[j]):
                j -= 1

        return ''.join(s)

C++ 代码实现

class Solution {
public:
    bool isVowelLetter(char letter) {
        letter = tolower(letter);
        return letter == 'a' || letter == 'e' || letter == 'i' || letter == 'o' || letter == 'u';
    }

    string reverseVowels(string s) {
        int i = 0;
        int j = s.size() - 1;

        while( i < j && !isVowelLetter(s[i]) ) i++;
        while( i < j && !isVowelLetter(s[j]) ) j--;

        while( i < j ) {
            swap(s[i], s[j]);

            i++;
            j--;

            while( i < j && !isVowelLetter(s[i]) ) i++;
            while( i < j && !isVowelLetter(s[j]) ) j--;
        }

        return s;
    }
};

Java 代码

class Solution {
    private boolean isVowel(char letter) {
        letter = Character.toLowerCase(letter);
        return letter == 'a' || letter == 'e' || letter == 'i' || letter == 'o' || letter == 'u';
    }

    public String reverseVowels(String s) {


        char[] chars = s.toCharArray();
        int i = 0, j = chars.length - 1;

        while (i < j && !isVowel(chars[i])) i++;
        while (i < j && !isVowel(chars[j])) j--;

        while (i < j) {
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
            i++;
            j--;

            while (i < j && !isVowel(chars[i])) i++;
            while (i < j && !isVowel(chars[j])) j--;
        }

        return new String(chars);
    }
}

Golang 代码实现

func isVowelLetter(c byte) bool {
	c = byte(unicode.ToLower(rune(c)))
	return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'
}

func reverseVowels(s string) string {
	bytes := []byte(s)
	i, j := 0, len(bytes)-1

    for i < j && !isVowelLetter(bytes[i]) {
        i++
    }
    
    for i < j && !isVowelLetter(bytes[j]) {
        j--
    }

	for i < j {
        bytes[i], bytes[j] = bytes[j], bytes[i]
			i++
			j--

	}

	return string(bytes)
}

0011 盛最多水的容器

你好啊，我是蓝莓，今天是每日一题的第 11 天。

题目清单：一起刷力扣

引用力扣题目：力扣 11 盛最多水的容器

题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

n == height.length
2 <= n <= 105
0 <= height[i] <= 104

实现

思路

这是一个使用双指针的题目
使用索引 i 从 height 数组的左侧开始遍历，i 的初始值为 0
使用索引 j 从 height 数组的右侧开始遍历，j 的初始值为 n - 1，其中 n 为数组长度
使用 res 保存当前的最大值，如果 min(height[i], height[j]) * (j-i) 大于当前的 res 那么就更新 res 的值
如果这时候 height[i] 更短一些，那么就尝试着向右移动 i 去寻找更长的左侧板子
如果这时候 height[j] 更短一些，那么就尝试着向左移动 j 去寻找更长的右侧板子
关于这种操作会不会漏掉一些其他的情况：当 height[i] 更短一些的时候，如果我们不选择移动 i 而是选择向左移动 j，那么你可以知道，底边的长度是必然会变小的，然而在向左移动 j 的过程中只会出现两种情况
（1）height[j] 变得更长了，但是这并没有用，因为height[i] 是短板，而且底边也在变小，所以并不能使得 res 变大；
（2）height[j] 变得更短了，甚至比 height[i] 还要短，这就更糟糕了，因为 height[j] 变成了短板，而且底边也在不断的变小；
经过以上分析，我们可以知道，我们可以直接排除掉这些不必要的运算过程，所以我们的方法是没有问题的。
关于这一点，在力扣上有一个题解很不错，可以参考：

题解传送门：11 盛最多水的容器题解

C++ 代码实现

class Solution {
public:
    int maxArea(vector& height) {
        int i = 0;
        int j = height.size() - 1;

        int res = 0;

        while( i < j ) {
            if( height[i] > height[j] ) {
                res = max(res, (j-i) * height[j]);
                j--;
            } else {
                // height[i] < height[j]
                res = max(res, (j-i) * height[i]);
                i++;
            }
        }

        return res;
    }
};

0209 长度最小的子数组

你好啊，我是蓝莓，今天是每日一题的第 12 天。

题目清单：一起刷力扣

引用力扣题目：209 长度最小的子数组

题目描述

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 104

进阶：

如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

实现

思路

使用滑动窗口
使用索引 l 代表窗口的左边界
使用索引 r 代表窗口的右边界
区间 nums[l...r) 代表窗口内的元素，r-l 是窗口的大小，r 的取值应该小于等于 len(nums)
使用 sum 记录窗口内元素的总和
当 sum 的值小于 target 的时候，说明窗口内的元素不够，这时候应该向右移动 r 来扩大窗口
当 sum 的值大于等于 target 的时候，比较当前的窗口长度是不是更小了，如果更小则更新窗口的最小长度，否则的话不需要更新；然后尝试着减小窗口的大小，也就是向右移动 l；
关于这种方法的正确性依然可以使用搜索空间的角度来思考
因为一开始的时候，nums[l...r) 内的元素总和不够，所以只能向右移动 r 扩展区间的大小，进而让总和变得更大
当总和满足要求的时候，我们为了找到更小的长度，这时候尝试着让 l 向右移动
这时候会漏掉一些情况吗？不会的，因为只要 r 不在当前位置，而是向左缩了一点，都不可能让这个区间内的元素总和满足要求的，所以我们可以排除掉很多的选项。

C++ 代码实现

class Solution {
public:
    int minSubArrayLen(int target, vector& nums) {
        int l = 0;
        int r = 0;

        int sum = 0;
        int res = INT_MAX;
        
        // 维护区间 nums[l...r)
        while( l < nums.size() ) {
            if( sum < target ) {
                // sum < target 但是 已经没法再继续扩展了
                if( r >= nums.size() ) break;

                r++;
                sum += nums[r-1];
            } else {
                res = min(res, r-l);
                sum -= nums[l];
                l++;
            }
        }

        if( res == INT_MAX ) return 0;
        
        return res;
    }
};

0209 长度最小的子数组

你好啊，我是蓝莓，今天是每日一题的第 13 天。

题目清单：一起刷力扣

引用力扣题目：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

**进阶：**尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

实现

思考

使用哈希表来记录扫描过程中每个元素出现的次数
如果的统计过程中，发现某个元素的出现次数已经属于多数元素了，直接返回即可

C++ 代码实现

class Solution {
public:
    int majorityElement(vector& nums) {
        unordered_map record;
        int target = nums.size() / 2;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            record[nums[i]]++;
            if( record[nums[i]] > target ) {
                return nums[i];
            }
        }

        return -1;
    }
};

0189 轮转数组

你好啊，我是蓝莓，今天是每日一题的第 14 天。

题目清单：一起刷力扣

引用力扣题目：189 轮转数组

题目描述

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

1 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

进阶：

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的原地算法解决这个问题吗？

实现

思路

k 对 len(nums) 取模，保证 k 是在有必要的轮转范围内
第一步，翻转整个数组
第二步，翻转前 k 个元素
第三步，翻转后 n-k 个元素

C++ 代码实现

class Solution {
public:
    void rotate(vector& nums, int k) {

        k = k % nums.size();

        // 1. 翻转整个数组
        reverse( nums, 0, nums.size() - 1 );

        // 2. 翻转前 k 个
        reverse( nums, 0, k-1);

        // 3. 翻转后 n-k 个
        reverse( nums, k, nums.size() - 1 );

    }

    void reverse( vector& nums, int i, int j ) {
        while( i < j ) {
            swap(nums[i++], nums[j--]);
        }
    }
};

0003 无重复字符的最长子串

你好啊，我是蓝莓，今天是每日一题的第 15 天。

题目清单：一起刷力扣

引用力扣题目：3 无重复字符的最长子串

题目描述

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串

的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

实现

思路

使用滑动窗口 + 记录每个字符在窗口内出现的次数
使用索引 i 代表窗口的左边界，使用索引 j 代表窗口的右边界，维护区间 [i...j] 为窗口
当纳入新的元素到窗口中的时候，如果发现该元素已经出现过一次了，那就从窗口的左侧开始缩小窗口，直到将该元素移出窗口的范围

C++ 代码实现

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0;
        int record[256];

        for( int k = 0 ; k < 256 ; k++ ) {
            record[k] = 0;
        }

        // 维护闭区间 [i...j] 为窗口
        for( int i = 0, j = 0 ; j < s.size() ; j++ ) {
            record[s[j]]++;
			
            // 跳过重复元素
            while(record[s[j]] > 1) record[s[i++]]--;
            
            res = max(res, j-i+1);
        }

        return res;
    }
};

0438 找到字符串中所有字母异位词

你好啊，我是蓝莓，今天是每日一题的第 16 天。

题目清单：一起刷力扣

引用力扣题目：438 找到字符串中所有字母异位词

题目描述

给定两个字符串 s 和 p，找到 s 中所有 p 的

异位词

的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

提示:

1 <= s.length, p.length <= 3 * 104
s 和 p 仅包含小写字母

实现

思路

使用定长的滑动窗口，滑动窗口的长度为我们要寻找的异位词的字符串的长度，也就是字符串 p 的长度
使用 record 数组来记录对每个 p 字符串中的字符，每个字符还需要多少个才能满足要求
在字符串 s 上进行滑动，每个被我们滑进窗口的字符对应在 record 中的记录就减少 1 ，因为这时候我们已经找到了一个字符。当然啦，有的字符可能是不需要的，一开始的需求量就是 0，所以这时候某些字符会的需求量会变为负数，也就是需求过剩了
每当我们完成一次滑动之后，我们就检查这个 record 中的记录是否都为 0，如果不是都为 0 的话，说明是不匹配的
窗口的长度已经固定了，所以只有 record 中的记录都为 0 的时候才是满足要求的

C++ 代码实现

class Solution {
public:
    vector findAnagrams(string s, string p) {
        
        // 保证 p 的长度是小于等于 s 的
        if(p.size() > s.size()) {
            return vector();
        }
        
        int record[26];  // 分别对 26 个字母还需要多少
        vector res;  // 保存结果

        // 数组置空
        memset(record, 0, sizeof(record));

        // 记录原始需求
        for( int i = 0 ; i < p.size() ; i++ ) {
            record[p[i]-'a']++;
        }

        // 使用定长的滑动窗口
        // 初始化一开始的窗口中的记录
        for( int i = 0 ; i < p.size() ; i++ ) {
            record[s[i]-'a']--;
        }

        // 窗口的区间是 [l...r]
        int l = 0;
        int r = p.size() - 1;

        while( true ) {
            // 检查当前是否满足要求
            int ok = true;
            for( int i = 0 ; i < 26 ; i++ ) {
                if(record[i] != 0) {
                    ok = false;
                    break;
                }
            }

            if(ok) {
                res.push_back(l);
            }
            
            if(r+1 < s.size()) {
                // 将左侧的字母移除, 对该字母的需求恢复 1
                record[s[l++]-'a']++;
                // 纳入新的元素到窗口中, 说明对该字母的需求减少 1
                record[s[++r]-'a']--;
            } else {
                // 说明已经滑动结束了
                break;
            }
        }

        return res;
    }
};

0076 最小覆盖子串

你好啊，我是蓝莓，今天是每日一题的第 17 天。

题目清单：一起刷力扣

引用力扣题目：76 最小覆盖子串

题目描述

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

提示：

m == s.length
n == t.length
1 <= m, n <= 105
s 和 t 由英文字母组成

实现

思路

使用可变的滑动窗口
这个题目和 438 号题目的题解类似，我们使用 record 记录对于每个字符的需求量
首先使用 t 字符串初始化一开始对每个字符的需求量都是多大
然后遍历 s 字符串，在窗口滑动的过程中分为两种情况
（1）当前如果不满足要求的话，那么就扩大窗口的范围，同时维护 record 中的记录
（2）如果当前已经满足要求了，那么我们就判断下，当前发现的子串的长度是不是比我们之前找到的子串的长度还要小，如果还要小的话就更新一下子串的起始位置和长度。接着，我们这时候不再扩大窗口了，我们尝试着缩小窗口去寻找更短的满足要求的子串

C++ 代码实现

class Solution {
public:
    string minWindow(string s, string t) {
        if( s.size() < t.size() ) {
            return "";
        }

        int record[256];

        // 数组置空
        memset(record, 0, sizeof(record));

        // 初始化原始需求量
        for( int i = 0 ; i < t.size() ; i++ ) {
            record[t[i]]++;
        }

        // 维护区间 [l...r)
        int l = 0;
        int r = 0;

        // 记录最小覆盖子串的起始位置
        int start = -1;
        // 记录最小覆盖子串的长度
        int minimum_size = INT_MAX;

        while( r <= s.size() ) {
            bool ok = true;

            // 检查是否满足要求
            for( int i = 'A' ; i <= 'z' ; i++ ) {
                if( record[i] > 0 ) {
                    ok = false;
                    break;
                }
            }

            if(ok) {
                // 记录当前的最小字符串
                if( minimum_size > r-l ) {
                    minimum_size = r-l;
                    start = l;
                }

                // 当前已经满足要求 尝试缩小窗口的大小
                record[s[l++]]++;
            } else {
                // 继续扩大窗口
                // 纳入新的元素到 record
                // 对该元素的需求减少 1
                record[s[r++]]--;
            }
        }
        
        if( start == -1 ) {
            return "";
        }

        return s.substr(start, minimum_size);
    }
};

0349 两个数组的交集

你好啊，我是蓝莓，今天是每日一题的第 18 天。

题目清单：一起刷力扣

引用力扣题目：349 两个数组的交集

题目描述

给定两个数组 nums1 和 nums2 ，返回 它们的

交集

。输出结果中的每个元素一定是唯一的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

实现

思路

这是一个简单题，可以通过这个题目熟悉一下编程语言中集合的使用方法
最简单的思路就是使用两个 set 分别对 nums1 和 nums2 去重
然后求两个集合的交集即可

C++ 代码实现

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        set record1;
        set record2;
        
        vector res;

        // 对 nums1 去重
        for( int num : nums1 ) {
            record1.insert(num);
        }

        // 对 nums2 去重
        for( int num : nums2 ) {
            record2.insert(num);
        }

        // 遍历集合 record2 中的元素，看看是不是在 record1 集合中也出现了
        // 如果同时满足 则这个就纳入 res 中
        for( set::iterator iter = record2.begin() ; iter != record2.end() ; iter++ ) {
            if( record1.find(*iter) != record1.end() ) {
                res.push_back(*iter);
            }
        }

        return res;
    }
};

0350 两个数组的交集 II

你好啊，我是蓝莓，今天是每日一题的第 19 天。

题目清单：一起刷力扣

引用力扣题目：350 两个数组的交集 II

题目描述

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

*进阶*：

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

实现

方法 1 思路

这是一个评分为简单的题目。
最简单的方法，我们使用分别使用 map1 和 map2 来统计 nums1 和 nums1 中每个数值出现的次数
然后，遍历 map1 或者 map2 任意一个都是可以的，我们需要找到既存在 map1 中也存在 map2 中的 key，然后向结果中添加两者出现的 key 的次数较小的那个作为添加的次数即可
这个题目其实主要是让我们熟悉使用 map 这种数据结构；在 C++ 的代码中，如果 map[key] 这个元素不存在的话，那么就会自动在数据结构中添加键为 key 并且初始值为 0 的值（这是对于 key 和 value 都是 int 类型而言的），所以我的代码才写成了这样

C++ 代码实现

class Solution {
public:
    vector intersect(vector& nums1, vector& nums2) {
        unordered_map map1;
        unordered_map map2;
        vector res;

        for( int i = 0 ; i < nums1.size() ; i++ ) {
            map1[nums1[i]]++;
        }

        for( int i = 0 ; i < nums2.size() ; i++ ) {
            map2[nums2[i]]++;
        }

        // 遍历 map1
        for( auto iter = map1.begin() ; iter != map1.end() ; iter++ ) {
            int key = iter->first;
            int value = iter->second;

            if( map2.find(key) != map2.end() ) {
                int sz = min(value, map2[key]);
                for( int k = 0 ; k < sz ; k++ ) {
                    res.push_back( key );
                }
            }
        }

        return res;
    }
};

方法 2 思路

我们也可以只统计 nums1 数组中每个元素出现的次数
然后我们遍历 nums2 数组就可以了，每当我们遍历到一项的时候，我们就去 map 数据结构中找一找，看看 nums1 中存不存在这个数？如果存在的话我们就把这个数添加到结果中去
但是，这里要注意了，比如 10 这个数在 nums1 中出现了 20 次，但是在 nums2 中出现了 30 次，那么我们就会在 nums2 中遍历到 30 次这个数了。这样就会在结果中添加 30 次，显然不符合题意。
所以，我们每次添加完成一个数的时候，我们就把 map 中的计数减少 1，只有我们查找到的这个数在 nums1 的 map 剩余的次数大于 0 的时候，我们才把这个数纳入结果中去

class Solution {
public:
    vector intersect(vector& nums1, vector& nums2) {
        // 时间复杂度 : O(1)
        unordered_map record;

        for( int i = 0 ; i < nums1.size(); i++ ) {
            if( record.find(nums1[i]) == record.end() ) {
                record.insert( make_pair(nums1[i], 1) );
            } else {
                record[nums1[i]] ++;
            }
        }

        vector res;

        for( int i = 0 ; i < nums2.size() ; i++ ) {
            if( record.find( nums2[i] ) != record.end() && record[nums2[i]] > 0 ) {
                record[nums2[i]] --;
                res.push_back( nums2[i] );
                if( record[nums2[i]] == 0 ) {
                    record.erase( nums2[i] );
                }
            }
        }

        return res;
    }
};

0242 有效的字母异位词

你好啊，我是蓝莓，今天是每日一题的第 20 天。

题目清单：一起刷力扣

引用力扣题目：242 有效的字母异位词

题目描述

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的

字母异位词

。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

实现

思路

这是一个简单题，可以用来练习使用 map
我们可以先使用 map 统计字符串 s 中每个字符出现的频率
然后，遍历字符串 t ，对于 t 中出现的字符是必须在 s 中出现相同次数的，每遍历到一个字符，我们就对 map 中统计到的频率进行减1的操作
如果我们发现一个字符在 map 中的频率已经小于等于 0 了，那就说明 s 字符串中的字符的个数不满足要求，就可以直接返回 false 了

C++ 代码实现

class Solution {
public:
    bool isAnagram(string s, string t) {
        unordered_map record;
		
        // 首先要保证 s 和 t 的长度是一直的才行
        if( s.size() != t.size() ) {
            return false;
        }

        for( int i = 0 ; i < s.size() ; i++ ) {
            record[s[i]]++;
        }

        for( int i = 0 ; i < t.size() ; i++ ) {
            if( record.find(t[i]) != record.end() && record[t[i]] > 0 ) {
                // 匹配的情况下对频率进行减 1 操作
                record[t[i]]--;
            } else {
                // 比匹配的情况下返回 false
                return false;
            }
        }
		
        // 如果字符串 t 已经遍历完了也没有发现不匹配的则说明匹配成功
        return true;
    }
};

0202 快乐数

你好啊，我是蓝莓，今天是每日一题的第 21 天。

题目清单：一起刷力扣

引用力扣题目：202 快乐数

题目描述

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

提示：

1 <= n <= 231 - 1

实现

思路

这是一个简单题，只需要按着题目来做即可
主要可以学习一下怎么取一个数值的十进制表示情况下的各个位置上的数值
为了防止死循环，我们需要对之前已经迭代过得数值做一个记录，直接使用哈希表即可

C++ 代码实现

class Solution {
public:
    bool isHappy(int n) {
        
        unordered_set record;
        record.insert(n);

        // 假设上一次得到的数值为 sum
        int sum = n;

        while( true ) {
            
            // 把上一次得到的数值 sum 放在 n 里面
            n = sum;
            // 重新计算各个位置上的数值平方的和
            sum = 0;

            // 只要 n 还是大于 0 的 那就不停地取末尾数值
            while( n > 0 ) {
                int res = n % 10;
                n = n / 10;
                sum += res * res;    
            }

            // 如果已经发现等于 1 了 说明是快乐数 直接返回
            if( sum == 1 ) return true;

            // 如果发现这个数值 在之前已经得到过了 那就没必要继续下去了
            // 会造成死循环 说明这不是一个快乐数
            if( record.find(sum) != record.end() ) {
                return false;
            }

            // 记录下当前迭代到的数值 sum
            record.insert( sum );
        }

        return false;
    }
};

0290 单词规律

你好啊，我是蓝莓，今天是每日一题的第 22 天。

题目清单：一起刷力扣

引用力扣题目：290 单词规律

题目描述

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", s = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", s = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", s = "dog cat cat dog"
输出: false

提示:

1 <= pattern.length <= 300
pattern 只包含小写英文字母
1 <= s.length <= 3000
s 只包含小写英文字母和 ' '
s 不包含 任何前导或尾随对空格
s 中每个单词都被 单个空格 分隔

实现

思路

按照题目的要求来做这个题目就可以了
需要我们使用两个 map 来记录映射关系
第一个映射关系是从 pattern 中的单个 char 到 s 字符串中的单个 word
第二个映射关系是从 s 中的单个 word 到 pattern 中的单个 char
为什么需要记录两次映射关系？
这是为了保证映射的唯一，因为 a 可能映射到 dog 也可能存在 cat 和 a 是对应的
如果我们不同时记录两个方向的映射的话，我们就没办法保证这个映射是唯一的
在代码中使用 forward 记录第一个映射关系，使用 backward 记录第二个映射关系
遍历 p 字符串并且在遍历的过程中去 s 字符串中寻找当 start 指向的起始位置的这个单词的结束位置的下一个位置 end

C++ 代码实现

class Solution {
public:
    bool wordPattern(string pattern, string s) {

        unordered_map forward;  // 从 char 到 word 的映射
        unordered_map backward;  // 从 word 到 char 的映射

        int start = 0;
        int end = 0;
        int wordCount = 0;  // 统计遍历过的 s 中的 word 的数量

        for( int i = 0 ; i < pattern.size() && end < s.size() ; i++, wordCount++ ) {

            // 寻找下一个单词
            while( s[end] != ' ' && end < s.size() ) end++;

            // 提取出这次找到的单词
            string word = s.substr(start, end-start);

            // 为再次寻找下一个单词做准备
            end += 1;
            start = end;

            if( forward.find(pattern[i]) != forward.end() && backward.find(word) != backward.end() ) {
                // 映射关系不唯一 返回失败
                if( forward[pattern[i]] != word || backward[word] != pattern[i] ) return false;
            } else {

                // 双向没有同时存在映射的情况下 若其中一个方向存在映射则失败
                if( forward.find(pattern[i]) != forward.end() || backward.find(word) != backward.end() ) {
                    return false;
                }

                // 两个方向都没有映射 就可以放心的添加映射了
                forward[pattern[i]] = word;
                backward[word] = pattern[i];
            }
        }

        // 如果 s 中的单词没有全部遍历完 或者 两者应该对应的单词的数量不一致 则返回失败
        if( end < s.size() || pattern.size() != wordCount ) {
            return false;
        }

        return true;
    }
};

0205 同构字符串

你好啊，我是蓝莓，今天是每日一题的第 23 天。

题目清单：一起刷力扣

引用力扣题目：205 同构字符串

题目描述

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:

输入：s = "egg", t = "add"
输出：true

示例 2：

输入：s = "foo", t = "bar"
输出：false

示例 3：

输入：s = "paper", t = "title"
输出：true

提示：

1 <= s.length <= 5 * 104
t.length == s.length
s 和 t 由任意有效的 ASCII 字符组成

实现

思路

这个题目和 290 号题目是一样的思路
使用 map 维护一个双向的数据结构就可以了
而且这个题目还不需要自己去拆分字符串中的单词
它只需要让字符之间拥有映射关系即可

C++ 代码实现

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map forward;
        unordered_map backward;

        // 起码长度是要相等的
        if( s.size() != t.size() ) {
            return false;
        }

        for( int i = 0 ; i < s.size() ; i++ ) {
            // 看看当前是不是双向都有映射关系
            if( forward.find(s[i]) != forward.end() && backward.find(t[i]) != backward.end() ) {
                if( forward[s[i]] != t[i] || backward[t[i]] != s[i] ) return false;
            } else {
                // 如果不是双向都有映射关系 但是其中一个方向出现了映射 那必然是错的
                if( forward.find(s[i]) != forward.end() || backward.find(t[i]) != backward.end() ) return false;

                // 如果都没有映射关系那么就保存当前发现的映射关系
                forward[s[i]] = t[i];
                backward[t[i]] = s[i];
            }
        }

        return true;
    }
};

0451 根据字符出现频率排序

你好啊，我是蓝莓，今天是每日一题的第 23 天。

题目清单：一起刷力扣

引用力扣题目：451 根据字符出现频率排序

题目描述

给定一个字符串 s ，根据字符出现的频率对其进行 降序排序 。一个字符出现的频率是它出现在字符串中的次数。

返回 已排序的字符串 。如果有多个答案，返回其中任何一个。

示例 1:

输入: s = "tree"
输出: "eert"
解释: 'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入: s = "cccaaa"
输出: "cccaaa"
解释: 'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入: s = "Aabb"
输出: "bbAa"
解释: 此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

提示:

1 <= s.length <= 5 * 105
s 由大小写英文字母和数字组成

实现

思路

首先使用哈希表来统计每个字符出现的频率，这里使用 unordered_map 就可以了
统计好频率之后，我们需要按照频率的递减顺序依次向字符串中追加字符
可以使用 map 来实现，它的底层数据结构是使用平衡二叉树来实现的
根据平衡二叉树的性质，我们可以知道，按照一定的顺序进行遍历各个节点的话，那么它是有序的
由于可能存在多个字符出现的频率都是相同的，所以我们要是用 频率 到 字符数组 的方式来存储

C++ 代码实现

class Solution {
public:
    string frequencySort(string s) {
        unordered_map record;
        map> sorted_record;
        
        // 先统计各个字符的频率 字符 -> 频率 的映射关系存储
        for( int i = 0 ; i < s.size() ; i++ ) {
            record[s[i]]++;
        }

        // 按照 频率 -> 字符 的映射关系存储
        for( auto iter = record.begin() ; iter != record.end() ; iter++ ) {
            sorted_record[iter->second].push_back(iter->first);
        }

        string res = "";

        // 按照 频率 从大到小的顺序遍历 sorted_record
        for( auto iter = sorted_record.rbegin() ; iter != sorted_record.rend() ; iter++ ) {
            int freq = iter->first;  // 取出这组字符的频率
            vector& arr = iter->second;  // 获取这组字符

            for( int i = 0 ; i < arr.size() ; i++ ) {
                // 把出现频率相同的字符全部都添加 freq 次到 res 的末尾
                for( int k = 0 ; k < freq ; k++ ) {
                    res.push_back(arr[i]);
                }
            }
        }

        return res;
    }
};

0001 两数之和

你好啊，我是蓝莓，今天是每日一题的第 24 天。

题目清单：一起刷力扣

引用力扣题目：1 两数之和

题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

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

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

**进阶：**你可以想出一个时间复杂度小于 O(n2) 的算法吗？

实现

思路

对于这个问题，你在第一时间想到的最简单的方法或许就是遍历所有成对的组合，然后依次检查他们是否符合要求
其实，我们可以使用 查找表 来代替寻找组合过程中的一层 for 循环，可以使 O(N^2) 的时间复杂度变为 O(N)
当我们拿到 nums 数组中的一个值的时候，我们这时候希望知道的是，这个数组中是不是存在另外一个数值 v ，是的 nums[i] + v 等于 target ？那么这个 v 其实就是 target - nums[i]，其实就是在询问，在 nums 中是否存在一个数值为 target - nums[i] 呢？
对于这个询问，我们可以将 nums 中的值存储在 map 中，其中 key 是数组中的每个值，value 是数组中这个值对应的 index。这样，我们就成功的把内层使用循环遍历查找的方式转换成了访问哈希表的方式，哈希表的查找效率是 O(1) ，因此时间复杂度可以降维 O(N)

C++ 代码实现 1

在代码实现上，我们先看一个比较粗糙的实现
在这个实现中，我们假设 nums[i] 对应的是两个满足要求的数值中在数组的左侧的那个值
我们询问查找表的那个值是位于 nums 数组右侧的那个值
但是你会发现，查找表中存储了 nums 数组中所有的值，这不科学，哈哈哈
但是这个并不会影响正确性，比如我问访问到 nums[10] 的时候询问查找表，发现没有满足要求的另一个数值，那么，当我们遍历到 10 以后的数值的时候，是不可能认为 nums[10] 是满足要求的，因为它是在全部的元素中进行询问的，如果 nums[10] 就是其中一个满足要求的值，那么必然我们遍历到 nums[10] 的时候就一定会得到答案

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        unordered_map record;

        // 构建查找表
        for( int i = 0 ; i < nums.size() ; i++ ) {
            record[nums[i]] = i;
        }

        for( int i = 0 ; i < nums.size() ; i++ ) {
            // 对整个 nums 数组询问是否存在 target - nums[i] 这个值 ？
            if(record.find(target - nums[i]) != record.end()) {
                if( i != record[target - nums[i]] ) {
                    return vector({i, record[target-nums[i]]});
                }
            }
        }

        return vector({-1, -1});        
    }
};

C++ 代码实现 2

其实我们没有必要对全局进行询问的，如果假设遍历过程中的 nums[i] 是两个满足要求的数值中靠右的那个元素，那么我们只需要对每个 nums[i] 去询问它左侧的所有的元素是否满足要求就可以了，这时候我们可以正向的遍历数组，同时构建哈希表即可
当然，如果我们假设遍历过程中的 nums[i] 是靠近数组左侧的那个满足要求的值，那么我们就需要反向的遍历 nums 数组，因为我们需要把它右侧的值都添加到查找表中


class Solution {
public:
    vector twoSum(vector& nums, int target) {
        // 使用查找表
        unordered_map record;

        for( int i =  0 ; i < nums.size() ; i++ ) {
            int v = nums[i];

            if( record.find( target - v ) != record.end() ) {
                int res[2] = {record[target-v], i};
                return vector(res, res+2);
            }

            record[v] = i;
        }

        return vector();
    }
};

0015 三数之和

你好啊，我是蓝莓，今天是每日一题的第 25 天。

题目清单：一起刷力扣

引用力扣题目：15 三数之和

题目描述

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000
-105 <= nums[i] <= 105

实现

思路 1

在 力扣 1 两数之和 题目中，我们已经知道了如何使用哈希表来减少一层循环的开销技巧
那么这个题目，依旧可以使用这个思路
最常规的做法是来三次循环，搜索所有可能的 三元组
那么，使用类似的方法，我们使用两个循环搜索所有的 二元组，在最内层使用哈希表来减少最内层的开销
这样一来，时间复杂度可从 O(N^3) 降低为 O(N^2)

C++ 代码实现

class Solution {
public:
    vector> threeSum(vector& nums) {
        unordered_map record;

        // 统计各个元素出现的次数
        for( int i = 0 ; i < nums.size() ; i++ ) {
            record[nums[i]] += 1;
        }

        // 排序
        sort(nums.begin(), nums.end());

        // 对排序后的元素去重
        auto iter = unique(nums.begin(), nums.end());
        nums.erase(iter, nums.end());

        // 保存结果
        vector> res;

        // 某个元素使用 3 次得到 0 的只有 0 本身
        if( record[0] >= 3 ) {
            res.push_back(vector({0, 0, 0}));
        }

        for( int i = 0 ; i < nums.size() && nums[i] <= 0 ; i++ ) {
            for( int j = i+1 ; j < nums.size() ; j++ ) {

                // 1 nums[i] 使用两次的情况 && nums[j] 使用一次的情况
                if( record[nums[i]] >= 2 && 2 * nums[i] + nums[j] == 0 ) {
                    res.push_back(vector({nums[i], nums[i], nums[j]}));
                }

                // 2 nums[j] 使用两次的情况 && nums[i] 使用一次的情况
                if( record[nums[j]] >= 2 && 2 * nums[j] + nums[i] == 0 ) {
                    res.push_back(vector({nums[i], nums[j], nums[j]}));
                }

                // 3 nums[i] 和 nums[j] 只使用一次 剩余的一个元素从 nums[j] 的右侧寻找
                int target = - ( nums[i] + nums[j] );
                if( target > nums[j] && record.find(target) != record.end() ) {
                    res.push_back(vector({nums[i], nums[j], target}));
                }
            }
        }

        return res;
    }
};

思路 2

遍历最左侧的元素 nums[i] 然后使用双指针的方法去寻找右边的两个元素，分别是 nums[l] 和 nums[r]
会出现重复的情况有两种
第一种就是遍历 nums[i] 的时候，最左侧已经用过一次这个值了，下一次又用到了这个值，就会导致重复的情况出现，因为双指针寻找的是 nums[i+1] 右侧的值，寻找的内容还是相同的，所以肯定会造成重复
第二种重复的情况是在双指针寻找的过程中，当我们寻找到一个成功的组合后，我们应该让 l 和 r 都向内靠拢一次，也就是 l++ 和 r-- 一次，但是有一种可能就是 nums[l+1] 的值等于 nums[l] 并且 nums[r-1] 的值等于 nums[r] ，这时候 nums[i] 没有变，那么势必也会造成重复的组合出现

C++ 代码实现

class Solution {
public:
    vector> threeSum(vector& nums) {
        // 排序
        sort(nums.begin(), nums.end());

        // 保存结果
        vector> res;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            // 防止 0 0 0 1 2 3 4 5 这种情况的去重 此时 i 指向最左侧的 0
            if( i > 0 && nums[i] == nums[i-1] ) continue;

            int l = i+1;
            int r = nums.size() - 1;

            while( l < r ) {
                int target = - nums[i];
                if( nums[l] + nums[r] == target ) {
                    res.push_back(vector({nums[i], nums[l], nums[r]}));
                    // 防止 -1 0 0 0 1 2 3 4 5 这种情况去重 此时 l 指向最左侧的 0
                    // 双指针指向的下一个元素 不能再和当前的元素一致了
                    while( l < r && nums[l+1] == nums[l] ) l++;
                    while( l < r && nums[r-1] == nums[r] ) r--;

                    // 发现下一个元素已经和当前元素不同的时候 更新 l 和 r
                    l++;
                    r--;
                } else if( nums[l] + nums[r] > target ) {
                    r--;
                } else {
                    l++;
                }
            }
        }

        return res;
    }
};

0016 最接近的三数之和

你好啊，我是蓝莓，今天是每日一题的第 27 天。

题目清单：一起刷力扣

引用力扣题目：16 最接近的三数之和

题目描述

给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。

示例 2：

输入：nums = [0,0,0], target = 1
输出：0
解释：与 target 最接近的和是 0（0 + 0 + 0 = 0）。

提示：

3 <= nums.length <= 1000
-1000 <= nums[i] <= 1000
-104 <= target <= 104

实现

思路

这仍然是一个数字和的问题，只是这一次并不是去寻找一个 三元组 并且使得三元组中的几个数值的和为 target，而是寻找一个接近 target 的值，所以我们没有办法使用 哈希表 来优化最内层的循环了，因为我们计算出的那个数值在哈希表中查找不到并不意味着不存在一个数值使得他们相加后接近于 target。
在使用对撞指针的过程中，我们是通过不断的逼近 target 从而来寻找一个值的。这就意味着，对撞指针不仅能够用来精确的寻找一个值，而且也能用来寻找一个 接近 的值。
在这个题目中，对撞指针是同时引用了两个值，所以原本的三层循环让我们变成了一个外层循环加上一层对撞指针的循环。因此时间复杂度可从 O(N^3) 优化为 O(N^2)

C++ 代码实现

class Solution {
public:
    int threeSumClosest(vector& nums, int target) {
        // 对撞指针

        // 排序
        sort(nums.begin(), nums.end());

        // 初始化 这是被搜索到的第一组值
        int sum = nums[0] + nums[1] + nums[nums.size() - 1];

        // 搜索
        for( int k = 0 ; k < nums.size() ; k++ ) {

            // 对撞指针搜索 nums[k+1...nums.size()-1]
            // 从而不断的趋近 target 寻找最接近的值
            int i = k+1;
            int j = nums.size() - 1;

            while( i < j ) {
                int temp = nums[k] + nums[i] + nums[j];
                if( abs(temp - target) < abs(sum - target) ) {
                    sum = temp;
                }

                if( temp > target ) {
                    j--;
                } else {
                    // temp < target
                    i++;
                }
            }
        }

        return sum;
    }
};

0454 四数相加 II

你好啊，我是蓝莓，今天是每日一题的第 28 天。

题目清单：一起刷力扣

引用力扣题目：454 四数相加 II

题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

实现

思路

这个情况，我们依然可以使用查找表对暴力方法进行优化
在以往的解题过程中，我们都是使用查找表对最内层的循环进行优化
对于四个数值的组合而言，优化后可以从 O(N^4) 降低到 O(N^3) 这个复杂度
其实我们还有更好的查找表使用技巧
我们可以先遍历两两成对的情况
（1）对 nums1 和 nums2 的数值组合成包含两个元素的元组和
（2）对 nums3 和 nums4 的数值组合成包含两个元素的元组和
（3）最后我们对所有的包含两个元组的元组和进行组合，组合成包含 4 个元素的元组和

C++ 代码实现

class Solution {
public:
    int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
        unsigned int n = nums1.size();

        unordered_map record1;
        unordered_map record2;

        for( int i = 0 ; i < n ; i++ ) {
            for( int j = 0 ; j < n ; j++ ) {
                record1[nums1[i] + nums2[j]] += 1;
                record2[nums3[i] + nums4[j]] += 1;
            }
        }

        int counter = 0;

        for( auto iter = record1.begin() ; iter != record1.end() ; iter++ ) {
            int k1 = iter->first;
            int v1 = iter->second;

            int k2 = -k1;
            if( record2.find(k2) != record2.end() ) {
                int v2 = record2[k2];
                counter += v1 * v2;
            }
        }

        return counter;
    }
};

0018 四数之和

你好啊，我是蓝莓，今天是每日一题的第 26 天。

题目清单：一起刷力扣

引用力扣题目：18 四数之和

题目描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

实现

思路

这个题目同样可以使用查找表优化
需要注意的是，由于这个需要使用四个数值组成一个 四元组 所以情况相对复杂一些
由于每个数值出现在 nums 数组中的次数可以有多次，所以组成四元组的方式主要有 4 种
（1）四元组中有一个互不相同的数值，并且满足要求的；
（2）四元组中有两个互不相同的数值，并且满足要求的；
（3）四元组中有三个互不相同的数值，并且满足要求的；
（4）四元组中有四个互不相同的数值，并且满足要求的；

C++ 代码实现

class Solution {
public:
    vector> fourSum(vector& nums, int target) {
        unordered_map record;

        // 统计每个数值出现的次数
        for( int i = 0 ; i < nums.size() ; i++ ) {
            record[nums[i]]++;
        }

        // 排序
        sort(nums.begin(), nums.end());

        // 去重
        auto iter = unique(nums.begin(), nums.end());
        nums.erase(iter, nums.end());

        // 保存结果
        vector> res;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            // 只有一个不同数字的情况
            if( record[nums[i]] >= 4 && 4 * (long long)nums[i] == target ) {
                res.push_back(vector({nums[i], nums[i], nums[i], nums[i]}));
            }

            for( int j = i+1 ; j < nums.size() ; j++ ) {
                // 两个不同数字的情况
                if( record[nums[i]] >= 3 && 3 * (long long)nums[i] + (long long)nums[j] == target ) {
                    res.push_back(vector({nums[i], nums[i], nums[i], nums[j]}));
                }

                if( record[nums[j]] >= 3 && (long long)nums[i] + 3 * (long long)nums[j] == target ) {
                    res.push_back(vector({nums[i], nums[j], nums[j], nums[j]}));
                }

                if( record[nums[i]] >= 2 && record[nums[j]] >= 2 && 2 * (long long)nums[i] + 2 * (long long)nums[j] == target ) {
                    res.push_back(vector({nums[i], nums[i], nums[j], nums[j]}));
                }

                for( int k = j+1 ; k < nums.size() ; k++ ) {
                    // 3 个不同数字的情况
                    if( record[nums[i]] >= 2 && 2 * (long long)nums[i] + (long long)nums[j] + (long long)nums[k] == target ) {
                        res.push_back(vector({nums[i], nums[i], nums[j], nums[k]}));
                    }

                    if( record[nums[j]] >= 2 && (long long)nums[i] + 2 * (long long)nums[j] + (long long)nums[k] == target ) {
                        res.push_back(vector({nums[i], nums[j], nums[j], nums[k]}));
                    }

                    if( record[nums[k]] >= 2 && (long long)nums[i] + (long long)nums[j] + 2 * (long long)nums[k] == target ) {
                        res.push_back(vector({nums[i], nums[j], nums[k], nums[k]}));
                    }

                    // 4 个不同数字的情况 使用哈希表优化一层循环
                    int num = target - (long long)(nums[i] + nums[j] + nums[k]);
                    if( record.find(num) != record.end() && num > nums[k] ) {
                        res.push_back(vector({nums[i], nums[j], nums[k], num}));
                    }
                }
            }
        } 

        return res;
    }
};

0049 字母异位词分组

你好啊，我是蓝莓，今天是每日一题的第 29 天。

题目清单：一起刷力扣

引用力扣题目：49 字母异位词分组

题目描述

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

示例 2:

输入: strs = [""]
输出: [[""]]

示例 3:

输入: strs = ["a"]
输出: [["a"]]

提示：

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

实现

思路

我们需要对每一个单词进行归类
归类的标准是这个单词用到的字母所属的集合是相同的；其实这个说法还是不太严谨，因为如果同时出现了两个相同的字母，我们是不能去重的；
所以呢，我们可以对每个单词的字母按照字典序进行排序，如果排序后展现出来的是同样的内容，那么它们就是同一个类别的

C++ 代码实现

class Solution {
public:
    vector> groupAnagrams(vector& strs) {
        unordered_map> record;

        for( int i = 0 ; i < strs.size() ; i++ ) {
            string s = strs[i];
            sort(s.begin(), s.end());
            record[s].push_back(strs[i]);
        }

        vector> res;

        for( auto iter = record.begin() ; iter != record.end() ; iter++ ) {
            res.push_back(iter->second);
        }

        return res;
    }
};

0447 回旋镖的数量

你好啊，我是蓝莓，今天是每日一题的第 30 天。

题目清单：一起刷力扣

引用力扣题目：447 回旋镖的数量

题目描述

给定平面上 n 对 互不相同 的点 points ，其中 points[i] = [xi, yi] 。回旋镖 是由点 (i, j, k) 表示的元组，其中 i 和 j 之间的欧式距离和 i 和 k 之间的欧式距离相等（需要考虑元组的顺序）。

返回平面上所有回旋镖的数量。

示例 1：

输入：points = [[0,0],[1,0],[2,0]]
输出：2
解释：两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]

示例 2：

输入：points = [[1,1],[2,2],[3,3]]
输出：2

示例 3：

输入：points = [[1,1]]
输出：0

提示：

n == points.length
1 <= n <= 500
points[i].length == 2
-104 <= xi, yi <= 104
所有点都 互不相同

实现

思路

在这里要考虑的是对于每一个三元组中的点 point[i] 来说，只要我们计算出所有其它的点到这个点的距离然后按照距离对其他所有的点进行归类就可以
归类后，我们通过遍历所有不同的距离中收集到的不同的点，我们计算一下，这些点使用排列的方式放在 j 和 k 的位置有多少种排列的方式
如果某类距离中收集到的点的数量为 k 那么根据排列的计算方法，我们可以知道有 k * (k-1) 中摆放方法

C++ 代码实现

class Solution {
public:
    int numberOfBoomerangs(vector>& points) {
        // 对于每一个点 point[i]
        // 计算出其它所有的点到这个点的欧拉距离为 dist 的顶点数量
        vector> record(points.size());

        for( int i = 0 ; i < points.size() ; i++ ) {
            for( int j = 0 ; j < points.size() ; j++ ) {
                int dist = distance(points[i], points[j]);
                record[i][dist]++;
            }
        }

        int counter = 0;

        for( int i = 0 ; i < points.size() ; i++ ) {
            for( auto iter = record[i].begin() ; iter != record[i].end() ; iter++ ) {
                int k = iter->second;
                counter += k * (k-1);
            }
        }

        return counter;
    }

    int inline distance(vector& p1, vector& p2) {
        int a = p1[0] - p2[0];
        int b = p1[1] - p2[1];
        return a * a + b * b;
    }
};

0149 直线上最多的点数

你好啊，我是蓝莓，今天是每日一题的第 31 天。

题目清单：一起刷力扣

引用力扣题目：149 直线上最多的点数

题目描述

给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。

示例 1：

输入：points = [[1,1],[2,2],[3,3]]
输出：3

示例 2：

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

提示：

1 <= points.length <= 300
points[i].length == 2
-10^4 <= xi, yi <= 10^4
points 中的所有点 互不相同

实现

思路

我们都知道两点确定一条直线
先确定一个点，然后求该点和其他所有点构成直线的斜率，使用求得的斜率作为哈希表的 key ，使用落在该斜率上的点的数量作为哈希表的值
现在最大的问题是，斜率是一个小数，但是在计算机中只有浮点数，所以是有误差的，不太能作为哈希表的键
另一种斜率表示法：我们可以使用比值的方式存储斜率，只需要将该分数的分子和分母化为最简就可以了，这样一来，我们就可以使用两个整型精确的表示一个分数了
设 a 为该分数的分子，b为该分数的分母，为了统一，若该分数为负数，我们总是让负号出现在 b 中
根据题目提供的信息我们可以知道
（1）表示斜率的分子被我们统一成了整数，结合每个点的坐标范围，我们可以计算出斜率的分子 a 的范围是 0 到 2 × 10^4
（2）表示斜率的分母 b 可正可负，所以分母的取值范围是 -2 × 10^4 到 2 × 10^4
最后，我们使用一个 32 位的整数来保存这两个内容，我们让 b 乘以 2 × 10^4 + 1 这样一来，我们就在数轴的中间部分空出了很大一部分的空间，我们让这个数值再加上 a ，这样一来，我们总是可以通过两个值的和得到唯一的键

C++ 代码实现

class Solution {
public:

    int _gcd(int a, int b) {
        if( b == 0 ) {
            return a;
        }

        return _gcd(b, a%b);
    }

    int gcd(int a, int b) {
        if( a == b ) {
            return a;
        }

        return _gcd(max(a, b), min(a, b));
    }

    int maxPoints(vector>& points) {
        // 对每一个点 i;
        // record[i] 记录其他点到该点不同斜率收集的点的数量
        // record[i][斜率] = 数量
        int res = 0;

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

            unordered_map record; 
            for( int j = 0 ; j < points.size() ; j++ ) {
                if( i == j ) continue;

                int a = points[i][0] - points[j][0];
                int b = points[i][1] - points[j][1];

                if( a == 0 ) {
                    b = 1;
                } else if( b == 0 ) {
                    a = 1;
                } else {
                    
                    if( a < 0 ) {
                        a = -a;
                        b = -b;
                    }
                    int ab_gcd = gcd(abs(a), abs(b));

                    a = a / ab_gcd;
                    b = b / ab_gcd;
                }

                // 从数轴上可以观察到这样不会产生冲突
                int key = 20001 * b + a;
                record[key] ++;
            }

            for( auto iter = record.begin() ; iter != record.end() ; iter++ ) {
                res = max(res, iter->second);
            }
        }

        return res+1;
    }
};

0219 存在重复元素 II

你好啊，我是蓝莓，今天是每日一题的第 32 天。

题目清单：一起刷力扣

引用力扣题目：219 存在重复元素 II

题目描述

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,1], k = 3
输出：true

示例 2：

输入：nums = [1,0,1,1], k = 1
输出：true

示例 3：

输入：nums = [1,2,3,1,2,3], k = 2
输出：false

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109
0 <= k <= 105

实现

思路

题目要求寻找两个重复的元素，并且这两个元素之间的距离不超过 k
我们可以维护一个滑动窗口，使用哈希表记录这个滑动窗口内的每个元素出现的次数
如果当前没有出现重复的元素，那么就向右滑动一下，扔掉旧的元素，纳入新的元素，并检查纳入新的元素后是否出现了重复的元素
这时候，如果出现了重复元素就可以直接返回成功了
如果没有出现，那就需要继续滑动窗口
如果所有的元素都扫过了一遍还是没成功，那肯定就是失败了

C++ 代码实现

class Solution {
public:
    bool containsNearbyDuplicate(vector& nums, int k) {
        
        int l = 0;
        int r = k < nums.size() - 1 ? k : nums.size() - 1;

        // num -> freq 
        unordered_map record;
        
        for( int i = 0 ; i <= r ; i++ ) {
            if(++record[nums[i]] >= 2) {
                return true;
            }
        }

        for( int i = r+1 ; i < nums.size() ; i++ ) {
            // 扔掉以前的元素
            record[nums[l++]]--;
            
            // 加入新的元素
            if(++record[nums[i]] >= 2) {
                return true;
            }
        }

        return false;
    }
};

0219 存在重复元素 II

你好啊，我是蓝莓，今天是每日一题的第 32 天。

题目清单：一起刷力扣

引用力扣题目：217 存在重复元素

题目描述

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

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

**输出：**true

解释：

元素 1 在下标 0 和 3 出现。

示例 2：

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

**输出：**false

解释：

所有元素都不同。

示例 3：

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

**输出：**true

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109

实现

思路

这是一个简单题，直接使用哈希表来记录每个遍历过得元素出现的次数就可以
当我们将一个新的元素加入到哈希表的统计后，我们就看看当前这个元素的出现次数是不是大于或等于 2 了，如果是的话，直接返回成功，不然继续遍历
如果遍历完所有的元素后都没有成功，那就说明不存在重复的元素，返回失败

C++ 代码实现

class Solution {
public:
    bool containsDuplicate(vector& nums) {
        unordered_map record;

        for( int num : nums ) {
            if( ++record[num] >= 2 ) {
                return true;
            }
        }

        return false;
    }
};

0220 存在重复元素 III

你好啊，我是蓝莓，今天是每日一题的第 32 天。

题目清单：一起刷力扣

引用力扣题目：220 存在重复元素 III

题目描述

给你一个整数数组 nums 和两个整数 indexDiff 和 valueDiff 。

找出满足下述条件的下标对 (i, j)：

i != j,
abs(i - j) <= indexDiff
abs(nums[i] - nums[j]) <= valueDiff

如果存在，返回 true *；*否则，返回 false 。

示例 1：

输入：nums = [1,2,3,1], indexDiff = 3, valueDiff = 0
输出：true
解释：可以找出 (i, j) = (0, 3) 。
满足下述 3 个条件：
i != j --> 0 != 3
abs(i - j) <= indexDiff --> abs(0 - 3) <= 3
abs(nums[i] - nums[j]) <= valueDiff --> abs(1 - 1) <= 0

示例 2：

输入：nums = [1,5,9,1,5,9], indexDiff = 2, valueDiff = 3
输出：false
解释：尝试所有可能的下标对 (i, j) ，均无法满足这 3 个条件，因此返回 false 。

提示：

2 <= nums.length <= 105
-109 <= nums[i] <= 109
1 <= indexDiff <= nums.length
0 <= valueDiff <= 109

实现

思路

这个题目设计到了二分搜索树的有序性，在 C++ 中的 set 底层是使用红黑树实现的，而 unordered_set 的底层是使用哈希表实现的
所以，我们可以使用 set，一旦它维护的元素有了顺序之后，我们就可以针对某个数值 key 去更快的寻找最接近 key 且大于或等于 key 的那个数值
在 C++ 中的 set 提供了 lower_bound 方法来来寻找大于等于 key 的数值

C++ 代码实现

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector& nums, int indexDiff, int valueDiff) {
        set record;

        for( int i = 0 ; i < nums.size() ; i++ ) {
            // 对于给定的 nums[i] 查找 record 中是否存在一个数组 num
            // nums[i] - valueDiff <= num <= nums[i] + valueDiff
            // 转换成寻找一个最接近 nums[i] - valueDiff 但是大于等于 nums[i] - valueDiff 的值
            // 而且这个值小于等于 nums[i] + valueDiff

            int key = nums[i] - valueDiff;
            int upper = nums[i] + valueDiff;
            if( record.lower_bound(key) != record.end() && *record.lower_bound(key) <= upper ) {
                return true;
            }

            record.insert( nums[i] );
            // 因为 valueDiff 最小的数值为 0
            // 如果 set 中存在了相同的元素
            // 那么就一定会满足题意 所以只要算法还在进行
            // 就说明一定没有向 set 添加过重复的元素
            if( record.size() == indexDiff + 1 ) {
                record.erase(nums[i-indexDiff]);
            }
        }

        return false;
    }
};

0206 反转链表

你好啊，我是蓝莓，今天是每日一题的第 33 天。

题目清单：一起刷力扣

引用力扣题目：206 反转链表

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

实现

思路

这是一个和链表相关的简单题
为了更容易的反转链表，我们引入一个虚拟头结点，这样能简化代码的逻辑，省掉很多的边界处理

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
		//如果链表为空则直接返回 空
        if( head == nullptr ) {
            return head;
        }
		
        // 创建一个虚拟头结点 让它的 next 指向真正的头结点 head
        ListNode* dummyHead = new ListNode(-1, head);
		
        // pre 表示当前遍历到的节点的前一个节点
        ListNode* pre = dummyHead;
        // cur 表示当前正要修改 next 指向的节点
        ListNode* cur = head;
		
        // 若 cur 已经为 nullptr 说明遍历结束
        while( cur != nullptr ) {
            // 记录 cur 指向的下一个节点
            ListNode* next = cur->next;
			
            // 让 cur 指向前一个节点 pre
            cur->next = pre;
            // 为下一轮循环做准备
            // 分别将 pre 和 cur 向后移动一下
            pre = cur;
            cur = next;
        }
		
        // 其实这个时候 整个链表的翻转已经结束了
        // 但是 最一开始的 head 节点已经成为了尾节点
        // 它应该指向 nullptr 才对
        // 恰巧我们记得 dummyHead 是指向最开始的 head 节点的
        // 我们通过它来修改 head 的 next 的指向
        // 当然你也可以直接通过 head 来修改
        dummyHead->next->next = nullptr;
		
        // 此时的 pre 正好就是翻转链表后的头结点
        return pre;
    }
};

0092 反转链表 II

你好啊，我是蓝莓，今天是每日一题的第 34 天。

题目清单：一起刷力扣

引用力扣题目：92 反转链表 II

题目描述

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：

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

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

提示：

链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n

进阶： 你可以使用一趟扫描完成反转吗？

实现

思路 1

比较简单的思路是，我们先遍历一遍链表来寻找几个关键的节点
然后再对中间部分的链表进行翻转，随后调整关键位置的指向

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode* dummyHead = new ListNode(-1, head);

        // 找到 left 和 right 代表的节点
        ListNode* leftPre = nullptr;  // left 的前一个节点
        ListNode* leftNode = nullptr;  // left 节点
        ListNode* rightNode = nullptr;  // right 节点
        ListNode* rightNext = nullptr;  // right 后一个节点

        ListNode* pre = dummyHead;  // 遍历过程中的前一个节点
        ListNode* cur = head;  // 遍历过程中的后一个节点

        // 寻找节点
        int counter = 1;
        while( cur != nullptr ) {
            if( counter == left ) {
                leftPre = pre;
                leftNode = cur;
            }
            
            if( counter == right ) {
                rightNode = cur;
                rightNext = cur->next;
            }

            pre = cur;
            cur = cur->next;
            counter++;
        }

        cur = leftNode;
        pre = leftPre;
        // 翻转链表
        while( cur != rightNext ) {
            ListNode* next = cur->next;

            cur->next = pre;
            pre = cur;
            cur = next;
        }

        // 调整翻转后的中间部分的链表指向关系
        leftNode->next = rightNext;
        leftPre->next = rightNode;

        return dummyHead->next;
    }
};

思路 2

在第一种方法中，我们遍历了两次链表才把问题解决
其实核心问题是要确定，在什么范围内才翻转链表？
根据题目描述，我们要在给定的范围内才需要对链表进行翻转
那就是这样的一个范围 counter >= left && counter <= right；其中 counter 代表当前是第几个节点

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode* dummyHead = new ListNode(-1, head);

        // 找到 left 和 right 代表的节点
        ListNode* leftPre = nullptr;  // left 的前一个节点
        ListNode* leftNode = nullptr;  // left 节点
        ListNode* rightNode = nullptr;  // right 节点
        ListNode* rightNext = nullptr;  // right 后一个节点

        ListNode* pre = dummyHead;  // 遍历过程中的前一个节点
        ListNode* cur = head;  // 遍历过程中的后一个节点

        int counter = 1;
        while( cur != nullptr ) {
            ListNode* next = cur->next;

            if( counter == left ) {
                leftPre = pre;
                leftNode = cur;
            }

            if( counter == right ) {
                rightNode = cur;
                rightNext = next;
            }

            // 如果在给定范围内 那就翻转链表
            if( counter >= left && counter <= right ) {
                cur->next = pre;
            }

            // 移动到下一个节点
            pre = cur;
            cur = next;
            counter++;
        }

        // 调整指针的指向
        leftPre->next = rightNode;
        leftNode->next = rightNext;
        
        return dummyHead->next;
    }
};

0083 删除排序链表中的重复元素

你好啊，我是蓝莓，今天是每日一题的第 35 天。

题目清单：一起刷力扣

引用力扣题目：83 删除排序链表中的重复元素

题目描述

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：

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

示例 2：

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

提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

实现

思路

题目已经保证了链表中存储的元素是按照升序排列的
（1）使用 pre 指向当前遍历的节点的前一个
（2）使用 cur 只想当前正在遍历的节点，如果 cur 节点的值和 pre 节点的值是一样的，那么就从链表中删除 cur 节点，并修改 pre 节点的 next 指针，否则说明当前节点是不重复的

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {

        if( head == nullptr ) {
            return head;
        }

        ListNode* pre = head;
        ListNode* cur = head->next;

        while( cur != nullptr ) {
            if( pre->val == cur->val ) {
                pre->next = cur->next;
                cur = pre->next;
            } else {
                pre = cur;
                cur = cur->next;
            }
        }

        return head;
    }
};

0086 分隔链表

你好啊，我是蓝莓，今天是每日一题的第 36 天。

题目清单：一起刷力扣

引用力扣题目：86 分割链表

题目描述

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

示例 1：

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

示例 2：

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

提示：

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

实现

思路

题目要求的我们将链表分割成两部分
（1）比 x 小的部分
（2）比 x 大或者等于的部分
对于这两个部分，我们可以新建两个虚拟头结点，然后遍历原始链表，每次遍历到的节点都将它从原始链表上摘下来放在对应分类的虚拟头结点所在的链表尾部，最后将两个新的链表进行合并即可
这样一来，不仅可以在一轮遍历中完成链表分割，而且保持了元素的相对顺序

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {

        if( head == nullptr ) {
            return head;
        }

        ListNode* lessHead = new ListNode(-1, nullptr);
        ListNode* greatHead = new ListNode(-1, nullptr);

        ListNode* lessCur = lessHead;
        ListNode* greatCur = greatHead;

        ListNode* cur = head;
        while( cur != nullptr ) {
            ListNode* next = cur->next;

            if( cur->val >= x ) {
                greatCur->next = cur;
                greatCur = cur;
            } else {
                // cur->val < x
                lessCur->next = cur;
                lessCur = cur;
            }
            
            cur->next = nullptr;
            cur = next;
        }

        ListNode* res = nullptr;

        if( lessHead->next != nullptr ) {
            res = lessHead->next;
        }

        if( res != nullptr ) {
            lessCur->next = greatHead->next;
        } else {
            res = greatHead->next;
        }

        return res;
    }
};

0328 奇偶链表

你好啊，我是蓝莓，今天是每日一题的第 37 天。

题目清单：一起刷力扣

引用力扣题目：328 奇偶链表

题目描述

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。

第一个节点的索引被认为是奇数， 第二个节点的索引为偶数，以此类推。

请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

示例 1:

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

示例 2:

输入: head = [2,1,3,5,6,4,7]
输出: [2,3,6,7,1,5,4]

提示:

n == 链表中的节点数
0 <= n <= 104
-106 <= Node.val <= 106

实现

思路

这个题目和 86 分隔链表 非常相似
同样的，使用两个虚拟头结点来存储对应类别的节点
遍历原始的链表，不停的摘下一个元素然后放在对应分类的链表中
最后将两个链表进行合并即可

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        ListNode* oddHead = new ListNode(-1, nullptr);
        ListNode* evenHead = new ListNode(-1, nullptr);

        ListNode* oddCur = oddHead;
        ListNode* evenCur = evenHead;

        ListNode* cur = head;
        bool isOdd = true;

        while( cur != nullptr ) {
            ListNode* next = cur->next;

            if( isOdd ) {
                oddCur->next = cur;
                oddCur = cur;
            } else {
                evenCur->next = cur;
                evenCur = cur;
            }

            cur->next = nullptr;
            cur = next;
            isOdd = !isOdd;
        }

        ListNode* res = nullptr;

        if( oddHead->next != nullptr ) {
            res = oddHead->next;
        }

        if( res == nullptr ) {
            res = evenHead->next;
        } else {
            oddCur->next = evenHead->next;
        }

        return res;
    }
};

0231 2的幂

你好啊，我是蓝莓，今天是每日一题的第 38 天。

题目清单：一起刷力扣

引用力扣题目：231 2的幂

题目描述

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

示例 1：

输入：n = 1
输出：true
解释：20 = 1

示例 2：

输入：n = 16
输出：true
解释：24 = 16

示例 3：

输入：n = 3
输出：false

提示：

-231 <= n <= 231 - 1

**进阶：**你能够不使用循环/递归解决此问题吗？

实现

思路

从整型在机器码的表示上来看，如果这个数值是 2 的整数幂的话，在数值为正的情况下低 31 个比特位只会出现一个比特位为 1 ，其余的比特位都为 0
2 的 0 次幂是一个特殊的情况可以单独进行判断
另外就是排除 n 为负数的情况

C++ 代码实现

class Solution {
public:
    bool isPowerOfTwo(int n) {
        
        // 排序 n 小于 0 的情况
        if( n < 0 ) {
            return false;
        }
        
        int nums = 0;

        // 统计非符号位上比特位为 1 的个数
        for( int size = 0 ; size < 31 ; size++ ) {
            if( n >> size & 0x1 ) {
                nums++;
            }
        }

        if( nums > 1 || nums == 0 ) {
            return false;
        }

        return true;
    }
};

0445 两数相加 II

你好啊，我是蓝莓，今天是每日一题的第 39 天。

题目清单：一起刷力扣

引用力扣题目：445 两数相加 II

题目描述

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

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

示例1：

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

示例2：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[8,0,7]

示例3：

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

提示：

链表的长度范围为 [1, 100]
0 <= node.val <= 9
输入数据保证链表代表的数字无前导 0

**进阶：**如果输入链表不能翻转该如何解决？

实现

思路

在做加减法的时候，肯定是要从权重最低的位开始计算
为了模拟这个计算过程，我们需要将链表进行翻转（虽然题目说要求不翻转，但是用栈其实都是一样的逻辑，只是没有了维护指针指向的开销而已）
所以在代码中实现了 reverseList 函数用来翻转链表，返回值为翻转后的链表头结点

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if( l1 == nullptr ) {
            return l2;
        }

        if( l2 == nullptr ) {
            return l1;
        }

        // 翻转 l1 和 l2 链表
        ListNode* num1 = reverseList(l1);
        ListNode* num2 = reverseList(l2);

        // 创建一个虚拟头结点 dummy 用来相加结果的链表
        ListNode* dummy = new ListNode(-1, nullptr);
        // cur1 和 cur2 分别在 num1 和 num2 链表上滑动
        ListNode* cur1 = num1;
        ListNode* cur2 = num2;

        // 用来表示下一轮的进位上的值
        int carry = 0;

        // carry != 0 表示 如果最后一次相加还产生了进位 还是要继续添加节点
        while( cur1 != nullptr || cur2 != nullptr || carry != 0 ) {
            if( cur1 != nullptr ) {
                carry += cur1->val;
                cur1 = cur1->next;
            }

            if( cur2 != nullptr ) {
                carry += cur2->val;
                cur2 = cur2->next;
            }

            // carry % 10 为当前位置的值
            // carry / 10 为下一位的进位值
            ListNode* newNode = new ListNode( carry % 10, dummy->next);
            dummy->next = newNode;

            carry = carry / 10;
        }

        ListNode* res = dummy->next;
        delete dummy;

        return res;
    }
    
    // 翻转非空链表
    ListNode* reverseList(ListNode* head) {
        ListNode* dummy = new ListNode(-1, head);

        ListNode* pre = dummy;
        ListNode* cur = head;

        while( cur != nullptr ) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        dummy->next->next = nullptr;

        delete dummy;
        return pre;
    }
};

0203 移除链表元素

你好啊，我是蓝莓，今天是每日一题的第 40 天。

题目清单：一起刷力扣

引用力扣题目：203 移除链表元素

题目描述

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

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

示例 2：

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

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

实现

思路

使用 pre 指向当前正在遍历的前一个节点（为了逻辑上一致，使用了虚拟头结点的技巧）
使用 cur 遍历链表，分为两种情况
（1）当前节点要删除，那么 pre 不需要移动，只需要让 cur 移动一下即可
（2）当前节点不需要删除，那么 pre 和 cur 都向前移动一次

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy = new ListNode(-1, head);

        ListNode* pre = dummy;
        ListNode* cur = head;

        while( cur != nullptr ) {
            if( cur->val == val ) {
                pre->next = cur->next;
                cur = pre->next;
            } else {
                pre = cur;
                cur = cur->next;
            }
        }

        return dummy->next;
    }
};

0082 删除排序链表中的重复元素 II

你好啊，我是蓝莓，今天是每日一题的第 41 天。

题目清单：一起刷力扣

引用力扣题目：82 删除排序链表中的重复元素 II

题目描述

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

示例 1：

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

示例 2：

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

提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

实现

思路

容易想到的是，我们可以使用两个指针 pre 和 cur ，如果我们发现两者指向的节点的值是相同的，那就说明我们发现了重复元素
这时候我们需要将等于我们发现的这个值的所有的节点全部删掉，方法其实很简单，我们只需要继续让 cur 向下继续找，找到第一个不等于当前发现的这个值的那个节点就可以了
随后，我们让 pre 的前一个节点的 next 指向我们发现的第一个不等于该值的节点，那么中间的链表就从逻辑上删除了
但是，问题来了，我们无法访问到 pre 的前一个节点，所以这时候可以再添加一个指针 prePre ，让它指向 pre 的前一个节点
最后，如果我们遍历的过程中，当前遍历到的节点是不重复的，那么就让每个指针都向后移动一次即可

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        // 虚拟头结点
        ListNode* dummy = new ListNode(-1, head);
        
        if( head == nullptr ) {
            return head;
        }

        ListNode* prePre = dummy;  // 指向 cur 的前一个的前一个元素
        ListNode* pre = head;  // 指向 cur 的前一个元素
        ListNode* cur = pre->next;  // 指向链表中的第二个节点，当前正在检查的节点

        while( cur != nullptr ) {
            if( pre->val == cur->val ) {
                // 发现重复元素
                int val = cur->val;
                // 将 cur 移动到当前发现的重复元素的最后一个元素的下一个节点处
                while( cur != nullptr && cur->val == val ) cur = cur->next;

                // 在逻辑上截断中间这组重复的元素
                prePre->next = cur;
                pre = cur;
                // cur 若为空说明已经结束；cur 不为空则继续算法
                if( cur != nullptr ) {
                    cur = cur->next;
                } else {
                    break;
                }
            } else {
                // 没有发现重复的元素 正常维护指针
                prePre = pre;
                pre = cur;
                cur = cur->next;
            }
        }

        return dummy->next;
    }
};

0021 合并两个有序链表

你好啊，我是蓝莓，今天是每日一题的第 42 天。

题目清单：一起刷力扣

引用力扣题目：21 合并两个有序链表

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

实现

思路

这个题目的做法和归并排序中归并的做法很像，在归并的过程中主要分为两种情况
（1）两个链表都不为空，这时候选择其中值较小的节点挂在最终链表的尾部
（2）其中一个链表为空，另一个链表不为空，这时候就直接无脑的将不为空的那个链表的所有节点都挂在最终链表的末尾即可

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* cur1 = list1;
        ListNode* cur2 = list2;

        ListNode* dummy = new ListNode(-1, nullptr);
        ListNode* cur = dummy;

        while( cur1 || cur2 ) {
            if( cur1 && cur2 ) {
                if( cur1->val < cur2->val ) {
                    cur->next = cur1;
                    cur = cur1;
                    cur1 = cur1->next;
                } else {
                    cur->next = cur2;
                    cur = cur2;
                    cur2 = cur2->next;
                }
            } else if( cur1 ) {
                cur->next = cur1;
                cur = cur1;
                cur1 = cur1->next;
            } else {
                // cur2 != nullptr
                cur->next = cur2;
                cur = cur2;
                cur2 = cur2->next;
            }
        }

        cur->next = nullptr;

        cur = dummy->next;
        delete dummy;

        return cur;
    }
};

0024 两两交换链表中的节点

你好啊，我是蓝莓，今天是每日一题的第 43 天。

题目清单：一起刷力扣

引用力扣题目：24 两两交换链表中的节点

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

实现

思路

使用三个指针 prePre 指针即将要交换的那两个元素的前一个元素
pre 指向需要交换的两个元素的第一个元素
cur 指向需要交换的两个元素的第二个元素
接下来就按照正常逻辑完成代码就行

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(-1, nullptr);

        if( head == nullptr || head->next == nullptr ) {
            return head;
        }

        ListNode* prePre = dummyHead;
        ListNode* pre = head;
        ListNode* cur = pre->next;

        while( true ) {
            ListNode* next = cur->next;

            // 交换节点
            prePre->next = cur;
            cur->next = pre;
            pre->next = next;

            // 为下一次交换做准备
            // 看看 pre 能不能更新
            prePre = pre;
            if(pre->next != nullptr ) {
                pre = pre->next;
            } else {
                // 如果 pre 更新后为空那就不需要再继续下去了
                break;
            }

            // 看看 cur 能不能更新
            if( pre->next != nullptr ) {
                cur = pre->next;
            } else {
                // 如果 cur 更新后为空 说明凑不够两个元素了
                break;
            }
        }

        cur = dummyHead->next;
        delete dummyHead;

        return cur;
    }
};

0025 K 个一组翻转链表

你好啊，我是蓝莓，今天是每日一题的第 44 天。

题目清单：一起刷力扣

引用力扣题目：25 K 个一组翻转链表

题目描述

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

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

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

示例 1：

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

示例 2：

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

提示：

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

**进阶：**你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

实现

思路

同样是翻转链表，只是这次是以 k 个节点为一组进行翻转
在我们翻转一整个链表的时候，我们预先已经知道的信息是 头结点、尾节点的下一个节点 nullptr
在我们知道了这两个节点后，我们就可以创建一个 虚拟节点 来简化代码的逻辑
但是每个以 k 个为一组的节点的头结点，我们是不知道的，所以我们最重要的任务其实是找到每一组的 头结点 和 尾节点的下一个节点 ，那么剩下的代码逻辑就可以直接复用之前写过的逻辑了
关于寻找 k 个节点为一组的头节点是很简单的，第一组的头结点就是整个链表的头节点
我们使用 cur 指针，让 cur 向后移动 k 次，那么 cur 指向的就是第一组的 ``尾节点的下一个节点，并且此时的 cur` 也是第二组的头节点
还有重要的一点是，我们该如何检查是不是能够凑出 k 个节点呢？比如你看题目中的最后两个节点无法凑出 3 个节点为一组的情况是不需要反转的，在这里我有两个方法
（1）就像代码里写的那样，如果我们在向后移动 k 次的过程中，循环都没执行完，cur就已经指向 nullptr 了，这说明肯定是凑不够了，已经没法再向后移动了
（2）第二种情况，我们在执行循环的时候定义了一个变量 i，你可以把这个变量定义在循环的外部，这样，你可以在结束循环后检查一下变量 i 是不是刚好等于 k ？如果不等于的话，那说明是没有移动够 k 次就由于 cur 指向了 nullptr 而停了下来
最后我们只需要判断一下，如果凑够了 k 个节点就直接复用以前的反转链表的逻辑就行了
如果没有凑够那一定是因为 cur 指向了空，我们什么都不用做，整个算法也就结束了

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummyHead = new ListNode(-1, head);

        // pre 指向需要反转的局部链表的头结点的前一个节点
        ListNode* pre = dummyHead;
        // 使用 cur 向后遍历 k 个节点 指向需要反转的局部链表的最后一个节点的下一个节点
        ListNode* cur = head;

        while( cur != nullptr ) {

            bool ok = true;  // 在寻找过程中 如果无法凑够 k 个节点则标记为 false
            for( int i = 0 ; i < k ; i++ ) {
                if( cur == nullptr ) {
                    // 无法再凑够 k 个了
                    ok = false;
                    break;
                }

                cur = cur->next;
            }

            // 如果凑够了 k 个节点那么就翻转它
            if(ok) {
                // 当前的头节点便是翻转后的尾节点
                ListNode* newEnd = pre->next;
                // 维护指针的指向
                pre->next = reverseList(pre->next, cur);
                // 让尾节点指向翻转前的尾节点的下一个节点
                newEnd->next = cur;
                // 那么反转后的尾节点就是 cur 的前一个节点
                pre = newEnd;
            }
        }

        cur = dummyHead->next;
        delete dummyHead;

        return cur;
    }

    ListNode* reverseList(ListNode* head, ListNode* end) {
        // head 表示需要翻转的链表头节点
        // end 表示需要翻转的链表的尾节点的下一个节点
        // 返回值为翻转后的链表头结点

        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* pre = dummyHead;
        ListNode* cur = head;

        while( cur != end ) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        delete dummyHead;
        return pre;
    }
};

0147 对链表进行插入排序

你好啊，我是蓝莓，今天是每日一题的第 45 天。

题目清单：一起刷力扣

引用力扣题目：147 对链表进行插入排序

题目描述

给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。

插入排序 算法的步骤:

插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。

下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。

对链表进行插入排序。

示例 1：

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

示例 2：

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

提示：

列表中的节点数在 [1, 5000]范围内
-5000 <= Node.val <= 5000

实现

思路

在数组上使用插入排序的时候，每次插入一个数值，我们都需要把插入点和后面的数值全部向后移动一个位置，然后空出来这个插入点的位置才能让我们插入
所以这主要还是一个链表的基础操作，就是插入一个节点
在寻找插入点的时候，我们可以注意这么两个条件（按照递增排序）
（1）如果当前待插入节点的值大于等于当前遍历到的插入点的值，那么就继续向后遍历，否则停下来
（2）如果当前遍历到的这个节点已经超出了排序完成的区间范围，那么就停下来（这一点可以通过：当前的节点的是不是当前待插入节点这一条件来判断）
好了，明确了以上两个问题我们再来看一下如何插入一个节点
我们要插入的这个节点本身就是链表中的，所以我们需要先把这个节点给取下来，这个过程就已经需要我们来维护当前节点的前一个节点的 next 指针的指向了，所以我们需要一个 pre 来记录当前的节点 cur 的前一个节点是谁
那么，同时，我们还需要维护插入位置的前一个节点的指针的指向，为了减少变量的使用，我直接用一个 search 来代表插入位置的前一个节点了，与此同时我们通过 search->next 也可以访问到当前需要比较大小的那个插入点位置的节点的 val ；当然了，你也可以再添加一个变量，或许用着方便一些
最后就是维护一下 cur 指针指向的那个节点，如果我们需要将这个节点插入到一个为止，那么 cur 的 next 指针也需要维护一下

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* pre = dummyHead;
        ListNode* cur = head;

        while( cur != nullptr ) {
            // search 指向比较元素的前一个节点
            ListNode* search = dummyHead;

            while( cur->val >= search->next->val && search->next != cur ) {
                search = search->next;
            }

            if( search->next != cur ) {
                // 这时候执行插入逻辑
                ListNode* searchNext = search->next;
                ListNode* curNext = cur->next;
                search->next = cur;
                cur->next = searchNext;
                pre->next = curNext;  // pre 不需要移动
                cur = pre->next;  // 此时应该更新 cur
            } else {
                // 这说明应当插入在已经排序完成的所有节点的后面
                // 那说明 cur 当前所处位置就是正确的 直接跳过即可
                pre = cur;
                cur = cur->next;
            }
        }

        cur = dummyHead->next;
        delete dummyHead;
        
        return cur;
    }
};

0148 排序链表

你好啊，我是蓝莓，今天是每日一题的第 46 天。

题目清单：一起刷力扣

引用力扣题目：148 排序链表

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

**进阶：**你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

实现

思路

对于 147 对链表进行插入排序 题目，按照要求我们直接在链表上使用了插入排序
但是对于当前这个题目而言，插入排序的时间复杂度是 O(N^2) 级别的时间复杂度不满足要求
相对来说，常见的排序算法，如 快速排序、归并排序 来讲，归并排序 是更适合在链表上使用的
接下来就看一下，如何在链表作为数据结构的基础上实现归并排序
归并排序有两种实现方式
（1）自顶向下的递归方式来实现
（2）自底向上的方式来实现
在这篇文章中，我们来看看自底向上的方式怎么实现，主要有这么几方面实现的要点
（1）自底向上的实现过程中需要明确从每一次归并的两个子链表的长度是多大？对于每一个将要归并的链表而言，它们必须是有序的才能被正确归并，所以 subSize 的大小应该是从 1 开始，也就是第一轮归并过程中，我们把相邻的每个元素看成一个单独的链表，归并成长度为 2 的链表；但是 subSize 最大应该增长到多少就要停止了？可以想象一下，如果一个链表的长度为 n 那么我们从中间切一刀，如果 subSize 刚好是 n/2 的话，那么我们只需要再归并一次就行了，但是 subSize 每次都是成倍增长的，可能不会刚好增长到 n/2，或许上一次的 subSize = 2n/5 那么下一次的 subSize 就等于 4n/5 ；所以 subSize 如果一旦大于等于 n ，那么就一定已经完成归并了；记住 subSize 指的是归并的两个链表中的单个链表的长度，所以归并的元素最大的量是 2subSize
（2）所以非常明确，应该有一层循环来处理每一轮归并过程中 subSize 的增长变化
（3）在每一轮的 subSize 确定后，我们如何归并？重要的是如何一步一步的找到所有成对出现的相邻的长度为 subSize 的链表；在这里我们使用 head1 来指向需要归并的第一个链表的头，使用 head2 来指向需要归并的第二个链表的头；使用 cur 来遍历整个大的链表，很容易我们可以知道 head1 就是 cur 还没有移动时所指向的节点，所以我们一开始就能确定第一组的 head1 是谁了。这时候我们让 cur 向后移动 subSize 个节点，我们通过 cur 节点的前一个节点 pre 可以知道 head1 链表的最后一个节点是谁，为了方便，我们让 head1 最后一个节点的 next 指向 nullptr ，而且此时 cur 指向的正是 head2 这个节点；接着我们再让 cur 移动 subSize 个节点，使用同样的方法，pre 指向的正是 head2 的最后一个节点，我们也让 head2 的最后一个节点指向 nullptr ；最后我们写一个 merge 函数来归并这两个链表就行了；
（4）在归并链表的时候，我们归并后的链表需要和 head1 前面的那部分衔接上，所以我们需要单独记录 head1 的前一个节点 preHead1
（5）当我们完成一组归并后，此时的 preHead1 和 pre 都应该指向归并完成的链表的最后一个节点，因为这个节点正是下一次寻找 head1 的前一个节点，而且这个节点也正是 cur 当前所指向的节点的前一个节点；完了让链表衔接上，我们还应该让归并完成的链表的最后一个节点指向当前的 cur 节点（别忘了，我们之前为了 merge 过程的方便给人家改成指向 nullptr 了）；接着我们所有的变量就又回到了最初的定义

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        int size = 0;

        for( ListNode* cur = head ; cur != nullptr ; cur = cur->next ) {
            size ++;
        }

        ListNode* dummyHead = new ListNode(-1, head);

        // 当 subSize 大于 size / 2 的时候，只需要再进行最后一轮归并就结束了
        for( int subSize = 1 ; subSize < size ; subSize += subSize ) {
            
            ListNode* pre = dummyHead;
            ListNode* cur = dummyHead->next;

            while( cur != nullptr ) {
                // 每完成一轮循环就要完成一组的归并
                ListNode* preHead1 = pre;
                ListNode* head1 = cur;
                // 跳过前半部分
                for( int i = 0 ; i < subSize && cur != nullptr ; i++ ) {
                    pre = cur;
                    cur = cur->next;
                }
                pre->next = nullptr;  // 截断 head1 链表

                ListNode* head2 = cur;
                // 跳过第二部分
                for( int i = 0 ; i < subSize && cur != nullptr ; i++ ) {
                    pre = cur;
                    cur = cur->next;
                }
                pre->next = nullptr;  // 截断 head2 链表

                // 合并两个链表 pre 指向合并后的链表的最后一个节点
                pre = mergeList(preHead1, head1, head2);
                pre->next = cur;  // 将链表链接在一起
            }
        }

        return dummyHead->next;
    }

    ListNode* mergeList(ListNode* dummyHead, ListNode* head1, ListNode* head2) {
        // 返回 合并后链表的最后一个节点

        ListNode* cur = dummyHead;

        ListNode* cur1 = head1;
        ListNode* cur2 = head2;

        // 一定是有一个链表被先放完的
        while( cur1 != nullptr && cur2 != nullptr ) {
            if( cur1->val < cur2->val) {
                cur->next = cur1;
                cur1 = cur1->next;
            } else {
                cur->next = cur2;
                cur2 = cur2->next;
            }
            cur = cur->next;
        }

        if( cur1 != nullptr ) {
            cur->next = cur1;
        } else if( cur2 != nullptr ) {
            cur->next = cur2;
        }

        while( cur->next != nullptr ) {
            cur = cur->next;
        }

        return cur;
    }
};

0237 删除链表中的节点

你好啊，我是蓝莓，今天是每日一题的第 47 天。

题目清单：一起刷力扣

引用力扣题目：237 删除链表中的节点

题目描述

有一个单链表的 head，我们想删除它其中的一个节点 node。

给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head。

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

给定节点的值不应该存在于链表中。
链表中的节点数应该减少 1。
node 前面的所有值顺序相同。
node 后面的所有值顺序相同。

自定义测试：

对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
我们将构建链表，并将节点传递给你的函数。
输出将是调用你函数后的整个链表。

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

提示：

链表中节点的数目范围是 [2, 1000]
-1000 <= Node.val <= 1000
链表中每个节点的值都是唯一的
需要删除的节点 node 是 链表中的节点 ，且 不是末尾节点

实现

思路

题目给定一个需要删除的节点，而且这个节点一定不是链表的最后一个节点，另外我们也不知道头节点是谁
所以我们可以把给定节点的下一个节点的元素拷贝到当前节点，然后删除给定节点的下一个节点
代码非常简单

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        ListNode* node2 = node->next;
        ListNode* next = node2->next;

        node->val = node2->val;
        node->next = next;
    }
};

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

你好啊，我是蓝莓，今天是每日一题的第 48 天。

题目清单：一起刷力扣

引用力扣题目：19 删除链表的倒数第 N 个结点

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

**进阶：**你能尝试使用一趟扫描实现吗？

实现

思路

最简单的思路是先遍历一遍链表看看有几个节点，然后计算出倒数第 n 个节点正着数是第几个
另外一种只需要遍历一遍的方法是使用两个指针，分别为 slow 和 fast ，我们让这两个指针之间空出一定的距离后再让它们两个同时向后移动，这样当 fast 走到底的时候，我们就可以通过 slow 找到倒数第 n 个节点是谁了

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(-1, head);
        ListNode* slow = dummyHead;
        ListNode* fast = head;
        
        // 让 fast 和 slow 之间相差 n 个节点（包括 fast 指向的节点本身）
        for( int i = 0 ; i < n ; i++ ) {
            fast = fast->next;
        }

        // 这时候让 slow 和 fast 同时移动
        // 当 fast 到尾的时候 slow 刚好指向需要被删除的节点的前一个节点
        while( fast != nullptr ) {
            slow = slow->next;
            fast = fast->next;
        }

        // 在逻辑上删除节点
        slow->next = slow->next->next;

        ListNode* newHead = dummyHead->next;
        delete dummyHead;

        return newHead;
    }
};

0143 重排链表

你好啊，我是蓝莓，今天是每日一题的第 49 天。

题目清单：一起刷力扣

引用力扣题目：143 重排链表

题目描述

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

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

示例 1：

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

示例 2：

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

提示：

链表的长度范围为 [1, 5 * 104]
1 <= node.val <= 1000

实现

思路

我们可以使用 slow 和 fast 指针来把原来的整个链表一分为二
slow 指针每次只移动一个位置
fast 指针每次移动两个位置
你可以自己手动模拟一下奇数个节点和偶数个节点的情况下 slow 指针最后移动到了哪个位置上
在我的代码实现中，slow 指针最后指向的是整个链表右侧那一半链表的头结点（而且如果是奇数的话，右侧的链表总是比左侧的链表多一个节点的）
好了，这样一来，我们只需要翻转右半部分的链表，然后将这两个链表按照题目要求的顺序拼接成为一个新的链表就可以了
最后要注意的一点是：我们要再设置一个 preSlow 指针用来指向左半部分链表的最后一个节点，然后将它的 next 指向 nullptr

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {

        if(head->next == nullptr) {
            return;
        }

        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* preSlow = dummyHead;
        ListNode* slow = head;
        ListNode* fast = head;

        while( fast != nullptr && fast->next != nullptr ) {
            preSlow = slow;
            slow = slow->next;
            fast = fast->next->next;
        }

        preSlow->next = nullptr;

        ListNode* dummyHead1 = new ListNode(-1, head);
        ListNode* dummyHead2 = new ListNode(-1, reverseList(slow));

        ListNode* cur = dummyHead;
        ListNode* cur1 = dummyHead1->next;
        ListNode* cur2 = dummyHead2->next;
        
        bool isCur1 = true;
        while( cur1 != nullptr && cur2 != nullptr ) {
            if(isCur1) {
                cur->next = cur1;
                cur = cur1;
                cur1 = cur1->next;
            } else {
                cur->next = cur2;
                cur = cur2;
                cur2 = cur2->next;
            }
            isCur1 = !isCur1;
        }

        // 一定是左半部分的链表先被用完
        // 我们需要把用半部分的链表的剩余部分拼接上去
        cur->next = cur2;

        delete dummyHead;
        delete dummyHead1;
        delete dummyHead2;
    }

    ListNode* reverseList(ListNode* head) {
        // head 表示需要翻转的链表头节点
        // 返回值为翻转后的链表头结点

        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* pre = dummyHead;
        ListNode* cur = head;

        while( cur != nullptr ) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        dummyHead->next->next = nullptr;

        delete dummyHead;
        return pre;
    }


};

0234 回文链表

你好啊，我是蓝莓，今天是每日一题的第 50 天。

题目清单：一起刷力扣

引用力扣题目：234 回文链表

题目描述

给你一个单链表的头节点 head ，请你判断该链表是否为

回文链表

。如果是，返回 true ；否则，返回 false 。

示例 1：

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

示例 2：

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

提示：

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

**进阶：**你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

实现

思路

这个题目和 143 重排链表 的做法非常相似，代码我都是直接复制过来的，做了一些简单的修改
可以参考 143 号题目的代码

C++ 代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        
        // 只有一个节点的情况直接返回 true 即可
        if( head->next == nullptr ) {
            return true;
        }

        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* preSlow = dummyHead;
        ListNode* slow = head;
        ListNode* fast = head;

        while( fast != nullptr && fast->next != nullptr ) {
            preSlow = slow;
            slow = slow->next;
            fast = fast->next->next;
        }

        preSlow->next = nullptr;
        delete dummyHead;

        ListNode* head1 = head;
        ListNode* head2 = reverseList(slow);

        ListNode* cur1 = head1;
        ListNode* cur2 = head2;

        while( cur1 != nullptr && cur2 != nullptr ) {
            if( cur1->val != cur2->val ) {
                return false;
            }

            cur1 = cur1->next;
            cur2 = cur2->next;
        }

        return true;
    }

    ListNode* reverseList(ListNode* head) {
        // head 表示需要翻转的链表头节点
        // 返回值为翻转后的链表头结点

        ListNode* dummyHead = new ListNode(-1, head);

        ListNode* pre = dummyHead;
        ListNode* cur = head;

        while( cur != nullptr ) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        dummyHead->next->next = nullptr;

        delete dummyHead;
        return pre;
    }
};

0020 有效的括号

你好啊，我是蓝莓，今天是每日一题的第 51 天。

题目清单：一起刷力扣

引用力扣题目：20 有效的括号

题目描述

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

**输入：**s = "()"

**输出：**true

示例 2：

**输入：**s = "()[]{}"

**输出：**true

示例 3：

**输入：**s = "(]"

**输出：**false

示例 4：

**输入：**s = "([])"

**输出：**true

提示：

1 <= s.length <= 104
s 仅由括号 '()[]{}' 组成

实现

思路

这是一个应用栈的简单题
（1）在遍历字符串 s 的过程中，如果我们遇到的是括号的左半部分，那么我们就把这个括号压入栈中
（2）如果在遍历的过程中，我们遇到的是括号的有半部分，那么我们就和栈顶的括号进行比对，看看是不是能够匹配成为一个完整的括号

C++ 代码实现

class Solution {
public:
    bool isValid(string s) {
        stack record;

        for( int i = 0 ; i < s.size(); i++ ) {
            if( s[i] == '(' || s[i] == '{' || s[i] == '[' ) {
                record.push(s[i]);
            } else {
                if( record.empty() ) {
                    return false;
                }

                char top = record.top();
                record.pop();
                bool c1 = (top == '(' && s[i] == ')');
                bool c2 = (top == '{' && s[i] == '}');
                bool c3 = (top == '[' && s[i] == ']');

                if( c1 || c2 || c3 ) {
                    continue;
                } else {
                    return false;
                }
            }
        }

        if( record.size() == 0 ) {
            return true;
        } else {
            return false;
        }
    }
};

0150 逆波兰表达式求值

你好啊，我是蓝莓，今天是每日一题的第 52 天。

题目清单：一起刷力扣

引用力扣题目：150 逆波兰表达式求值

题目描述

给你一个字符串数组 tokens ，表示一个根据逆波兰表示法表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 '+'、'-'、'*' 和 '/' 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

1 <= tokens.length <= 104
tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

实现

思路

这是一个应用栈的中等题
对于这个题目来说，我们顺序遍历题目中所给的所有 tokens
（1）如果我们发现当前正在遍历的 token 是一个数值的话，那么我们就把它送入栈中
（2）如果我们发现当前在正在遍历的 token 是一个运算符的话，那么我们就从栈中取出两个值按照当前的这个运算符进行运算，然后把运算后的结果放入栈中
有一个需要注意的地方：那就是元素的入栈顺序和出栈的顺序是相反的，对于加法和乘法这种遵守交换律的运算还好，但是对于减法和除法是不行的。我们要知道，我们从栈中取出的第一个值实际上对应于 tokens 数组中的后面的一个数值（这一点在代码中有体现）

C++ 代码实现

class Solution {
public:
    int evalRPN(vector& tokens) {
        stack nums;

        for( int i = 0 ; i < tokens.size() ; i++ ) {
            string token = tokens[i];

            if( token != "+" && token != "-" && token != "*" && token != "/" ) {
                nums.push(stoi(token));
            } else {
                int num2 = nums.top();
                nums.pop();

                int num1 = nums.top();
                nums.pop();

                if( token == "+" ) {
                    nums.push(num1 + num2);
                } else if( token == "-" ) {
                    nums.push(num1 - num2);
                } else if( token == "*" ) {
                    nums.push(num1 * num2);
                } else if( token == "/" ) {
                    nums.push(num1 / num2);
                }
            }     
        }

        return nums.top();
    }
};

0071 简化路径

你好啊，我是蓝莓，今天是每日一题的第 53 天。

题目清单：一起刷力扣

引用力扣题目：71 简化路径

题目描述

给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为 更加简洁的规范路径。

在 Unix 风格的文件系统中规则如下：

一个点 '.' 表示当前目录本身。
此外，两个点 '..' 表示将目录切换到上一级（指向父目录）。
任意多个连续的斜杠（即，'//' 或 '///'）都被视为单个斜杠 '/'。
任何其他格式的点（例如，'...' 或 '....'）均被视为有效的文件/目录名称。

返回的 简化路径 必须遵循下述格式：

始终以斜杠 '/' 开头。
两个目录名之间必须只有一个斜杠 '/' 。
最后一个目录名（如果存在）不能以 '/' 结尾。
此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。

返回简化后得到的 规范路径 。

示例 1：

**输入：**path = "/home/"

输出："/home"

解释：

应删除尾随斜杠。

示例 2：

**输入：**path = "/home//foo/"

输出："/home/foo"

解释：

多个连续的斜杠被单个斜杠替换。

示例 3：

**输入：**path = "/home/user/Documents/../Pictures"

输出："/home/user/Pictures"

解释：

两个点 ".." 表示上一级目录（父目录）。

示例 4：

**输入：**path = "/../"

输出："/"

解释：

示例 5：

**输入：**path = "/.../a/../b/c/../d/./"

输出："/.../b/d"

解释：

"..." 在这个问题中是一个合法的目录名。

提示：

1 <= path.length <= 3000
path 由英文字母，数字，'.'，'/' 或 '_' 组成。
path 是一个有效的 Unix 风格绝对路径。

实现

思路

这是一个力扣的中等题
对于这个题目来说，我们先将 path 字符串按照 / 拆分，然后遍历拆分后的结果，对于每一个拆分后的结果判断需要做什么操作
（1）如果当前项是 .. 说明我们要返回到当前所在目录的上一级目录，那其实就是把记录中的刚访问过的那个目录的名字给它删掉就好了
（2）如果当前的项是 . 说明我们要访问当前所在的目录，这说明我们什么都不用做，静静的待在当前所在的目录就可以了，直接跳过就 ok
（3）如果当前访问到的是以上两种情况以外的项，那么说明我们应该访问当前的这个项，所以这时候我们应该在结果中添加这一项
还有更多的细节都在代码中啦！

C++ 代码实现

class Solution {
public:
    string simplifyPath(string path) {
        // 先讲 path 按照 '/' 字符进行拆分
        vector names = split(path, '/');
        // result 保留最后的路径中所包含的项
        vector result;

        for( string name : names ) {
            if( name == ".." ) {
                // 如果是 .. 说明我们应该跳转到当前访问的目录的上一级目录
                // 所以直接将当前访问的目录给 pop 出去就可以了
                // 注意检查是不是当前目录就是根目录了
                // 如果当前目录就是根目录，说明 result 里面没有元素
                if( result.size() >= 1 ) {
                    result.pop_back();
                }
            } else if( name == "." ){
                // 如果是访问当前目录，那就直接跳过好啦
                continue;
            } else {
                // 将要访问的新的目录名纳入结果中
                result.push_back(name);
            }
        }

        // 使用 res 来拼接最终简化后的字符串
        string res = "";
        for( string name : result ) {
            res += "/" + name;
        }
        
        // 很有可能简化后的字符串就是根目录
        // 所以我们应该看看 res 是不是为空
        //  如果为空的话，我们直接返回根目录就可以了
        if( res == "" ) {
            return "/";
        }

        // 不为空则返回 res
        return res;
    }

    vector split(const string& str, char delimiter) {
        // 按照 delimiter 字符将 str 字符串拆拆分为多个子串
        // 若拆分出来的某个子串为空串的话 ==> 直接丢弃
        vector slices;
        int start = 0;

        while( start < str.size() ) {
            // start 是上一次的拆分点的下一个字符
            // 寻找到拆分点 end
            int end = str.find(delimiter, start);
            if( end == -1 ) break;
            // 取 str[start, end) 这个区间内的元素
            string slice = str.substr(start, end-start);
            start = end + 1; // 让 start 移动到这一次的拆分点的下一个字符
            // 丢弃空串
            if( slice.empty() ) continue;
            // 保留非空串
            slices.push_back(slice);
        }

        // 很有可能最后一个子串没有被装进结果中 ==> 做一次特殊的检查
        if( start < str.size() && !str.substr(start, str.size()-start).empty() ) {
            slices.push_back(str.substr(start, str.size()-start));
        }

        return slices;
    }
};

0102 二叉树的层序遍历

你好啊，我是蓝莓，今天是每日一题的第 54 天。

题目清单：一起刷力扣

引用力扣题目：102 二叉树的层序遍历

题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

实现

思路

这是一个力扣的中等题
这是数据结构中的广度优先基础方法
只是在我们进行广度优先搜索的过程中要想个办法明确当前遍历的是哪一层，因为我们的节点一旦放入队列中后，我们就不知道这个节点是不是不属于我们正在遍历的那一层了
但是，你可以明确的知道，二叉树的最上层只有一个根节点，在你遍历这一层的时候，你通过判断它这个节点的左子树和右子树是否为空的情况时，也就知道了下一层有多少个节点了，其实当你遍历完当前这一层的时候，队列中装进去的刚好就是下一层的所有节点
好啦，那么具体的逻辑看代码就懂啦

C++ 代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        // q 队列用于辅助广度优先搜索
        queue q;
        // res 里面的每一个 vector 用来存储一层的元素
        vector> res;

        // 如果这是一个空二叉树 直接返回空的 res 即可
        if( root == nullptr ) {
            return res;
        }

        // 为把第一层的元素装进去做准备
        res.push_back(vector());

        int level = 0;  // 当前正在遍历的层（自顶向下从 0 开始）
        int nodeNums = 1;  // 当前层的节点数量
        q.push(root);  // 将 root 节点放入队列中

        while(!q.empty()) {
            TreeNode* node = q.front();
            q.pop();

            // 若左子树不为空则将左子树的根节点放入队列中
            if( node->left != nullptr ) {
                q.push(node->left);
            }

            // 若右子树不为空则将右子树的根节点放入队列中
            if( node->right != nullptr ) {
                q.push(node->right);
            }

            // 将当前遍历的节点的值放入 level 层的 vector 中
            res[level].push_back(node->val);
            nodeNums--;  // 将当前层的节点计数减少 1
            
            // 如果当前层已经遍历完了 并且 队列中还有元素
            // 那么维护这些变量
            if( nodeNums <= 0 && !q.empty() ) {
                level++;  // 移动到下一层
                res.push_back(vector());  // 初始化下一层的 vector
                nodeNums = q.size();  // 当前队列中存储的元素便是下一层的所有节点
            }
        }

        return res;
    }
};

0107 二叉树的层序遍历 II

你好啊，我是蓝莓，今天是每日一题的第 55 天。

题目清单：一起刷力扣

引用力扣题目：107 二叉树的层序遍历 II

题目描述

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

实现

思路

这是一个力扣的中等题
这是数据结构中的二叉树广度优先基础方法
这个题目和 102 号题目是非常相似的
在 102 号题目，我们已经知道如何把每二叉树每一层的值给遍历出来了
在当前这个题目中，它要求我们按照正常的广度优先遍历的相反的顺序将每一层的节点的值输出
那么，我们只需要按照 102 号题目的方法遍历，然后将代码中 res 数组颠倒一下顺序即可

C++ 代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector> levelOrderBottom(TreeNode* root) {
        vector> res;
        queue q;

        if( root == nullptr ) {
            return res;
        }

        int level = 0;
        q.push(root);

        while( !q.empty() ) {
            int size = q.size();
            res.push_back(vector());
            
            for( int i = 0 ; i < size ; i++ ) {
                TreeNode* front = q.front();
                q.pop();
                
                if( front->left ) {
                    q.push(front->left);
                }

                if( front->right ) {
                    q.push(front->right);
                }

                res[level].push_back(front->val);
            }

            ++level;
        }

        int half = level / 2;
        for( int i = 0 ; i < half ; i++ ) {
            swap(res[i], res[level-i-1]);
        }

        return res;
    }
};

0103 二叉树的锯齿形层序遍历

你好啊，我是蓝莓，今天是每日一题的第 56 天。

题目清单：一起刷力扣

引用力扣题目：103 二叉树的锯齿形层序遍历

题目描述

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-100 <= Node.val <= 100

实现

思路

这个题目和 102 以及 107 题目依然是相似的
当前题目的代码，直接沿用了 107 号题目的代码，仅仅在代码最后的交换顺序的部分做出了简单的修改
我们依然是先按照正常的广度优先遍历的方式遍历二叉树
遍历完成后，我们去改变 res 数组中某些层的顺序，从而满足题目的要求

C++ 代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector> zigzagLevelOrder(TreeNode* root) {
        vector> res;
        queue q;

        if( root == nullptr ) {
            return res;
        }

        int level = 0;
        q.push(root);

        while( !q.empty() ) {
            int size = q.size();
            res.push_back(vector());
            
            for( int i = 0 ; i < size ; i++ ) {
                TreeNode* front = q.front();
                q.pop();
                
                if( front->left ) {
                    q.push(front->left);
                }

                if( front->right ) {
                    q.push(front->right);
                }

                res[level].push_back(front->val);
            }

            ++level;
        }

        for( int i = 1 ; i < level ; i+=2 ) {
            int sz = res[i].size();
            int half = sz / 2;
            for( int j = 0 ; j < half ; j++ ) {
                swap(res[i][j], res[i][sz-j-1]);
            }
        }

        return res;
    }
};

0199 二叉树的右视图

你好啊，我是蓝莓，今天是每日一题的第 57 天。

题目清单：一起刷力扣

引用力扣题目：199 二叉树的右视图

题目描述

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1：

**输入：**root = [1,2,3,null,5,null,4]

输出：[1,3,4]

解释：

示例 2：

**输入：**root = [1,2,3,4,null,null,null,5]

输出：[1,3,4,5]

解释：

示例 3：

**输入：**root = [1,null,3]

输出：[1,3]

示例 4：

**输入：**root = []

输出：[]

提示:

二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100

实现

思路

这个题目和 107 题目依然是相似的
当前题目的代码，直接沿用了 107 号题目的代码
我们依然是先按照正常的广度优先遍历的方式遍历二叉树
遍历完成后，我们去改变 res 数组中某些层的顺序，从而满足题目的要求

C++ 代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector rightSideView(TreeNode* root) {
        vector> res;
        vector view;
        queue q;

        if( root == nullptr ) {
            return view;
        }

        int level = 0;
        q.push(root);

        while( !q.empty() ) {
            int size = q.size();
            res.push_back(vector());
            
            for( int i = 0 ; i < size ; i++ ) {
                TreeNode* front = q.front();
                q.pop();
                
                if( front->left ) {
                    q.push(front->left);
                }

                if( front->right ) {
                    q.push(front->right);
                }

                res[level].push_back(front->val);
            }

            ++level;
        }

        for( int i = 0 ; i < res.size() ; i++ ) {
            view.push_back(res[i][res[i].size()-1]);
        }

        return view;
    }
};

0279 完全平方数

你好啊，我是蓝莓，今天是每日一题的第 58 天。

题目清单：一起刷力扣

引用力扣题目：279 完全平方数

题目描述

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

输入：n = 12
输出：3 
解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

提示：

1 <= n <= 104

实现

思路

这是一个中等难度的题目
解决这个问题可以采用图的广度优先搜索的方法
图的顶点是当前剩余还需要拼凑的数值
图的边是完全平方数的平方
经过一条边，就相当于让顶点的值减去了一个完全平方数的平方从而来到了一个新的顶点
因此，广度优先搜索的层数的深度，就是我们要求的值

C++ 代码实现

/ 图的广度优先搜索
// 看遍历到第几层的时候能够遍历到节点 0
class Solution {
public:
    int numSquares(int n) {
        // v, step
        queue> q;
        vector visted(n+1, false);
        q.push( make_pair(n, 0) );

        while( !q.empty() ) {
            pair v = q.front();
            q.pop();

            int num = v.first;
            int step = v.second;

            if( num == 0 ) {
                return step;
            }

            for( int i = 1 ; num - i*i >= 0 ; i++ ) {
                int next = num - i*i;
                if( visted[next] == false) {
                    q.push( make_pair(next, step+1) );
                    visted[next] = true;
                }
            }
        }

        return -1;
    }
};

C++ 代码实现优化

// 优化：提前算法的结束步骤
class Solution {
public:
    int numSquares(int n) {
        // v, step
        queue> q;
        vector visted(n+1, false);
        q.push( make_pair(n, 0) );

        while( !q.empty() ) {
            pair v = q.front();
            q.pop();

            int num = v.first;
            int step = v.second;



            for( int i = 1 ; ; i++ ) {
                int next = num - i*i;
                if( next < 0 ) {
                    break;
                }

                if( visted[next] == false) {
                    
                    // 提前返回的步骤
                    if( next == 0 ) {
                        return step+1;
                    }

                    q.push( make_pair(next, step+1) );
                    visted[next] = true;
                }
            }
        }

        return -1;
    }
};

硬核：计算机是如何跑起来的

哈喽，在今天这篇文章中，我们一起来看看当计算机通电之后是怎么开始运行代码的？

从我们第一次开始学习写代码，大多数人应该都是学习的C语言吧，我们就直接在操作系统的基础上开始编译并且运行的，那么操作系统本身也是一个程序，操作系统这段代码是怎么开始运行的呢？

本文是基于 x86 架构的 cpu ，在实验中使用的宿主机操作系统是 Ubuntu，让我们体验一下掌控 CPU 执行大权的感觉

1 谋权篡位第一程

大家应该都听说过 BIOS 这个东西吧，它的全名叫做 Base Input Output System 也就是基本输入输出系统。BIOS 也是一段程序，只不过它是在硬件出厂的时候就已经被写死在存储器中了，CPU 会自动地去执行 BIOS 这段代码，也就是说这都是被事先设计好的，一开始就是会自动的去干这件事儿，这是被写死在硬件层面的。

当然，我们的计算机能做的事情很多，仅仅能执行 BIOS 这段代码肯定是不够的，为了能够让我们接任 CPU 的大权，BIOS 这段代码会先对计算机做一些检查，最终 BIOS 会自动地去加载磁盘上的第 1 个扇区的 512B 的内容到内存的 0x7c00 地址处，紧接着加载完成后，CPU 的 IP 寄存器就是指向 0x7c00 地址处开始执行被加载到内存中的那 512B 的代码啦。

另外 BIOS 还提供了一些功能，比如我们可以通过 BIOS 所提供的功能从硬盘的某个扇区开始读取数据，还可以向屏幕上输出一些最简单的字符。

划重点

总之，你现在知道啦，我们最早能够接任 CPU 大权的代码就必须要写在磁盘的第 1 个扇区那 512B 的地方。

你会不会有疑问？我们的操作系统可不止 512B，虽然说我们的操作系统不止 512B，但是我们可以在这 512B 内再写一个加载程序，然后让这个程序去加载一个更大的程序。

这里所说的加载，其实就是把磁盘上的数据复制到内存上的某个位置而已，因为CPU只能直接读取内存中的数据。

操作系统的加载

实际上操作系统的加载分为了三个步骤

BIOS 把MBR加载到 0x7c00 处的位置
MBR 将操作系统加载器加载到内存的某个位置
操作系统的加载器再去加载操作系统的代码到内存

在这篇文章中，我们只关心磁盘的第一个扇区，我们会在磁盘的第一个扇区写入一些代码，然后使用 BIOS 的功能在屏幕上输出一些字符，这样就可以代表我们的这个代码顺利被夹在而且被 CPU 执行啦。

2 搭建实验环境

安装汇编编译器

sudo apt-get install nasm

安装 qemu 模拟器

sudo apt-get install qemu-system-x86

制作一个磁盘镜像

这样我们就拥有了一个磁盘镜像，我么使用 disk.img 作为 qemu 虚拟机的硬盘

dd if=/dev/zero of=disk.img bs=512 count=20480

3 让我们运行一下

我们先来写一个汇编文件就叫 mbr.S

首先来看这段汇编代码的 vstart=0x7c00 的作用，当我们使用这个伪指令的时候，我们就是告诉汇编语言的编译器说，这段代码我以后肯定是要从内存地址的 0x7c00 处开始放的，所以在你编译这段代码的时候，有关内存的寻址操作也要按照 0x7c00 这个位置作为其实地址来编译代码。

在代码中你还会看到 0xb800 这样一个地址，因为 0xb800是被写入到段寄存器中的，所以真实的内存起始地址应该是 0xb8000。可以先不管这个内容，因为这个就涉及到了上古时代的 8086 CPU 的寻址方式了。

如果我们想要在屏幕上显示一些内容的话，我们只需要将数据写入从这个地址开始的内存单元即可。

从 0xb8000 开始每两个字节作为一组，其中低地址的那个字节用来存储写入的字符的值，其中高地址的那个字节用来存储这个字符显示时候的背景色这类东西。

比如说: mov byte [gs:0x00],'h' 和 mov byte [gs:0x01],0xA4 这两条指令，其中第一条指令就是在 0xb8000地址处写入了字符 h 的 ASCII值，在高地址的那个字节 0xb8001 地址处写入了字符 h 对应的颜色以及底色，其中高字节中的低4位控制底色，高4位控制字符的颜色，你可以动手修改它的值自己尝试一下。

在这段汇编代码的最后你还看到了 times 510-($-$$) db 0和 db 0x55,0xaa 这两条指令，这两条指令达到的效果就是在第一个扇区的最后两个字节的位置写入了 0x55 和 0xaa 这两个内容。因为第一个扇区的内容被自动加载到 0x7c00处还有一个要求，那就是这个扇区的最后两个位置要填入 0x55 和 0xaa ，只有这样，这个扇区的数据才会被 BIOS 加载。这都是约定好的，不必在意，没有什么特殊的原因。

编译汇编代码

SECTION MBR vstart=0x7c00         
   mov ax,cs      
   mov ds,ax
   mov es,ax
   mov ss,ax
   mov fs,ax
   mov sp,0x7c00
   mov ax,0xb800
   mov gs,ax     

   mov byte [gs:0x00],'h'
   mov byte [gs:0x01],0xA4

   mov byte [gs:0x02],'e'
   mov byte [gs:0x03],0xA5

   mov byte [gs:0x04],'l'
   mov byte [gs:0x05],0xB6	  

   mov byte [gs:0x06],'l'
   mov byte [gs:0x07],0xC7

   mov byte [gs:0x08],'o'
   mov byte [gs:0x09],0xD8

   mov byte [gs:0x0A],' '
   mov byte [gs:0x0B],0xE9

   mov byte [gs:0x0C],'w'
   mov byte [gs:0x0D],0xFA

   mov byte [gs:0x0E],'o'
   mov byte [gs:0x0F],0xA4

   mov byte [gs:0x10],'r'
   mov byte [gs:0x11],0xAC

   mov byte [gs:0x12],'l'
   mov byte [gs:0x13],0xAD

   mov byte [gs:0x14],'d'
   mov byte [gs:0x15],0xAE

   jmp $

   times 510-($-$$) db 0
   db 0x55,0xaa

好啦，接着我把 mbr.S 放在文件中进行编译，其中我们使用命令 nasm -f bin -o mbr.bin mbr.S

参数 -f 就是 format ，就是说我们编译出来的代码需要是二进制格式的
参数 -o 就是 output，用来表示输出文件的文件名

做个磁盘镜像

那么我就在当前目录下制作一个磁盘镜像好啦

使用命令 dd if=/dev/zero of=disk.img bs=512 count=20480

当我们做好磁盘镜像后，我们需要把我们编译生成的二进制代码原封不动的拷贝到磁盘镜像 disk.img 的第 1 个扇区

我们可以通过命令 dd if=mbr.bin of=./disk.img conv=notrunc来把 mbr.bin 中的数据拷贝到 disk.img 中

参数 if 是 input file 就是输入文件
参数 of 是 output file 就是输出文件
conv = notrunc 代表的意思是，当拷贝 mbr.bin 的数据覆盖进 disk.img 的时候，不要清空覆盖不到的那些位置上的 disk.img 的数据，比如 mbr.bin 只有 512B，那么就原有的 disk.img 中的第 2 个扇区和后边的那些扇区的数据都不会受到影响。

奔跑吧！

最后，我们就让 qemu 工作起来，hello world 仪式感来咯！

使用命令 qemu-system-i386 -m 128M -drive file=disk.img,index=0,media=disk,format=raw

在这些参数中，我们使用 file 用来指定虚拟机启动时所使用的磁盘镜像，因为我执行这条命令的时候 disk.img 就在当前目录下，所以我直接这样写就可以啦。

当我们的 qemu 虚拟机跑起来之后，就有了下图的效果

哈哈哈，我第一次跑到这里的时候还是很兴奋的，这可是我们在计算机上能够接手的第一个程序嗷！

你会发现屏幕上还有一些其他的字，那是因为我们并没有清空屏幕上的内容，当我们在 0xb8000 处开始写入数据的时候，原来这个地方的数据就被我们覆盖啦，所以就变成了图中的这个样子。

编译 Linux 内核 && 添加系统调用

在这篇文章中做一个小实验，先对 Linux 内核的源码做一些小改动，我们就只是在其中添加一个系统调用就好了，然后我们对内核进行编译并使用它

目标：

添加系统调用
编译 && 安装
测试我们的系统调用

1 添加系统调用

实验环境

我这次是直接在安装了 Ubuntu 系统的虚拟机中进行实验的，当前系统的内核版本是 ubuntu 6.8.0

blueberry@ubuntu:~/expr/linux-6.8.9$ uname -a
Linux ubuntu 6.8.0-31-generic #31-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 20 00:40:06 UTC 2024 x86_64 x86_64 x86_64 GNU/Linux

下载源码

我们得先下载一个 Linux 的内核源码

传送门：https://kernel.org/

我们直接来到这里进行下载就可以了，你可以下载一个你感兴趣的版本，而我就直接下载 6.8.9 这个版本了

为了简单，我就不对下载后的内核源码进行正确性的验证了，通常来说是没有问题的，在文章的最后我给出了我参考的资料，这些资料里面会有更详细的内容

好啦，我已经把源码下载到了这个路径

blueberry@ubuntu:~/expr$ pwd
/home/blueberry/expr
blueberry@ubuntu:~/expr$ ls
linux-6.8.9.tar.xz

解压

对源码文件进行解压，解压后 linux-6.8.9 就是我们要的源码啦

blueberry@ubuntu:~/expr$ tar -xf linux-6.8.9.tar.xz 
blueberry@ubuntu:~/expr$ ls
linux-6.8.9  linux-6.8.9.tar.xz

修改源码

你只需要按照我接下来的操作进行就可以了，先不用特别在意为什么要这么做

1. 修改 syscall_64.tbl

blueberry@ubuntu:~/expr/linux-6.8.9/arch/x86/entry/syscalls$ pwd
/home/blueberry/expr/linux-6.8.9/arch/x86/entry/syscalls
blueberry@ubuntu:~/expr/linux-6.8.9/arch/x86/entry/syscalls$ ls -ltr
total 40
-rw-rw-r-- 1 blueberry blueberry 15278 May  2 14:35 syscall_64.tbl
-rw-rw-r-- 1 blueberry blueberry 18346 May  2 14:35 syscall_32.tbl
-rw-rw-r-- 1 blueberry blueberry  2527 May  2 14:35 Makefile
blueberry@ubuntu:~/expr/linux-6.8.9/arch/x86/entry/syscalls$ vim syscall_64.tbl

来到这个文件的 346 行，在这里添加一行；这里的 335 是系统调用号，你可以根据你下载的内核版本，自己选择一个合适的系统调用号填上去就可以了，只要不和别的重复即可

 335     64      helloworld           sys_helloworld

2. 修改 syscalls.h

blueberry@ubuntu:~/expr/linux-6.8.9/include/linux$ pwd
/home/blueberry/expr/linux-6.8.9/include/linux
blueberry@ubuntu:~/expr/linux-6.8.9/include/linux$ vim syscalls.h

我们在 933 行添加一行如下的代码：

asmlinkage long sys_helloworld(char * words, int count);

3. 修改 sys.c

blueberry@ubuntu:~/expr/linux-6.8.9/kernel$ pwd
/home/blueberry/expr/linux-6.8.9/kernel
blueberry@ubuntu:~/expr/linux-6.8.9/kernel$ vim sys.c

我们直接来到这个文件的末尾，添加如下代码：

asmlinkage int sys_helloworld(char * words, int count) {
        int ret;
        char buffer[512];
        if(count >= 512){
                return -1;
        }
        copy_from_user(buffer, words, count);
        ret = printk("User Mode says %s to the Kernel Mode!", buffer);
        return ret;
}

SYSCALL_DEFINE2(helloworld, char *, words, int, count) {
        return sys_helloworld(words, count);
}

2 编译 && 安装

接下来我们就来编译内核并将它进行安装

安装所必要的工具

blueberry@ubuntu:~/expr/linux-6.8.9$ sudo apt install bc binutils bison dwarves flex gcc git gnupg2 gzip libelf-dev libncurses5-dev libssl-dev make openssl pahole perl-base rsync tar xz-utils

生成配置文件 .config

Linux 内核的编译是受到这么一个文件进行控制的，比如哪些模块要被编译，哪些干脆不要了，这些内容都是在这样一个配置文件中的

既然我们编译好的内核最终是要安装到虚拟机这台机器本身的，那么最好的方式当然是参考虚拟机本身的内核所使用的配置文件啦，在我的机器上，这个默认的配置文件在这个位置：

blueberry@ubuntu:/boot$ pwd
/boot
blueberry@ubuntu:/boot$ ls -ltr
total 89272
-rw

裸机程序也能调试？

你好啊，我是蓝莓；

如果你想自己动手写一个简单的操作系统内核，一定需要去调试这个程序，毕竟可能出现很多的 bug，可是这种不依赖于具体的操作系统的代码，我们该怎么去调试呢？

好在，我们已经有了 QEMU 虚拟机和 GDB 这样的调试工具，能够帮助我们来调试它。那么在这篇文章就使用一个非常简单的例子，来演示一下，如何调试一个裸机上运行的代码。

1、写一段代码

在我的这篇文章中介绍了什么是 MBR 并且介绍了，我们该如何在 QEMU 中启动一个不依赖于具体操作系统的代码。在阅读本文之前可以先去读这篇文章。

传送门：硬核：计算机是如何跑起来的，MBR谋权篡位

在 MBR 的那篇文章中我们使用的汇编语言格式是 intel 风格的。但是在本篇文章中，我们要使用 GCC 来对我们的文件进行编译，所以只好采用 AT&T 风格的汇编了。

所以，我们就有了下面的这段汇编代码，你直接复制就好啦；

.section .text
.global _start
.code16                # 使用 16 位代码模式

_start:
    jmp main           # 跳转到主程序

# 使用 0x7C00 作为程序加载基地址
main:
    movw %cs, %ax      
    movw %ax, %ds
    movw %ax, %es
    movw %ax, %ss
    movw %ax, %fs
    movw $0x7c00, %sp
    movw $0xb800, %ax
    movw %ax, %gs     

    movb $'h', %gs:(0x00)
    movb $0xA4, %gs:(0x01)

    movb $'e', %gs:(0x02)
    movb $0xA5, %gs:(0x03)

    movb $'l', %gs:(0x04)
    movb $0xB6, %gs:(0x05)

    movb $'l', %gs:(0x06)
    movb $0xC7, %gs:(0x07)

    movb $'o', %gs:(0x08)
    movb $0xD8, %gs:(0x09)

    movb $' ', %gs:(0x0A)
    movb $0xE9, %gs:(0x0B)

    movb $'w', %gs:(0x0C)
    movb $0xFA, %gs:(0x0D)

    movb $'o', %gs:(0x0E)
    movb $0xA4, %gs:(0x0F)

    movb $'r', %gs:(0x10)
    movb $0xAC, %gs:(0x11)

    movb $'l', %gs:(0x12)
    movb $0xAD, %gs:(0x13)

    movb $'d', %gs:(0x14)
    movb $0xAE, %gs:(0x15)



# 填充到 510 字节
.space 510 - (.-_start)

# MBR 标识符 0xAA55
.word 0xAA55

这段代码的作用其实就是在屏幕上输出 hello world；而且，这还是彩色的呢！哈哈哈

2、编译 && 链接 && 写入二进制程序

我们已经准备好了代码，那么就让我们编译一下叭

创建虚拟磁盘

可以看到，这样，我们的目录中就有了我们写好的代码 mbr.S 以及使用 dd 命令创建好的一个给 QEMU 使用的虚拟磁盘啦。

➜  mbr dd if=/dev/zero of=disk.img bs=512 count=20480
20480+0 records in
20480+0 records out
10485760 bytes (10 MB, 10 MiB) copied, 0.0675632 s, 155 MB/s
➜  mbr ls -ltr
total 10244
-rw-rw-r-- 1 blueberry blueberry     1029 Nov 13 20:01 mbr.S
-rw-rw-r-- 1 blueberry blueberry 10485760 Nov 13 20:06 disk.img

生成二进制代码

在这里经过编译和链接后生成的 mbr.bin 就是一个二进制代码，这里面放的就是 CPU 可以直接拿来执行的指令，不包含任何没有用的信息。

➜  mbr gcc -m32 -ffreestanding -c mbr.S -o mbr.o 
➜  mbr  ld -m elf_i386 -Ttext 0x7c00 --oformat binary mbr.o -o mbr.bin
➜  mbr ls -ltr
total 10252
-rw-rw-r-- 1 blueberry blueberry     1029 Nov 13 20:01 mbr.S
-rw-rw-r-- 1 blueberry blueberry 10485760 Nov 13 20:06 disk.img
-rw-rw-r-- 1 blueberry blueberry     1000 Nov 13 20:12 mbr.o
-rwxrwxr-x 1 blueberry blueberry      512 Nov 13 20:13 mbr.bin

我们把 mbr.bin 这个二进制代码直接写入到 disk.img 的第一个扇区上；这样，当 QEMU 启动的时候，BIOS 就会自动把这部分代码加载到内存的 0x7c00 处运行啦。

写入二进制程序

直接使用 dd 命令写入就好啦，现在 mbr.bin 就被我们写入到了 disk.img 中

➜  mbr dd if=mbr.bin of=disk.img bs=512 count=1
1+0 records in
1+0 records out
512 bytes copied, 0.000340003 s, 1.5 MB/s
➜  mbr ls -ltr
total 16
-rw-rw-r-- 1 blueberry blueberry 1029 Nov 13 20:01 mbr.S
-rw-rw-r-- 1 blueberry blueberry 1000 Nov 13 20:12 mbr.o
-rwxrwxr-x 1 blueberry blueberry  512 Nov 13 20:13 mbr.bin
-rw-rw-r-- 1 blueberry blueberry  512 Nov 13 20:16 disk.img

编译生成带有符号的 ELF 文件

在我们调试的过程中，我们希望能看到机器上正在执行的指令和我们编写的汇编源码之间的映射关系，每当机器代码之后之后能够对应到相应的汇编代码的某一行上。ELF 文件就是做这件事情用的，比如我们在 mbr.S 中有一个符号是 main 那么在 ELF 文件中就可以记录上 main 和具体的地址是一个怎样的映射关系，它又对应到了 mbr.S 这个文件中的第几行代码。所有的这些内容都可以记录在 ELF 文件中。

➜  mbr gcc -m32 -nostdlib -g -fdebug-prefix-map=$PWD=. -c -o mbr.o mbr.S
➜  mbr ld -m elf_i386 -Ttext 0x7c00 -o mbr.elf mbr.o
➜  mbr ls -ltr
total 24
-rw-rw-r-- 1 blueberry blueberry 1029 Nov 13 20:01 mbr.S
-rwxrwxr-x 1 blueberry blueberry  512 Nov 13 20:13 mbr.bin
-rw-rw-r-- 1 blueberry blueberry  512 Nov 13 20:16 disk.img
-rw-rw-r-- 1 blueberry blueberry 1748 Nov 13 20:21 mbr.o
-rwxrwxr-x 1 blueberry blueberry 4520 Nov 13 20:21 mbr.elf

-g : 这个参数就是在告诉 gcc 要把我们提及到的那些符号信息记录下来
-fdebug-prefix-map=$PWD=. : 用来告诉 gcc 我们的源码文件 mbr.S 是在 ELF 文件的同一个目录中的
-Ttext 0x7c00 : 因为我们的代码是要加载到 0x7c00 处运行的，所以我们需要告诉链接器，我们的代码未来要在哪儿执行

最后我们就有了 mbr.elf 这个中间人了。

3、调试裸机程序

启动 QEMU

qemu-system-i386 -m 128M -drive file=disk.img,index=0,media=disk,format=raw -s -S

-s：这是 -gdb tcp::1234 的简写，表示 QEMU 会在 TCP 端口 1234 上启动一个 GDB 服务器。这样就可以使用 GDB（或其他兼容的调试器）远程连接到这个端口，进行调试。
-S：启动虚拟机时会暂停 CPU，这样虚拟机不会立即运行。这个选项适用于调试时的初始化。使用这个选项后，虚拟机会在启动后暂停，直到使用调试器发送“继续”命令时才会运行。

如果你是使用终端连接的 Linux 系统，因此不能够显示 QEMU 创建的图形界面的话可以使用如下命令启动，这样就可以使用没有界面的形式启动了

qemu-system-i386 -m 128M -drive file=disk.img,index=0,media=disk,format=raw -s -S -nographic

好啦，我们先打开一个终端启动 QEMU 之后，我们再打开另外一个终端使用 GDB 连接 QEMU 进行远程调试。

gdb 调试

➜  mbr ls -ltr
total 24
-rw-rw-r-- 1 blueberry blueberry 1029 Nov 13 20:01 mbr.S
-rwxrwxr-x 1 blueberry blueberry  512 Nov 13 20:13 mbr.bin
-rw-rw-r-- 1 blueberry blueberry  512 Nov 13 20:16 disk.img
-rw-rw-r-- 1 blueberry blueberry 1748 Nov 13 20:21 mbr.o
-rwxrwxr-x 1 blueberry blueberry 4520 Nov 13 20:21 mbr.elf
➜  mbr gdb mbr.elf
GNU gdb (Ubuntu 9.2-0ubuntu1~20.04.2) 9.2
... 此处省略一大堆输出信息 ...
Reading symbols from mbr.elf...
(gdb) target remote :1234
Remote debugging using :1234
0x0000fff0 in ?? ()
(gdb) break _start
Breakpoint 1 at 0x7c00: file mbr.S, line 6.
(gdb) break main
Breakpoint 2 at 0x7c02: file mbr.S, line 10.

首先输入 gdb mbr.elf 进入到 gdb 的调试界面中
target remote :1234 : 进入到 gdb 的调试界面后输入这个命令，用来告诉 gdb 我们要连接哪个 QEMU 进行调试，那当然就是启动在 localhost:1234 这个位置上的 QEMU 进行调试啦
break _start : 在 mbr.S 的源码文件中 _start 这个位置上打一个断点，当然啦，你也可以直接指定某一条指令所处的内存地址进行打断点的。看到没有！你会发现它告诉你 _start 这个符号是在 mbr.S 的第 6 行。Breakpoint 1 at 0x7c00: file mbr.S, line 6.
break main : 这个和 3 是同理的

让程序跑起来

这时候我们在 gdb 调试界面输入 c 就可以让它运行到第一个断点处停下来啦。这时候，你还可以输入 list 命令，你就看到了对应的汇编源码啦。

(gdb) c
Continuing.

Breakpoint 1, _start () at mbr.S:6
6	    jmp main           # 跳转到主程序
(gdb) list
1	.section .text
2	.global _start
3	.code16                # 使用 16 位代码模式
4	
5	_start:
6	    jmp main           # 跳转到主程序
7	
8	# 使用 0x7C00 作为程序加载基地址
9	main:
10	    movw %cs, %ax

再跑一下子

这次我们可以运行到 main 这个位置啦，或许你会好奇 main 难道不是位于 mbr.S 的第 9 行吗？另外，_start 是位于 mbr.S 的第 5 行，可是为什么显示的是第 6 行呢。

Breakpoint 1, _start () at mbr.S:6

Breakpoint 2, main () at mbr.S:10

这可能是因为 main 和 _start 只是一个符号，并不是真实要执行的指令，其实 main 和它下边的第一条指令 movw %cs, %ax 对应的是同一个地址，main符号本身就只是 movw %cs, %ax 指令所处的地址的一个别名而已。

(gdb) c
Continuing.

Breakpoint 2, main () at mbr.S:10
10	    movw %cs, %ax      
(gdb) list
5	_start:
6	    jmp main           # 跳转到主程序
7	
8	# 使用 0x7C00 作为程序加载基地址
9	main:
10	    movw %cs, %ax      
11	    movw %ax, %ds
12	    movw %ax, %es
13	    movw %ax, %ss
14	    movw %ax, %fs

好啦！太棒了！恭喜你完成了，你可以尝试着在每一次输出字符的位置都打上一个断点，然后看着字符一个一个的输出出来试试呢，完成这个测试，一定要使用 QEMU 的图形界面形式才可以嗷。

Python 天生支持多态

哈喽 ~

你好啊，我是蓝莓：）

Python 是一个天生支持多态的编程语言，如果你曾经学过 Java 或 C++ ，那么你一定知道，如果想让一个变量既可以指向一个类的父类也能指向这个类本身，那么就要把这个变量定义成这个类的父类的类型才可以。但是，在 Python 中就简单多了，Python 是一门动态编程语言，不需要声明变量的类型就可以直接为它赋值，而这个变量是什么类型取决于你为它赋了一个什么样类型的值。

1 给类起个新名字

在 Python 中的变量可以理解为一个便利贴（标签），当你把一个值赋给一个变量的时候，就相当于你为这个值起了一个新的名字，你想对这个值的操作都可以用这个 名字 来表示。

这时候，你可以类比一下 人，当每个人出生到这个世界的时候是没有 代号 的，如果一个人没有代号，我们就不知道该怎么用语言来描述了，比如有一个婴儿刚出生在我们的面前。我们可以说让 他 喝牛奶。如果语言中都不存在代词这种东西的话，我们甚至无法来描述如何让这个刚出生的婴儿喝牛奶。这时候，我们可以为这个婴儿贴上几个标签，比如第一个标签是 蓝莓 ，第二个标签是 蓝宇，第三个标签是 'blueberry'，这时候，这些标签的作用都是完全一样的。

让 蓝莓 喝牛奶
让 蓝宇 喝牛奶
让 blueberry 喝牛奶

这三句话表达的意思都是一样的，那么类比到 Python 中也是完全等同的，比如这个婴儿已经有了 蓝莓 这个标签，那么当我执行这样一个语句:

蓝宇 = 蓝莓

执行完这条语句之后，我就为这个刚出生的婴儿起了一个新的名字，这个新名字叫 蓝宇，一定不要有任何偏见，虽然我们是用 蓝莓 这个标签赋值给了 蓝宇。但是要知道 蓝莓 对于这个婴儿而言也是一个普通的标签而已，只不过一开始我们就有了 蓝莓 这个标签，所以后续的操作都需要通过它来表达。可，现在情况不一样了，这个婴儿又多出来一个叫 蓝宇 的标签，现在这两个标签的同等级别的，没有什么高低之分，这两个标签都贴在了这个婴儿身上成为了这个婴儿的代号。

看看编程中是什么情况

比如当我创建一个名字叫 Blueberry 的类：

class Blueberry:
    def say(self):
        print('I am blueberry 蓝莓')

这里的类名 Blueberry 就是这个客观存在的类的一个标签（名字），如果在这个类诞生的那一刻起就没有名字的话，我们甚至不知道该如何去操作它，所以在定义类的时候就先给它贴上这么一个标签 Blueberry。

好啦，这时候我再给它贴上一个新的标签 BlueVerse：

BlueVerse = Blueberry

Blueberry

对于刚诞生的这个客观存在的类而言，它拥有了两个标签，现在执行下边这段代码：

你可以看到它正常的输出了 I am blueberry 蓝莓

blueberry = Blueberry()
blueberry.say()

BlueVerse

接着我们再执行这段代码：

你会发现，他们输出了同样的内容，不必多说，相信聪明的你看到这里一定就明白啦！

BlueVerse = Blueberry
blue_verse = BlueVerse()
blue_verse.say()

2 更有趣的玩儿法

那么，看到了上边的内容后，就可以有很多的想象空间了，比如我们可以像下边这样玩儿一下：

其实，我特别喜欢《名侦探柯南》里边的黑帮大佬：琴酒（Gin），也特别喜欢灰原哀（Haibara Ai）。在这里定义了三个类，分别是 Blueberry , HaibaraAi, Gin，这三个类中都包含着一个名字相同的 成员函数

class Blueberry:
    def say(self):
        print('I am blueberry 蓝莓')

class HaibaraAi:
    def say(self):
        print('I am Haibara Ai 灰原哀')
        
class Gin:
    def say(self):
        print('I am Gin 琴酒')

接着我给这三个类分别起个别名：

members = [Blueberry, HaibaraAi, Gin]

你看到了嘛，这里用的是列表给他们起别名，其实都是一样的，比如 members[0] 也是一个变量嘛，members[0] 就是 Blueberry 的别名。

接着再执行这段代码：

遍历每一个类，然后实例化它，再调用实例对象的 say 方法，不必多说，相信聪明的你也明白这里啦！

for member in members:
    obj = member()
    obj.say()

今天就分享这么多啦 ~

如果你看到了这里 ~

给我点个赞叭 ~ 谢谢你的支持哇 ~

Python 函数天生带有暂停键

Python 生成器函数

在很多编程语言中的函数都是被调用之后就一气呵成的执行到底，知道这个函数执行 return 之后，它的使命也就结束了，然而 Python 中的函数有一个更有趣的特性，与其说是函数，不如把它叫做 生成器

普通的函数

定义一个函数，这个函数的功能就是返回 斐波那契 数列的前 $n$ 个元素的值，那么我选择使用一个列表返回这些元素，对于这个函数而言有一个缺点就是，如果 $n$ 的值非常大的话，那就需要等待这个函数把所有的前 $n$ 个值全部计算完成后才能返回

def fib(n):
    a, b = 1, 1
    if n == 1:
        return [1]
    if n == 2:
        return [1, 1]

    res = [a, b]
    for i in range(n-2):
        a, b = b, a+b
        res.append(b)
    
    return res

在这儿看一下这个函数的使用效果，你可以看到这个函数能够函数好的完成这个任务，如果我在做一件事情的时候并不需要它把所有的数据都计算出来一起返回给我，而是我使用一个它就计算一个出来，待我需要使用下一个的时候，它再把下一个数值返回给我，这样就能够同时兼顾生产数据和消费数据了。

生成器函数

那么，生成器函数应运而生，顾名思义 生成器 就是生产者，是用来生产数据的

创建生成器函数关键在于使用 yield 关键字替换 return ，其中 yield 的作用与 return 十分相似，但是也有一些区别

创建一个最简单的生成器函数，通过下边这段代码，我就创建了一个名字叫做 example 的生成器对象。现在你发现了，使用函数的方式竟然就像使用 类 一样，generator_example() 不再是简简单单的调用函数并执行里边的代码，而是通过 generator_example() 创建了一个生成器 对象。

def generator_example():
    yield 'hello world'
    yield 'I am blueberry'
    yield 'I want to help you to become better :)'
    
example = generator_example()

生成器对象 example 是可以被迭代的，是可以被遍历的，那么就让我们使用 for 语句来遍历一下：

for each in example:
    print(each)

你看到，这三个字符串都被输出出来了！

那么如何来证明，这个生成器是一次计算一个数值而不是把所有的数值都计算出来的呢？

我对上边的生成器函数做一个简单的修改：

def generator_example():
    print('输出了第 1 个字符串')
    yield 'hello world'
    
    print('输出了第 2 个字符串')
    yield 'I am blueberry'
    
    print('输出了第 1 个字符串')
    yield 'I want to help you to become better :)'

example = generator_example()

这时，我通过 next 函数来遍历生成器的内容，如果你不理解 next 函数的话。联想下 for 语句遍历数据，在你使用 for 遍历一个可迭代类型对象的时候，你不能让它遍历到一个数值后停下来，一旦停下来这一轮的遍历就结束了。

如果你使用 next 的话，可以一次只遍历出来一个值，下一次的时候接着上一个值进行迭代

在生成器 generator_example 中我放了几个 print 语句，通过下边的输出，你可以发现，yield 出去 s1 后并没有执行这条 yield 语句下边的 print 语句，这就说明了此时生成器被暂停下来了！

是不是很有趣？

最后再使用生成器实现一下斐波那契数列：

生成器实现斐波那契

def fib_generator(n):
    assert n >= 3, 'n 应大于等于 3'
    
    yield 1
    yield 1

    a, b = 1, 1
    for i in range(3, n+1):
        a, b = b, a+b
        yield b

for each in fib_generator(9):
    print(each, end=', ')

彻底理解 Python 装饰器

在 Python 中有一个很有趣的语言特性是装饰器。

假象这样一个场景：你写了一个函数，当你完成了这个函数的功能后，你希望这个函数在每次运行的时候都能记录下来自己的调用时间或者运行时间到一个指定的地方存储下来，或者就是非常简单的，在每次运行完成一个函数后把自己的运行时间给输出出来。

相信聪明的你，一定知道了应该如何完成这个操作，我们先来看看用最简单的方法要怎么来完成。

1 先随便写个函数吧

就写一个最简单的函数好啦，乘方运算。

计算 a 的 b 次方。

def blueberry_pow(a, b):
    return a ** b

让我运行一下：

2 计算函数运行时长

可以直接这样写，使用 time.time() 分别记录 blueberry_pow 函数运行前的时间点 start 和运行结束后的时间点 end。最后用结束时间 end 减去开始时间 start 就是 blueberry_pow 函数的运行时长 run_time 了。

import time

start = time.time()
blueberry_pow(1000000, 1000000)
end = time.time()

run_time = end - start

print('blueberry_pow 的运行时长是: ', run_time)

3 浅包装一下

聪明的你一定会觉得这个方法真是太简单了！可是 Python 这门编程语言一直都非常讲究 优雅 二字，毕竟人家的官方文档介绍中都说自己非常的 elegant 呢！这怕是最自恋的编程语言了吧！

我们知道在 Python 中一切皆对象，那么函数本身也是个对象，我们可以直接把函数 blueberry_pow 赋值给变量，甚至当做参数进行传递。

那么，第一种写法就有了，我们专门写一个记时用的函数，然后把 blueberry_pow 当做参数传递给这个记时函数，在这里边运行。

第 1 个参数 func 是传递了需要被记录时间的函数，其后的第 2 个参数 args 和第 3 个参数 kwargs 如果你学习过函数的参数传递方式相关的内容的话，一定见过这样的写法。在这里就不展开细聊这种参数传递方法了。总之，你知道的我们传递给 timer 的第 2 个参数开始的值都被我们按照同样的方式传递给了 func 所代表的函数就好啦。

def timer(func, *args, **kwargs):
    start = time.time()
    res = func(*args, **kwargs)
    end = time.time()

    run_time = end - start
    print('blueberry_pow 的运行时长是: ', run_time)
    
    return res

res = timer(blueberry_pow, 100000, 666666)

接着让我们来使用 timer 函数对blueberry_pow 函数记个时，你会发现，同样可以完成这个人物。

4 再进一步包装

有了第 3 部分的方法后，可以使用 timer 工具函数对它进行记时。

我们能不能直接在 blueberry_pow 的基础上创造一个新的函数，让这个新的函数增加上一个记录时间的功能呢？

当然啦，我们可以这样来写。

顾名思义 add_timer 就是要为 func 函数添加一个 timer 的功能。让我们来看看在 add_timer 中做了什么呢？

你可以发现，我们在函数的内部定义了一个函数 new_func 然后我们在 new_func 函数中不仅运行了 func 函数，而且还运行了一些我们希望添加的记时功能。最后我们把定义好的 new_func 函数作为 add_timer 函数的返回值返回出去。这样一来，我们就可以为任意的函数 func 添加上记时功能了。

在这里，我们为 blueberry_pow 函数添加计时功能，并且将 add_timer 函数返回出去的函数起个名字叫 new_blueberry_pow 。接着我们调用 new_blueberry_pow 函数的时候就像是调用 blueberry_pow 函数一样的使用方法即可。

def add_timer(func):
    def new_func(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()

        run_time = end - start
        print('blueberry_pow 的运行时长是: ', run_time)

    return new_func

new_blueberry_pow = add_timer(blueberry_pow)
res = new_blueberry_pow(100000, 666666)

5 优雅的装饰器

在第 4 部分中，我们看到了，可以使用这样的方式来在 blueberry_pow 的基础上创建一个新的函数，让这个新的函数拥有计时功能。

那么在第 4 部分中唯一不足的地方就是这个过程看起来还是不够优雅，并且我们创建出来的新的函数 new_blueberry_pow 的名字相较于 blueberry_pow 的函数名字发生了变化，然而这个变化其实是多余的。

另外，new_blueberry_pow = add_timer(blueberry_pow) 这一行代码看起来也实在是多余。

害！人家 Python 可是一门儿自称是非常 elegant 的一门编程语言，自然对这一点有了原生的语言特性作为支持。

那就是装饰器啦！

让我们把代码重新来一遍，定义装饰器，其实就是在定义一个像第 4 部分中 add_timer 一样的函数而已。

定义装饰器 timer

哈哈，你发现了，timer 函数和第 4 部分中的 add_timer 函数中的内容长的一模一样！我只是给它改了个名字而已。

def timer(func):
    def new_func(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()

        run_time = end - start
        print('blueberry_pow 的运行时长是: ', run_time)

    return new_func

定义乘方运算函数

接着！让我们来定义一个 蓝莓 专用的乘方运算函数 blueberry_pow ，哈哈 ~

你会发现在函数定义的上边一行多了一个 @timer，这就是把 timer 装饰器用在 blueberry_pow 函数上。

@timer
def blueberry_pow(a, b):
    return a ** b

这时候让我们调用一下blueberry_pow 函数，看看会发生什么呢？

哇偶！是不是很神奇？我们直接调用 blueberry_pow 函数就直接拥有了计时功能了！

哈哈，那么这个实现原理就和第 4 部分中所说到的 add_timer 函数的工作原理是完全一样的！

只不过在第 5 部分中我为 add_timer 函数改了个名字改成了 timer 函数并且在定义 blueberry_pow 函数的时候，在其上方写了一个 @timer。那么@timer的作用就是说，当你在调用blueberry_pow函数的时候，你先把blueberry_pow函数丢给timer函数，然后timer函数会返回一个新的函数new_func，这时候在接受timer函数的返回值的时候把它赋值给blueberry_pow这个标签。

经过这样的一番折腾后，我们的blueberry_pow函数就得到了装饰，得到了一些改造。

彻底理解 Python 万物皆对象

在 Python 中的一切内容都是以对象的形式存在的。

自定义的类本身是一个对象（类对象），通过类对象实例化的东西也是一个对象（实例对象）。甚至创建出的一个浮点数也是一个对象（浮点对象）。

当我们在 Python 中写出这样的代码时，你会不会感到奇怪？

a = float(6.66)

如果你已经使用了很久一段时间 Python 的话，对这个操作是非常熟悉的。一直都在强调，万物皆对象，那么创建浮点类型实例对象的对象就是 float 对象，按理来说 float 是一个对象，可是它竟然可以被调用？一个对象竟然可以像函数一样被调用啊！

可以被调用的对象称为 可调用对象，对于内建对象 float 而言，在实现 CPython 的时候肯定是事先就被写好了这个被调用后所执行的逻辑了。那么对于我们自己创建类所生成的实例对象同样可以完成诸如这样的魔法操作。

在我的这篇文章中有提到过，这类看上去非常神奇的内容是如何实现的，如果希望一个对象可以被调用，那么我们就实现 __call__ 魔法函数即可。

可参考这篇文章：

【遇见 Python 魔法函数】

在这儿，简单体会一下 __call__ 魔法函数的使用

class Blueberry:
    def __call__(self):
        print('hello world, I am blueberry')

blueberry = Blueberry()
blueberry()

我们只需要实现 __call__ 方法，随后在调用 blueberry 对象的时候就会执行实现定义好的 __call__ 函数里的代码了

考察浮点数值对象

我们就通过最简单的浮点类型的对象深入理解 Python 中万物皆对象是如何实现的。

在 Python 中有两个非常特别的 对象 分别是 type 和 object。其中 type 是类型对象，另外所有的对象的基类都是 object，也就是说在继承链的最顶端一定是 object 对象。

内建对象的基类

我们先看看内建对象 float 的基类是谁，通过如下的代码，我们可以发现 float 对象是继承自 object 对象的，证明了内建对象继承自 object。其中通过查看 float 的 __mro__ 属性可以看到一个对象的继承链。两种方式都验证了这一点。

isinstance(float, object)

float.__mro__

内建类型的类型

查看 float 的类型，通过以下两种方式都是可以查看一个对象对应的 type 的。

一文总结 Go 语言语法

目录：

变量定义
常量和枚举
条件语句
循环语句
函数定义
指针
内建容器：array （数组）
内建容易：slice （切片）
内建容器：map
Go 面向 “对象”
Go 的包
Interface 接口
Goroutine 并发编程
Channel 通道

1 变量定义

变量的初始值

在 go 语言中，每个变量都有初值，整型变量 a 的初始值是 0，字符串变量的初始值是空串 ""

func variableZeroValue() {
	var a int  // 直接定义一个变量出来
	var s string

	fmt.Printf("variable a: %d \n", a)
	fmt.Printf("variable s: %q \n", s)
}

outputs:

variable a: 0 
variable s: ""

手动赋值

func variableInitialValue() {
	var a, b int = 1, 2 // 定义的时候还可以赋初值
	var s string = "hello world."
	fmt.Println(a, b, s)
}

outputs:

1 2 hello world.

类型推断

func variableInitialValue() {
    var a, b = 1, 2 // 可以省略类型
   	var s = "hello world."
	fmt.Println(a, b, s)
}

outputs:

1 2 hello world.

更简洁的类型推断写法

func variableShorter() {
	a, b, s := 1, 2, "hello world." // 多个类型的是可以放在一起写的；并且在定义的时候写冒号就可以了 var 都可以省略
	fmt.Println(a, b, s)
    
    b = 666 // 第二次再用它的时候就不用写冒号咯
    fmt.Println(b)
}

outputs:

1 2 hello world.
666

函数体外定义变量（包内变量）

定义包级别的变量必须使用关键字开始，而不能使用冒号的形式定义变量

var a = 666 // 在函数外面定义变量的时候必须使用 var 来定义，也是可以推断出来的

// 还可以一次定义多个变量
var (
	aa = 111
	bb = 222
	cc = 333
)

内置变量的类型

complex 代表复数

bool, string
(u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
byte, rune
float32, float64, complex64, complex128

类型转换是强制的

func triangle() {
	var a, b int = 3, 4
	var c int
	c = int(math.Sqrt(float64(a*a + b*b))) // 因为 Sqrt 接收的是浮点数，所以你必须显示的进行转换而不会自动转换

	fmt.Println(a, b, c)
}

outputs:

3 4 5

2 常量和枚举

普通常量的定义

func constant() {
	const filename = "helloworld.txt"
	const a, b = 666, 999
	var c int
	c = int(math.Sqrt(a*a + b*b)) // 常量相当于文本替换
	fmt.Println(filename, c)
    
    // 定义一组常量
    const (
		c1 = 111
		c2 = 222
	)
	fmt.Println(c1, c2)
}

// 也可以定义为包内的常量，则包内部的函数都可以使用

outputs:

helloworld.txt 1200
111 222

枚举类型

iota 代表这个常量列表是自增值，使用下划线代表不使用这个位置的值

func enums() {
	const (
		cpp = iota // iota 代表从 0 开始, 并且后面的都是在 iota 的基础上自增 1 的
		_ // 这里相当于 1，用下划线代表不用这个 1 了
		python // 这里相当于 2
	)

	// b, kb, mb, gb, tb, pb
	const (
		b = 1 << (10 * iota) // 你甚至还可以写成表达式 相当于是：1 << (10 * 0)
		kb // 这里相当于 1 << (10 * 1)
		mb // 这里相当于 1 << (10 * 2)
		gb // 后面以此类推
		tb
		pb
	)
	fmt.Println(cpp, python)
	fmt.Println(b, kb, mb, gb, tb, pb)
}

outputs:

0 2
1 1024 1048576 1073741824 1099511627776 1125899906842624

3 条件语句

普通的条件判断

func bounded(v int) int {
	if v > 100 { // 条件语句不用写圆括号
		return 100
	} else if v < 0 {
		return 0
	} else {
		return v
	}
}

带分号的 if

先运行前半句，然后才执行 err 是否为空的判断，这里的 contents 是属于 if 语句这个作用域的

在条件语句中 || 表示两个条件之间的或运算，&& 表示两个条件之间的与运算

func main() {
	const filename = "hello.txt"
	
    // 这里代表先执行分号前面的语句，然后再判断分号后面的语句是否为 true
    // 并且 contents 和 err 都是if语句局部的量
	if contents, err := os.ReadFile(filename); err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s \n", contents)
	}
}

outputs:

hello
world.

switch 语句

每一个 case 后面默认带有 break 的功能

func eval(a, b int, op string) int {
	var result int
	
    // op 和某一个 case 后面的值相等 则执行相应的 case 里面的内容
    // 每个 case 执行完成后自动 break 出去
	switch op {
	case "+":
		result = a + b
	case "-":
		result = a - b
	case "*":
		result = a * b
	case "/":
		result = a / b
	}
	return result
}

// switch 语句可以有 default 分支
// panic 用于停止程序的运行
func grade(score int) string {
	g := ""
	switch {
	case score < 0 || score > 100:
		panic(fmt.Sprintf("Wrong score: %d", score))
	case score < 60:
		g = "F"
	case score < 80:
		g = "C"
	case score < 90:
		g = "B"
	case score <= 100:
		g = "A"
	}
	return g
}

4 循环语句

for 循环

func main() {
    
    // 1
	sum := 0

	for i := 1; i <= 100; i++ { // 同理不需要圆括号
		sum += i
	}

	fmt.Println(sum)
	
    // 2
	sum2 := 0

	i := 0
	for ; i <= 100; i++ { // 可以不写 第一个分号前面的内容
		sum2 += i
	}

	fmt.Println(sum2)
	
    // 3
	sum3 := 0

	i = 0
	for i <= 100 { // 这就相当于其他那些常见语言中的 while 循环了
		sum3 += i
		i++
	}
    
    // 4 死循环
    for { // 这个直接代表死循环，相当于常见语言的 while(true)
        // TODO 	
	}

	fmt.Println(sum3)
}

5 函数定义

定义函数和返回值

// 返回值类型写在圆括号后面
// 如果有多个返回值
// 返回值类型要用圆括号包裹起来 (int, int) 代表返回两个 int 类型的返回值
// 一般情况下, golang 中第一个返回数据，第二个返回值一般定义为 error 类型
func eval(a, b int, op string) (int, error) {
	var result int
	
	switch op {
	case "+":
		result = a + b
	case "-":
		result = a - b
	case "*":
		result = a * b
	case "/":
		result = a / b
	default: // switch 语句是可以有 default 的
		return 0, fmt.Errorf("unsupported operation")
	}

	return result, nil
}

函数也是一等公民

func div(a, b int) int {
	return a / b
}

func apply(op func(int, int) int, a, b int) int {
	p := reflect.ValueOf(op).Pointer()
	opName := runtime.FuncForPC(p).Name()
	fmt.Printf("Calling function %s with args "+"(%d, %d)\n", opName, a, b)
	return op(a, b)
}

func main() {
    // div 这个函数本身也可以被当做参数传递
	res := apply(div, 10, 2)
	fmt.Println(res)
}

oputputs:

Calling function main.div with args (10, 2)
5

匿名函数

func main() {
    // 定义一个匿名函数传递给刚才的 apply 函数也是可以的
	res := apply(func(a, b int) int {
		return a / b
	}, 10, 2)
	fmt.Println(res)
}

可变参数列表

// 直接写 ... 就代表你可以传递任意个 int 类型的数值进来
// 我们可以遍历 nums 获取值
func sum(nums ...int) int {
	s := 0
	for i := range nums { // 使用 range 关键字获取索引 i
		s += nums[i] 
	}

	return s
}

6 指针

// golang 中的指针不能运算
// golang 中只有值传递
func main() {
	var a int = 2
	var pa *int = &a // 用一个 * 号代表 pa 是一个指向 int 数据类型的指针; pa 的值是 a 的地址
	*pa = 3 // 在使用 pa 的时候加上 * 号代表的就是 pa 指向的那个数据本身了
	fmt.Println(pa, *pa)
}

outputs:

0x140000a6018 3

作为参数传递

func modifyValue(nums *int) {
	*nums = 666
}

// go 语言中只有值传递，我们可以把 nums 的地址传进去
// 通过地址访问 nums 所代表的内存区域本身
func main() {
	nums := 111
	modifyValue(&nums)
	fmt.Println(nums)
}

outputs:

7 内建容器：数组

数组

func main() {
	var arr1 [5]int // 指定数组长度为 5； 每个元素的类型是 int 类型
	arr2 := [3]int{1, 2, 3} // 还可以赋初值
	arr3 := [...]int{2, 4, 6, 8, 10} // 写 ... 代表这个数组的长度根据你填写的数值个数进行自动生成

	fmt.Println(arr1)
	fmt.Println(arr2)
	fmt.Println(arr3)

	var grid [4][5]int // 一个 4 行 5 列的二维数组
	fmt.Println(grid)
	
    // 使用 len 可以获取数组的长度
	for i := 0; i < len(arr3); i++ {
		fmt.Println(arr3[i])
	}

	fmt.Println("range 1")
    // 只返回数组的索引 i
	for i := range arr3 {
		fmt.Println(arr3[i])
	}

	fmt.Println("range 2")
    // 返回索引 i 的同时返回这个位置的值 v
	for k, v := range arr3 {
		fmt.Println(k, v)
	}
}

outputs:

[0 0 0 0 0]
[1 2 3]
[2 4 6 8 10]
[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]
2
4
6
8
10
range 1
2
4
6
8
10
range 2
0 2
1 4
2 6
3 8
4 10

数组数值类型

数组名代表的是数组全部的内容，因此数组的长度不一样代表的是两种不同的数据类型，比如：

arr1 [5]int 和 arr2 [3]int 是两种不同的数组并且从数组到数组的参数传递是基于拷贝的

8 内建容器：切片

切片

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	
    // 和 python 里面的切片很像
    // go 中的切片是以一个具体的数组作为载体的
    // 切片是对这个数组的一个 view，仅仅是一个引用
	fmt.Println("arr[2:6] = ", arr[2:6])
	fmt.Println("arr[:6] = ", arr[:6])
	fmt.Println("arr[2:] = ", arr[2:])
	fmt.Println("arr[:] = ", arr[:])
}

outputs:

arr[2:6] =  [2 3 4 5]
arr[:6] =  [0 1 2 3 4 5]
arr[2:] =  [2 3 4 5 6 7 8]
arr[:] =  [0 1 2 3 4 5 6 7 8]

切片是 view

func updateSplice(s []int) {
	for i, v := range s {
		s[i] = v + 1
	}
}

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8}

	updateSplice(arr[:])
	fmt.Println(arr)

	updateSplice(arr[:])
	fmt.Println(arr)
}

outputs:

[1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7 8 9 10]

切片的可扩展性

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

	s1 := arr[2:6]
	fmt.Println("s1: ", s1)
	fmt.Printf("len(s1) = %d, cap(s1) = %d \n", len(s1), cap(s1))

	s2 := s1[3:5] // 数组本身还在, slice 只是数组的 view
    // 你可以发现，我们竟然能访问这个切片以后的内容；因为这些内容真实存在于底层数组中
	fmt.Println("s2: ", s2)
	fmt.Printf("len(s2) = %d, cap(s2) = %d \n", len(s2), cap(s2))

	// slice 的实现
	// 1. ptr 指向 slice 开始的元素
	// 2. len 代表 slice 的长度
	// 3. cap 代表 ptr 到数组末尾的长度; 因此可向后扩展, 但是不能向前扩展
	// slice[i] 其中 i < len ; slice[s, e] 其中 e <= cap 即可
    // len 仅代表 slice 的长度，而 cap 代表的是这个切片的起始位置到这个底层的数组的结束位置的长度
}

outputs:

s1:  [2 3 4 5]
len(s1) = 4, cap(s1) = 6 
s2:  [5 6]
len(s2) = 2, cap(s2) = 3

对切片添加元素

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}

	s1 := arr[2:6]
	fmt.Println("s1: ", s1)
	fmt.Printf("len(s1) = %d, cap(s1) = %d \n", len(s1), cap(s1))

	s2 := s1[3:5] // 数组本身还在, slice 只是数组的 view
	fmt.Println("s2: ", s2)
	fmt.Printf("len(s2) = %d, cap(s2) = %d \n", len(s2), cap(s2))

	// slice 的实现
	// 1. ptr 指向 slice 开始的元素
	// 2. len 代表 slice 的长度
	// 3. cap 代表 ptr 到数组末尾的长度; 因此可向后扩展, 但是不能向前扩展
	// slice[i] 其中 i < len ; slice[s, e] 其中 e <= cap 即可

	s3 := append(s2, 111)
	s4 := append(s3, 222)

	fmt.Printf("v = %v, len(s3) = %d, cap(s3) = %d \n", s3, len(s3), cap(s3))
	fmt.Printf("v = %v, len(s4) = %d, cap(s4) = %d \n", s4, len(s4), cap(s4))

	// 添加元素的时候如果超过了底层数组的 cap, 则会重新分配一个底层数组
    // 所以 append 每次都会返回一个新的引用，因为我们可以已经抛弃了原来的那个底层数组
	// 因此在添加元素的时候随时都有可能造成底层数组的改变, 因此必须接收 append 的返回值
	// 从而使用一个新的 切片 来对数组进行 view
	s4[2] = 999 // 此时切片 s3 和 s4 已经不是同一个数组的 view 了, 是 go 重新帮我们分配的数组了
	fmt.Printf("v = %v, len(s3) = %d, cap(s3) = %d \n", s3, len(s3), cap(s3))
	fmt.Printf("v = %v, len(s4) = %d, cap(s4) = %d \n", s4, len(s4), cap(s4))
}

直接创建切片

直接创建切片的话，go 会自动为我们创建底层数组，因此，我们创建的切片看上去就好像是那个数组的引用一样

实际上切片中存储的是指向这个数组的指针，我们拷贝切片其实拷贝的是那个指针，因此我们操作这个切片的拷贝，实际上操作的是同一个底层数组

func main() {
	var s []int // 直接定义 slice 类型, 此时 s 的值为 nil

	for i := 0; i < 100; i++ {
        // 观察 cap 的变化
        // 当 cap 产生变化的时候，说明引用的底层数组已经变了
		fmt.Printf("len(s) = %d, cap(s) = %d \n", len(s), cap(s))
		s = append(s, i*2)
	}
}

outputs:

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

按长度创建切片

func main() {
	s := make([]int, 18)
	fmt.Printf("len(s) = %d, cap(s) = %d \n", len(s), cap(s))

	ss := make([]int, 20, 32)
	fmt.Printf("len(ss) = %d, cap(ss) = %d \n", len(ss), cap(ss))

	copy(s, ss)  // 只会根据 s 的容量 cap 进行拷贝, 超过容量大小的部分不拷贝
	fmt.Printf("len(s) = %d, cap(s) = %d \n", len(s), cap(s))
}

outputs:

len(s) = 18, cap(s) = 18 
len(ss) = 20, cap(ss) = 32 
len(s) = 18, cap(s) = 18

切片删除元素

func main() {
	s := make([]int, 16, 32)
	fmt.Printf("len(s) = %d, cap(s) = %d \n", len(s), cap(s))

	// 删除中间某个元素
	ss := append(s[:3], s[4:]...)
	fmt.Printf("len(ss) = %d, cap(ss) = %d \n", len(ss), cap(ss))

	s[0] = 111
	fmt.Println(ss)

	// 删除头元素
	ss = ss[1:]
	fmt.Println(ss)

	// 删除尾元素
	ss = ss[:len(ss)-1]
	fmt.Println(ss)
}

outputs:

len(s) = 16, cap(s) = 32 
len(ss) = 15, cap(ss) = 32 
[111 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0]

9 内建容器：map

func main() {
	// map 是无序的
    // 除了 slice, map, function 的内建类型都可以作为 key
    // 创建一个 k 和 v 都是 string 类型的 map
	m := map[string]string{
		"name":    "blueberry",
		"address": "China",
	}

	fmt.Println(m)

	m2 := make(map[string]string) // empty map
	var m3 map[string]string      // nil: 同样可以参与运算

	fmt.Println(m2)
	fmt.Println(m3)

	height, ok := m["height"]
	fmt.Println("height: ", height) // 拿到的是空串
	fmt.Println("ok: ", ok)

	// 一般情况下可以这样写,
	if height2, okk := m["height"]; okk {
		fmt.Println("ok height: ", height2)
	}

	for k, v := range m {
		fmt.Println(k, v)
	}

	// 删除元素
	delete(m, "name")
	fmt.Println("delete name: ", m)

	// 创建复合 map
	mm := make(map[string]map[string]string)
	fmt.Println(mm)

	mm["blueberry"] = make(map[string]string)
	mm["blueberry"]["name"] = "111"
	mm["blueberry"]["height"] = "222"

	fmt.Println(mm["blueberry"])
}

outputs:

map[address:China name:blueberry]
map[]
map[]
height:  
ok:  false
name blueberry
address China
delete name:  map[address:China]
map[]
map[height:222 name:111]

10 golang 的面向对象

golang 仅支持封装，不支持继承和多态；可以面向接口编程

结构体

package main

import (
	"fmt"
)

// type 代表 User 是一个数据类型
// struct 代表 User 是一个 struct 类型的数据类型
// 然后在花括号内定义具体的内容
type User struct {
	name    string
	address string
	height  int
}

func createUser(name, address string, height int) *User {
	return &User{name: name, address: address, height: height}
}

func main() {
	// 1. 直接创建
	var user1 User

	// 2. 赋初值
	user2 := User{
		name:    "blueberry",
		address: "China",
		height:  999,
	}

	// 3. 创建 User 并返回它的指针
	user3 := new(User)
	user3.height = 111
	user3.name = "blueberry3"
	user3.address = "US"

	// 4. 所谓构造函数
	user4 := createUser("blueberry", "China and US", 999)

	// 看看内容
	fmt.Println(user1)
	fmt.Println(user2)
	fmt.Println(user2.name)
	fmt.Println(user3)
	fmt.Println(user4)
}

outputs:

{  0}
{blueberry China 999}
blueberry
&{blueberry3 US 111}
&{blueberry China and US 999}

为结构定义方法

package main

import (
	"fmt"
)

type User struct {
	name    string
	address string
	height  int
}

func createUser(name, address string, height int) *User {
	return &User{name: name, address: address, height: height}
}

// 使用指针接受者定义的方法
// 当使用指针接收者的时候，不会每次在调用 print 的时候都把 User 的内容拷贝一次
// 而是传递 User 实例的指针给 user 这个变量，这时候你可以通过 user 改变它的内容对外界产生影响
// 当然，你可以把 * 号去掉，一旦去掉，就会拷贝 User 里面的内容给 user 变量，你所作出的改变对外界没有影响
func (user *User) print() {
	fmt.Println("name: ", user.name)
	fmt.Println("address: ", user.address)
	fmt.Println("height: ", user.height)
}

func main() {
	user := createUser("blueberry", "China and US", 999)
	user.print()
}

outputs:

name:  blueberry
address:  China and US
height:  999

11 go 的包

user.go

package user

import "fmt"

// 大写开头代表的是在其他包内也可以访问
// 小写开头的话只能在当前的包内访问
// type 指明 User 是一个数据结构
type User struct {
	Name    string
	Address string
	Height  int
}

func CreateUser(name, address string, height int) *User {
	return &User{Name: name, Address: address, Height: height}
}

func (user *User) Print() {
	fmt.Println("name: ", user.Name)
	fmt.Println("address: ", user.Address)
	fmt.Println("height: ", user.Height)
}

main.go

package main

import (
	"fmt"
	"learngo/user"
)

func main() {
	blueberry := user.CreateUser("blueberry", "China and US", 999)
	blueberry.Print()

	fmt.Println(blueberry.Name)
}

outputs:

name:  blueberry
address:  China and US
height:  999
blueberry

type 关键字

// 还可以使用 type 为 []int 起一个别名
type Queue []int

12 接口 Interface

Retriever.go

定义结构体

package mock

type Retriever struct {
	Contents string
}

func (r *Retriever) Get(url string) string {
	return r.Contents
}

main.go

定义结构并使用接口接收 Retriever 结构体的实例；使用接口接收结构体的实例就可以完成不同的结构体之间使用同一个类型的变量进行引用了，就像 Python 中一样灵活，甚至使用一个接口类型的数组可以让每个元素引用多个不同类型的结构体实例，遍历这个数组并且调用同一个方法！

接口变量中包含两个内容：

实现者的类型 %T
实现者的拷贝或者指向实现者的指针 %v

使用接口的时候，为接口赋值分为两种情况：

指针接收者：若结构体绑定的方法使用的是指针接收者，则为接口赋值的时候要取地址
值接收者：若结构体绑定的方法使用的是值接收者，则为接口赋值的时候可以取地址也可以不取地址，如果是以取地址的方式进行复制，那么接口变量中包含的就是指向结构体实例的指针，如果不取地址则接口变量中包含一份结构体实例的拷贝

package main

import (
	"fmt"
	"learngo/mock"
)

type Retriever interface {
	Get(url string) string
}

func download(r Retriever) string {
	return r.Get("www.baidu.com")
}

func main() {
	var r Retriever
	r = &mock.Retriever{Contents: "hello world."} // 指针接收者
	fmt.Println(download(r))
}

outputs:

hello world.

一般类型

interface {} 代表的是任意类型，当 interface 中不写任何方法的时候则代表不用实现任何方法的类型都可以被该接口接收，所以就是代表任意类型咯；在某些情况下这样做产生的代价就是可能只有在运行的时候才能知道会报错

接口组合

type Retriever interface {
	Get(url string) string
}

type Poster interface {
	Post(url string) string
}

// 组合后：RetrieverPoster 可以调用 Get 和 Post
type RetrieverPoster interface {
	Retriever
	Poster
	Connect(host string) string
}

Reader Writer 接口

// 使用 io.Reader 接口的例子
func printFileContents(reader io.Reader) {
	scanner := bufio.NewScanner(reader)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

func main() {
	file, err := os.Open("hello.txt")

	if err == nil {
		printFileContents(file)
	} else {
		fmt.Println(err)
	}

	ss := "I \nam \nblueberry \ngo on"

	printFileContents(strings.NewReader(ss))

}

outputs:

hello
world
1
2
3
4
5
I 
am 
blueberry 
go on

stringer 接口

// 实现 stringer 接口 ==> 用于格式化为字符串
type User struct {
	name string
	age  int
}

func (u User) String() string {
	return fmt.Sprintf("name is %s, age is %d", u.name, u.age)
}

func main() {
	var user User
	user.name = "blueberry"
	user.age = 999

	fmt.Printf("the user contents: %s\n", user)
	fmt.Println("the user contents:", user)
}

outputs:

the user contents:name is blueberry, age is 999
the user contents: name is blueberry, age is 999

type

到这里可以搜索一下类型断言 type assertion 和 type switch 相关的内容，这里就不展开写了

13 Goroutine 并发编程

go 关键字：创建 goroutine

goroutine 是轻量级的线程，类似于协程
非抢占式多任务处理，由协程主动交出控制权：碰到 io 操作的时候会主动交出控制权

func main() {

	for i := 0; i < 10; i++ {
        // 在调用函数的时候使用 go 关键字，就相当于让该函数相对于调用它的那个执行流而言并发了
		go func(num int) {
			for {
				fmt.Println("Hello World from goroutine:", num) // 碰到这行 io 操作会主动拐交出控制权
				runtime.Gosched()                               // 主动交出控制权
			}
		}(i)
	}

	time.Sleep(time.Millisecond)
}

outputs:

Hello World from goroutine: 2
Hello World from goroutine: 4
Hello World from goroutine: 4
Hello World from goroutine: 1
Hello World from goroutine: 1
Hello World from goroutine: 1
Hello World from goroutine: 7
Hello World from goroutine: 7
Hello World from goroutine: 2
Hello World from goroutine: 2
Hello World from goroutine: 2
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 0
Hello World from goroutine: 8

go 语言调度器

go 语言会根据需要开一定数量的线程；goroutine 是放在线程中运行的，至于放在哪个线程中被操作系统调度进而运行要看 go 语言自己进行调度；调度器会在合适的位置进行自动切换

I/O 或者 select
channel
等待锁的时候
有时在函数调用的时候进行切换
runtime.Gosched()

某些其他的地方也可能会切换；本质还是非抢占式的

14 Channel 通道

协程之间通信的机制 Channel

创建 channel

package main

import (
	"fmt"
	"time"
)

func worker(ch chan int) {
	for {
		n := <-ch
		fmt.Println(n)
	}
}

func generator() {
	var c chan int // 此时的 c 是 nil
	//c = make(chan int) 通过这种方式创建的 channel 是没有缓存的; 发送后若接收方没有收完，发送方会阻塞
	c = make(chan int, 10) // 需要 make 出来; 创建一个能够缓存 10 个 int 类型数据的 channel

	go worker(c)

	for i := 0; i < 10; i++ {
		c <- i
	}
    close(c) // 当关闭 channel 后，接收方还是可以收数据的，收到的是具体类型的零值

	time.Sleep(time.Millisecond * 2)
}

func main() {
	generator()
}

outputs:

接收方判断 channel 是否关闭

func worker(ch chan int) {
	for {
        // 我们可以在接受数据的时候这样做
        // ok 中是一个布尔值
		n, ok := <-ch
		if !ok {
			break
		}
		fmt.Println(n)
	}
}

使用 range

func worker(ch chan int) {
	for n := range ch {
        // 使用这样的方法遍历，如果 channel 不被 close
        // 那么当 channel 空了之后会一直等待
        // 直到程序运行结束
        // 如果 channel 被 close 了，那么该过程也就结束了
		fmt.Println(n)
	}
}

等待 goroutine 完成的方法

func worker(ch chan int, done chan bool) {
	for n := range ch {
		fmt.Println(n)
	}
	done <- true // 如果这里不往通道内输入一个值，那么 generator 那里就要一直等待下去了
}

func generator() {
	c := make(chan int, 10)
	done := make(chan bool)

	go worker(c, done)

	for i := 0; i < 10; i++ {
		c <- i
	}

	close(c)
	<-done // 用好 channel 阻塞的特性，使用一个 channel 进行等待
}

func main() {
	generator()
}

使用 WaitGroup

func worker(ch chan int, wg *sync.WaitGroup) {
	for n := range ch {
		fmt.Println(n)
	}
	wg.Done()
}

func generator() {
	c := make(chan int, 10)
	var wg sync.WaitGroup
	wg.Add(1) // 代表执行 1 次 Done 之后就算完成等待了

	go worker(c, &wg)

	for i := 0; i < 10; i++ {
		c <- i
	}

	close(c)
	wg.Wait() // 直到使用 wg 执行 1 次 Done 操作后，这里才会通过
    // 具体是 wg 执行几次 Done 操作才会通过这要看在使用 wg.Add 的时候那个值添加的是几
}

func main() {
	generator()
}

select 调度

func generator(c chan int) {
	for i := 0; i < 1000; i++ {
		c <- i
	}
}

func main() {
	var c1 chan int
	var c2 chan int
	c1 = make(chan int)
	c2 = make(chan int)

	go generator(c1)
	go generator(c2)

	// 当达到 5 秒后会自动向 tm 中发送一个数据
	tm := time.After(5 * time.Second)
	
    // 写个死循环不停的使用 select 
	for {
		// select 会选择一个不会阻塞的 case 执行
        // 如果都阻塞的话，那就等着就行了，或者是如果都阻塞但是有 default 那么就会执行 default 里面的内容
		// Note: 若对一个值为 nil 的通道进行操作，则一定阻塞
		select {
		case n := <-c1: // c1 产生数据的时候走这里
			fmt.Println("reveived from c1:", n)
		case n := <-c2: // c2 产生数据的时候走这里
			fmt.Println("reveived from c2:", n)
		case <-tm: // 当达到 5 秒的时候，这里可以收数据
			fmt.Println("done!")
			return
		default: // 当都无法收或发数据的时候走这个分支
			fmt.Println("wait")
			time.Sleep(time.Millisecond * 100)
		}
	}
}

outputs:

// 省略 ...
reveived from c2: 65
reveived from c1: 64
wait
reveived from c1: 65
reveived from c2: 66
wait
reveived from c2: 67
reveived from c1: 66
wait
reveived from c2: 68
reveived from c1: 67
wait
reveived from c1: 68
done!

传统的同步机制

type atomicInt struct {
	value int
	lock  sync.Mutex // 这是一把锁
}

func (a *atomicInt) increment() {
	// TODO: before lock
	func() {
		// 使用匿名函数在一块儿代码区里锁定资源
		a.lock.Lock()
		defer a.lock.Unlock()

		a.value++
	}()
	//TODO: after unlock
}

func (a *atomicInt) get() int {
	a.lock.Lock() // 上锁
	defer a.lock.Unlock() // 解锁
    // 使用 defer 关键字就是代表在函数 return 之前才执行 defer 后面的语句

	return a.value
}

func main() {
	var nums atomicInt
	go func() {
		for {
			nums.increment()
		}
	}()

	time.Sleep(time.Millisecond)

	fmt.Println(nums.get())
}

Golang 线程同步

通常在 Go 语言中有两种方法可以用来做线程同步

sync.Cond
channel

channel 的很好理解，当我们从一个 channel 中接收数据的时候，如果里面没有数据，那我们直接就阻塞在那里了；在这篇文章中就来看看怎么使用 sync.Cond 完成同步

sync.Cond

定义结构体和方法

type BlueberryInt struct {
	num  int
	lock sync.Mutex
	cond *sync.Cond
}

func NewBlueberryInt() *BlueberryInt {
    // 创建 BlueberryInt 结构体
	var obj BlueberryInt
	obj.num = 0
	obj.cond = sync.NewCond(&obj.lock) // 使用结构体中的 lock 作为锁
	return &obj // 返回该结构体的指针
}

func (b *BlueberryInt) IncreaseLocked() {
    // IncreaseLocked 意味着在做加法操作的时候这个函数需要上锁后才能使用
	b.num++
}

func (b *BlueberryInt) DecreaseLocked() {
    // IncreaseLocked 意味着在做减法操作的时候这个函数需要上锁后才能使用
	b.num--
}

func (b *BlueberryInt) Signal() {
    // 当完成一件事情后，我们就发送 Signal
	b.cond.Signal()
}

func (b *BlueberryInt) Wait() {
    // 当我们调用 Wait 的时候，我们还不能马上执行操作
    // 我们需要收到 Signal 后 才可以继续执行
	b.cond.Wait()
}

func (b *BlueberryInt) Lock() {
    // 上锁
	b.lock.Lock()
}

func (b *BlueberryInt) UnLock() {
    // 解锁
	b.lock.Unlock()
}

主要逻辑

我们分别做 1000 次加法和 1000 次减法，但是呢，我们先让做减法的 goroutine 运行起来，并且使用 Sleep 等待 1 秒钟，确保它已经跑起来了；如果我们没有使用 sync.Cond 的话，这时候减法操作拿到锁之后就可以直接完成 1000 次的减法了，但是我们调用了 num.Wait() 来等待信号

为什么我们在做减法的 goroutine 中已经使用了 num.Lock 之后，在做加法的 goroutine 中还能够获得锁呢？这就是因为我们在 NewBlueberryInt 中的这行代码 obj.cond = sync.NewCond(&obj.lock) ，但我们调用 Wait 的时候，它会先释放我们传入的那把锁并且阻塞在那里，然后等待信号的到来，当它收到信号之后重新获取那把锁然后再继续执行操作

func main() {
	// 做了加法才能做减法
	b := NewBlueberryInt()
	fmt.Printf("the num b is %d \n", b.num)

	// 做减法 1000 次
	go func(num *BlueberryInt) {
		num.Lock()
		num.Wait() // 等待信号
		for i := 0; i < 1000; i++ {
			num.DecreaseLocked()
		}
		num.UnLock()
	}(b)

	time.Sleep(time.Second)

	// 做加法 1000 次
	go func(num *BlueberryInt) {
		num.Lock()
		for i := 0; i < 1000; i++ {
			num.IncreaseLocked()
		}
		num.Signal() // 发送信号
		num.UnLock() // 一定要记得释放锁，不然做减法的 goroutine 那里就永远走不动了
	}(b)

	time.Sleep(time.Second)

	b.Lock()
	fmt.Printf("the num b is %d \n", b.num)
	b.UnLock()
}

最后的输出结果就是这样的：

the num b is 0 
the num b is 0

思考的维度和付费意识

这篇文章分享两部分内容

思考的维度
付费意识
分享一篇文章

在前几天我偶然间听了刘润老师的直播，觉得很有趣，我还做了一个笔记，分享一下。

1 思考的维度

0 维思考

从几何的角度来看，0 维是一个点。相信你一定听说过一句话：“掌握一项技能”。比如餐厅的厨师，他们的技术就是烹饪料理，再比如为视频或者文章写文案的小伙伴，他们的技能就是写文案。这都是属于一个点上的能力。0 维思考者是抱着自己的思想不懂得进化的人，就是一直停留在一个点上，想要用一个技术打遍天下。不能动，兵来将挡，水来土掩，就是不会动，一直是自己那一套技能

总结：0 维思考就是战术就是手艺。

1 维思考

1 维思考属于战略层面，在 1 维就是一根直线，有了前和后，前进或者后退。

有了梦想就有了目标，就是 1 维了，我们开始选定一个方向，并且去朝着方向出发。比如要登上一座山，有很多条路可以选择。假设其中一条路是在上午偏向中午的时间有很多很多的人开始登上这条路并且比较好走的一条路，还有另外一条路就是几乎没有什么人去但是登山的过程很复杂，因为路不好走。

如果我们选择第一条路，正面上山就要早起，千军人马，需要勤奋的能力。
如果我们选择第二条路，那么我们就可以多睡一会，北面上山没人，但是要有更强的登山能力。

总结：这两个方式都可以让我们登山，但是不同的选择需要不能的能力，没有最好战略，只有最适合自己的战略。

分享一下在刘润老师的直播里讲到了一个品牌：North Face

North Face 是北面的意思，这是一个户外运动的品牌，North Face 的名字源于山上最冷最难攀登的北坡。

2 维思考

2 维思考是模式并且有了左右，什么模式呢，在商业中就是指 商业模式

北大的魏伟教授定义商业模式 : 利益相关者的交易结构

如何理解呢？那就是：所在行业的玩家供应商广告商巴啦吧啦，他们之间的利益关系交易结构。

举个例子：

在 2 维就像是开车，坐在主驾驶的人负责执行向前还是向后，主驾驶是 CEO 是首席执行官。但是坐在副驾驶的人就更重要了，副驾驶的人手中有一个城市的二维地图，从一个地方到另外一个地方，一条路走不通还可以选择另外一条。副驾驶才是那个知道全局的人，拿着地图的人是“上帝”。去空中看一看，上帝之眼，全局观。

总结：主驾驶是 CEO 负责执行，副驾驶是全局的指挥者，选错了路，奥迪不如奥拓。

在这里我用计算机的知识阐述一下我对选路的理解，在计算机中经常会要求最优解，但是很多问题似乎是没有最优解的，那么这时候，我们可以求一个局部最优解，一般来说也是一个不错的选择。

3 维思考

3 维在几何上来看是一个体，3 维的思考是创新。

再次用驾车的例子：

堵车怎么办？如果你是城市的建设者，你是不是能够通过一些措施来优化这个情况呢？建个立交桥？可以从天上开过去？挖个隧道？可以从地底下开过去？

回到商业的世界：

跨境电商，相当于立交桥，中间商赚差价被跨越了，使得中国和某些国家直接建立了关系。有人说，这打击了实体店？那为什么实体店不能创新呢？

总结：3 维的思考是创新。

其实你有没有发现，我们生活在三维空间中，但是我们更像是生活在二维的世界中。

比如现在的疫情让我们隔离在小区里，简简单单的一个围墙一个栅栏一个门就把我们给挡住了？可是我们生活在三维世界里呀，我们不能从上边跨越吗？如果我们可以自由的在第三个维度上移动，那么现在的一切围墙对我们来说都不再是障碍了。古代的皇宫是围墙，美国的白宫也有围墙。如果有可穿戴的飞行设备，我们就可以在第三个维度自由移动。

4 维思考

4 维的思考是古今，是过去和未来，是在不同的历史时期，面对一件事情做出的决策。

总结：4 维加上了时间的概念，过去和未来。

5 维思考

5 维的思考是概率

这是这几个维度中，我最喜欢的。

为什么说是概率呢？比如我去打篮球，我每一次的投球都是有投中的概率和投不中的概率的。如果我可以有足够的力量控制能力，和非常正确的投球姿势，这能够很大程度上提高我投中的概率，但是我仍然是有投不中的概率。

说点玄幻的，这个世界可能是存在平行宇宙的，当我投中的那一瞬间，这个宇宙就分叉了，其中两个分叉的宇宙就是，我投中了和我没有投中，进而一直分叉下去，如果我属于那个一直投中的宇宙里边的我，那么我现在就是一个篮球巨星了，显然：我不属于那个我一直投中球的宇宙。哈！如果是的话，我现在就不会坐在这里敲键盘了。

接着刚才的说，什么是正确的投球姿势呢？正确的事情就是大概率成功的事情，正确的姿势没有投中的球都比错误的姿势投中要重要。因为存错的姿势让一个人投中，这只是 幸存者偏差。人人都知道，吸烟喝酒有害健康，为什么还有人说：你看！谁谁谁抽烟喝酒现在也长命百岁的，但是，我瞧瞧告诉你，可能 100 个有不良嗜好的人 99 个人都不太好了，只有一个幸存者让你看到了，因为只有活着的人才能说话，才能让你看到。

总结：正确的事情就是大概率成功的事情，正确的事情重复做，这能让我们大概率的成功，但不是绝对能成功。

这个世界不存在绝对能够成功的方法，这边这两句话，我以前非常的讨厌，现在，我对它们的想法变了。

谋事在人，成事在天 Man disposes God disposes
尽人事，听天命

Man disposes God disposes:

尽我们的所能，剩下的交给上帝交给运气来裁定。

最后分享一段话：

我们总是喜欢拿“顺其自然”来敷衍人生路上的荆棘坎坷，却很少承认，真正的顺其自然，其实是竭尽所能之后的不强求，而非两手一摊的不作为。

Instead of admitting that the truth of "let it be" is to readily accept any kind of outcome after making full efforts rather than to do nothing at the very beginning,we'd rather take "let it be" as an excuse to evade the path of thorns in our life.

2 付费意识

刚才我在浏览知识星球的时候，看到我关注的一个博主的球友问他，你现在做的社群都这么大了，而且知识星球这个平台扣除的付费手续费还不少，在 IOS 系统上扣除的更多，你为什么就没有想着自己去做一个软件来用呢？

博主：做一个软件，不仅需要开发的成本，还需要后期维护的成本，而且做一个社群本身就已经很不容易了。

总结：专业的事情交给专业的人来做，付费就是在买时间

如果你想使用盗版，可能为了省一点钱，你要花费一个上午来寻找盗版资源，可是你最后还可能找不到，而且你使用到的工具一定不仅只有这一个，在长期来看，这会浪费巨大的经历，让自己的主业甚至完成的很糟糕。最后得不偿失。

分享一篇文章

刘润：你们不懂罗永浩

不确定性才是常态；我希望你无限可能

今天我在朋友圈发了一条消息；我的一个朋友看到了这条消息后，就突然来找到聊天，我觉得这段聊天内容很有趣，分享给大家。

1、我的朋友圈内容

里面三张图的内容分别是：

2、聊天内容

小伙伴：在某种程度上，他还是很让人佩服的，只是他看不起大多数人。人都是这样，看来他也是凡人，欲望满身。

蓝莓：或许做个普通人 ~ 然后才能放开枷锁，又不曾说过自己道德高尚，不曾说过自己是个圣人 ~ 没什么不好的，哈哈哈，而且，本来也就是个普通人。

小伙伴：对 ~ 他和秦始皇死前在寻找长生不老药是一种目的。只是借助了高新科技更科学了。

蓝莓：我不清楚他是不是想一直活着。我记得乔布斯说过没有哪个人想要死去 ~ 不过我记得他说他想在生命结束前做什么事儿来着，是不是真的我也就不清楚了。不过从现在来看，人确实最终还是不能一直活着，那就尽可能尝试你想做的一切：）

小伙伴：脑机接口应该是可行，也给自己留好了退路

蓝莓：那就拭目以待叭 ~

小伙伴：如果不成就葬在火星，真苦啊

蓝莓：真不错 ~ 那就争取每个人都去追求 “酷”

小伙伴：你有没有觉得科学技术和艺术魔术的术字是一种解释；其实就像变戏法～作品还是人的信仰。有了戏剧性就很酷；抖音作品也是不管搞笑的还是技术的就是反差感

蓝莓：这不太清楚了，我语文能力不怎么样，不过参考一下三体里面的想法，火鸡科学家 ~ 其实我觉得关于抖音作品这一点更应该去研究自媒体运营相关的内容。或许：自己的顿悟，只是别人的基本功。（或许这只是专业自媒体运营人的基本功）

番外什么是火鸡科学家呢？这是一个农场主的故事，有一家农场，这个农场里面有一群火鸡，这些火鸡被关在一个密闭的看不到外面世界的棚子里面。每天按时按点，农场主都会去给这些火鸡喂食。然后有一个“聪明”的火鸡就发现了，嗷！原来每天的一个特定时间都会有食物从天而降，因此这个“聪明”的火鸡就宣布我发现了世界运转的规律，因此这个火鸡也就是火鸡科学家。事实上很多东西都只是我们发现的规律，例如万有引力（有质量的物体会彼此吸引，因此我们和地球会彼此吸引）。有一天！他们到了这个时间点怎么等也等不来食物，结果这些火鸡都被 kill 掉了。

小伙伴：做个不被定义的人吧 ~ 毕竟人生这么短，我也不是马斯克

蓝莓：马斯克已经在那里了，没有人说过只有马斯克才能发射火箭，只不过恰好他发射了，你或许能发射飞船：）

小伙伴：哈哈哈哈哈哈哈我只是callback人生很短不像马斯克可以试图长生不老 [玫瑰][玫瑰]

蓝莓：世界也不是线性发展的，人总是习惯性的用线性的方式推演未来，你未来或许无限可能 ~ 你或许能长生不老 ~ 哈哈哈 ~ 未来总是充满了不确定性 ~

小伙伴：3q[玫瑰][玫瑰]

蓝莓：哈哈哈，行 ~ 那快去做好准备，迎接不确定性 ~

=====================

不是鼓励大家反人性，而只是，不必道德绑架自己（又不是圣人，只是普通人）

希望你的未来无限可能，如果......如果说......你真的有你想去做的事情，那就屏蔽掉一些声音，专心去做叭。如果说，你还没有，或者还在寻找，又或者想法还没那么清晰。那就去慢慢寻找，那就一步一步推进下去，我相信想法会越来越清晰的。很多事情，或许只是想，是想不出来的，只有去做的时候，思路才逐渐变得明朗起来，加油！

就像扎克伯格曾经在一次演讲中说到：

但我想告诉你一个秘密：没有人从一开始就知道如何做，想法最开始，并不完全成型，只有当你不断推进时，它才变得逐渐清晰，你需要开始努力。

搭建一个全自动发布的超牛博客

前几天在公众号看到了鱼皮发的一篇文章，讲了他的文档博客是如何搭建的，建议看本文之前可以先看看他的文章，鱼皮文章的传送门：

https://mp.weixin.qq.com/s/xti5QUoh6UOuCs81uNfJHA

本着好奇的心，我就去折腾了一番，最后我发现，虽然已经很简化了！但还是太麻烦了，毕竟我是真的懒，我更希望，我在本地写好内容之后，我根本不需要去我的博客手动添加一篇文章就能让它自己显示出来。

为了，我做了一套自动化工具来完成这件事情，那么这篇文章就是在鱼皮给出的方法的基础上添加了一些自动化工具，实现博客的全自动发布。

1、蓝莓的博客已经上线了

我早在几个月前就已经使用 Typecho 做了一个博客，但总是感觉不太好用，没办法将所有的内容做成的更有体系化。文档类型的博客让我觉得是一个非常好的选择，所以最后采用了 vuepress 重新改造了蓝莓的小站。

传送门:https://blueberry-universe.cn

购买域名
完成 ICP 备案
完成公安备案
使用 vuepress 生成博客的静态文件
采用 Nginx 对静态文件进行托管

在我部署的过程中，是采用了 Nginx 进行静态文件托管的，当然，你也可以采取别的方法。

2、获取博客的模板

可以直接访问我的 github 代码仓，获取这套模板

https://github.com/teenager-lijh/cocoalgo/tree/template

直接下载 cocoalgo 代码仓的 template 分支即可

接下来，你就直接把这个代码上传到你要部署的服务器上就可以了，在这里我使用虚拟机进行演示，我的虚拟机本地 ip 为 10.211.55.100

上传代码到虚拟机后，我们来看看 cocoalgo 里面都有什么

所有的配置文件都在红色箭头所指向的 .vuepress 文件夹中
蓝色框框所框出来的是我博客中的主题，目前我的在线博客中共有 6 个主题
绿色箭头所指向的四个文件，是我做的 4 个自动化的处理工具

来看看绿色箭头所指向的 4 个自动化处理工具都是做什么的

fix_markdown.py : 由于我是用的 markdown 编辑工具是 typora，每次当我粘贴图片到 markdown 的时候，我会让它自动为我创建一个 assets 资源文件夹，然后它采用的相对路径是例如 assets/images.jpg 这样的形式，但是 vuepress 很不巧的不识别这种相对路径，如果改成 ./assets/images.jpg 的形式就能够被 vuepress 识别并且正确渲染，所以我做了一个 fix_markdown.py 工具递归的对所有的 markdown 文件进行修改
resize_image_files.py : 这个工具是用来对图像进行缩放的，由于我的云服务器带宽特别小，而我的图片都太大啦，加载速度太慢。这个工具会对 .vuepress/dist 这个文件夹中所有的图像文件进行缩放并重新保存，缩放后的图像大小会保证在 400KB 以内
generate_config.py : 这个文件是全自动化的核心秘密，看过鱼皮的视频之后，你应该会知道，每次我们发布一篇文章之后都要在 .vuepress 中对相应的配置文件进行修改，但是现在，全都不用了！在 cocoalgo 文件夹中还有一个文件叫做 config.list 。这里面存储了当前的博客有几个主题，以及这几个主题在 cocolgo 目录中的位置。这个文件的内容我放在了下面，你可以看看。每一行都由三个元素构成，每个元素之间使用空格隔开，第一个元素表示了你的一个主题所存储的文章相对于 cocoalgo 的位置，由于我都是直接放在了 cocoalgo 目录中，所以第一个直接就写目录的名称即可，第二项内容你应该很眼熟，这个是每个主题中想要展示出来的文章要进行配置的配置文件，现在你不需要进行配置了，你只需要给出这个配置文件的名称即可（名字可以随意写，但是一定要以 .ts 结尾），第三项内容直接和第一项内容保持一致即可（这里设置的是配置文件中 title 对应的配置项，你可以根据需求进行修改，或者直接和第一项保持一致）

# config.list 文件
蓝莓随便扯 ideaSideBar.ts 蓝莓随便扯
操作系统 osSideBar.ts 操作系统
计算机网络 cnSideBar.ts 计算机网络
力扣刷题 lcSideBar.ts 力扣刷题
分布式系统 dsSideBar.ts 分布式系统
Pythoner pythonerSideBar.ts Pythoner

最后就是 deploy.sh 这个工具了，deploy.sh 需要传递一个参数，这个参数是一个字符串，你需要告诉它，cocoalgo 本地代码仓所在的位置是哪里，然后 deploy.sh 会自动进入到该代码仓并且去拉取远程端的 main 分支到本地，如果发现远程端的 main 分支比本地更新了，那么 deploy.sh 会清除本地代码仓所有没有用的东西并恢复到最近的一条提交记录上，拉取远程端的内容覆盖本地。接着，deploy.sh 会调用 npm docs:build 命令生成静态文件到 .vuepress 目录中的 dist 目录中。

接着，我们什么都不需要做了，如果我们使用了 Nginx 来对静态文件进行代理，那么，我们只需要让 Nginx 代理的静态文件目录始终指向 cocoalgo/.vuepress/dist 目录即可

最重要的一点

我相信你的主题肯定不会天天变吧，你只需要配置一下 config.list 文件就可以了。

只要我们在本地提交了代码到远程端，服务器上开一个定时任务，定时的执行 deploy.sh 就可以了，这样就可以实现定时自动检查并且发布的功能了。

3、动手安装吧

这里演示的 cocoalgo 是我自己的仓库，你需要下载我的代码，并且自己新建一个代码仓到 main 分支中，然后把我这里面除了 cocoalgo/.git 目录的内容外，全部拷贝过去，然后进行实验

安装所依赖的工具，在这里你要和我的 node 以及 npm 的版本保持一致，这两项的安装很简单，我就不详细说了

blueberry@ubuntu:~/Lib/cocoalgo$ node -v
v16.20.2
blueberry@ubuntu:~/Lib/cocoalgo$ npm -v
8.19.4

安装依赖包

在这里下载的过程中可能很慢，你可以尝试使用国内的源进行安装，速度会快得多

# 进入到 cocoalgo 执行如下命令
npm i

安装 Nginx 并配置

我这里使用的 Nginx 的版本是 1.26.2

首先去官网下载 Nginx 到服务器上，然后对它解压，解压之后我们可以看到这些内容

blueberry@ubuntu:~/Downloads/nginx-1.26.2$ ls -ltr
total 780
-rw-r--r-- 1 blueberry blueberry     49 Aug 13  2019 README
-rw-r--r-- 1 blueberry blueberry   1397 Aug 13  2019 LICENSE
-rwxr-xr-x 1 blueberry blueberry   2502 Aug 13  2019 configure
-rw-r--r-- 1 blueberry blueberry 452171 Aug 13  2019 CHANGES.ru
-rw-r--r-- 1 blueberry blueberry 296463 Aug 13  2019 CHANGES
drwxr-xr-x 2 blueberry blueberry   4096 Sep 28 08:25 man
drwxr-xr-x 2 blueberry blueberry   4096 Sep 28 08:25 html
drwxr-xr-x 9 blueberry blueberry   4096 Sep 28 08:25 src
drwxr-xr-x 4 blueberry blueberry   4096 Sep 28 08:25 contrib
drwxr-xr-x 2 blueberry blueberry   4096 Sep 28 08:25 conf
drwxr-xr-x 6 blueberry blueberry   4096 Sep 28 08:25 auto
drwxrwxr-x 3 blueberry blueberry   4096 Sep 30 10:36 objs
-rw-rw-r-- 1 blueberry blueberry    355 Sep 30 10:36 Makefile

生成 Makefile

blueberry@ubuntu:~/Downloads/nginx-1.26.2$ ./configure --prefix=/usr/local/nginx --pid-path=/var/run/nginx/nginx.pid --lock-path=/var/lock/nginx.lock --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --with-http_gzip_static_module --http-client-body-temp-path=/var/temp/nginx/proxy --http-fastcgi-temp-path=/var/temp/nginx/fastcgi --http-uwsgi-temp-path=/var/temp/nginx/uwsgi --http-scgi-temp-path=/var/temp/nginx/scgi --with-http_ssl_module --with-http_image_filter_module

编译并安装

blueberry@ubuntu:~/Downloads/nginx-1.26.2$ make
blueberry@ubuntu:~/Downloads/nginx-1.26.2$ make install

完成上述命令之后，我们就完成了 Nginx 的安装，根据 ./configure 中的配置，我们可以知道 Nginx 被安装到了 /usr/local/nginx 这个位置。

修改 Nginx 的配置文件

我们进入到 /usr/local/nginx/conf 并编辑 nginx.conf 文件（配置文件中的 user 这个后面写你的 cocoalgo 所在用户目录的用户名，这个很重要，不然会出现一些权限问题）

如果你不配置 https 的话配置文件这么写


user  blueberry;
worker_processes  2;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    gzip  on;

    # 小于 1B 的文件不会压缩
    gzip_min_length 1;

    # 压缩比 可以设置 1-9
    # 数值越大 压缩级别越大 占用的 CPU 越多
    gzip_comp_level 3;

    # 压缩文件的类型
    gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png application/json;

    server {
        listen       80;
        # 这里写你的博客的域名 没有域名就写虚拟机的 ip
        server_name  blueberry-universe.cn;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   /root/Library/cocoalgo/.vuepress/dist;
            index  index.html index.htm;
	}

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

如果你配置 https 的话，配置文件这样写

user  blueberry;
worker_processes  2;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    gzip  on;

    # 小于 1B 的文件不会压缩
    gzip_min_length 1;

    # 压缩比 可以设置 1-9
    # 数值越大 压缩级别越大 占用的 CPU 越多
    gzip_comp_level 3;

    # 压缩文件的类型
    gzip_types text/plain application/javascript application/x-javascript text/css application/xml text/javascript application/x-httpd-php image/jpeg image/gif image/png application/json;

    server {
        listen       80;
        # 这里写你的博客的域名 没有域名就写虚拟机的 ip
        server_name  blueberry-universe.cn;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
        	# 在这里配置你的 dist 文件夹的路径
            root   /home/blueberry/Lib/cocoalgo/.vuepress/dist;
            index  index.html index.htm;
	}

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }

    server {
        listen 443 ssl;
        server_name blueberry-universe.cn; 

        # 配置 ssl 证书
        ssl_certificate	/usr/local/nginx/conf/blueberry-universe/blueberry-universe.cn_bundle.crt;
        # 配置证书秘钥
        ssl_certificate_key	/usr/local/nginx/conf/blueberry-universe/blueberry-universe.cn.key;
        # ssl 会话 cache
        ssl_session_cache	shared:SSL:1m;
        # ssl 会话超时时间
        ssl_session_timeout	5m;

        # 配置加密套件 写法遵循 openssl 标准
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_ciphers HIGH:!aNULL:!MD5:!RC4:!DHE;
	ssl_prefer_server_ciphers on;

        location / {
            proxy_pass http://blueberry-universe.cn;
        }
    }
}

4、让它跑起来

在 github 建你自己的仓库这些，就你自己来完成好啦，记得在你的服务器上配置上 github 代码仓的 ssh 对应的私钥，这样才能让 deploy.sh 有权限去拉取远程端的代码的。

配置定时任务

使用 crontab 配置定时任务，让 deploy.sh 每分钟执行一次，来看看远程端的代码是不是更新了，当然啦，你可以把执行的频率设置的更长一些

crontab -l 查看当前都有哪些定时任务

blueberry@ubuntu:~/Downloads/nginx-1.26.2$ crontab -l
*/1 * * * * /home/blueberry/Lib/cocoalgo/deploy/deploy.sh /home/blueberry/Lib/cocoalgo >> /home/blueberry/Lib/update.log 2>&1

这是我已经添加的定时任务，你可以使用 crontab -e 命令编辑这个定时任务的列表，然后把你的定时任务添加进去就可以了，添加的过程和使用 vim 操作文件是一样的，添加完成后使用 :wq 保存并退出即可

在定时任务重你可以看到 deploy.sh 后面传入的参数 /home/blueberry/Lib/cocoalgo 就是服务器上的本地代码仓的所在位置，我们需要把这个东西告诉 deploy.sh 才可以，在这里我把 deploy.sh 每次运行后输出的日志保存在了 ~/Lib 目录中的 update.log 文件中

启动 Nginx

只需要这样，Nginx 就会默认使用 nginx.conf 启动啦！

blueberry@ubuntu:/usr/local/nginx/sbin$ pwd
/usr/local/nginx/sbin
blueberry@ubuntu:/usr/local/nginx/sbin$ ls
nginx
blueberry@ubuntu:/usr/local/nginx/sbin$ ./nginx

注意事项

当然啦，在第一次启动的时候，你可以先在 cocoalgo 目录下先手动的运行 npm run docs:build 命令生成一次配置文件，后续，每次远程端有新的文章上去之后，让它自己去拉取并且更新即可

彻底搞懂虚拟网络搭建

你好啊，我是蓝莓，最近在研究和计算机网络的内容，就和大家分享一下

用过 docker 的小伙伴应该能领会到 docker 在部署一些应用时真的是十分方便啊，那么我们的侧重点在于 docker 在宿主机是如何访问外网的，这里所指的外网是指宿主机外部的网络。本文中所介绍的虚拟网络搭建方式与 docker 所应用的是非常相似的，但是本文并不涉及任何和 docker 相关的内容。

目标：

使用 QEMU 创建虚拟机
创建虚拟网桥，为虚拟网桥配置 ip
为虚拟机创建虚拟网卡并配置 ip
为虚拟机配置路由表
使用Linux做数据转发
使用 iptables 为宿主机提供 NAT 功能
配置 DNS 服务器

1 QEMU 创建虚拟机

我的宿主机是一台真实的物理机器，安装了 22.04.1-Ubuntu 系统

安装 QEMU 的方法也是很简单的，在这里就不详细说明了，可以直接搜索 ubuntu 安装 QEMU 会有非常多的安装教程可供参考。

下载系统镜像

虽然我的物理机器是 22.04.1-Ubuntu ，但是我在创建虚拟机的时候采用了ubuntu-18.04.6-live-server-amd64.iso

镜像下载地址：https://releases.ubuntu.com/18.04.6/ubuntu-18.04.6-live-server-amd64.iso

下载好系统镜像后，我将该镜像放在如下位置

 /home/blueberry/Downloads/ubuntu-18.04.6-live-server-amd64.iso

创建虚拟磁盘

在这篇文章中一共需要使用 QEMU 创建两台虚拟机 ubuntu 和 ubuntu2，为此，也应该创建两个虚拟磁盘供它使用。先回到家目录，然后创建一个文件夹 qemu 用来存放稍后要创建的虚拟磁盘，随后我们分别创建两个大小为 40G 的虚拟磁盘 ubuntu.img 和 ubuntu2.img

cd ~
mkdir qemu
qemu-img create -f qcow2 ubuntu.img 40G
qemu-img create -f qcow2 ubuntu2.img 40G

安装虚拟机 ubuntu

接下来我们就分别安装两台虚拟机

安装 ubuntu 虚拟机，简单介绍下几个参数：

-name: 指定虚拟机的名字
-m: 指定虚拟机的 RAM 内存大小为 2048M
-hda: 指定虚拟机所使用的虚拟磁盘所在路径
-cdrom: 指定该虚拟机所使用的镜像所在路径
-boot: 虚拟机启动方式，这里选择 d 则是从 cdrom 这里启动
-vnc: 打开一个 vnc 服务，供我们安装虚拟机使用，这里的 19 代表的是 5919 端口，默认是从 5900 端口开始使用的

其他的参数就照着写就好了

qemu-system-x86_64 \
        -enable-kvm \
        -name ubuntu \
        -m 2048 \
        -hda /home/blueberry/qemu/ubuntu.img \
        -cdrom /home/blueberry/Downloads/ubuntu-18.04.6-live-server-amd64.iso \
        -boot d \
        -vnc :19 \
        -cpu host

接下来，你还需要一个 vnc 客户端作为你的虚拟机屏幕，可以直接使用 vnc viewer 作为客户端，官网传送门：

https://www.realvnc.com/en/connect/download/viewer/

使用 vnc 连接虚拟机

打开 vnc viewer 后，直接在地址栏输入宿主机的 ip 地址以及 vnc 服务对应的端口号之后连接即可

打开后，你只需要按照正常的操作系统安装流程进程安装就可以了

安装虚拟机 ubuntu2

好啦，安装 ubuntu2 的过程是一样的，那你只需要适当的调整参数之后，进行安装就可以了

2 创建虚拟网桥

接下来，我们在宿主机创建一个网桥 br0 并且为该网桥分配 ip 地址

我们先来查看一下宿主机中当前的网络接口情况，可以发现，我的物理网卡对应的名称是 enp2s0

➜  ~ ifconfig
enp2s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.184  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::8a4:75b8:a07:2a83  prefixlen 64  scopeid 0x20<link>
        ether 94:c6:91:61:10:ec  txqueuelen 1000  (Ethernet)
        RX packets 354  bytes 79267 (79.2 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 202  bytes 35860 (35.8 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 154  bytes 14234 (14.2 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 154  bytes 14234 (14.2 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

创建网桥 br0

➜  ~ sudo brctl addbr br0

创建两个网桥上的接口

使用命令 tunctl -b 创建 tap device，默认的名字分别为 tap0 和 tap1，我目前理解的是，我们创建 tap device 然后再把这个东西给绑在网桥 br0 上就好像是让这个网桥拥有了两个插口，这样，我们可以在这个网桥上插两台计算机设备，这个理解可能有点牵强，欢迎大佬进行指正

➜  ~ sudo tunctl -b
tap0
➜  ~ sudo tunctl -b
tap1

查看当前的网络接口

我们可以通过 ip link show 来查看网络接口，然而使用 ifconfig 是没办法看到没有启动的网络接口的

➜  ~ ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: enp2s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether 94:c6:91:61:10:ec brd ff:ff:ff:ff:ff:ff
3: virbr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN mode DEFAULT group default qlen 1000
    link/ether 52:54:00:10:65:68 brd ff:ff:ff:ff:ff:ff
4: br0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether e2:eb:19:ae:67:37 brd ff:ff:ff:ff:ff:ff
5: tap0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 2a:34:1e:9f:42:d2 brd ff:ff:ff:ff:ff:ff
6: tap1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether d6:cd:ae:4c:b2:b8 brd ff:ff:ff:ff:ff:ff

绑定 tap device 到 br0

通过下面的方法进行绑定

addif 代表的是 add interface，添加接口

➜  ~ sudo brctl addif br0 tap0
➜  ~ sudo brctl addif br0 tap1

另外的你也可以通过 ip 命令中所提供的工具完成这个操作，这两种操作达到的效果都是一样的，这里的 link 代表的是 link layer 链路层

➜  ~ sudo ip link set tap0 master br0
➜  ~ sudo ip link set tap1 master br0

以上两种方式你选择其中一种就可以了

查看网桥的接口情况

这时候我们就可以看到 tap0 和 tap1 已经成功捆绑在 br0 网桥上了

➜  ~ brctl show
bridge name	bridge id		    STP enabled    interfaces
br0		8000.e2eb19ae6737	    no		       tap0
							                   tap1
virbr0		8000.525400106568	yes

启动网络接口

我们分别启动刚才创建的三个虚拟设备，然后再使用 ifconfig 查看网络接口的情况，这时候我们查看到刚才创建好的网络设备全部都启动了

➜  ~ sudo ip link set br0 up
➜  ~ sudo ip link set tap0 up
➜  ~ sudo ip link set tap1 up
➜  ~ ifconfig
br0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether e2:eb:19:ae:67:37  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

enp2s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.184  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::8a4:75b8:a07:2a83  prefixlen 64  scopeid 0x20<link>
        ether 94:c6:91:61:10:ec  txqueuelen 1000  (Ethernet)
        RX packets 3059  bytes 429509 (429.5 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 1050  bytes 136524 (136.5 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 213  bytes 19837 (19.8 KB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 213  bytes 19837 (19.8 KB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

tap0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether 2a:34:1e:9f:42:d2  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

tap1: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether d6:cd:ae:4c:b2:b8  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

为网桥 br0 配置 ip

在这里将 br0 的 ip 设置为 192.168.166.1 且其中的 24 就是代表设置子网掩码为 255.255.255.0

➜  ~ sudo ifconfig br0 192.168.166.1/24 
➜  ~ ifconfig
br0: flags=4099  mtu 1500
        inet 192.168.166.1  netmask 255.255.255.0  broadcast 192.168.166.255
        ether e2:eb:19:ae:67:37  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

3 为虚拟机创建虚拟网卡并配置 ip

刚才我们已经安装完成了虚拟机，那么再次启动的时候，你就不需要再挂在那个系统的镜像文件了，我们启动虚拟机的时候使用如下的命令进行启动

启动 ubuntu

之前没讲过的两行参数代表的是，我们要为这台虚拟机虚拟出来一张网卡，并且指定该虚拟网卡的 mac 地址为 52:54:00:12:34:10，另外我们要将该网卡插在 br0 网桥的 tap0 这个接口上

sudo qemu-system-x86_64 \
        -enable-kvm \
        -name ubuntu \
        -m 2048 \
        -hda /home/blueberry/qemu/ubuntu.img \
        -vnc :19 -cpu host \
        -net nic,macaddr=52:54:00:12:34:10,model=virtio \
        -net tap,ifname=tap0,script=no,downscript=no

启动 ubuntu2

类似的，我们通过如下命令启动 ubuntu2 虚拟机

sudo qemu-system-x86_64 \
        -enable-kvm \
        -name ubuntu \
        -m 2048 \
        -hda /home/blueberry/qemu/ubuntu2.img \
        -vnc :29 \
        -cpu host \
        -net nic,macaddr=52:54:00:12:34:20,model=virtio \
        -net tap,ifname=tap1,script=no,downscript=no

当我们启动了这两台虚拟机之后，我们就可以使用 vnc 客户端分别对两台虚拟机进行连接了

为 ubuntu 的网卡配置 ip

在为虚拟机的网卡配置 ip 的时候，一定要注意，该网卡的 ip 需要和我们的网桥所配置的 ip 处于同一个网段内

先试用 ifconfig 查看到这台虚拟机的网卡的名称是 ens3，然后为该网卡设置一个 ip: 192.169.166.100

sudo ifconfig ens3 192.169.166.100

这时候，我们使用 ping 命令来看一下能不能在虚拟机内部与网桥 br0 进行通信

ping 192.168.166.1

为 ubuntu2 的网卡配置 ip

类似的，我们再为 ubuntu2 的网卡配置 ip，经过检查后，说明该虚拟机 ubuntu2 也是可以与网桥 br0 进行通信的

到此位置，位于同一个网桥上的虚拟机已经可以相互通信了，我在 ubuntu2 虚拟机上 ping ubuntu 虚拟机，结果如下：

4 为虚拟机配置路由表

为什么还要为虚拟机配置路由表呢？现在两台虚拟机不是已经能通信了吗？先来看一下我所处的网络结构：

尽管两台虚拟机已经可以正常通信了，但是我们现在可以尝试 ping 一下宿主机的 ip 以及与宿主机在同一个网段上的其他的机器

在 ubuntu 虚拟机上进行尝试，我们可以发现 192.168.1.191 是不可达的。我们从网络结构的拓扑图中可以看出虚拟网桥和外部的网络根本就是断开的嘛。这怎么可能让他们相互通信呢，这只是其中一个原因。另外一个原因是，路由表还需要进行配。

查看路由表

通过如下命令查看路由表：

route -n

我们可以发现，路由表里面只有网段为 192.168.166/24 的路由规则，而网段为 192.168.1.0/24 的路由规则根本就不存在嘛，那我们不如直接配置一个默认的路由，其他的所有 ip 的寻址都通过虚拟机的网卡 ens3 将数据发出并且是发送到网桥那里，网桥的 ip 为 192.168.166.1

添加默认路由

通过如下命令，我们添加一条默认路由到虚拟机 ubuntu 的路由表中

sudo route add default gw 192.168.166.1

这时候我们再次使用 ping 命令进行测试，与上次不同的是，这次并没有直接显示网络不可达而是在等待网络返回响应，由于网桥那边和外界的网络是断开的，所以仅仅是添加了路由还不够

ping 192.168.1.191

5 使用 Linux 做数据转发

对于 linux 系统而言，它是能够收到虚拟网桥 br0 的数据包的，因此，我们可以通过 linux 操作系统作为桥梁，将 br0 网桥的数据包转发到宿主机的网卡 enp2s0 上，这样一来，我们就可以将虚拟机内部的数据包真实的发送出去了

我们通过下面两个命令来打开 linux 的这个功能

➜  ~ sudo sysctl net.ipv4.conf.all.forwarding=1
net.ipv4.conf.all.forwarding = 1
➜  ~ sudo iptables -P FORWARD ACCEPT

好啦，现在我们是把网桥 br0 上的数据原封不动的直接通过宿主机的网卡转发出去，但是别忘了，我们的数据包中的源地址相对于宿主机所处的网络环境可是一个内网地址，所以我们还需要使用 NAT 技术做一个源地址转换，好在 iptables 已经提供了非常好用的功能为我们所用

6 使用 iptables 为宿主机提供 NAT 功能

先看看宿主机的 iptables 中已经配置的规则

➜  ~ sudo iptables -t nat -L --line-numbers
Chain PREROUTING (policy ACCEPT)
num  target     prot opt source               destination         

Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination         

Chain POSTROUTING (policy ACCEPT)
num  target     prot opt source               destination

可以看到我这里都是空的，所以我可以放心的去添加一条规则来做 NAT 了

➜  ~ sudo iptables -t nat -A POSTROUTING -s 192.168.166.0/24 ! -o br0 -j MASQUERADE
➜  ~ sudo iptables -t nat -L --line-numbers
Chain PREROUTING (policy ACCEPT)
num  target     prot opt source               destination         

Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination         

Chain POSTROUTING (policy ACCEPT)
num  target     prot opt source               destination         
1    MASQUERADE  all  --  192.168.166.0/24     anywhere

那么刚才我们用到的这条命令，大致意思就是说：把 linux 收到的属于 192.168.166.0/24 这个网段的数据包全都使用源地址转换的方式交给宿主机的物理网卡转发出去

sudo iptables -t nat -A POSTROUTING -s 192.168.166.0/24 ! -o br0 -j MASQUERADE

来让我们看看，现在我们的虚拟机与外部的网络环境是否打通了，我在虚拟机 ubuntu 上尝试了一下，真是太棒了，已经能够和我的计算机进行通信了！

7 配置 DNS 服务器

好啦，截止目前为止，只要我们的宿主机的网络是可以连接互联网的，那么虚拟机也是同样可以连同互联网的，不过我们尝试 ping www.baidu.com 会发现不行，那是因为我们还没有配置域名服务器，让我们配置一下

我们只需要编辑这个文件就可以了，但是这种方式只能是临时配置，重启之后就没有咯

sudo vim /etc/resolv.conf

再让我们试一下！哇塞，这次可以了！！！

酷酷的算法

蓝莓程序岛

本站内容

优秀博客推荐

优秀图书推荐

1、操作系统

2、Java

3、数据库

4、Kafka

5、Spring

6、操作系统

分布式系统学习之路

一起刷力扣

基础

1、数组

入门

三路快排

对撞指针

滑动窗口

更多练习

2、查找表

set && map 入门

set && map 练习

查找表问题

键值选择

滑动窗口 + 查找表

二分搜索树的顺序性

3、链表

入门

虚拟头结点的使用

双指针

4、栈，队列，优先队列

栈

队列

广度优先搜索

优先队列

5、二叉树

基础

递归终止条件

递归问题的定义

二分搜索树

6、递归和回溯

基础

排列

组合

二维平面的回溯

floodfill

练习

7、动态规划

基础

重叠子问题

状态定义和状态转移

背包问题

最长上升子序列 LIS（Longest Increasing Subsequence）

最长公共子序列 LCS （Lonogest Common Sequence）

8、贪心算法

待分类

操作系统学习之路

优雅的编程语言 Python

蓝莓的胡思乱想

计算机网络学习之路

图解分布式共识算法 Raft（领导者选举）

1 Raft

2 Leader Election

三种状态

记录状态使用的字段

3 RPC

RequestVote

AppendEntries

002-N-Queens

1 问题描述：

2 解题思路

3 代码实现 C++

003-Minimum-Depth-of-Binary-Tree

1 题目描述

2 层次遍历代码实现思路

3 代码实现 C++

0752-Open-The-Lock

1 题目描述

2 解题思路