面试001+自己经历的

001基础

[!^1-^127]

把word的文字全部删除，使用替换。

刷题的时候还是用纯编辑器写比较好，常用的函数名和参数都要记住。
零拷贝

问的问题：哪里用到过？
用到的时机？

0、自我介绍：

本科计算机专业，现在研究生也是计算机专业
本科修学分，基础知识，
本科计算机专业，现在研究生也是计算机专业
本科修学分，基础知识，
现在做过的项目
nfs、树莓派内核升级，升级gcc,

1、介绍上一个实习做了啥?啥部门？
2、介绍pi集群，
说了编译东西，升级操作系统，升级工具链

自我介绍
2、实习项目介绍
3个数据流，session+restore+sission数据库个人常走，大家的高热路线。check，eta,restore，排序模型，
3、oe监控平台,预发环境：AB,比较，灰度发布，用到什么中间键：阿波罗，ression数据库，线上发布平台，监控平台，每个trace请求,
查看日志，
pm,qa，rd, 策略算法。
4、遇到的问题？
及时的和它门交流，一下子就解决了。

1、服务注册发现？

1、树莓派系统升级了哪些东西？
2、树莓派系统要怎么给别人用呢？

自我介绍：
介绍下实习？
根据简历发问？
1、做过哪些排查问题的事情？
2、使用top之后，机器负载很高，但是cpu空闲是怎么回事？
io密集型任务，cpu密集型任务，1、当大量io队列时候会出现这种情况。

0、学校实验室：

现在做过的项目
nfs、树莓派内核升级，升级gcc,
两个主节点有状态保存吗？没有，主要考虑的是算法性能，重新启动计算服务也花不了太多时间，不必搞成工程化的一直稳定运行，有这方面的考虑，

1、内存布局：按行存->内存中不连续，跳跃性访存-> 缓存命中率不高，128B,27 * 8B=216B
解决：所有行一次分配内存，然后顺序存储。

2、高斯赛德尔算子中的 数据访问顺序改进，两层for循环反向—>同向。

3、多线程：解决数据依赖，着色法。
外层增加一层颜色迭代器循环，同一种颜色内：去并行循环处理。循环“I”可以通过插入编译器指令来并行处理

4、两个内核的循环优化：短循环展开。指令流水线

研究生做了哪些工作
项目，这里面的细节问了很多，感觉每次都能问到痛点

1、集群测试的数据集的量级是多少？
3-4M
2、集群和机器学习深度学习平台有啥区别关系联系？

0、实习：

怎么同步两个线程的任务同步？
wait函数？条件变量要和互斥锁一起使用。

1、路线精排你的评判标准是什么？
粗排有模型的评测指标，
精排我有自己的评判指标，红路灯个数（乘车体验），走不走高速。
2、你做的啥模块？
5、怎么判断这个乘客的个人常走路线？
6、排序的算法是啥？精排的算法是啥？

多少的qps?

1、字节

1.1、test001基础问题：

1、海量IP，给出IP，求出IP出现的次数？
字典树、哈希、位图
trie，又称前缀树或字典樹，是一种有序树，用于保存关联数组，其中的键通常是字符串。 与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。 一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。
2、找数组中的前k大个数？
3、select poll epoll区别，什么时候用select和poll？
select时间复杂度O（N)
poll 时间复杂度O（N）
epollO(1)
epoll实际上是事件驱动（每个事件关联上fd）的，此时我们对这些流的操作都是有意义的。（复杂度降低到了O(1)）
参考

4、sizeof
运算符，返回对象的字节大小。
5、C++内存模型，常量存储区，静态变量和全局变量
程序运行前
全局区：全局变量、静态变量、常量（字符串常量、const修饰的全局常量）
（.bss段和.data段）
全局和静态变量被分配到同一块内存中。在C语言中，未初始化的放在.bss段中，初始化的放在.data段中；在C++里则不区分了。

代码区 （.text段） ：共享和只读
存放代码（如函数），不允许修改（类似常量存储区），但可以执行（不同于常量存储区）

程序运行后
堆 heap ：
由new分配的内存块，其释放编译器不去管，由我们程序自己控制（一个new对应一个delete）。如果程序员没有释放掉，在程序结束时OS会自动回收。涉及的问题：“缓冲区溢出”、“内存泄露”

栈 stack ：
是那些编译器在需要时分配，在不需要时自动清除的存储区。存放局部变量、函数参数。
存放在栈中的数据只在当前函数及下一层函数中有效，一旦函数返回了，这些数据也就自动释放了。
参考

6、虚函数的实现
参考
参考2
7、udp适用于什么场景
参考
应用场景
#######TCP应用场景
当对网络通信质量有要求时，比如：整个数据要准确无误的传递给对方，这往往对于一些要求可靠的应用，比如HTTP,HTTPS,FTP等传输文件的协议，POP,SMTP等邮件的传输协议。常见使用TCP协议的应用：
1.浏览器使用的：HTTP
2.FlashFXP:FTP
3.Outlook:POP，SMTP
4.QQ文件传输

######UDP 文件传输协议
对当前网络通讯质量要求不高的时候，要求网络通讯速度尽量的快，这时就使用UDP
日常生活中常见使用UDP协议：
1.QQ语音
2.QQ视频
3.TFTP

8、tcp和udp可以绑定到同一个端口吗？如何实现
可以，tcp和udp是不同的软件模块，
参考
端口的唯一性的标识不是端口号，而是端口号和协议名称的组合，应用程序和协议寻址时就是靠的这个组合
参考2
9、http协议，connection选项的作用
参考
http1.0的时候，建立一次连接之后，每个TCP连接只能发送一个请求。发送数据完毕，连接就关闭，如果还要请求其他资源，就必须再新建一个连接。
增加一个字段：Connection: keep-alive，让服务器不中断连接，以便其他请求复用。服务器同样回应这个字段。

1.1 版的最大变化，就是引入了持久连接（persistent connection），即TCP连接默认不关闭，可以被多个请求复用，不用声明Connection: keep-alive。
管道机制，一个连接中的多个请求，一起输入管道，而不必回答前一个请求之后，再发送另外一个请求。

分块传输编码
参考

10、如何优化一条sql的查询语句
不要把SQL语句写得太复杂
使用“临时表”暂存中间结果
参考
10.1一条查询语句很慢什么原因？
1，一直挺快偶尔慢：未落盘，数据库一直在忙，缓存满了，开始停下来往磁盘写数据时候，就会慢。。。此处的数据有锁，被别的进程拿走了，只能等了。
2、一直都很慢：1、没有索引，有索引，没用索引查询。
参考
11、msyql有哪些索引
B+树索引O（log（N））
hash索引，
fulltext全文索引
R-treer树地图索引
参考
12、联合索引，最左匹配的原理
13、redis有哪些淘汰策略

1. volatile-lru：从设置过期时间的数据集(server.db[i].expires)中挑选出最近最少使用的数据淘汰。没有设置过期时间的key不会被淘汰，这样就可以在增加内存空间的同时保证需要持久化的数据不会丢失。

2. volatile-ttl：除了淘汰机制采用LRU，策略基本上与volatile-lru相似，从设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰，ttl值越大越优先被淘汰。

3. volatile-random：从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰。当内存达到限制无法写入非过期时间的数据集时，可以通过该淘汰策略在主键空间中随机移除某个key。

4. allkeys-lru：从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰，该策略要淘汰的key面向的是全体key集合，而非过期的key集合。

5. allkeys-random：从数据集(server.db[i].dict)中选择任意数据淘汰。

