2024届快手测试开发面试面经

总共三面，技术面都参加了，题目也全部回答出来了，但是最终没过。

一面

1. 最熟悉的编程语言

我说是C++和python

2. C++ static的作用

3. C++ const的作用

4. coding

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 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 均按 非递减顺序 排列

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = None

def merge(l1, l2):
    head1 = ListNode(0)
    p1 = head1
    for i in l1:
        t1 = ListNode(i)
        p1.next = t1 
        p1 = p1.next 
    
    head2 = ListNode(0)
    p2 = head2
    for i in l2:
        t2 = ListNode(i)
        p2.next = t2 
        p2 = p2.next 
    
    res = ListNode(0)
    p = res
    h1 = head1.next
    h2 = head2.next
    while h1 != None and h2 != None:
        if h1.val <= h2.val:
            t1 = h1.next
            h1.next = None
            p.next = h1
            p = p.next
            h1 = t1
        else:
            t2 = h2.next
            h2.next = None
            p.next = h2
            p = p.next
            h2 = t2
    if h1 != None:
        p.next = h1 
    if h2 != None:
        p.next = h2 
    return res.next

# l1 = [1,2,4]
# l2 = [1,3,4]

# l1 = []
# l2 = []

l1 = []
l2 = [0]

head = merge(l1, l2)
while head != None:
    print(head.val, end = " ")
    head = head.next

5. coding

实现快速排序

def findpos(a, l, r):
    tmp = a[l]
    left, right = l, r 
    while left <= right:
        while left <= right and tmp >= a[left]:
            left += 1
        while left <= right and tmp < a[right]:
            right -= 1
        t = a[left]
        a[left] = a[right]
        a[right] = t 
    a[l] = a[left]
    a[left] = tmp
    return right

def quicksort(a, l, r):
    if l >= r:
        return
    p = findpos(a, l, r)
    quicksort(a, l, p - 1)
    quicksort(a, p + 1, r)

arr = [1, 30, 10, 9, 54, 5, 43, 90, 8, 3, 2]
quicksort(arr, 0, len(arr) - 1)
print(arr)

二面

1. 问实习项目

2. 梯度爆炸的原因

3. 使用激活函数的原因

4. 为什么常见的激活函数是那几个

5. http,ip是哪一层

6. 拥塞控制算法

7. 延迟和抖动

8. 最擅长的编程语言是哪些？

9. 虚函数和纯虚函数

10. 分布式mysql

11. 主从同步

12. 多进程通信的方式有哪些

管道 共享内存 信号量 消息队列

13. coding

Leetcode 买股票

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。要求只能遍历一次数组

def f(arr):
    mi = arr[0]
    n = len(arr)
    ans = int(-1e9)
    for i in range(1, n):
        # if arr[i] > mi:
        ans = max(ans, arr[i] - mi)
        mi = min(mi, arr[i])
    return ans

arr = [6, 5, 4, 3, 2, 1]
print(f(arr))

三面

1. 问项目

2. 场景题: 怎么计算两个手机视频通话的端到端延时

条件和要求:

(1) 我身边有两台手机，可以自己操作

(2) 可以借助其他现实中存在的工具

(3) 尽可能精确

我的方案:

用秒表，拍摄一个移动的物体，记录它刚进入第一个手机的镜头的时间，记录它第二个手机刚出现这个手机的镜头的出现时间。

更好的方案:

直接拍摄秒表，记录两只手机出现的秒表记录的时间的时间差。

3. coding

1. 题目：已知某棵二叉树的前序遍历结果和这颗二叉树中序遍历结果，重建这棵二叉树

说明：（以C++为例）

- 树节点定义

  struct Node {

    Node* left;
 
    Node* right;
 
    int value;
 
  };

- 前序遍历：当遍历到某个节点时，先访问当前节点，再访问左子树，再访问右子树

- 中序遍历：当遍历到某个节点时，先访问左子树，再访问当前节点，再访问右子树

- 举例：

1

2 3

4 5 6

前序遍历结果：1 2 4 5 3 6

中序遍历结果：4 2 5 1 3 6

- 实现：Node* rebuild(int* pre_order, int pre_len, int* in_order, int in_len);

#include <iostream>
using namespace std;

Node* create(int* pre_order, int prel, int prer, 
int* in_order, int inl, int inr) 
{
    if(prel > prer) {return NULL;}
    Node *root = new node;
    root->value = pre_order[prel];
    int k = inl;
    for(int k = inl; k <= inr; ++k) 
    {
        if(in_order[k] == pre_order[prel]) { break; }
    }
    int numleft = k - inl;
    root->left = create(pre_order, prel + 1, prel + numleft, in_order, inl, k - 1);
    root->right = create(pre_order, prel + numleft + 1, prer, int_order, k + 1, inr);
}

Node* rebuild(int* pre_order, int pre_len, int* in_order, int in_len)
{
    Node *root = create(pre_order, 0, pre_len - 1,
    in_order, 0, in_len - 1);
    return root;
}

int main() {
    cout << "Hello World!" << endl;
}

4. 上述的二叉树应该使用哪些测试样例