talk is cheap show me the code

lc206：链表反转：给你单链表的头节点 head ࿰c;请你反转链表࿰c;并返回反转后的链表。

<code class="prism language-cpp">class="token keyword">class class="token class-name">Solution class="token punctuation">{
class="token keyword">publicclass="token operator">:
    ListNodeclass="token operator">* class="token function">reverseListclass="token punctuation">(ListNodeclass="token operator">* headclass="token punctuation">) class="token punctuation">{
    class="token keyword">ifclass="token punctuation">(headclass="token operator">==class="token keyword">nullptrclass="token operator">||class="token operator">!headclass="token operator">->nextclass="token punctuation">)class="token keyword">return headclass="token punctuation">;
    class="token keyword">auto node1class="token operator">=headclass="token punctuation">;
    class="token keyword">auto node2class="token operator">=headclass="token operator">->nextclass="token punctuation">;
    node2class="token operator">=class="token function">reverseListclass="token punctuation">(node2class="token punctuation">)class="token punctuation">;
    node1class="token operator">->nextclass="token operator">->nextclass="token operator">=node1class="token punctuation">;
    node1class="token operator">->nextclass="token operator">=class="token keyword">nullptrclass="token punctuation">;
    class="token keyword">return node2class="token punctuation">;
    class="token punctuation">}
class="token punctuation">}class="token punctuation">;
code>

lc70爬楼梯进阶࿰c;爬楼梯高级进阶：一次可以跳1-n阶台阶

爬楼梯原版：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

原版：

<code class="prism language-cpp">class="token keyword">class class="token class-name">Solution class="token punctuation">{
class="token keyword">publicclass="token operator">:
    class="token keyword">int class="token function">climbStairsclass="token punctuation">(class="token keyword">int nclass="token punctuation">) class="token punctuation">{
        vectorclass="token operator"><class="token keyword">intclass="token operator">>class="token function">dpclass="token punctuation">(nclass="token operator">+class="token number">1class="token punctuation">)class="token punctuation">;
        class="token comment">//dp[0]=0;
         class="token keyword">if class="token punctuation">(n class="token operator"><= class="token number">1class="token punctuation">) class="token keyword">return nclass="token punctuation">;
        dpclass="token punctuation">[class="token number">1class="token punctuation">]class="token operator">=class="token number">1class="token punctuation">;
        dpclass="token punctuation">[class="token number">2class="token punctuation">]class="token operator">=class="token number">2class="token punctuation">;
        class="token keyword">forclass="token punctuation">(class="token keyword">int iclass="token operator">=class="token number">3class="token punctuation">;iclass="token operator"><=nclass="token punctuation">;iclass="token operator">++class="token punctuation">)class="token punctuation">{
            dpclass="token punctuation">[iclass="token punctuation">] class="token operator">= dpclass="token punctuation">[i class="token operator">- class="token number">1class="token punctuation">] class="token operator">+ dpclass="token punctuation">[i class="token operator">- class="token number">2class="token punctuation">]class="token punctuation">;
        class="token punctuation">}
        class="token keyword">return dpclass="token punctuation">[nclass="token punctuation">]class="token punctuation">;
    class="token punctuation">}
class="token punctuation">}class="token punctuation">;
code>

扩展：（ACM)

<code class="prism language-cpp">class="token macro property">class="token directive-hash">#class="token directive keyword">include class="token string"><iostream>
class="token keyword">using class="token keyword">namespace stdclass="token punctuation">;

class="token comment">// 爬楼梯问题的函数࿰c;输入 n 表示楼梯的阶数࿰c;返回方法数
class="token keyword">int class="token function">climbStairsclass="token punctuation">(class="token keyword">int nclass="token punctuation">) class="token punctuation">{
    class="token comment">// 如果楼梯阶数小于等于2࿰c;直接返回 n࿰c;因为方法数就是 n
    class="token keyword">if class="token punctuation">(n class="token operator"><= class="token number">2class="token punctuation">) class="token punctuation">{
        class="token keyword">return nclass="token punctuation">;
    class="token punctuation">}

    class="token comment">// 初始化第1阶和第2阶的爬楼梯方法数
    class="token keyword">int dp1 class="token operator">= class="token number">1class="token punctuation">; class="token comment">// 表示到达第1阶的方法数
    class="token keyword">int dp2 class="token operator">= class="token number">2class="token punctuation">; class="token comment">// 表示到达第2阶的方法数

    class="token comment">// 临时变量用于存储当前阶数的爬楼梯方法数
    class="token keyword">int current class="token operator">= class="token number">0class="token punctuation">;