6. no-enviction：禁止驱逐数据，也就是当内存不足以容纳新入数据时，新写入操作就会报错，请求可以继续进行，线上任务也不能持续进行，采用no-enviction策略可以保证数据不被丢失，这也是系统默认的一种淘汰策略。
   参考

1.2、002

概率题：一个地方的夫妻，一胎生了男孩继续生，生了女孩不再生，二三四五胎…亦然，直到生个女孩，问最后男孩女孩的比例，问一个夫妻生男孩的个数的期望是多少
概率题：有一个函数rand7可以随机生成0到7，问如何使用rand7实现rand5，证明机会均等。又问如何使用rand5实现rand7。
socket编程的流程，accept调用和三次握手的关系，accept什么时候会阻塞，accept队列是由谁维护的
编程：之字形打印二叉树

1.3、test003

研究生做了哪些工作
项目，这里面的细节问了很多，感觉每次都能问到痛点
协程介绍一下，协程怎么调度
python java了解多少
一个服务如何提高并发
场景题：一千台服务器两两连接，服务器之间的延迟不断变化，如何确定任意两台服务器之间的最短路径，答了floyd算法，问floyd算法怎么写。最后写两个函数，一个函数根据服务器之间的延迟更新图，一个函数实现迪杰斯特拉算法。
实习时长

项目积累：
thrift协议的底层实现

基础知识：
http数据传输的基本过程？

数据库：
两个表：学生表：学生id，学生名字
课程表：课程id,课程分，
挑选出那些平均分不及格的同学姓名。

我的思路：先把一个学生所有的课程挑出来，然后求平均分有没有及格。

算法题：
一串股票序列的最大收益，
我的思路：动态规划，但是没写出来！

两个链表反向按位求和
我的思路：使用deque容器

1、对thrift底层加深理解
2、算法题：保持手感！

1、自我介绍
2、32位操作系统寻址空间有多大？
2的32次方 4G
3、数据库常用操作
4、HTTP常用方法？
5、上线的常用Linux命令，如何查日志关键字？
cat 文件名 |grep 关键字， 然后1> 1.log
vi如果/查找文件太大会崩，

6、tcp/ip介绍一下
ACK=0还是等于1？ 第3次挥挥手，为什么不把中间两次合到一起，变成3次，？非得4次？
ACK位置1，有效，ACK号，是syn+len,
延迟确认,可以把第二次挥手和第三次挥手搞一起。

fin关键字
7、单链表返回到数第n个元素，
方法一：使用vector存起来，然后随机访问根据下标取出来数据。追问 vector开的内存最小多小？24B size_t 8 容量 size_t 8 长度，int * 8 数据指针
方法二：快慢指针

8、字符串找子串？有括号，
HTT(HOH)3RE
H有几个？
有7个

怎么解？展开括号。
或者根据括号倍乘。

byte
1、自我介绍：
2、介绍一下你做的最熟悉的一个项目
3、一些知识点：虚函数实现

自我介绍：
本科计算机专业，现在研究生也是计算机专业
本科修学分，基础知识，
现在做过的项目
nfs、树莓派内核升级，升级gcc,

虚函数：怎么实现的？

http://c.biancheng.net/cpp/biancheng/view/244.html
多态时的函数重载，为了实现基类和子类函数同名，功能不同而存在的一种方法
横向函数重载，参数或者参数类型总得不同，
而虚函数是为了基类和子类的同名函数，参数、参数类型都相同，但函数体不同，而实现的纵向重载
使用一个基类的指针，当字类中调用了虚函数时候，实现的是子类中的虚函数功能
用一个指向基类的指针实现的。
每一个类都有一个虚函数表(v-table)，每个对象都有一个虚函数指针(vptr)
纯虚函数：因为c++没有接口，想规范子类的行为。基类声明不能实现（动物），子类实现，必须重写虚函数

第一题：
225https://leetcode-cn.com/problems/merge-intervals/?utm_source=LCUS&utm_medium=ip_redirect_q_uns&utm_campaign=transfer2china

class MyStack{
private:
list<int>l;
int  tem=0;

public:
        MyStack()  // 构造函数，没有返回值
        {

        }
        void push(int x)  // 压栈
        {
            l.push_back(x);
            if(l.size()==1)
            {
                tem=x;
            }
            else
            {
                if(x<tem)
                tem=x;
            }
        }
        int  pop()  // 删除并返回栈顶元素
        {
            int tem=l.back();
            l.pop_back();
            return tem;
        }
        int getMin()
        {

            return tem;
        }
        
        int top()
        {
            return l.back();
        }

        bool empty()
        {
            if(l.empty())
            return true;
            else
            return false;
        }
};

第2题：
56
https://leetcode-cn.com/problems/merge-intervals/

4、亚马逊一面：

1、集群测试的数据集的量级是多少？
3-4M
2、集群和机器学习深度学习平台有啥区别关系联系？
3、什么时候使用进程，什么时候使用线程？
频繁的进行创建和销毁就使用线程。因为进程开销大。
进程适用于多机多核系统。线程适用于多核系统。
4、算法题：实现atoi函数，

腾讯微博，几个模块，怎么组织内容的存储，数据库几张表？
有好友关系，动态按照时间顺序进行展示。怎么设计这个？

5.粉笔

学生id,分数，班级
1 100 1
2 90 1
3 79 1
4 100 2
5 82 2
6 99 3
7 80 3
按照班级把各班的最高成绩展示出来，sql
2、给出一个数，把这个数倒置一下，考虑正负，边界，32767，转不过来。
正负相同。

6、龙湖

1、25匹马，5个赛道，取前3？不能记时间，需要跑几次？
7次，法网的小组循环赛程为了快，对名次，并不是最公平的！
如果想要取前5，需要几次？
8-10次、
2、一个火柴烧完需要30秒，怎么取15秒？
两头烧，
3、数组和hash那个快？
分需求回答！读时数组快，写是hash快。
4、怎么判断两个链表有交集？
两层循环，如何优化？
时间复杂度变成O（N）：遍历到最后一个，如果想等肯定相交了。

7、金山云

1、介绍上一个实习做了啥?啥部门？
2、介绍pi集群，
说了编译东西，升级操作系统，升级工具链。
3、1，1，2，3，5斐波那契数列，
4、把一个无序数组中的数字，分成小于5和大于5的两部分。
双指针：快排的第一步。

半小时，也没问基础知识。应该是过了。

8、快手

异步多线程
C++11的feature特性？就是子线程
线程通信：互斥量，信号量，条件变量

a=std::move(b),的实现过程，中间都有啥函数？
我只说了，不用拷贝，

移动语句了解多少？

操作系统：
sleep(1)中间发生了啥？
进程的运行->阻塞->就绪状态、

Z字形打印二叉树。

9、字节

1、grpc有没有枚举？
只知道thrift是有的，grpc不知道。可以可以
2、ip数据报格式？

tcp

3、http和https?
有ssl加密。超文本协议http
安全套接字超文本传输协议HTTPS
加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。
4、http压缩？
* 1、文件格式压缩，（无损压缩算法：gif,png,有损jpeg）
* 2、端到端压缩技术
* 3、逐跳压缩技术
参看
5、怎么看进程负载？
一些命令：
top
vmstat -n 1

方法1：使用iotop工具
这是一个python脚本工具，使用方法如：iotop -o

sudo apt install iotop
sudo iotop -o 

方法2：使用工具dmesg
使用dmesg之前，需要先开启内核的IO监控：
echo 1 >/proc/sys/vm/block_dump或sysctl vm.block_dump=1

方法3：使用命令“iostat -x 1“确定哪个设备IO负载高:

iostat -x 1 3

avg-cpu: %user %nice %system %iowait %steal %idle
1.06 0.00 0.99 1.09 0.00 97.85

6、post和get的区别？

3

4 POST和GET请求的区别小结
请求参数：GET请求参数是通过URL传递的，多个参数以&连接，POST请求放在request body中。
请求缓存：GET请求会被缓存，而POST请求不会，除非手动设置。
收藏为书签：GET请求支持，POST请求不支持。
安全性：POST比GET安全，GET请求在浏览器回退时是无害的，而POST会再次请求。
历史记录：GET请求参数会被完整保留在浏览历史记录里，而POST中的参数不会被保留。
编码方式：GET请求只能进行url编码，而POST支持多种编码方式。
对参数的数据类型：GET只接受ASCII字符，而POST没有限制。

这里还想补充说明一点，就是通过浏览器地址栏输入URL访问资源的方式都是GET请求。

算法题？
给一个可重复的字符数组char {b,d,a,f}长度m,一个字符串str="bagagageefae"长度n,求可以通过字符数组组成长度为m的字符子串的第一个下标的位置？
思路：通过暴力的滑动窗口往右移动。
优化：把每个滑动窗口先进行求和。如果和相等再进行子串排序，如果和不相等，就直接滑动窗口往后移动。

给定m个字符 [a, b, c, d]，字符可能重复，以及一个长度为n的字符串tbcacbdata，问能否在这个字符串中找到一个长度为m的连续子串，使得这个子串刚好由上面m个字符组成，顺序无所谓，返回任意满足条件的一个子串的起始位置，未找到返回-1。

1. 输入 [a, b, c, d] + tbcacbdata -> 3
2. 输入 [a, b, c, c] + tbcacbdata -> 1
3. 输入 [a, b, c, d] + abctbcdata -> 4
4. 输入 [a, b, c, c] + bcabcdata -> 1

#include <iostream>
#include<string>

using namespace std;
int main() {
    //int a;
    //cin >> a;
    cout << "Hello World!" << endl;
}
int solution(char * s,string &str){
    string s1;
    int m=s.size();
    int sum1 = 0;
    int n = str.size();
    if(m>n) return -1;
    for(int i = 0;i<m;i++){
        s1+=s[i];
        sum1+=s[i];
    }
    
    
    sort(s1.begin(),s1.end());
    string s2;
    int sum2 = 0;
    for(int j =0;j<m;j++){
        s2+=str[j];
        sum2+=str[j];
    }
    if(sum1 == sum2){
        string s3=s2;
        sort(s3.begin(),s3.end());
        if(s1==s3){
            return 0;
        }
    }
    int t = n - m; 
    for(int i=m;i<n;i++){
        s2.erase(i-m);
        s2+=str[i];
        
        sum2 = sum2 -s2[i-m]+str[i];
        if(sum2 == sum1){
            string s4 = s2;
            sort(s4.begin(),s4.end());
            if(s1==s4){
                return i-m;
            }
        }
    }
    return -1;
    
    
    
        
}

9.2字节二面：

1、asc11码和utf-8的区别？占多少字节？

• 1、ASCII码：一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最小值0，最大值255。如一个ASCII码就是一个字节。
• 2、UTF-8编码：一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。
  Unicode编码：Unicode是一种编码规范，是为解决全球字符通用编码而设计的，而UTF-8,UTF-16等是这种规范的一种实现，它是接口，UTF-8和UTF-16是实现类.
• 3、GBK编码：一个英文等于一个字节，一个中文（含繁体）等于两个字节。
  GB2312编码：一个英文等于一个字节，一个中文（含繁体）等于两个字节。
• 4、符号：英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占1个字节的大小，中文句号“。”占2个字节的大小。
  我答占一个

2、多进程如何调度？同步？调度的时机？
除了io阻塞之外还有啥时机？时间片，还有啥？
wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；

sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；

notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；

notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

grpc框架？你知道的是rpc框架？网络协议栈？

pb和json的区别？
1、protobuf是google开发的一个数据传输格式，类似json
2、protobuf是二进制的、结构化的，所以比json的数据量更小，也更对象化
3、protobuf不是像json直接明文的，这个是定义对象结构，然后由protbuf库去把对象自动转换成二进制，用的时候再自动反解过来的。传输对我们是透明的！我们只管传输的对象就可以了
参考

什么时候用pb什么时候用json?
pb,二进制格式非常小，有利于远程传输），解析速度非常快。不是自描述的，必须要有格式定义（ .proto 文件）。
json,结构简单，具有较好的可读性，发展比较成熟，最重要的是在JS中可以直接使用JSON

char sgs[10],memset(sgs,0,100)，之后会发生什么？

#include<stdio.h>
#include<string.h>
int main(){
        char sgs[10];
        memset(sgs,0,100);
        return 0;
}


 ./a.out
*** stack smashing detected ***: <unknown> terminated
Aborted (core dumped)

memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存按字节做初始化工作
参考

什么是缓冲区溢出？
超过缓冲区能保存的最大数据量的数据，向缓冲区内填充数据时超过了缓冲区本身的容量，而导致数据溢出到被分配空间之外的内存空间，使得溢出的数据覆盖了其他内存空间的数据），
程序运行失败、系统关机、重新启动，或者执行攻击者的指令，比如非法提升权限。

线程和协程的区别？
协程是一种用户态的轻量级线程，协程的调度完全由用户控制。从技术的角度来说，“协程就是你可以暂停执行的函数”。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

1. 一个线程可以多个协程，一个进程也可以单独拥有多个协程。

2. 线程进程都是同步机制，而协程则是异步。

3. 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。

4）线程是抢占式，而协程是非抢占式的，所以需要用户自己释放使用权来切换到其他协程，因此同一时间其实只有一个协程拥有运行权，相当于单线程的能力。

5）协程并不是取代线程, 而且抽象于线程之上, 线程是被分割的CPU资源, 协程是组织好的代码流程, 协程需要线程来承载运行, 线程是协程的资源, 但协程不会直接使用线程, 协程直接利用的是执行器(Interceptor), 执行器可以关联任意线程或线程池, 可以使当前线程, UI线程（主线程）, 或新建新程.。

6）线程是协程的资源。协程通过Interceptor来间接使用线程这个资源。

协程调度的时机？
协程调度时机二：Channel读写
Golang中的channel读写均是同步语义 ，写满的、读空的channel都会触发协程调度。
向channel写数据
无论是无缓冲还是有缓冲channel，当向channel写数据发现channel已满时，都需要将当前写的协程挂起，并进行一次调度，当前M转而执行P内的其他协程。直到有人再读该channel时发现有阻塞等待写的协程时将其唤醒。
协程调度时机三：抢占式调度
Golang在1.4版本中加入了抢占式调度的逻辑，抢占式调度必然可能在g执行的某个时刻被剥夺cpu，让给其他协程。

线程的栈空间可以相互读吗？
可以！
解引用空指针会发生什么？
其中空指针引用是一类普遍存在的内存故障，当指针指向无效内存地址时对其引用,有可能产生不可预见的错误，导致软件系统崩溃。空指针引用缺陷可能导致系统崩溴、拒绝服务等诸多不良后果

tcp最后一条消息怎么确认？最后一个序列号？
A第4次挥手时候，A端会有一个TIME_WAIT的时长，如果最后的等待时间内没有B重发的第3次挥手，就说明A发的第4次挥手消息收到了。
3次握手4次挥手

发送端有判断？

http的报文内容？

3

