2019年最新總結，阿里，騰訊，百度，美團，頭條等技術面試題目(一)

時間 2019-11-08

標籤 2019年最新總結阿里騰訊百度頭條技術面試題目欄目阿里巴巴简体版

原文原文鏈接

1.1.1 如何實現一個高效的單向鏈表逆序輸出？

出題人：阿里巴巴出題專家：昀龍／阿里雲彈性人工智能負責人node

參考答案：下面是其中一種寫法，也能夠有不一樣的寫法，好比遞歸等。供參考。python

typedef struct node{
    int           data;
    struct node*  next;
    node(int d):data(d), next(NULL){}
}node;

void reverse(node* head)
{
    if(NULL == head || NULL == head->next){
        return;
    }
    
    node* prev=NULL;
    node* pcur=head->next;
    node* next;
    
    while(pcur!=NULL){
        if(pcur->next==NULL){
            pcur->next=prev;
            break;
        }
        next=pcur->next;
        pcur->next=prev;
        prev=pcur;
        pcur=next;
    }
    
    head->next=pcur;
    node*tmp=head->next;
    while(tmp!=NULL){
        cout<<tmp->data<<"\t";
        tmp=tmp->next;
    }
}
複製代碼

1.1.2 已知sqrt(2)約等於1.414，要求不用數學庫，求sqrt(2)精確到小數點後10位

出題人：——阿里巴巴出題專家：文景／阿里雲 CDN 資深技術專家c++

參考答案：程序員

考察點

1.基礎算法的靈活應用能力（二分法學過數據結構的同窗都知道，但不必定往這個方向考慮；若是學過數值計算的同窗，應該還要能想到牛頓迭代法並解釋清楚）面試

2.退出條件設計算法

解決辦法

已知 sqrt(2)約等於 1.414，那麼就能夠在(1.4, 1.5)區間作二分查找，如： a) high=>1.5 b) low=>1.4 c) mid => (high+low)/2=1.45 d) 1.45*1.45>2 ? high=>1.45 : low => 1.45 e) 循環到 c)緩存
退出條件 a) 先後兩次的差值的絕對值<=0.0000000001, 則可退出bash

const double EPSINON = 0.0000000001;

double sqrt2( ){
    double low = 1.4, high = 1.5;
    double mid = (low + high) / 2;
    
    while (high – low > EPSINON){
        if (mid*mid < 2){
            high = mid;
        }
        else{
            low = mid;
        }
        mid = (high + low) / 2;
    }
    
    return mid;
}
複製代碼

1.1.3 給定一個二叉搜索樹(BST)，找到樹中第 K 小的節點

出題人：阿里巴巴出題專家：文景／阿里雲 CDN 資深技術專家數據結構

參考答案：app

考察點 1.基礎數據結構的理解和編碼能力

2.遞歸使用

說明：保證輸入的 K 知足 1<=K<=(節點數目）

樹相關的題目，第一眼就想到遞歸求解，左右子樹分別遍歷。聯想到二叉搜索樹的性質，root 大於左子樹，小於右子樹，若是左子樹的節點數目等於 K-1，那麼 root 就是結果，不然若是左子樹節點數目小於 K-1，那麼結果必然在右子樹，不然就在左子樹。所以在搜索的時候同時返回節點數目，跟 K 作對比，就能得出結果了。

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

class Solution {
    private class ResultType {
    
        boolean found;  // 是否找到
        
        int val;  // 節點數目
        ResultType(boolean found, int val) {
            this.found = found;
            this.val = val;
        }
    }

    public int kthSmallest(TreeNode root, int k) {
        return kthSmallestHelper(root, k).val;
    }

    private ResultType kthSmallestHelper(TreeNode root, int k) {
        if (root == null) {
            return new ResultType(false, 0);
        }

        ResultType left = kthSmallestHelper(root.left, k);

        // 左子樹找到，直接返回
        if (left.found) {
            return new ResultType(true, left.val);
        }

        // 左子樹的節點數目 = K-1，結果爲 root 的值
        if (k - left.val == 1) {
            return new ResultType(true, root.val);
        }

        // 右子樹尋找
        ResultType right = kthSmallestHelper(root.right, k - left.val - 1);
        if (right.found) {
            return new ResultType(true, right.val);
        }

        // 沒找到，返回節點總數
        return new ResultType(false, left.val + 1 + right.val);
    }
}

複製代碼

1.1.4 LRU 緩存機制設計和實現一個 LRU（最近最少使用）緩存數據結構，使它應該支持一下操做：get 和 put。 get(key) - 若是 key 存在於緩存中，則獲取 key 的 value（老是正數），不然返回 -1。 put(key,value) - 若是 key 不存在，請設置或插入 value。當緩存達到其容量時，它應該在插入新項目以前使最近最少使用的項目做廢。

出題人：文景／阿里雲 CDN 資深技術專家

參考答案：

python版本的：

class LRUCache(object):
    def __init__(self, capacity):
    """ :type capacity: int """
    self.cache = {}
    self.keys = []
    self.capacity = capacity
    
    def visit_key(self, key):
        if key in self.keys:
            self.keys.remove(key)
        self.keys.append(key)
    
    def elim_key(self):
        key = self.keys[0]
        self.keys = self.keys[1:]
        del self.cache[key]
        
    def get(self, key):
        """ :type key: int :rtype: int """
        if not key in self.cache:
            return -1
        self.visit_key(key)
        return self.cache[key]
    
    def put(self, key, value):
        """ :type key: int :type value: int :rtype: void """
        if not key in self.cache:
        if len(self.keys) == self.capacity:
        self.elim_key()
        self.cache[key] = value
        self.visit_key(key)

def main():
    s =
    [["put","put","get","put","get","put","get","get","get"],[[1,1],[2,2],[1],[3,3],[2],[
    4,4],[1],[3],[4]]]
    obj = LRUCache(2)
    l=[]
    for i,c in enumerate(s[0]):
        if(c == "get"):
            l.append(obj.get(s[1][i][0]))
        else:
            obj.put(s[1][i][0], s[1][i][1])
    print(l)

if __name__ == "__main__":
    main()

複製代碼

c++版本的：

class LRUCache{
    public:
        LRUCache(int capacity) {
            cap = capacity;
        }
        
        int get(int key) {
            auto it = m.find(key);
            if (it == m.end()) return -1;
            l.splice(l.begin(), l, it->second);
            return it->second->second;
        }
        
        void set(int key, int value) {
            auto it = m.find(key);
            if (it != m.end()) l.erase(it->second);
            l.push_front(make_pair(key, value));
            m[key] = l.begin();
            if (m.size() > cap) {
                int k = l.rbegin()->first;
                l.pop_back();
                m.erase(k);
            }
        }
}
複製代碼