    class="token comment">// 动态规划࿰c;从第3阶开始计算到第n阶的爬楼梯方法数
    class="token keyword">for class="token punctuation">(class="token keyword">int i class="token operator">= class="token number">3class="token punctuation">; i class="token operator"><= nclass="token punctuation">; iclass="token operator">++class="token punctuation">) class="token punctuation">{
        class="token comment">// 当前阶数的方法数是前两阶方法数之和
        current class="token operator">= dp1 class="token operator">+ dp2class="token punctuation">;

        class="token comment">// 更新 dp1 和 dp2࿰c;准备计算下一阶
        dp1 class="token operator">= dp2class="token punctuation">; class="token comment">// dp1 向前移动
        dp2 class="token operator">= currentclass="token punctuation">; class="token comment">// dp2 向前移动
    class="token punctuation">}

    class="token comment">// 最终返回 dp2࿰c;表示第n阶的方法数
    class="token keyword">return dp2class="token punctuation">;
class="token punctuation">}

class="token keyword">int class="token function">mainclass="token punctuation">(class="token punctuation">) class="token punctuation">{
    class="token keyword">int nclass="token punctuation">;
    class="token comment">// 输入楼梯的阶数
    cout class="token operator"><< class="token string">"请输入楼梯的阶数："class="token punctuation">;
    cin class="token operator">>> nclass="token punctuation">;

    class="token comment">// 调用函数计算方法数并输出结果
    class="token keyword">int result class="token operator">= class="token function">climbStairsclass="token punctuation">(nclass="token punctuation">)class="token punctuation">;
    cout class="token operator"><< class="token string">"爬到第 " class="token operator"><< n class="token operator"><< class="token string">" 阶楼梯的不同方法有：" class="token operator"><< result class="token operator"><< class="token string">" 种。" class="token operator"><< endlclass="token punctuation">;

    class="token keyword">return class="token number">0class="token punctuation">;
class="token punctuation">}
code>

1.C++的多态实现原理是什么？

多态是：允许同一接口通过不同类型的对象进行不同的行为。通过虚函数和继承体系来实现࿰c;就是动态多态。
核心是：<code>虚函数表、虚指针code>

声明了虚函数时࿰c;编译器会创建<code>一个独立的虚函数表code>。
包含了虚函数指针࿰c;指向具体实现的函数。
如果子类重写了࿰c;那对应的条目将会指向子类的函数实现。

调用虚函数的时候：
通过虚指针找到对应的虚函数表
再根据虚函数表中记录的函数地址࿰c;调用具体的函数
这就是运行时多态࿰c;它运行的时候确定调用哪个函数。

静态多态：函数重载（函数名相同 参数不同）和模板

2、多态分几种类型？

1.静态：函数重载+模板（允许函数和类以通用方式实现。编译器根据传递的类型生成具体的函数版本。）（泛型编程 不用指定具体类型 可以自动生成具体类型）

2.动态：继承和虚函数

3.多态的特点有哪些？

1.接口的统一：从基类的接口可以调用派生类的行为
2.运行时多态：动态绑定 根据实际类型确定要调用的函数
3.可扩展性+可维护性（高内聚低耦合）
4.虚函数表的开销还是可以挺小的

4.智能指针本质是什么？

我认为智能指针的本质就是一个一个的模板类࿰c;然后引入了RAII的机制࿰c;资源获取时就初始化࿰c;来管理动态分配的资源࿰c;确保不使用的时候就可以自动释放。避免内存泄漏。
1.封装了原本的指针࿰c;析构函数是自动调用࿰c;并且可以自动delete。
2.引用计数:对于特定的那两个 还得维护引用计数࿰c;当引用计数为0的时候就释放资源。weak_ptr不影响引用计数的弱引用。防止循环应用。

c_119">5.malloc是如何工作的？底层调度原理࿰c;是系统调用吗？

首先malloc是在<code>堆code>上分配内存࿰c;大小可以增长或者缩减。
只要调用malloc࿰c;就从堆里寻找大小合适的内存࿰c;返回其地址。
但是引入了<code>内存池code>࿰c;就是预申请࿰c;然后使用。避免系统调用。
如果出现内存碎片问题࿰c;就会用空闲链表（free list） 或 伙伴系统（buddy system）管理。
first-fit:在空闲链表中第一个够大的用
best-fit：选择最小能满足要求的
worst-fit：选择最大的块

malloc用到的系统调用：
1.brk和sbrk：调用用于分配小块内存（通常小于128KB）
2.mmap：用于分配大块内存。