算法题：只有0,1的数组，如何排序？
直接调用库函数sort时间复杂度：O(NLogN)
方式2：一次遍历统计0的个数，然后第二次遍历赋值数组，
方式3，双指针：

#include <iostream>
#include<vector>

using namespace std;

vector<int> solution(vector<int> & nums){
    int first =0;
    int last = nums.size() -1;
    while(first != last){
        if(nums[first] == 0){
            first ++;
        }
        if(nums[last] == 1){
            last--;
        }
        int tem = nums[first];
        nums[first] = nums[last];
        nums[last] = tem;
    }
    return nums;
}
int main() {
    //int a;
    //cin >> a;
    cout << "Hello World!" << endl;
    vector<int> nums ={0,1,1,1,0,1};
    vector<int> res = solution(nums);
    for(int i =0;i < 6;i++){
        cout<<res[i]<<" "<<endl;
    }
    return 0;
}

11、米哈游

0、c++多态，实现原理？
先答的静态多态（函数重载），动态多态：父类指针指向子类对象，忘记说了虚函数相关的，this指针，vptr虚函数指针（是一个成员指针变量），指向虚函数表，此指针32位系统占4字节，64位系统占用8字节

实现原理：子类有对父类的虚函数的重写，
所谓的动态联编：根据实际的对象类型来判断重写函数的调用。
当类中有虚函数时：此类中就会有编译器维护的虚函数表，虚函数成员会被编译器放入虚函数表中，编译器为每个类的对象提供一个虚表指针vptr，这个指针指向对象所属类的虚函数表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。，也就是说，每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的，虚函数表指针这个指针变量，跟随对象（就是对象的一个数据成员），通过这个虚标指针变量正确调用相应的虚函数。

c++是在构造函数中进行虚表的创建和虚表指针的初始化。

总结：

对于虚函数调用来，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以才能实现动态的对象函数调用，这就是C++多态性实现的原理。
参考

1、static关键字？

代码段，数据段，.bss，栈段，共享库，堆段，环境变量。
static关键字修饰的变量跟随类，通过类名访问，普通变量通过类的对象访问，常对象只能访问常函数，常函数只能访问常变量。

面向过程程序设计中的static和面向对象程序设计中的static

1.1、静态全局变量有以下特点：

• 该变量在全局数据区分配内存；
• 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；
• 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；所以当使用static修饰的全局变量在不同文件中可以重名。

1.2、静态局部变量

常规的局部变量保存在栈空间，函数调用完之后就销毁。但是静态局部变量保存在全局数据区，作用域是局部作用域，当定义它的函数或语句块结束时，其作用域随之结束

1.3、静态函数

只能在声明它的文件中可见，可用。不会与其他文件中的函数有命名冲突。
面向对象的static关键字（类中的static关键字）

2.1、静态数据成员

静态数据成员只有一份拷贝，跟随类，而普通类数据成员有多少对象就各自有自己的拷贝。
存储在全局数据区，
• 同全局变量相比，使用静态数据成员有两个优势：

1. 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
2. 可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

2.2、静态成员函数

没有this指针，不能访问非静态数据成员。
参考

2、shared_ptr是线程安全的吗？shared_ptr如何实现的？怎么保证两个进程同时读写，计数的正确性？
我答不是，一个计数，

effective modern c++ 智能指针这一章说的很清楚，shared_ptr 的引用计数是原子操作的。
shared_ptr本身不是线程安全的。比如多线程读写同一个shared_ptr可能会读到一个错误的信息（写线程刚刚写入一个成员然后读线程就开始读取，读到了一半旧一半新值）。

解决方案之一就是加锁。

智能指针管理的对象本身的线程安全由其自己保证。
对同一个对象分享所有权的shared_ptr在多个线程上的析构不需要外部加锁保护，C++标准以及标准的实现保证这一动作的线程安全性。

3、什么会引发段错误？如何定位？

• 1 解引用空指针(常常由函数返回，并未经检查就使用)，
• 2 解引用非法值（指针），
• 3 权限不正确，试图写入只读文本，
• 4 堆栈空间耗尽，用完了栈或者堆空间(虚拟内存虽然巨大，但也有可能使用殆尽)

Segmentation fault,段错误是由于内存管理单元(负责支持虚拟内存的硬件)的异常所导致，而该异常则通常是由于解除引用一个未初始化或非法的指针引起的。产生段错误的地方有可能在自己编写的代码中，也有可能出现在库函数中(传递一个非法指针给库函数)。令人很不爽的是，段错误除了只有一个简单的错误信息之外，没有任何额外的提示，并且有的段错误不是每次都会出现。
如何调试？
1、dmesg + nm
2、使用fprintf
根据代码执行的情况，确定大致产生“段错误”的地方，使用fprintf(stderr,””,…);来确定具体产生的位置。切记调试信息要输出到错误输出，因为错误输出默认不缓存，标准输出是有缓存的，程序崩溃可能导致缓存数据没有输出，所以建议调试信息都输出到错误输出。
3、gdb调试
编译程序时加上-ggdb选项，使用gdb调试。

gcc -ggdb foo.c
gdb a.out
(gdb) run
Starting program: ./a.out 

Program received signal SIGSEGV, Segmentation fault.
0x00000000004004f6 in main ()
(gdb) 

可以看到“段错误”实在main函数中产生的，那么可以在产生段错误的函数上打上断点，之后单步调试，便可以找出产生段错误的真正原因。

4、new之后会怎么样？
先去看内存够不够分配，如果不够分配就返回分配错误，如果够分，就按构造函数进行初始化工作。
5、tcp中的nagle算法
参考
TCP/IP协议中,无论发送多少数据,总是要在数据前面加上协议头,同时,对方接收到数据,也需要发送ACK表示确认.为了尽可能的利用网络带宽,TCP总是希望尽可能的发送足够大的数据.(在一个连接中会设置MSS参数,因此,TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据).Nagle算法就是为了尽可能发送大块数据,避免网络中充斥着许多小数据块.

6、流量控制和拥塞控制？怎么知道网络环境拥挤不拥挤？
一个是端到端，一个是网络环境，慢启动。

