今日頭條後端面試記錄

時間 2019-11-06

標籤今日頭條後端面試記錄欄目快樂工作简体版

原文原文鏈接

前言

最近參加了一下頭條後端工程師的面試, 很慘, 一面就掛掉了.java

回來以後也對面試過程作了一些總結,就不夾帶私貨了,這篇文章主要對面試過程當中的技術問題作一個覆盤.node

1. 求二叉樹的最遠節點的距離

這是一道 LeetCode 原題, 原題連接面試

求二叉樹的最遠距離節點間的節點. 首先總結幾個規律:redis

一棵樹的直徑要麼徹底在其左子樹中,要麼徹底在其右子樹中, 要麼路過根節點.
一棵樹的直徑 = 以該樹中每個節點爲根節點, 求路過根節點的最大直徑, 全部節點的最大值就是這棵樹的直徑.
求通過根節點的直徑, 能夠分解爲: 求左子樹的最深葉子 + 右子樹的最深葉子.

因此咱們要作:後端

遞歸的求每個節點的 路過根節點的直徑(求當前節點的左子樹最深葉子和右子樹的最深葉子),取其最大值.
求某一個節點的最深葉子, 就等於他的左子樹最深葉子 + 1 和右子樹最深葉子 + 1 的較大值.
在求最深葉子的時候, 實際上是求出了當前節點直徑的(左邊最深葉子 + 右邊最深葉子 + 2), 爲了不重複計算, 咱們在遞歸求最深葉子的時候, 把直徑也記錄下來.)

代碼以下:安全

public int diameterOfBinaryTree(TreeNode root) {
       AtomicReference<Integer> ret = new AtomicReference<>(0);
        find(root, ret);
       return ret.get();
   }

   private int find(TreeNode node, AtomicReference<Integer> result) {
       if (node == null) return 0;
       int left = 0, right = 0;
       if (node.left != null) left = find(node.left,result) + 1;
       if (node.right != null) right = find(node.right,result) + 1;
       int tmp = Math.max(result.get(), left + right);
       result.set(tmp);
       return Math.max(left, right);
   }
複製代碼

代碼很簡單, 就是遞歸的求節點的左子樹最遠葉子和右子樹最遠葉子. 而後在計算過程當中, 將 當前節點的直徑 做爲一個備選項存儲,最後求最大直徑便可.服務器

2. Java的裝箱與拆箱

Java在1.5添加了自動裝箱和拆箱機制. 總的來講基本就是基本類型和對應的包裝類型之間的自動轉換.微信

以下面的代碼中:併發

public class BoxTest {
    public static void main(String [] args){
        Integer a = 10; // 裝箱
        int b = a; // 拆箱
    }
}
複製代碼

咱們將代碼編譯以後進行反編譯, 能夠看到函數

很明顯在代碼中的 #2 ,#3 處進行了裝箱和拆箱.

分別調用了Integer的 valueOf 方法和intValue 方法.

3. CMS垃圾收集器的收集過程當中,何時會暫停用戶線程?

這裏不對全部的垃圾收集器展開講解, 有興趣的朋友們能夠移步 JVM的數據區域與垃圾收集.

衆所周知, CMS的垃圾收集過程以下:

因此在初始標記和從新標記兩個階段仍是須要暫停用戶線程的.

4. ConcurrentHashMap在讀取的過程當中爲何不須要加鎖?

查看ConcurrentHashMap 的源碼能夠發現, Node節點的定義是:

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;
}
複製代碼

能夠看到, 裏面定義了幾個屬性, 分別以下:

final修飾的hash值,初始化後不能再次改變.
final修飾的key,初始化後不能再次改變.
volatile 修飾的值
volatile 修飾的下一節點指針

在get(Ojbect)方法的調用過程當中.

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //獲取hash值
    int h = spread(key.hashCode());
    //經過tabat獲取hash桶, tabAt是一個線程安全的操做, 有UnSafe來保證的.
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        //若是該hash桶的第一個節點就是查找結果,則返回
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //第一個節點是樹的根節點,按照樹的方式進行遍歷查找
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        //第一個節點是鏈表的根節點,按照鏈表的方式遍歷查找
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}
複製代碼

在這個過程當中,

獲取hash桶的根節點, 經過 tabAt 來操做, 線程安全.
遍歷的時候用到了node的next屬性, 因爲其與volatile修飾的, 因此線程間可見,出現併發問題.
返回時讀取node的volatile屬性val.

因此 get 過程當中不用加鎖也能夠正確的獲取對象.

5. Redis的字典rehash和JDK中hashmap等rehash有什麼不一樣?

這個問題比較寬泛,我我的的理解有如下兩點.

hashmap rehash的時候的另一張table是臨時建立的. 而 redis 是時刻保持兩張表的引用的. 只是在須要rehash的時候才分配足夠的空間.
hashmap rehash是一次性的,集中的完成rehash過程, 而redis是漸進式hash.

hashmap的rehash過程想必你們都是瞭解的, 那麼這麼稍微說一下redis的漸進式hash.

首先, rehash是要將原來表中的全部數據從新hash一遍,存放到新的表格中, 以進行擴容.

而redis是一個單線程的高性能的服務, 若是一個hash表中有幾億條數據, rehash 花費的時間將比較長, 而在此期間, redis是沒法對外提供服務的, 這是不可接受的.

所以, redis實現了漸進式hash. 過程以下:

假如當前數據在ht[0]中, 那麼首先爲ht[1]分配足夠的空間.
在字典中維護一個變量, rehashindex = 0. 用來指示當前rehash的進度.
在rehash期間, 每次對字典進行增刪改查操做, 在完成實際操做以後, 都會進行一次rehash操做, 將 ht[0] 在rehashindex 位置上的值rehash到ht[1]上. 將 rehashindex 遞增一位.
隨着不斷的執行, 原來的 ht[0] 上的數值總會所有rehash完成, 此時結束rehash過程.

在上面的過程當中有兩個問題沒有提到: