【Golang开发面经】百度（三轮技术面）

// Go map 的底层结构体表示
type hmap struct {
    count     int    // map中键值对的个数，使用len()可以获取 
    flags     uint8
    B         uint8  // 哈希桶的数量的log2，比如有8个桶，那么B=3
    noverflow uint16 // 溢出桶的数量
    hash0     uint32 // 哈希种子

    buckets    unsafe.Pointer // 指向哈希桶数组的指针，数量为 2^B 
    oldbuckets unsafe.Pointer // 扩容时指向旧桶的指针，当扩容时不为nil 
    nevacuate  uintptr        

    extra *mapextra  // 可选字段
}

const (
    bucketCntBits = 3
    bucketCnt     = 1 << bucketCntBits     // 桶数量 1 << 3 = 8
)

// Go map 的一个哈希桶，一个桶最多存放8个键值对
type bmap struct {
    // tophash存放了哈希值的最高字节
    tophash [bucketCnt]uint8
    
    // 在这里有几个其它的字段没有显示出来，因为k-v的数量类型是不确定的，编译的时候才会确定
    // keys: 是一个数组，大小为bucketCnt=8，存放Key
    // elems: 是一个数组，大小为bucketCnt=8，存放Value
    // 你可能会想到为什么不用空接口，空接口可以保存任意类型。但是空接口底层也是个结构体，中间隔了一层。因此在这里没有使用空接口。
    // 注意：之所以将所有key存放在一个数组，将value存放在一个数组，而不是键值对的形式，是为了消除例如map[int64]所需的填充整数8（内存对齐）
    
    // overflow: 是一个指针，指向溢出桶，当该桶不够用时，就会使用溢出桶
}

【Golang开发面经】百度（三轮技术面）_排序算法

当向 map 中存储一个 kv 时，通过 k 的 hash 值与 buckets 长度取余，定位到 key 在哪一个bucket中，hash 值的高8位存储在 bucket 的 tophash[i] 中，用来快速判断 key是否存在。当一个 bucket 满时，通过 overflow 指针链接到下一个 bucket。

二面

又深挖项目，这次挖了快40分钟了。。

go里面 slice 和 array 有区别吗？

slice，是切片，是引用类型，长度可变。
array，是数组，是值类型，长度不可变。

slice的底层其实是基于array 实现的。

归并排序是稳定的吗？时间复杂度是多少？

是的，归并排序中相等元素的顺序不会改变。

总时间 = 分解时间+解决问题时间+合并时间。

分解时间就是把一个待排序序列分解成两序列，时间为一常数，时间复杂度o(1)。
解决问题时间是两个递归式，把一个规模为n 的问题分成两个规模分别为n/2 的子问题，时间为2T(n/2)。
合并时间复杂度为o(n)。
总时间T(n)=2T(n/2)+o(n)，这个递归式可以用递归树来解，其解是o(nlogn)。

所以是O(nlogn)

写一个归并排序吧

func mergeSort(arr *[]int, l int, r int) {
    if l >= r {
        //不可再分隔,只有一个元素
        return
    }
    mid := (l+r)/2
    mergeSort(arr,l,mid)
    mergeSort(arr,mid+1,r)
    if (*arr)[mid] > (*arr)[mid+1] {
        merge(arr, l, mid, r)
    }
}

//将arr[l...mid]和arr[mid+1...r]两部分进行归并
func merge(arr *[]int, l int, mid int, r int)  {
    //先把arr中[l..r]区间的值copy一份到arr2
    //注意:这里可优化，copyarr 可改为长度为r-l+1的数组,下面的赋值等操作按偏移量l来修改即可，
    copyarr := make([]int, r+1)
    for index := l; index <= r; index++ {
        copyarr[index] = (*arr)[index]
    }
    //定义要合并的两个子数组各自目前数组内还没被合并的首位数字下标为i,j
    //初始化i，j
    i := l
    j := mid+1
    //遍历并逐个确定数组[l,r]区间内数字的顺序
    for k := l; k <= r; k++ {
        //防止i/j"越界"，应该先判断i和j的下变是否符合条件（因为两个子数组应该符合i<=mid j<=r）
        if i > mid {
            (*arr)[k] = copyarr[j]
            j++
        }else if j > r {
            (*arr)[k] = copyarr[i]
            i++
        }else if copyarr[i] < copyarr[j] {
            (*arr)[k] = copyarr[i]
            i++
        }else{
            (*arr)[k] = copyarr[j]
            j++
        }
    }
}

func TestMerge(t *testing.T) {
    arr := []int{8,6,2,3,1,5,7,4}
    mergeSort(&arr, 0, len(arr)-1)
    fmt.Println(arr)
}

空chan和关闭的chan进行读写会怎么样？

空chan

读会读取到该chan类型的零值。
写会直接写到chan中。

关闭的chan

读已经关闭的 chan 能一直读到东西，但是读到的内容根据通道内关闭前是否有元素而不同。如果有元素，就继续读剩下的元素，如果没有就是这个chan类型的零值，比如整型是 int，字符串是"" 。
写已经关闭的 chan 会 panic。因为源码上面就是这样写的，可以看src/runtime/chan.go