慢启动指数增长，慢启动阈值，拥塞避免算法，加法增大，
当拥塞窗口大小cwnd大于等于慢启动阈值ssthresh (slow start threshold）后，就进入拥塞避免（算法）加法增大。

网络丢包：信号1：超时重传机制，信号2：收到重复确认的ACK。
会把慢启动阈值变成当前拥塞窗口的一半，执行拥塞避免（算法）加法增大，也叫快恢复算法（快重传算法）。

7、tcp与udp的区别？开发一个游戏如何选择？
tcp面向连接，流式传输，可靠的，账户和密码用tcp,游戏画面使用udp,

8、io多路复用？什么时候选择select,什么时候选择epoll?
select，window系统，poll,epoll是linux系统，通信数据量小就使用select,不必遍历。

9、查看进程占用资源？如果一个进程占用100%如何进一步确定？
vmstat,iostat,top,
查看更详细的内存占比

cat /proc/10997/status

10，进程线程的区别？两个线程的栈空间如何交换信息？
是因为不同的线程栈是不对其他线程设防的。所以，如果一个线程以某种方式得到一个指向其他线程栈的指针，那么他就可以读写这个栈的任何部分”
参考

-1、祖龙娱乐一面面经（别人）

海量ip的题
1、vector, map,unordered_map 实现
vector 是最常用的容器之一，其底层所采用的数据结构非常简单，就只是一段连续的线性内存空间。
map底层是采用红黑树实现的，它的查询复杂度是O(lgn);unordered_map实际上是hash_map的实现，理论上它的查询复杂度是O(1)的

2、哈希冲突解决方法
开放定址法、（线性探查，平方探查，）
链地址法（拉链法）、
再哈希法、（同时构造多个不同的哈希函数，）
建立公共溢出区等 （将哈希表分为公共表和溢出表，当溢出发生时，将所有溢出数据统一放到溢出区。）

3、红黑树和完全平衡二叉树(AVL)
红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。
平衡二叉树(AVL)的性质
它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

区别：

1、红黑树放弃了追求完全平衡，追求大致平衡，在与平衡二叉树的时间复杂度相差不大的情况下，保证每次插入最多只需要三次旋转就能达到平衡，实现起来也更为简单。

2、平衡二叉树追求绝对平衡，条件比较苛刻，实现起来比较麻烦，每次插入新节点之后需要旋转的次数不能预知。

4、稳定排序有哪些
不稳定：快排，堆排序，希尔排序，直接选择排序。
稳定：直接插入排序，冒泡，归并排序，基数排序，

5、C++ 内存分区

6、new 和 malloc
1、new是关键字，编译器支持，库函数，头文件
2、delete 数组需要[], free
3、构造析构函数， malloc没有构造析构
4、new不必指定内存大小，根据类型推断，malloc必须指定开辟的内存大小
5、返回确定的类型指针，malloc返回（void *）还得强制类型转换
6、失败了：new返回bad_alloc malloc返回null
7、malloc使用红黑树组织分配了的内存块，
8、如果不够了，malloc会在分配地方后面检查还有没有空地方，如果有连续的空内存，就接上，如果没有就重新分配并拷贝数据，而new没有这个机制，

7、虚函数
参考1
参考2

8、拷贝构造函数, 什么时候会调用拷贝构造函数, 什么时候需要去自己定义拷贝构造函数?(深拷贝和浅拷贝)
1、赋值运算符：初始化，用一个对象初始化另一个对象，
2、值传递的方式作为函数参数，传值，
3、值传递的方式返回局部变量
参考1
参考2
如果你需要定义一个非空的析构函数，那么，通常情况下你也需要定义一个拷贝构造函数。(等价于:在堆区分配了内存。)

9、C++ 11 新特性?

C++11的特性主要包括下面几个方面：
参考

• 提高运行效率的语言特性：右值引用、泛化常量表达式
• 原有语法的使用性增强：初始化列表、统一的初始化语法、类型推导、范围for循环、Lambda表达式、final和override、构造函数委托
• 语言能力的提升：空指针nullptr、default和delete、长整数、静态assert
• C++标准库的更新：智能指针、正则表达式、哈希表等

右值引用，
for语句，
自动类型推导auto,decltype
智能指针，
move函数，移动语句

• 将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast<T&&>(lvalue);
  C++移动语义即提出了一个右值引用，使用std::move可以强制将左值引用转为右值引用。而对于右值引用，程序可以调用移动构造函数进行对象的构造，减少了原来调用拷贝构造函数的时候很大的开销。移动构造函数和移动赋值运算符的实现即是对象所有权的转让，让那些左值对象（临时对象）变成右值对象的过程。
  参考1左值引用，右值引用，左值，右值
  参考2
  清楚 ---------- C++移动语义及拷贝优化

构造函数委托(会有好几个构造函数)
Lambda表达式

参考

12、地平线

一面：
1、docker与虚拟机的区别？
2、docker共享宿主机的操作系统吗？
对
3、写过dockerfile？
4、进程线程协程的区别，
5、go的垃圾回收？
手写快排？

#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;

void qsort(vector<int>& arr, int l, int r) {
	if (l >= r) return;  //子数组长度为1时，终止递归
	int i = l, j = r;  // 哨兵划分的操作，以arr[l]为哨兵，

	while (i < j) {  //    一趟
		while (i < j && arr[j] >= arr[l]) j--;  // 先从右往左，
		while (i < j && arr[i] <= arr[l]) i++;		
		swap(arr[i], arr[j]);    // 交换，
	}
	swap(arr[i], arr[l]);  // i==j时候，把这个i和哨兵l,相交换，之后调用左右子序列，

	qsort(arr, l, i - 1);
	qsort(arr, i + 1, r);
}

int main() {
	vector<int>nums;
	int num;
	do {
		cin >> num;
		nums.push_back(num);
	} while (getchar() != '\n');

	int l = 0, r = nums.size() - 1;
	qsort(nums, 0, r);

	for (int i = 0; i < nums.size(); i++) {
		cout << nums[i] << " ";
	}
	cout << endl;
	
	return 0;
}

堆排？
换两个字符串的最长公共子串。

13、百度一面

多少的qps?
2、键盘输入x = 10,y = 20的执行过程？
3、mysql的数据类型？
4、加索引一定快吗？
为什么快？B+树，数据结构使得快。
5、docker怎么实现的隔离性？
利用Linux内核特性实现的隔离
6、docker的几大组件？构成镜像的命令？
7、主从复制?A,B是从，C是主，怎么保证A,B同步？
8、共享单车项目？
9、接收，存储，查询，（量特别大，怎么搞？）

算法题1：
1、输入www.baidu.com调用get方法，返回的是一个json字符串，解析其中的value

func testGet() {
 
url := "https://baidu.com"
 
req, err := http.NewRequest("GET", url, nil)
 
client := &http.Client{}
 
resp, err := client.Do(req)
 
if err != nil {
 
panic(err)
 
}
 
defer resp.Body.Close()
 
fmt.Println("response Status:", resp.Status)
 
fmt.Println("response Headers:", resp.Header)
 
body, _ := ioutil.ReadAll(resp.Body)
 
fmt.Println("response Body:", string(body))
 
}

算法题2：读取自己电脑磁盘后缀为.jpg的文件，如果有重复的，统计重复的个数，

#include <vector>
#include <string>
#include <iostream>
using namespace  std;
    

int main(int argc, const char* argv[]){
    FILE* fp;
    vector<string> vecLine;

    if(argc!=2) {
        printf("需要一个参数指定要操作的文件路径！\n");
        return 0;
    }

    if(!(fp=fopen(argv[1], "r"))){
        cout<<"读文件失败，文件路径不正确！"<<endl;
        return 0;
    }

    char* buf = new char[1024*1024];
    if(!buf){
        cout<<"内存分配失败，程序退出！"<<endl;
        return 0;
    }
    fgets(buf, 4096, fp);

    while(!feof(fp)){
        vecLine.push_back(buf);
        fgets(buf, 4096, fp);
    }

    fclose(fp);

    if(!(fp=fopen(argv[1], "w"))){
        cout<<"写文件失败，文件路径不正确！"<<endl;
        return 0;
    }

    for(size_t i=0;i<vecLine.size();++i){
        if(i==36 || i==37 || i==38){
            vecLine[i]="# "+vecLine[i];
        }
        printf("%s", vecLine[i].c_str());
        fputs(vecLine[i].c_str(), fp);
    }

    cout<<"已经成功注释掉MPICH环境变量！"<<endl;

    fputs("MPI_HOME=/home/pi/openmpi\n", fp);
    fputs("export PATH=${MPI_HOME}/bin:$PATH\n", fp);
    fputs("export LD_LIBRARY_PATH=${MPI_HOME}/lib:$LD_LIBRARY_PATH\n", fp);
    fputs("export MANPATH=${MPI_HOME}/share/man:$MANPATH\n", fp);
    cout<<"已经成功添加openMPI环境变量！"<<endl;

    fclose(fp);
    delete []buf;

    return 0;
}

算法题3、反转链表，

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next) return head;  // 特判0，1
        ListNode * pre=nullptr;  // 初始化
        auto cur=head;
        auto tem=head;
        //while(!cur){  *******************************             又是这里             ！！！！！！！
        while(cur){
            tem=cur->next;  //保存后方
            cur->next=pre;  // 反指前方

            pre=cur;  // 迭代前进
            cur=tem;
        }
        return pre;
    }
};