malloc工作过程：
1.初始化空闲链表 初始化呢哦寸尺
2.检查内存池࿰c;足够大的就可以分配了
3.内存池不够了࿰c;用brk/sbrk or mmap向os申请新的
4.更新空闲链表
5.free就可以释放

c_139">6.malloc有哪些缺点？

1.malloc维护了空闲链表 时间开销 性能不佳
2.产生内存碎片
3.仅仅分配了而已࿰c;还没有初始化。还得自己初始化。
4.malloc必须搭配free࿰c;不然就会内存泄漏
5.还不能动态扩展

7.mmap是什么？

就是内存映射文件࿰c;把文件或者其他内容被映射到虚拟地址空间。
避免使用系统调用read和write࿰c;提高性能。
程序可以像访问普通内存一样访问文件。

mmap 的使用场景：

<code>文件内容的直接访问：通过映射文件࿰c;可以避免数据在用户空间和内核空间之间的拷贝࿰c;提高效率。
动态内存分配：在需要分配大块内存时࿰c;可以使用 mmap 来避免传统的堆分配方法可能导致的内存碎片问题。
进程间共享内存：通过映射相同的文件࿰c;或者使用匿名映射࿰c;可以实现进程间的内存共享。
code>

8.多线程会有什么问题？

1.竞争：多个线程同时访问或者修改
2.死锁：等待彼此释放资源的无限期等待。
3.资源的竞争࿰c;i/o 内存 cpu
4.执行顺序
5.线程安全

9.Mysql的存储引擎你知道那些？区别是什么
c="https://i-blog.csdnimg.cn/direct/121afd4ce3aa47e6a028c72ed1b44088.png" alt="在这里插入图片描述" />

9.索引分别有什么结构？

1.B树
2.B+树 变种 叶子节点存值 叶子节点还有链表
3.哈希表 键值对 不能范围
4.跳表 logn 随机化实现平衡 动态变化的高效查找

10.B+树和B树有什么区别？

1.B+树所有数据存储在叶子节点中 内部节点只有索引信息。
2.B+树叶子节点之间还有链表链接 可以范围查找
3.B+树的插入删除简单

11.索引使用的时候有什么需要注意的？

1. 选择合适的索引类型

根据查询需求选择：

<code>对于范围查询（如 BETWEEN、LIKE 'abc%'）和排序操作࿰c;B-Tree 索引是合适的选择。
对于等值查询（如 =）࿰c;哈希索引可能更高效。
对于复杂的文本搜索࿰c;全文索引（Full-Text Index）适合。
对于需要处理空间数据的应用࿰c;R-Tree 索引是合适的选择。
code>

2. 索引的覆盖范围

选择适当的列进行索引：

<code>通常将经常用于查询条件（WHERE 子句）、排序（ORDER BY）和连接（JOIN）操作的列进行索引。
避免对经常变化的列（如经常更新的字段）进行索引࿰c;因为频繁的更新会影响索引的性能。
code>

3. 索引的数量

避免过多的索引：

<code>虽然索引可以提高查询性能࿰c;但每个索引都需要额外的存储空间࿰c;并且会增加插入、删除和更新操作的开销。
过多的索引可能会导致性能下降࿰c;因此应根据实际需要合理设置索引数量。
code>

4. 索引的维护

定期重建和优化索引：

<code>索引在数据库的使用过程中可能会变得碎片化。定期重建和优化索引可以提升性能。
在 MySQL 中࿰c;可以使用 OPTIMIZE TABLE 语句来优化表和索引。
code>

5. 索引的覆盖

利用覆盖索引：

<code>覆盖索引（Covering Index）是指索引包含了查询所需的所有列࿰c;这样数据库可以通过索引来满足查询࿰c;无需访问表的实际数据。
使用覆盖索引可以显著提高查询性能。
code>

6. 监控和评估

监控索引的性能：

<code>定期使用数据库的性能监控工具来评估索引的使用情况和效率。
使用 EXPLAIN 语句来分析查询执行计划࿰c;检查索引的使用情况。
code>

7. 索引的选择性

考虑索引的选择性：

<code>索引的选择性是指索引列的唯一值的比例。选择性高的索引（唯一值多）通常比选择性低的索引（重复值多）更有效。
对选择性低的列建立索引可能不会带来显著的性能提升。
code>

8. 联合索引

合理使用联合索引：

<code>对于多个列的查询条件࿰c;联合索引可以显著提高性能。需要注意联合索引的列顺序࿰c;通常将选择性高的列放在前面。
在查询中使用的列顺序应与联合索引的列顺序相匹配。
code>

