字节后端一面面经

布隆过滤器

PS：使用多个哈希函数：减少哈希冲突，降低判断数据是否存在的误判率

os调度算法

索引（结构、回表、下推、索引覆盖）

Redis实现分布式锁的方式和Zookeeper，两种方式对比、优缺点

redis

Zookeeper

讲一下缓存击穿，实际生产环境中会有什么情况造成缓存击穿？

讲一下nginx除了轮询还有什么方法？轮询和最小连接数分别用在什么地方，最小连接数的连接具体是什么？

最小连接数指的是后端服务器当前正在处理的活跃连接数，包括正在进行的请求。Nginx 会选择连接数最少的服务器来处理新请求，以确保负载均衡。

讲一下HTTP里面长连接和短连接，分别会在什么场景使用

长连接通常用于需要频繁通信的应用场景，如即时通讯、在线游戏等。 短连接是指在每次通信结束后立即关闭连接，下次通信时需要重新建立连接。 短连接在网络通信中的优点是避免了长时间的连接占用，可以更好地控制网络资源的使用情况。 短连接通常用于数据传输不频繁的应用场景，如HTTP请求、文件下载等。

讲一下Redis的Zset表，你说底层用到了跳表，那么他和红黑树的区别在哪里呢？你说跳表用了索引实现，那如果我插入一个数据后会导致索引不可用吗？

Redis 的 Zset（有序集合）

Zset 是 Redis 提供的一种数据结构，允许存储唯一的元素，每个元素都有一个关联的分数（score），根据分数进行排序。它支持高效的范围查询和排序操作。

跳表与红黑树的区别

1. 数据结构

• 跳表：是一种概率性数据结构，由多个层级的链表组成。每一层都是一份有序链表，底层包含所有元素，随着层级的增加，元素数量逐渐减少。
• 红黑树：是一种自平衡的二叉搜索树，通过颜色标记节点来保持树的平衡，确保操作的时间复杂度为 O(log n)。

2. 性能

• 跳表：
  • 平均时间复杂度为 O(log n) 的插入、删除和查找。
  • 对于简单的实现，跳表的常数因子较小，性能较好。
• 红黑树：
  • 在最坏情况下，所有操作的时间复杂度也是 O(log n)，但由于树的结构，常数因子可能较大。

3. 实现复杂性

• 跳表：相对简单，容易实现。
• 红黑树：实现复杂，需要保持树的平衡，涉及旋转和颜色调整。

课程表

https://leetcode.cn/problems/course-schedule/

func canFinish(numCourses int, prerequisites [][]int) bool {
    book := make([]int, numCourses)
    mp := make([][]int, numCourses)
    for _,v :=  range prerequisites{
        mp[v[1]] = append(mp[v[1]], v[0])
        book[v[0]]++
    }
    ans := 0
    for i:=0;i<numCourses;i++{
        if book[i]==0{
            find(mp, book, i, &ans)
        }
    }
    return ans==numCourses
}

func find(mp [][]int, book []int, x int, ans *int){
    if book[x]==0{
        *ans++
    }
    book[x]--
    for _,v := range mp[x]{
        book[v]--
        if book[v]==0{
            find(mp, book, v, ans)
        }
    }
}

二叉搜索树转换为双向链表

https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&&tqId=11179&qru=/ta/coding-interviews/question-ranking

package main
import (
    . "nc_tools"
    "fmt"
)
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
 * 
 * @param pRootOfTree TreeNode类 
 * @return TreeNode类
*/
func Convert( pRootOfTree *TreeNode ) *TreeNode {                                                                                   
    if pRootOfTree==nil{
        return nil
    }
    now := pRootOfTree
    l := Convert(pRootOfTree.Left)
    r := Convert(pRootOfTree.Right)
    now.Left = nil
    now.Right = nil
    var root *TreeNode
    if l!=nil{
        root = l
        for l.Right!=nil{
            tmp := l.Right
            tmp.Left = l
            l = tmp
        }
        l.Right = now
        now.Left = l
    }else{
        root = now
    }
    now.Right = r
    if r!=nil{
        r.Left = now
    }
    for r!=nil && r.Right!=nil{
        r.Right.Left = r
        r = r.Right
    }
    return root
}