14、腾讯1面

翻转链表
买股票的最佳时机
1、slice{1,2，3}从一个函数作为参数传到第二个函数，增加456，再回到原来的函数，slice，会变吗？
2、c++和go内存模型？
3、垃圾回收？
4、unique_ptr怎么拷贝？给另外一个？为啥会取代auto_ptr?
不能赋值！
5、innodb和myslim哪个可靠性更高？
innodb,更高，为啥？断电？
有啥机制？回滚？
6、redis的zset底层数据结构？
7、对哪种算法最熟悉？
拆成小问题，子问题重叠，符合动态规划的题型？
8、ranker多线程异步解决问题？

15、好未来一面(44min)

自我介绍
2、实习项目介绍
3个数据流，session+restore+sission数据库个人常走，大家的高热路线。check，eta,restore，排序模型，
3、oe监控平台,预发环境：AB,比较，灰度发布，用到什么中间键：阿波罗，ression数据库，线上发布平台，监控平台，每个trace请求,
查看日志，
pm,qa，rd, 策略算法。
4、遇到的问题？
及时的和它门交流，一下子就解决了。
5、并发并行，
6、go的数据结构，
2类：
值传递，
引用传递，slice,map，chan,

8、算法题：（理解错了，写错了，不过即时理解对了，也不会写！）
重排链表1423
限定语言：Python、C++、Java、Go、C、Javascript、Python 3
将给定的单链表
要求使用原地算法，不能只改变节点内部的值，需要对实际的节点进行交换。

示例1
输入
{1,2,3,4}
输出
{1,4,2,3}
说明
给定head链表1->2->3->4, 重新排列为 1->4->2->3,会取head链表里面的值打印输出
示例2
输入
{1,2,3,4,5}
输出
{1,5,2,4,3}

15.2、二面(38min)

自我介绍
2、项目、技术栈，（问的比较顶层，显得很有水平）
3、进程，线程，
4、什么时候自定义构造函数(拷贝构造函数)，析构函数，
我回答的是什么时候调用拷贝构造函数，那3种。感觉有点答非所问。
5、c++的容器？容器的底层实现？
顺序容器，关联容器。
string底层
vector底层
deque底层
vector,string,map，set,
我答map底层使用hash实现，感觉是错的？
STL的map底层是用红黑树实现的，查找时间复杂度是log(n)
6、TCP的报文格式？rtt是啥？MSL是啥？MTU?
rrt有啥作用？第4次挥手的正确接收，超时重传。
往返时延（Round-Trip Time，RTT）
MSL 是Maximum Segment Lifetime英文的缩写，中文可以译为“报文最大生存时间”，
ip头中有一个TTL域，TTL是 time to live的缩写，中文可以译为“生存时间”，

7、pcb里边都有啥？
1.进程ID（
2.特征信息：一般分系统进程、用户进程、或者内核进程等
3.进程状态：运行、就绪、阻塞，表示进程现的运行情况
4.优先级：表示获得CPU控制权的优先级大小
5.通信信息：进程之间的通信关系的反映，由于操作系统会提供通信信道
6.现场保护区：保护阻塞的进程用
7.资源需求、分配控制信息
8.进程实体信息，指明程序路径和名称，进程数据在物理内存还是在交换分区（分页）中
9.其他信息：工作单位，工作区，文件信息等 [1]

7、算法题？（理解错了，写错了，不过即时理解对了，也不会写！）
合并两个有序跳表，节点的值是一个有序的vector,

#include <iostream>
#include<vector>
using namespace std;
struct Node{
    vector<int> val;
    Node * next;
    Node(vector<int> & v):val(v),next(nullptr){}
};

Node *  solution (Node * head1,Node * head2){
    auto h1 = head1, h2 = head2;
    vector<int>v1(1);
    Node * dumpHead = new Node(v1,nullptr);
    auto res = dumpHead;
    
    while(h1 != nullptr && h2 != nullptr){
        if(h1->val < h2->val){
            dumpHead->next = h1;
            h1 = h1->next;
        }
        else{
            dumpHead->next = h2;
            h2 = h2->next;
        }
    }
    if(h1){
        dumpHead->next = h1;
    }
    else{
        dumpHead->next = h2;
    }
    return res->next;
    
}

int main() {
    //int a;
    //cin >> a;
    cout << "Hello World!" << endl;
}

15.3、3面hr (23min)

自我介绍，
成长，遇到的困难？怎么解决？
组内氛围？
4带1带我。
目标规划？
技术大佬？
多久？
1年？够吗？
有重复的工作吗？

16、阿里云

17、美团一面

问项目：
实验室：
滴滴：
问一些基础知识：
1、TCP粘包，就这一个没有回答上来。
把边界搞出来，报文长度。

算法题：直接返回数组中前k小的数.
先说思路：直接排序保存，然后追问还有啥思路？我说小根堆，他让写，我就说随便写一个，就：
直接调用库函数，sort（）一下子就秒了，面试官让写一个排序，就整了一个快排。

class Solution {
public:
    void qsort(vector<int> &nums,int l,int r){
        if(l >= r) return ;
        int i=l, j = r;
        
        while(i < j){
            while(i < j && nums[j] >= nums[l]) j--;
            while(i < j && nums[i] <= nums[l]) i++;
            swap(nums[i],nums[j]);
        }
        swap(nums[i],nums[l]);
        qsort(nums,l,i-1);
        qsort(nums,i+1,r);
    }
    
    
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        int n = input.size();
        if(n <= k) return input;
        qsort(input,0,input.size() - 1);
        vector<int>res(input.begin(),input.begin() + k);
        return res;
        
    }
};

17.2、美团二面

0、go介绍？
1、编译型语言，天然高并发，chan通道，垃圾回收，
1、go语言中chan的size()有的是0有的不是0的区别是什么？
2、go语言的特点？适合的场景
3、go语言是面向对象语言吗？
3.2、go语言怎么实现面向对象
go语言不支持面向对象的语法，但自己实现了对面向对象的支持。

• 1struct中匿名子段实现继承，
• 2、方法和函数的区别，自带调用的主题，不需要c++中隐喻的"this"和Python语言中令人困惑的"self"
• 3、接口是Go语言对面向对象支持的标志。实现了接口的所有方法，就是这个接口的实现类

4、你认为学习java语言主要学习什么？为什么要学习jvm?
java语言的重点：它的中间件，各种适用的场景。
为了编程中遇到问题，找解决办法。
5、你认为学习到什么程度就可以上手编程了？
6、你都怎么学习的？
看书，视频
6、滴滴最大的技术在哪里？
派单，发单。
7、学习一个新语言做个比较看看，go语言哪里实现了多态？
8、软件工程主要讲什么？什么是软件危机？

18、虾皮二面：

自己设计用户登录，注册，需要考虑什么?
2、https怎么把自己的密钥发过去？不被截取？在这里插入图片描述

对称加密算法：DES、3DES、AES、Blowfish、IDEA、RC5、RC6
非对称加密算法：SSH, HTTPS, TLS，电子证书，电子签名，电子身份证
第三方发给C端的数字证书

3、redis中一致性hash,问题？
4、分布式数据库？
5、

19、深信服一面

1、mmap函数都做了啥？
零拷贝