9. 避免覆盖不必要的列

避免创建不必要的索引：

<code>确保索引用于实际需要的列࿰c;避免在不经常用于查询的列上创建索引。
检查和移除冗余或无效的索引࿰c;以减少维护开销和存储需求。
code>

12.索引的缺点是什么？

1. 增加存储开销

额外的存储空间：

<code>每个索引都需要额外的存储空间。尤其是在索引涉及多个列时࿰c;存储开销会显著增加。
对于大表或有多个索引的表࿰c;存储开销可能变得相当可观。
code>

2. 影响写操作性能

插入、更新和删除的开销：

<code>索引需要在数据插入、更新和删除时进行维护。这会导致额外的开销࿰c;因为数据库必须同时更新索引。
在高并发的环境下࿰c;频繁的写操作可能导致性能下降。
code>

3. 可能的维护复杂性

索引的维护：

<code>对索引进行定期维护（如重建、优化）是必要的࿰c;以避免碎片化和性能下降。维护索引可能增加管理复杂性和系统开销。
需要监控和分析索引的性能࿰c;确保它们在实际应用中仍然有效。
code>

4. 可能的选择性降低

选择性低的索引：

<code>对选择性较低的列（如包含大量重复值的列）建立索引࿰c;可能不会显著提高查询性能࿰c;甚至可能导致性能下降。
对这些列的索引可能会增加额外的存储开销࿰c;但带来的性能提升有限。
code>

5. 影响查询优化

查询优化的挑战：

<code>在某些情况下࿰c;数据库优化器可能无法选择最优的索引࿰c;导致查询性能下降。
需要定期检查和调整索引策略࿰c;以确保查询优化器能够利用正确的索引。
code>

6. 对多表连接的影响

连接性能的影响：

<code>虽然索引可以提高单表查询的性能࿰c;但在复杂的多表连接查询中࿰c;索引的效果可能会受到限制。
不恰当的索引策略可能导致连接操作的性能问题。
code>

13.使用索引查询一定会变快么？

使用索引通常可以提高查询性能࿰c;但并不总是保证查询一定会变快。索引的效果取决于多个因素࿰c;包括数据分布、查询类型、索引设计以及数据库的实际执行情况。

1. 数据选择性

   选择性高的列：索引在选择性高的列上（即列中包含大量唯一值）通常能显著提高查询性能。例如࿰c;使用索引在员工表的员工ID列上进行查找。
   选择性低的列：如果索引的列选择性低（即列中包含大量重复值）࿰c;索引的效果可能有限。例如࿰c;在性别列上建立索引࿰c;可能不会显著提高查询性能࿰c;因为性别列的值重复较多。

2. 查询类型

   简单查询：对于简单的等值查询࿰c;索引通常能显著提高性能。例如࿰c;SELECT * FROM employees WHERE employee_id = 123。
   复杂查询：对于复杂的查询࿰c;如多表连接、大量数据聚合或子查询࿰c;索引的效果可能受到限制。索引不能总是优化所有复杂查询࿰c;特别是在涉及大量数据处理时。

3. 索引设计

   索引选择：选择合适的索引类型（如 B-Tree、哈希索引、全文索引等）以及合理的索引组合对于提高查询性能至关重要。联合索引可能对多列查询更有效。
   索引维护：索引需要定期维护以防止碎片化。未优化的索引可能会影响查询性能。

4. 查询计划

   数据库优化器会根据查询的执行计划选择是否使用索引。如果优化器判断使用索引不合适࿰c;可能会选择全表扫描。
   使用 EXPLAIN 语句可以帮助分析查询的执行计划࿰c;检查索引是否被有效使用。

5. 数据更新频率

索引会增加数据插入、更新和删除操作的开销。如果表的写操作频繁࿰c;索引的维护成本可能会抵消其查询性能的提升。
6. 索引的选择性和覆盖性

<code>覆盖索引：使用覆盖索引（即索引包含查询所需的所有列）可以显著提高性能࿰c;因为数据库可以只访问索引而不需要回表查询。
索引优化：确保索引列的顺序和组合适应查询条件࿰c;以最大化索引的效率。
code>

7. 表大小

在小表上࿰c;索引可能不会有明显的性能提升࿰c;因为全表扫描的成本可能与使用索引的成本相当。

14.redis有哪些持久化策略？二者在实际使用上有什么差异呢？

c="https://i-blog.csdnimg.cn/direct/f913aaba55214fd2948f2bcfb0dfbfde.png" alt="在这里插入图片描述" />