字节豆包C++一面-面经总结

talk is cheap show me the code

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

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    if(head==nullptr||!head->next)return head;
    auto node1=head;
    auto node2=head->next;
    node2=reverseList(node2);
    node1->next->next=node1;
    node1->next=nullptr;
    return node2;
    }
};

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

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

原版：

class Solution {
public:
    int climbStairs(int n) {
        vector<int>dp(n+1);
        //dp[0]=0;
         if (n <= 1) return n;
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

扩展：（ACM)

#include <iostream>
using namespace std;

// 爬楼梯问题的函数，输入 n 表示楼梯的阶数，返回方法数
int climbStairs(int n) {
    // 如果楼梯阶数小于等于2，直接返回 n，因为方法数就是 n
    if (n <= 2) {
        return n;
    }

    // 初始化第1阶和第2阶的爬楼梯方法数
    int dp1 = 1; // 表示到达第1阶的方法数
    int dp2 = 2; // 表示到达第2阶的方法数

    // 临时变量用于存储当前阶数的爬楼梯方法数
    int current = 0;

    // 动态规划，从第3阶开始计算到第n阶的爬楼梯方法数
    for (int i = 3; i <= n; i++) {
        // 当前阶数的方法数是前两阶方法数之和
        current = dp1 + dp2;

        // 更新 dp1 和 dp2，准备计算下一阶
        dp1 = dp2; // dp1 向前移动
        dp2 = current; // dp2 向前移动
    }

    // 最终返回 dp2，表示第n阶的方法数
    return dp2;
}

int main() {
    int n;
    // 输入楼梯的阶数
    cout << "请输入楼梯的阶数：";
    cin >> n;

    // 调用函数计算方法数并输出结果
    int result = climbStairs(n);
    cout << "爬到第 " << n << " 阶楼梯的不同方法有：" << result << " 种。" << endl;

    return 0;
}

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

多态是：允许同一接口通过不同类型的对象进行不同的行为。通过虚函数和继承体系来实现，就是动态多态。

核心是：虚函数表、虚指针

声明了虚函数时，编译器会创建一个独立的虚函数表。

包含了虚函数指针，指向具体实现的函数。

如果子类重写了，那对应的条目将会指向子类的函数实现。

调用虚函数的时候：

通过虚指针找到对应的虚函数表

再根据虚函数表中记录的函数地址，调用具体的函数

这就是运行时多态，它运行的时候确定调用哪个函数。

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

2、多态分几种类型？

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

2.动态：继承和虚函数

3.多态的特点有哪些？

1.接口的统一：从基类的接口可以调用派生类的行为

2.运行时多态：动态绑定 根据实际类型确定要调用的函数

3.可扩展性+可维护性（高内聚低耦合）

4.虚函数表的开销还是可以挺小的

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

我认为智能指针的本质就是一个一个的模板类，然后引入了RAII的机制，资源获取时就初始化，来管理动态分配的资源，确保不使用的时候就可以自动释放。避免内存泄漏。

1.封装了原本的指针，析构函数是自动调用，并且可以自动delete。

2.引用计数:对于特定的那两个 还得维护引用计数，当引用计数为0的时候就释放资源。weak_ptr不影响引用计数的弱引用。防止循环应用。

5.malloc是如何工作的？底层调度原理，是系统调用吗？

首先malloc是在堆上分配内存，大小可以增长或者缩减。

只要调用malloc，就从堆里寻找大小合适的内存，返回其地址。

但是引入了内存池，就是预申请，然后使用。避免系统调用。

如果出现内存碎片问题，就会用空闲链表（free list） 或 伙伴系统（buddy system）管理。

first-fit:在空闲链表中第一个够大的用

best-fit：选择最小能满足要求的

worst-fit：选择最大的块

malloc用到的系统调用：

1.brk和sbrk：调用用于分配小块内存（通常小于128KB）

2.mmap：用于分配大块内存。

malloc工作过程：

1.初始化空闲链表 初始化呢哦寸尺

2.检查内存池，足够大的就可以分配了

3.内存池不够了，用brk/sbrk or mmap向os申请新的

4.更新空闲链表

5.free就可以释放

6.malloc有哪些缺点？

1.malloc维护了空闲链表 时间开销 性能不佳

2.产生内存碎片

3.仅仅分配了而已，还没有初始化。还得自己初始化。

4.malloc必须搭配free，不然就会内存泄漏

5.还不能动态扩展

7.mmap是什么？

就是内存映射文件，把文件或者其他内容被映射到虚拟地址空间。

避免使用系统调用read和write，提高性能。

程序可以像访问普通内存一样访问文件。

mmap 的使用场景：

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

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

1.竞争：多个线程同时访问或者修改

2.死锁：等待彼此释放资源的无限期等待。

3.资源的竞争，i/o 内存 cpu

4.执行顺序

5.线程安全

9.Mysql的存储引擎你知道那些？区别是什么

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

1.B树

2.B+树 变种 叶子节点存值 叶子节点还有链表

3.哈希表 键值对 不能范围

4.跳表 logn 随机化实现平衡 动态变化的高效查找

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

1.B+树所有数据存储在叶子节点中 内部节点只有索引信息。

2.B+树叶子节点之间还有链表链接 可以范围查找

3.B+树的插入删除简单

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

1. 选择合适的索引类型

根据查询需求选择：

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

2. 索引的覆盖范围

选择适当的列进行索引：

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

3. 索引的数量

避免过多的索引：

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

4. 索引的维护

定期重建和优化索引：

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

5. 索引的覆盖

利用覆盖索引：

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

6. 监控和评估

监控索引的性能：

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

7. 索引的选择性

考虑索引的选择性：

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

8. 联合索引

合理使用联合索引：

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

9. 避免覆盖不必要的列

避免创建不必要的索引：

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

12.索引的缺点是什么？

1. 增加存储开销

额外的存储空间：

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

2. 影响写操作性能

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

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

3. 可能的维护复杂性

索引的维护：

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

4. 可能的选择性降低

选择性低的索引：

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

5. 影响查询优化

查询优化的挑战：

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

6. 对多表连接的影响

连接性能的影响：

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

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

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

1. 数据选择性

   选择性高的列：索引在选择性高的列上（即列中包含大量唯一值）通常能显著提高查询性能。例如，使用索引在员工表的员工ID列上进行查找。

   选择性低的列：如果索引的列选择性低（即列中包含大量重复值），索引的效果可能有限。例如，在性别列上建立索引，可能不会显著提高查询性能，因为性别列的值重复较多。

2. 查询类型

   简单查询：对于简单的等值查询，索引通常能显著提高性能。例如，SELECT * FROM employees WHERE employee_id = 123。

   复杂查询：对于复杂的查询，如多表连接、大量数据聚合或子查询，索引的效果可能受到限制。索引不能总是优化所有复杂查询，特别是在涉及大量数据处理时。

3. 索引设计

   索引选择：选择合适的索引类型（如 B-Tree、哈希索引、全文索引等）以及合理的索引组合对于提高查询性能至关重要。联合索引可能对多列查询更有效。

   索引维护：索引需要定期维护以防止碎片化。未优化的索引可能会影响查询性能。

4. 查询计划

   数据库优化器会根据查询的执行计划选择是否使用索引。如果优化器判断使用索引不合适，可能会选择全表扫描。

   使用 EXPLAIN 语句可以帮助分析查询的执行计划，检查索引是否被有效使用。

5. 数据更新频率

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

6. 索引的选择性和覆盖性

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

7. 表大小

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

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