2、define宏展开，怎样让他不展开，printf(),
后面如果没有#，或者双#，就展开到底，如果有就不展开了，
##是字符串拼接，

3、.S文件是什么状态的？汇编代码？
.c源文件---->预处理—>.i文件—>编译---->汇编语言源代码.s文件，---->汇编—>.o文件，------>链接—>可执行文件

4、arp协议会把ip转成百度的mac地址吗？
ARP 就是一种解决地址问题的协议，它以 IP 地址为线索，定位下一个应该接收数据分包的主机 MAC 地址。如果目标主机不在同一个链路上，那么会查找下一跳路由器的 MAC 地址。

5、icmp的作用，差错信息，可不可达，差错信息都有啥？】
检测网络通信故障和实现链路追踪，最典型的应用就是PING和tracerooute

6、动态分配内存？

7、如何执行一个函数？

19.2、深信服二面

第一题：马走日，给定最起终点，求最少步数到达
第二题：红黄蓝一行涂色问题
第三题：实现memcpy(void * dst, void * src, size_t n)函数
1、备用主节点有状态的同步吗？
计算到一部分之后，如果主节点挂了，重新计算吗？还是可以接着计算？
重新计算，我们主要是算法的提升。
2、分任务的时候，分完了，如果从节点挂掉了，怎么办？他这个节点上的任务怎么办？
会在最后有一个同步等待的过程。只有都完成了才会接着进行下一步，如果有一个没完成任务，就都等着，重新分配。所以才会每个pi只启动2个进程。

深信服sp加面（现场面，挂了）

1、问实验室的项目
特别仔细，都要讲的很清楚。
2、问实习经历
3、学得最好的一门课？
上次答得算法，这次回答操作系统，下次再有这个问题，就回答c++语言。
进程调度。阻塞，内存上阻塞，外存上阻塞。外存上阻塞不能说成挂起。
问了一个小时多点，然后sp没加上。

深信服hr

15分钟左右，知道了sp没过，就是一个小白菜。

20、知乎

1、服务注册发现？
2、hash扩容？
redo,undolog
4、redis中zset为啥是跳表？

21、蚂蚁

1、树莓派系统升级了哪些东西？
2、树莓派系统要怎么给别人用呢？
3、面试题，一个出现一次，其余出现2次，求出这个数？

auto res = 0;
for(auto tem : nums){
	res ^=tem;
	}
	return res;

面试题2：找出二叉树的最大高度
非递归的和递归的，
递归的写法有点卡，！！！

21.2 蚂蚁二面

自我介绍：
介绍下实习？
根据简历发问？
1、做过哪些排查问题的事情？
2、使用top之后，机器负载很高，但是cpu空闲是怎么回事？
io密集型任务，cpu密集型任务，1、当大量io队列时候会出现这种情况。
3、
平面有n个点，构成图，怎么搞？
最小生成树，k算法，p算法
并查集
4、100台机器，每个有一个日志文件，统计日志文件的每一行出现关键字的行出现的次数，
例子：
第一行：蚂蚁123
第二行：蚂蚁abc
第三行：蚂蚁123
第四行：123abc
关键字：蚂蚁，
所以：
蚂蚁123 出现两次，
蚂蚁abc 出现一次，
我回答：每个机器 把出现关键字 的行搞进map,统计，然后汇总到同一台机器，再分组规约到一起，传送消息的时候，通过NFS，需要保证数据没有丢失，或者出错，通过md5加密。
3、滴滴学到了什么？
demo->大型项目
结构清晰，统一rpc，
编码规范，Google统一标准，
有问题及时沟通，自己的难题，他们解释之后很简单，
一直也在写东西，
开会分析问题，

4、

22、抖音客户端

1、http和rpc的区别，为啥大家搞rpc?
HTTP 它是协议，交互格式，至于要不要用 HTTP 这个格式，就是大家自己看着办。
RPC远程过程调用----> 本地调用

1、想即使服务被拆分了但是使用起来还是和之前本地调用一样方便。
所以就出现了 RPC 框架，来屏蔽这些底层调用细节，使得我们编码上还是和之前本地调用相差不多。
2、http冗余，RPC 都是内部调用所以不需要太考虑通用性，只要公司内部保持格式统一即可。
3、做各种定制化的协议来使得通信更高效
4、三方平台提供的接口都是通过 HTTP 协议调用的

2、QQ和微信好用，浏览器不好用，怎么排查问题？
思路1：比较qq和浏览器用到的相同的地方，不同的地方，
思路二：换个浏览器试试，
思路3：对面资源有问题，
3、宏定义和内联函数的区别，不同优缺点，
类型检查
预处理，运行时
文本替换，传参调用
宏不能调试，inline可以调试
提高程序的运行效率：使用带参数的宏既代替了函数的功能，又避免了函数入栈和出栈操作，减少了系统的开销，提高了运行的效率。

4、c和c++的区别？
5、
面评：基础知识中规中矩。
2、抗压能力，一个题不行，也没事。

23、百度一面（52min）

1、自我介绍
2、实习：多进程异步协调子问题？有多个子线程数据依赖吗？怎么解决的？
3、c++基础知识：虚函数？
手写了一个const char *p1, char const * p2,还有一个，问他们的区别？
map和unordered_map的区别？如果自定义数据填充map,需要注意什么？自定义比较器。除了自定义比较器，还能真么解决？我回答：那就没必要使用map了，可以使用其他的数据结构，map就是为了那个红黑树结构。
4、进程通信，线程同步？
5、数据库：主键索引和自己建立的索引的区别？
6、聚集索引和非聚集索引的区别？
7、算法题：给一个全局变量，很多线程，如何保证线程安全？

P *p = nullptr;
*P getinstance(){

};

解法

 mutex mtx;  // 锁
P *p = nullptr;
*P getinstance(){
	mtx.lock();
	return p;
	ntx.unlock();
};

24、京东

1、精简指令集和复杂指令集的区别？
X86有一个好的都要移植过去？
2、模型排序，为啥要重排？修改模型参数不就行了？为啥需要人工重排？
因为会动态换路，行程中多路线的时候换路需求，参数不能都传给了模型，传给模型的参数是一开始能传的，后边的参数还没有发生！

3、grpc，传一个int，过程，
如果修改成字符串，应该怎么做呢？

4、负载均衡和服务发现？
5、4次挥手
6、ip和域名的对应关系，
域名就像人的名字一样，有大名、小名、外号等等多个称谓，人还是同一个。
7、https和http，怎么传那个密钥？
使用对方的公钥加密传、
算法题1：

A表
user_id  class

B表
user_id score
求按班级总分降序排列的sql

算法题2：
123454321
求折线点，

//自己写的，考虑了左右两边，这样会出现，如果只有两个元素，会越界的问题
int find(vector<int>& arr) {
	int n = arr.size();
	int i = 0, j = n - 1;
	while (i < j) {
		int mid = i + (j - i) / 2;
		if (mid - 1 >= 0 && arr[mid - 1] < arr[mid] && (mid + 1) <= j && arr[mid]> arr[mid + 1]) {
			return arr[mid];
		}
		else if (arr[mid - 1] > arr[mid]) {
			j = mid;
		}
		else {
			i = mid;
		}
	}
}

// 正常只需要考虑右侧就行，

25、百度实习一面211019

1、写一个二叉树的遍历
2、写一个二叉搜索树的插入操作
3、写一个map使用二叉搜索树实现的插入接口

// 在线面试平台。将链接分享给你的朋友以加入相同的房间。
// Author: tdzl2003<dengyun@meideng.net>
struct Node{
  int key;
  int val;
  Node * left;
  Node * right;
  Node(int k, int v):key(k),val(v),left(nullptr),right(nullptr){}
};
void preOrder(Node * root, vector<int>& res){
  if(!root) return;
  res.push_back(root->val);
  preOrder(root->left,res);
  preOrder(root->right,res);
}
vector<int> preTraversal(Node * root){
  vector<int> res;
  preOrder(root,res);
  return res;
}

void insert(Node * root, Node * node){
 	if(!root) root = node;
  
  if(root->left == nullptr && root->key > node->key){
   	root->left = node; 
    return;
  }
  else if(root->right == nullptr && root->key < node->key){
    root->right = node;
    return;
  }
  else if(root->left && root->key > node->key){
   	insert(root->left,node); 
  }
  else if(root->right && root->key < node->key){
    insert(root->right,node);
  }
  
  
  3  4
}


class MyMap {
  private:
  Node *p;
  MyMap(){
   p = new Node(-1,-1);
  }
public:
  void insert(int key, int value){
    Node * p1 = new Node(key,value);
    insert(p,p1);
    
    
  }
};


struct ListNode{
  int val;
  ListNode * next;
  ListNode(int v):val(v),next(nullptr){}
};

ListNode * reverseList(ListNode * head){
  if(!head || !head->next) return head;
  ListNode * pre = nullptr;
  auto cur = head;
  auto tem = head;
  while(cur){
    tem = cur->next;
    cur->next = pre;
    
    pre = cur;
    cur = tem;
  }
  return pre;
}

26、百度校招一面

1、集群的任务调度，多线程怎么安排？高性能计算这块了解不深入。
只有一个配置文件，配置每个树莓派开多少个进程，静态的读取配置。
任务调度这一块涉及的比较少。
所有进程，按mpi分组根据任务分组，如果能整除就快，如果不能整除，就会等待。
多线程高性能调度计算这块了解不深入。主要工作是算法层面的加强。
查mpi底层怎么高性能调度？

1.1，你会怎么优化等待时间？
没得优化啊，这里必须等待这个任务完成才能下一步。

2、grpc，介绍一下。

2.2、定制两个模块使用grpc，交互？
实现。说下步骤，设计流程？

忘记说序列化，反序列化了，
微服务消费者
微服务动态代理
协议请求（序列化）
rpc客户端。
3、析构函数的调用场景？
delete时候，

4、www页面打不开，怎么排查？有什么工具？
首先看返回的状态码，确定哪里出现了错误。
域名解析出现了问题？缓存没及时更新。

5、utf-8编码，一个文件10亿行，每行<=10个字符，估算一下多大？

10G,
一个机器内存只有500M，统计词频最多的10行？
文件名a.txt.
首先让写shell命令，不会
又让写c++,

27、小米一面20211020（一共两面24 * 14）

1、go语言中，函数和方法的区别，方法的发起者，是struct和struct的指针的区别？
在使用上的考虑：方法是否需要修改接收器？如果需要，接收器必须是一个指针。
在效率上的考虑：如果接收器很大，比如：一个大的结构体，使用指针接收器会好很多。
在一致性上的考虑：如果类型的某些方法必须有指针接收器，那么其余的方法也应该有指针接收器，所以无论类型如何使用，方法集都是一致的。

2、kill -9 和kill -15的区别？
kill -15 == kill 优雅，安全的的退出，SIGterm
3、

算法体：求一个字符串的最长回文串

28百度校招2面

1、grp流程？
2、用户态，内核态区别？
3、http和https的区别？
4、你知道的O(NlogN)时间复杂度算法？
5、用的传输文件的命令？
wget,scp,sz，rz,sftp

算法题：跑楼梯，斐波那契数列
2、lru
3、链表变成1423

29、360二面

1、如果内存泄漏怎么调试，都用过什么内存泄漏的工具。
2、平时代码出问题了？怎么调试的？
gbk,调试
3、
算法题：123—> 一百二十三
一个战士的战斗力是5，可以挑战1-5层，问有1-1000层，给你两个相同战斗力的战士，最少挑战多少次？可以确定出战士的战斗力？

30、百度实习2面

capacity()开辟内存，没有初始化，只能push_back()而不能使用[]访问。
resize（）会改变size()的值。
clear（）
vector中的resize,和clear区别

clear()之后，
将会清空temp中的所有元素，包括temp开辟的空间（size），但是capacity会保留，即不可以以temp[1]这种形式赋初值，只能通过temp.push_back(value)的形式赋初值。
那如何把vector的capacity置0？
vectorres;
nums.swap(res);

2、锁的开销？
互斥锁，会有进程调度上下文切换的开销
自旋锁，会有cpu忙等待，占用cpu资源的开销。
3、

百度实习3面（过了）

空间局部访问性：
时间局部性：循环
循环展开优化的角度是：指令流水线。

31、京东1面（算法1028）

1、3级缓存
伪共享
2、

5、算法题
定长数组实现队列

32、京东二面（算法）

为啥要人工重排？
运营和产品调整和干预的接口。
自研树莓派系统—> 分布式集群。
3、过程中遇到的难题？怎么解决的?
4、硬盘做存储器，而不是做内存！
5、
然后面试官自己介绍了一下自己的业务：
商业提升，广告部门，广告算法组，
模型训练，特征工程。

32、京东加面4面（算法）

1、内存布局：按行存->内存中不连续，跳跃性访存-> 缓存命中率不高，128B,27 * 8B=216B
解决：所有行一次分配内存，然后顺序存储。

2、高斯赛德尔算子中的 数据访问顺序改进，两层for循环反向—>同向。

3、多线程：解决数据依赖，着色法。
外层增加一层颜色迭代器循环，同一种颜色内：去并行循环处理。循环“I”可以通过插入编译器指令来并行处理

4、两个内核的循环优化：短循环展开。指令流水线

1、堆排序，快排，介绍步骤，时间复杂度，稳定吗，不稳定的原因？

2、python和c语言的区别？
除了编译型语言，解释型语言，快慢。还有啥？
从内存，多线程的角度说下？

3、设计模式？原理，设计哲学。思路？
单例模式：为了解决
适配器模式：
适配器模式本意是复用已有的代码,对已经存在的功能进行包装转换,以另一种形式提供出去.比如HashSet,对于调用方来说其内部使用的HashMap是不可见的,调用方不关心内部被适配者是谁,只是关注该功能本身也就是Set接口.

装饰者模式本意是增强功能,其装饰者与被装饰者对于调用方是很清晰的,比如ContreteDecoratorA decoratorA = new ContreteDecoratorA(new ComponentInterfaceImpl());就很清晰的知道使用ContreteDecoratorA装饰了ComponentInterfaceImpl.另外ContreteDecoratorA并没有改变ComponentInterfaceImpl的功能提供出去,而是为其进行了增强处理

4、cpu都有啥？

33,京东5面

1、先写一个图的深度或者广度优先遍历。
（没写出来）给换了一个字符串去重。

2、实习时候用到的设计模式，场景？
3、一些常见的机器学习模型。知道哪些？
4、虚继承？
5、纯虚函数，和虚函数的区别、
6、自己的优势？
7、

34、荣耀1面

1、路线精排你的评判标准是什么？
粗排有模型的评测指标，
精排我有自己的评判指标，红路灯个数（乘车体验），走不走高速。
2、你做的啥模块？
5、怎么判断这个乘客的个人常走路线？
6、排序的算法是啥？精排的算法是啥？
3、const作用，
4、为啥析构函数要是虚函数？

7、

谢谢你的参与？

35、荣耀2面()

因为已经找到工作，而且他们爽约让我白等40分钟，我就直接拒了，