一些面試題，整理自網絡

騰訊面試題：tcp三次握手的過程，accept發生在三次握手哪一個階段？

答accept發生在三次握手以後。

第一次握手：客戶端發送syn包(syn=j)到服務器。

第二次握手：服務器收到syn包，必須確認客戶的SYN（ack=j+1），同時本身也發送一個ASK包（ask=k）。

第三次握手：客戶端收到服務器的SYN＋ACK包，向服務器發送確認包ACK(ack=k+1)。

三次握手完成後，客戶端和服務器就創建了tcp鏈接。這時能夠調用accept函數得到此鏈接。

 

const的含義及實現機制，好比：const int i,是怎麼作到i只可讀的？

const用來講明所定義的變量是隻讀的。

這些在編譯期間完成，編譯器可能使用常數直接替換掉對此變量的引用。

 

用UDP協議通信時怎樣得知目標機是否得到了數據包

能夠在每一個數據包中插入一個惟一的ID，好比timestamp或者遞增的int。

發送方在發送數據時將此ID和發送時間記錄在本地。

接收方在收到數據後將ID再發給發送方做爲迴應。

發送方若是收到迴應，則知道接收方已經收到相應的數據包；若是在指定時間內沒有收到迴應，則數據包可能丟失，須要重複上面的過程從新發送一次，直到肯定對方收到。

 

求一個論壇的在線人數，假設有一個論壇，其註冊ID有兩億個，每一個ID從登錄到退出會向一個日誌文件中記下登錄時間和退出時間，要求寫一個算法統計一天中論壇的用戶在線分佈，取樣粒度爲秒。

一天總共有 3600*24 = 86400秒。

定義一個長度爲86400的整數數組int delta[86400]，每一個整數對應這一秒的人數變化值，可能爲正也可能爲負。開始時將數組元素都初始化爲0。

而後依次讀入每一個用戶的登陸時間和退出時間，將與登陸時間對應的整數值加1，將與退出時間對應的整數值減1。

這樣處理一遍後數組中存儲了每秒中的人數變化狀況。

定義另一個長度爲86400的整數數組int online_num[86400]，每一個整數對應這一秒的論壇在線人數。

假設一天開始時論壇在線人數爲0，則第1秒的人數online_num[0] = delta[0]。第n+1秒的人數online_num[n] = online_num[n-1] + delta[n]。

這樣咱們就得到了一天中任意時間的在線人數。

 

在一個文件中有 10G 個整數，亂序排列，要求找出中位數。內存限制爲 2G。

不妨假設10G個整數是64bit的。

2G內存能夠存放256M個64bit整數。

咱們能夠將64bit的整數空間平均分紅256M個取值範圍，用2G的內存對每一個取值範圍內出現整數個數進行統計。這樣遍歷一邊10G整數後，咱們便知道中數在那個範圍內出現，以及這個範圍內總共出現了多少個整數。

若是中數所在範圍出現的整數比較少，咱們就能夠對這個範圍內的整數進行排序，找到中數。若是這個範圍內出現的整數比較多，咱們還能夠採用一樣的方法將此範圍再次分紅多個更小的範圍（256M=2^28，因此最多須要3次就能夠將此範圍縮小到1，也就找到了中數）。

 

兩個整數集合A和B，求其交集。

1.      讀取整數集合A中的整數，將讀到的整數插入到map中，並將對應的值設爲1。

2. 讀取整數集合B中的整數，若是該整數在map中而且值爲1，則將此數加入到交集當中，並將在map中的對應值改成2。

經過更改map中的值，避免了將一樣的值輸出兩次。

2.      也能夠將A和B分別排序，而後利用歸併的思想搞定。

 

有1到10w這10w個數，去除2個並打亂次序，如何找出那兩個數？

申請10w個bit的空間，每一個bit表明一個數字是否出現過。

開始時將這10w個bit都初始化爲0，表示全部數字都沒有出現過。

而後依次讀入已經打亂循序的數字，並將對應的bit設爲1。

當處理完全部數字後，根據爲0的bit得出沒有出現的數字。

 

首先計算1到10w的和，平方和。

而後計算給定數字的和，平方和。

兩次的到的數字相減，能夠獲得這兩個數字的和，平方和。

因此咱們有

x + y = n

x^2 + y^2 = m

解方程能夠獲得x和y的值。

 

有1000瓶水，其中有一瓶有毒，小白鼠只要嘗一點帶毒的水24小時後就會死亡，至少要多少隻小白鼠才能在24小時時鑑別出那瓶水有毒？

最容易想到的就是用1000只小白鼠，每隻喝一瓶。但顯然這不是最好答案。

 

既然每隻小白鼠喝一瓶不是最好答案，那就應該每隻小白鼠喝多瓶。那每隻應該喝多少瓶呢？

 

首先讓咱們換種問法，若是有x只小白鼠，那麼24小時內能夠從多少瓶水中找出那瓶有毒的？

因爲每隻小白鼠都只有死或者活這兩種結果，因此x只小白鼠最大能夠表示2^x種結果。若是讓每種結果都對應到某瓶水有毒，那麼也就能夠從2^x瓶水中找到有毒的那瓶水。那如何來實現這種對應關係呢？

第一隻小白鼠喝第1到2^(x-1)瓶，第二隻小白鼠喝第1到第2^(x-2)和第2^(x-1)+1到第2^(x-1) + 2^(x-2)瓶....以此類推。

 

回到此題，總過1000瓶水，因此須要最少10只小白鼠。

 

根據上排給出十個數，在其下排填出對應的十個數, 要求下排每一個數都是上排對應位置的數在下排出現的次數。上排的數：0，1，2，3，4，5，6，7，8，9。

0，1，2，3，4，5，6，7，8，9

6，2，1，0，0，0，1，0，0，0

經過一個循環作，三次循環搞定.

任意0-N，都是N-3的位置是1，前面是N-4,2,1，其餘是0

 

給40億個不重複的unsigned int的整數，沒排過序的，而後再給幾個數，如何快速判斷這幾個數是否在那40億個數當中?

unsigned int 的取值範圍是0到2^32-1。咱們能夠申請連續的2^32/8=512M的內存，用每個bit對應一個unsigned int數字。首先將512M內存都初始化爲0，而後每處理一個數字就將其對應的bit設置爲1。當須要查詢時，直接找到對應bit，看其值是0仍是1便可。

 

IBM面試題：c++中引用和指針有什麼不一樣？指針加上什麼限制等於引用？

引用不是一個變量，它只表示該引用名是目標變量名的一個別名，它自己不是一種數據類型，所以引用自己不佔存儲單元，系統也不給引用分配存儲單元。引用一經肯定就不能修改。

指針是一個變量，須要在內存中分配空間，此空間中存儲所指對象的地址。因爲指針是一個普通變量，因此其值還能夠經過從新賦值來改變。

把指針定義爲const後，其值就不能改變了，功能和引用相似，但有本質的區別。

 

谷歌面試題：1024! 末尾有多少個0？

末尾0的個數取決於乘法中因子2和5的個數。顯然乘法中因子2的個數大於5的個數，因此咱們只需統計因子5的個數。

是5的倍數的數有： 1024 / 5 = 204個

是25的倍數的數有：1024 / 25 = 40個

是125的倍數的數有：1024 / 125 = 8個

是625的倍數的數有：1024 / 625 = 1個

因此1024! 中總共有204+40+8+1=253個因子5。

也就是說1024! 末尾有253個0。

 

谷歌面試題：給定能隨機生成整數1到5的函數，寫出能隨機生成整數1到7的函數

只要咱們能夠從 n 個數中隨機選出 1 到 n 個數，反覆進行這種運算，直到剩下最後一個數便可。

咱們能夠調用 n 次給定函數，生成 n 個 1 到 5 之間的隨機數，選取最大數所在位置便可知足以上要求。

例如

初始的 7 個數 [1,2,3,4,5,6,7].

7 個 1 到 5 的隨機數 [5, 3,1,4,2,5,5]

那麼咱們保留下[1,6,7],

3 個1 到 5 的隨機數[2,4,1]

那麼咱們保留下[6]

6 就是咱們此次生成的隨機數。

 

產生K個數(k>1) 假定產生的數分別爲n1,n2,n3,n4...

那麼定義產生的數爲n1-1+（n2-2）*5+（n3-1）*5^2+（n4-1）*5^3........

因而產生的數位於區間（0，5^k-1)

而後把5^k分紅k等分，產生的數位於哪一個等分就是那個產生的隨機數（0~6），而後+1便可

若是位於k等分的餘數範圍，則從新執行一次上述過程

不用擔憂餘數問題，當k取3時落到餘數範圍的機率就已經下降爲6/125

 

判斷一個天然數是不是某個數的平方。固然不能使用開方運算。

假設待判斷的數字是 N。

 

方法1：

遍歷從1到N的數字，求取平方並和N進行比較。

若是平方小於N，則繼續遍歷；若是等於N，則成功退出；若是大於N，則失敗退出。

複雜度爲O(n^0.5)。

 

方法2：

使用二分查找法，對1到N之間的數字進行判斷。

複雜度爲O(log n)。

 

方法3：

因爲

(n+1)^2

=n^2 + 2n + 1，

= ...

= 1 + (2*1 + 1) + (2*2 + 1) + ... + (2*n + 1)

注意到這些項構成了等差數列（每項之間相差2）。

因此咱們能夠比較 N-1， N - 1 - 3， N - 1 - 3 - 5 ... 和0的關係。

若是大於0，則繼續減；若是等於0，則成功退出；若是小於 0，則失敗退出。

複雜度爲O(n^0.5)。不過方法3中利用加減法替換掉了方法1中的乘法，因此速度會更快些。

 

給定一個未知長度的整數流，如何隨機選取一個數？

方法1.

將整個整數流保存到一個數組中，而後再隨機選取。

若是整數流很長，沒法保存下來，則此方法不能使用。

 

方法2.

若是整數流在第一個數後結束，則咱們一定會選第一個數做爲隨機數。

若是整數流在第二個數後結束，咱們選第二個數的機率爲1/2。咱們以1/2的機率用第2個數替換前面選的隨機數，獲得知足條件的新隨機數。

....

若是整數流在第n個數後結束，咱們選第n個數的機率爲1/n。咱們以1/n的機率用第n個數替換前面選的隨機數，獲得知足條件的新隨機數。

....

利用這種方法，咱們只需保存一個隨機數，和迄今整數流的長度便可。因此能夠處理任意長的整數流。

 

設計一個數據結構，其中包含兩個函數，1.插入一個數字，2.得到中數。並估計時間複雜度。

1.      使用數組存儲。

插入數字時，在O(1)時間內將該數字插入到數組最後。

獲取中數時，在O(n)時間內找到中數。（選數組的第一個數和其它數比較，並根據比較結果的大小分紅兩組，那麼咱們能夠肯定中數在哪組中。而後對那一組按照一樣的方法進一步細分，直到找到中數。）

 

2. 使用排序數組存儲。

插入數字時，在O(logn)時間內找到要插入的位置，在O(n)時間裏移動元素並將新數字插入到合適的位置。

得到中數時，在O(1)複雜度內找到中數。

 

3. 使用大根堆和小根堆存儲。

使用大根堆存儲較小的一半數字，使用小根堆存儲較大的一半數字。

插入數字時，在O(logn)時間內將該數字插入到對應的堆當中，並適當移動根節點以保持兩個堆數字相等（或相差1）。

獲取中數時，在O(1)時間內找到中數。

 

谷歌面試題：在一個特殊數組中進行查找

給定一個固定長度的數組，將遞增整數序列寫入這個數組。當寫到數組尾部時，返回數組開始從新寫，並覆蓋先前寫過的數。請在這個特殊數組中找出給定的整數。

假設數組爲a[0, 1, ..., N-1]。

咱們能夠採用相似二分查找的策略。

首先比較a[0]和a[N/2]，若是a[0] < a[N/2]，則說明a[0,1,...,N/2]爲遞增子序列，不然另外一部分是遞增子序列。

而後判斷要找的整數是否在遞增子序列範圍內。若是在，則使用普通的二分查找方法繼續查找；若是不在，則重複上面的查找過程，直到找到或者失敗爲止。

 

谷歌面試題：給定兩個已排序序列，找出共同的元素

不妨假設序列是從小到大排序的。定義兩個指針分別指向序列的開始。

若是指向的兩個元素相等，則找到一個相同的元素；若是不等，則將指向較小元素的指針向前移動。

重複執行上面的步驟，直到有一個指針指向序列尾端。若是兩個數組大小差很少，用你的方法就好了，若是數組大小差得不少，就遍歷小的，而後在大的裏二分查找~

 

編程實現兩個正整數的除法，固然不能用除法操做符。

 

// return x/y.

int div(const int x, const int y) {

....

}

int div(const int x, const int y) {

int left_num = x;

int result = 0;

while (left_num >= y) {

    int multi = 1;

    while (y * multi <= (left_num >> 1)) {

       multi = multi << 1;

    }

    result += multi;

    left_num -= y * multi;

}

return result;

}

 

微軟面試題：計算n bit的整數中有多少bit 爲1

設此整數爲x。

方法1：

讓此整數除以2，若是餘數爲1，說明最後一位是1，統計值加1。

將除得的結果進行上面運算，直到結果爲0。

 

方法2：

考慮除法複雜度有些高，可使用移位操做代替除法。

將 x 和 1 進行按位與操做（x&1），若是結果爲1，說明最後一位是1，統計值加1。

將x 向右一位（x >> 1），重複上面過程，直到移位後結果爲0。

 

方法3：

若是須要統計不少數字，而且內存足夠大，能夠考慮將每一個數對應的bit爲1的數量記錄下來，這樣每次計算只是一次查找操做。

 

微軟面試題：快速求取一個整數的7倍

乘法相對比較慢，因此快速的方法就是將這個乘法轉換成加減法和移位操做。

能夠將此整數先左移三位（×8）而後再減去原值：X << 3 - X。

 

微軟面試題：判斷一個數是否是2的n次冪

設要判斷的數是無符號整數X。

首先判斷X是否爲0，若是爲0則不是2的n次冪，返回。

X和X-1進行按位與操做，若是結果是0，則說明這個數是2的n次冪；若是結果非0，則說明這個數不是2 的n次冪。

 

證實：

若是是2的n次冪，則此數用二進制表示時只有一位是1，其它都是0。減1後，此位變成0，後面的位變成1，因此按位與後結果是0。

若是不是2的n次冪，則此數用二進制表示時有多位是1。減1後，只有最後一個1變成0，前面的 1仍是1，因此按位與後結果不是0。

 

微軟面試題：判斷數組中是否包含重複數字

給定一個長度爲N的數組，其中每一個元素的取值範圍都是1到N。判斷數組中是否有重複的數字。（原數組沒必要保留）

方法1.

對數組進行排序（快速，堆），而後比較相鄰的元素是否相同。

時間複雜度爲O(nlogn)，空間複雜度爲O(1)。

 

方法2.

使用bitmap方法。

定義長度爲N/8的char數組，每一個bit表示對應數字是否出現過。遍歷數組，使用 bitmap對數字是否出現進行統計。

時間複雜度爲O(n)，空間複雜度爲O(n)。

 

方法3.

遍歷數組，假設第 i 個位置的數字爲 j ，則經過交換將 j 換到下標爲 j 的位置上。直到全部數字都出如今本身對應的下標處，或發生了衝突。

時間複雜度爲O(n)，空間複雜度爲O(1)。

 

微軟面試題：刪除鏈表中的重複項

一個沒有排序的鏈表，好比list={a,l,x,b,e,f,f,e,a,g,h,b,m}，請去掉重複項，並保留原順序，以上鍊表去掉重複項後爲newlist={a,l,x,b,e,f,g,h,m}，請寫出一個高效算法(時間比空間更重要)。

創建一個hash_map，key爲鏈表中已經遍歷的節點內容，開始時爲空。

從頭開始遍歷鏈表中的節點：

- 若是節點內容已經在hash_map中存在，則刪除此節點，繼續向後遍歷；

- 若是節點內容不在hash_map中，則保留此節點，將節點內容添加到hash_map中，繼續向後遍歷。

 

微軟面試題：編一個程序求質數的和

編一個程序求質數的和，例如F(7) = 2+3+5+7+11+13+17=58。

 

方法1：

對於從2開始的遞增整數n進行以下操做：

用 [2，n-1] 中的數依次去除n，若是餘數爲0，則說明n不是質數；若是全部餘數都不是0，則說明n是質數，對其進行加和。

 

空間複雜度爲O(1)，時間複雜度爲O(n^2)，其中n爲須要找到的最大質數值（例子對應的值爲17）

方法2：

能夠維護一個質數序列，這樣當須要判斷一個數是不是質數時，只需判斷是否能被比本身小的質數整除便可。

 

對於從2開始的遞增整數n進行以下操做：

用 [2，n-1] 中的質數（2，3，5，7，開始時此序列爲空）依次去除n，若是餘數爲0，則說明n不是質數；若是全部餘數都不是0，則說明n是質數，將此質數加入質數序列，並對其進行加和。

 

空間複雜度爲O(m)，時間複雜度爲O(mn)，其中m爲質數的個數（例子對應的值爲7），n爲須要找到的最大質數值（例子對應的值爲17）。

方法3：

也能夠不用除法，而用加法。

申請一個足夠大的空間，每一個bit對應一個整數，開始將全部的bit都初始化爲0。

對於已知的質數（開始時只有2），將此質數全部的倍數對應的bit都改成1，那麼最小的值爲0的bit對應的數就是一個質數。對新得到的質數的倍數也進行標註。

對這樣得到的質數序列累加就能夠得到質數和。

 

空間複雜度爲O(n)，時間負責度爲O(n)，其中n爲須要找到的最大質數值（例子對應的值爲17）

 

微軟面試題：給出一種洗牌算法

給出洗牌的一個算法，並將洗好的牌存儲在一個整形數組裏。

假設數組Card[0 - 53]中的54個數對應54張牌，從第一張牌（i = 0）開始直到倒數第二張牌（i = 52），每次生成一個[ i, 53]之間的數r，將Card[i]和Card[r]中的數互換。

 

微軟面試題：找到兩個單向鏈表的第一個公共節點

若是兩個單向鏈表有公共節點，則兩個鏈表會構成Y型結構，最後一個節點相同。

 

咱們能夠從頭開始遍歷兩個鏈表，找到最後一個節點的指針，設爲p_a，p_b。同時記錄下兩個鏈表的長度len_a，len_b（假設len_a >= len_b)。

若是p_a == p_b，則說明兩個鏈表有公共節點，不然沒有。

若是有公共節點，則第一個公共節點距起始節點的距離知足 len_a - start_a == len_b - start_b。

因此第一個可能的公共節點距起始節點的距離是 len_a - len_b, 0。咱們從這兩個節點開始比較，直到找到第一個公共節點。

 

微軟面試題：如何在鏈表裏如何發現循環連接?

解答：

從鏈表的開始處，由兩個指針A和B同時開始遍歷鏈表。指針A每向前移動一步，指針B都向前移動兩步。若是在移動了N步之後，指針A和B指向了同一個節點，則此鏈表中存在循環鏈表。

分析：

固然還能夠在遍歷的過程當中存儲節點的地址，經過不斷的比較地址來判斷有沒有循環鏈表。但這種算法會使用更多的內存。

若是考官比較變態，還能夠直接考複製鏈表。若是複製前沒有測試循環鏈表，那很差意思，只能扣分了

 

谷歌面試題：找到鏈表的倒數第m個節點

方法1：

首先遍歷鏈表，統計鏈表的長度N。

而後再次遍歷鏈表，找到第N-m個節點，即爲倒數第m個節點。

 

方法2：

使用兩個指針，並使它們指向的節點相距m-1個。

而後同時向前移動兩個指針，當一個指針指最後一個節點時，第二個指針指向倒數第m個節點。

 

兩個方法的複雜度都是O(n)。

可是當N較大而m較小時，方法2可能會更快一些。由於方法2能更好利用CPU的緩存。

 

谷歌面試題：給定一個排序數組，如何構造一個二叉排序樹？

採用遞歸算法。

選取數組中間的一個元素做爲根節點，左邊的元素構造左子樹，右邊的節點構造有子樹。

 

谷歌面試題：數組中是否有兩個數的和爲10

1.

比較任意兩個數的和是否爲10。如

for (int i = 0; i < n; ++i) { for (int j = i+1; j < n; ++j) { .... }}

複雜度爲O(n*n)。

 

2.

將數組排序後，對每一個數m，使用二分查找在數組中尋找10-m。

複雜度爲O(nlogn)。

 

3.

將數組存儲到hash_set中去，對每一個數m，在hash_set中尋找10-m。

複雜度爲O(n)。

 

4.

若是數組很大，超過內存的容量，能夠按照hash(max(m, 10-m))%g，將數據分到g個小的group中。而後對每一個小的group進行單獨處理。

複雜度爲O(n)。

 

谷歌面試題：找到兩個字符串的公共字符，並按照其中一個的排序

寫一函數f(a,b)，它帶有兩個字符串參數並返回一串字符，該字符串只包含在兩個串中都有的並按照在a中的順序。寫一個版本算法複雜度O(N^2)和一個O(N) 。

O(N^2)：

對於a中的每一個字符，遍歷b中的每一個字符，若是相同，則拷貝到新字符串中。

 

O(N)：

首先使用b中的字符創建一個hash_map，對於a中的每一個字符，檢測hash_map中是否存在，若是存在則拷貝到新字符串中。

 

在給定整數序列中，找出最大和的子序列

給定一個整數序列，其中有些是負數，有些是正數，從該序列中找出最大和的子序列。好比：-5，20，-4，10，-18，子序列[20，-4，10]具備最大和26。

 int GetMaxSubArraySum(int* array, int array_len) {

`    int current_sum = 0;

`    int max_sum = 0;

`    for (int i = 0; i < array_len; ++i) {

`      current_sum += array[i];

`      if (current_sum > max_sum) {

`        max_sum = current_sum;

`      } else if (current_sum < 0) {

`        current_sum = 0;

`      }

`    }

`    return max_sum;

` }

 

谷歌面試題：將無向無環連通圖轉換成深度最小的樹

已知一個無向無環連通圖T的全部頂點和邊的信息，現須要將其轉換爲一棵樹，要求樹的深度最小，請設計一個算法找到全部知足要求的樹的根結點，並分析時空複雜度。

 

最簡單直接的方法就是把每一個節點都試一遍：

假設某個節點爲根節點，計算樹的深度。當遍歷完全部節點後，也就找到了使樹的深度最小的根節點。

但這個方法的複雜度很高。若是有n個節點，則時間複雜度爲O(n^2)。

 

樹的深度取決於根節點到最深葉節點的距離，因此咱們能夠從葉節點入手。

葉節點會且只會和某一個節點連通（反之不成立，由於根節點也可能只和一個節點連通），因此咱們很容易找到全部可能的葉節點。

題目能夠等價於找到了兩個葉節點，使得兩個葉節點之間的距離最遠。根節點就是這兩個葉節點路徑的中間點（或者中間兩個點的任意一個）。

咱們能夠每次都將鏈接度爲1的節點刪掉，直到最後只剩下1個或2個節點，則這一個節點，或者兩個節點中的任意一個，就是咱們要找的根節點。

 

谷歌面試題：將字符串中的小寫字母排在大寫字母的前面

有一個由大小寫組成的字符串，如今須要對它進行修改，將其中的全部小寫字母排在大寫字母的前面（大寫或小寫字母之間不要求保持原來次序）。

初始化兩個int變量A和B，表明字符串中的兩個位置。開始時A指向字符串的第一個字符，B指向字符串的最後一個字符。

逐漸增長A的值使其指向一個大寫字母，逐漸減少B使其指向一個小寫字母，交換A，B所指向的字符，而後繼續增長A，減少B....。

當A>=B時，就完成了從新排序。

 

谷歌面試題：如何拷貝特殊鏈表

有一個特殊的鏈表，其中每一個節點不但有指向下一個節點的指針pNext，還有一個指向鏈表中任意節點的指針pRand，如何拷貝這個特殊鏈表？

拷貝pNext指針很是容易，因此題目的難點是如何拷貝pRand指針。

假設原來鏈表爲A1 -> A2 ->... -> An，新拷貝鏈表是B1 -> B2 ->...-> Bn。

爲了可以快速的找到pRand指向的節點，並把對應的關係拷貝到B中。咱們能夠將兩個鏈表合併成

A1 -> B1 -> A2 -> B2 -> ... -> An -> Bn。

從A1節點出發，很容易找到A1的pRand指向的節點Ax,而後也就找到了Bx，將B1的pRand指向Bx也就完成了B1節點pRand的拷貝。依次類推。

當全部節點的pRand都拷貝完成後，再將合併鏈表分紅兩個鏈表就能夠了。

 

谷歌面試題：10分鐘內看到一輛車的機率是多少？

若是在高速公路上30分鐘內看到一輛車開過的概率是0.95，那麼在10分鐘內看到一輛車開過的概率是多少？(假設爲常機率條件下)

假設10分鐘內看到一輛車開過的機率是x，那麼沒有看到車開過的機率就是1-x，30分鐘沒有看到車開過的機率是(1-x)^3，也就是0.05。因此獲得方程

(1-x)^3 = 0.05

解方程獲得x大約是0.63。

 

百度面試題：從輸入url到顯示網頁，後臺發生了什麼？

簡單來講有如下步驟：

1. 查找域名對應的IP地址。這一步會依次查找瀏覽器緩存，系統緩存，路由器緩存，ISP DNS緩存，根域名服務器。

2. 向IP對應的服務器發送請求。

3. 服務器響應請求，發回網頁內容。

4. 瀏覽器解析網頁內容。

固然，因爲網頁可能有重定向，或者嵌入了圖片，AJAX，其它子網頁等等，這4個步驟可能反覆進行屢次才能將最終頁面展現給用戶。

百度面試題：設計DNS服務器中cache的數據結構

要求設計一個DNS的Cache結構，要求可以知足每秒5000以上的查詢，知足IP數據的快速插入，查詢的速度要快。（題目還給出了一系列的數據，好比：站點數總共爲5000萬，IP地址有1000萬，等等）

DNS服務器實現域名到IP地址的轉換。

 

每一個域名的平均長度爲25個字節（估計值），每一個IP爲4個字節，因此Cache的每一個條目須要大概30個字節。

總共50M個條目，因此須要1.5G個字節的空間。能夠放置在內存中。（考慮到每秒5000次操做的限制，也只能放在內存中。）

能夠考慮的數據結構包括hash_map，字典樹，紅黑樹等等。

 

百度面試題：將多個集合合併成沒有交集的集合

給定一個字符串的集合，格式如：{aaa bbb ccc}， {bbb ddd}，{eee fff}，{ggg}，{ddd hhh}要求將其中交集不爲空的集合合併，要求合併完成後的集合之間無交集，例如上例應輸出{aaa bbb ccc ddd hhh}，{eee fff}， {ggg}。

（1）請描述你解決這個問題的思路；

（2）請給出主要的處理流程，算法，以及算法的複雜度

（3）請描述可能的改進。

集合使用hash_set來表示，這樣合併時間複雜度比較低。

 

1. 給每一個集合編號爲0，1，2，3...

2. 建立一個hash_map，key爲字符串，value爲一個鏈表，鏈表節點爲字符串所在集合的編號。

遍歷全部的集合，將字符串和對應的集合編號插入到hash_map中去。

3. 建立一個長度等於集合個數的int數組，表示集合間的合併關係。例如，下標爲5的元素值爲3，表示將下標爲5的集合合併到下標爲3的集合中去。

開始時將全部值都初始化爲-1，表示集合間沒有互相合並。

在集合合併的過程當中，咱們將全部的字符串都合併到編號較小的集合中去。

遍歷第二步中生成的hash_map，對於每一個value中的鏈表，首先找到最小的集合編號（有些集合已經被合併過，須要順着合併關係數組找到合併後的集合編號），而後將鏈表中全部編號的集合都合併到編號最小的集合中（經過更改合併關係數組）。

4.如今合併關係數組中值爲-1的集合即爲最終的集合，它的元素來源於全部直接或間接指向它的集合。

 

算法的複雜度爲O(n)，其中n爲全部集合中的元素個數。

題目中的例子：

0: {aaa bbb ccc}

1: {bbb ddd}

2: {eee fff}

3: {ggg}

4: {ddd hhh}

生成的hash_map，和處理完每一個值後的合併關係數組分別爲

aaa: 0。[-1, -1, -1, -1, -1]

bbb: 0, 1。[-1, 0, -1, -1, -1]

ccc: 0。[-1, 0, -1, -1, -1]

ddd: 1, 4。[-1, 0, -1, -1, 0]

eee: 2。[-1, 0, -1, -1, 0]

fff: 2。[-1, 0, -1, -1, 0]

ggg: 3。[-1, 0, -1, -1, 0]

hhh: 4。[-1, 0, -1, -1, 0]

因此合併完後有三個集合，第0，1，4個集合合併到了一塊兒，

第2，3個集合沒有進行合併。

 

百度面試題：用C語言將輸入的字符串在原串上倒序

 void revert(char* str) {

`    char c;

`    for (int front = 0, int back = strlen(str) - 1;

`         front < back;

`         ++front, --back) {

`      c = str[back];

`      str[back] = str[front];

`      str[front] = c;

`    }

` }

 

 

百度面試題：找出給定字符串對應的序號

序列Seq=[a,b,…z,aa,ab…az,ba,bb,…bz,…,za,zb,…zz,aaa,…] 相似與excel的排列，任意給出一個字符串s=[a-z]+(由a-z字符組成的任意長度字符串），請問s是序列Seq的第幾個。

注意到每滿26個就會向前進一位，相似一個26進制的問題。

好比ab，則位置爲26*1 + 2；

好比za，則位置爲26*26 + 1；

好比abc，則位置爲26*26*1 + 26*2 + 3

 

百度面試題：找出第k大的數字所在的位置

寫一段程序，找出數組中第k大小的數，輸出數所在的位置。例如{2，4，3，4，7}中，第一大的數是7，位置在4。第二大、第三大的數都是4，位置在一、3隨便輸出哪個都可。

先找到第k大的數字，而後再遍歷一遍數組找到它的位置。因此題目的難點在於如何最高效的找到第k大的數。

 

咱們能夠經過快速排序，堆排序等高效的排序算法對數組進行排序，而後找到第k大的數字。這樣整體複雜度爲O(N logN)。

 

咱們還能夠經過二分的思想，找到第k大的數字，而沒必要對整個數組排序。

從數組中隨機選一個數t，經過讓這個數和其它數比較，咱們能夠將整個數組分紅了兩部分而且知足，{x, xx, ..., t} < {y, yy, ...}。

在將數組分紅兩個數組的過程當中，咱們還能夠記錄每一個子數組的大小。這樣咱們就能夠肯定第k大的數字在哪一個子數組中。

而後咱們繼續對包含第k大數字的子數組進行一樣的劃分，直到找到第k大的數字爲止。

平均來講，因爲每次劃分都會使子數組縮小到原來1/2，因此整個過程的複雜度爲O(N)。

 

百度面試題：找到知足條件的數組

給定函數d(n) = n + n的各位之和，n爲正整數，如 d(78) = 78+7+8=93。 這樣這個函數能夠當作一個生成器，如93能夠當作由78生成。

定義數A：數A找不到一個數B能夠由d(B)=A，即A不能由其餘數生成。如今要寫程序，找出1至10000裏的全部符合數A定義的數。

申請一個長度爲10000的bool數組，每一個元素表明對應的值是否能夠有其它數生成。開始時將數組中的值都初始化爲false。

因爲大於10000的數的生成數一定大於10000，因此咱們只需遍歷1到10000中的數，計算生成數，並將bool數組中對應的值設置爲true，表示這個數能夠有其它數生成。

最後bool數組中值爲false的位置對應的整數就是不能由其它數生成的。

 

百度面試題：對正整數，算獲得1須要操做的次數

實現一個函數，對一個正整數n，算獲得1須要的最少操做次數。

操做規則爲：若是n爲偶數，將其除以2；若是n爲奇數，能夠加1或減1；一直處理下去。

例子：

func(7) = 4，能夠證實最少須要4次運算

n = 7

n-1 6

n/2 3

n-1 2

n/2 1

要求：實現函數(實現儘量高效) int func(unsign int n)；n爲輸入，返回最小的運算次數。

給出思路(文字描述)，完成代碼，並分析你算法的時間複雜度。

 

int func(unsign int n) {

if (n == 1) {

return 0;

}

if (n%2 == 0) {

return 1 + func(n/2);

}

int x = func(n+1);

int y = func(n-1);

if (x > y) {

return y + 1;

} else {

return x + 1;

}

}

假設n表示成二進制有x bit，能夠看出計算複雜度爲O(2^x)，也就是O(n)。

 int func(unsign int n) {

`    if (n == 1) {

`      return 0;

`    }

`    if (n % 2 == 0) {

`      return 1 + func(n/2);

`    }

`    if (n == 3) {

`      return 2;

`    }

`    if ( n & 2) {

`      return 1 + func(n + 1);

`    } else {

`      return 1 + func(n - 1);

`    }

` }

百度面試題：找出N！後面的0的個數

容易理解，題目等價於求因子2和因子5出現的次數。

對於因子2來講，數字2，4，6，8，10....2n...中存在因子2，這樣就得到了 N/2 （其中N/2只取結果的整數部分）個因子2。這些數字去除因子2後，變成1，2，3....N/2，又能夠提取N/4個因子2....這樣一直到只剩下1個數（1）。因此N！中總共能夠得到N/2 + N/4 + N/8 +....個因子2。

同理，N！中能夠得到N/5 + N/25 + ... 個因子5。

尾部連續0的個數就是因子2和因子5較少的那個。

 

對於題目中的例子，18！中包含9+4+2+1個因子2，包含3個因子5。因此尾部有3個連續0。

 

計算的複雜度爲O(logN)。

 

百度面試題：找出被修改過的數字

n個空間（其中n<1M），存放a到a+n-1的數，位置隨機且數字不重複，a爲正且未知。如今第一個空間的數被誤設置爲-1。已經知道被修改的數不是最小的。請找出被修改的數字是多少。

例如：n=6，a=2，原始的串爲5, 3, 7, 6, 2, 4。如今被別人修改成-1, 3, 7, 6, 2, 4。如今但願找到5。

 

因爲修改的數不是最小的，因此遍歷第二個空間到最後一個空間能夠獲得a的值。

a 到 a+n-1這 n個數的和是 total = na + (n - 1)n/2。

將第二個至最後一個空間的數累加得到 sub_total。

那麼被修改的數就是 total - sub_total。

 

百度面試題：在100w個數中找最大的前100個數

應該使用某種數據結構保存迄今最大的100個數。每讀到一個新數時，將新數和保存的100個數中的最小一個相比較，若是新數更大些，則替換。這樣掃描一遍100w個數也就得到了最大的100個數。

對於保存的100個數的數據結構，應該在最小複雜度的條件下知足

1）能夠得到最小的數；

2）將最小數替換爲另外一個數後能夠從新調整，使其能夠知足條件1。

可見小根堆能夠知足這些條件。

因此應該採用小根堆+掃描的方法。

 

方法1：相似《算法導論》中用二分法求第K大數，理想TC是O(n)。

 

百度面試題：正向最大匹配分詞，怎麼作最快？

用全部詞生成一個字典樹，匹配的過程就是查字典的過程。

假設咱們有兩個詞」百度「，」百家姓「，那麼生成的字典樹就是：

 

百---度*

|

|-----家----姓*

 

其中「度」和「姓」旁邊的星號表示這是一個有效詞。

對於句子「百度面試題「，首先在字典中找」百「，找到了；繼續向下查找」度「，又找到了；繼續向下查找」面「，沒有找到。那麼」百度「就是咱們分出來的第一個詞。

還能夠用hash_map來作。

首先用全部的詞生成一個hash_map，假設咱們有兩個詞「百度，「百家姓」，那麼生成hash_map以下：

{

百：0

百度：1

百家：0

百家姓：1

}

其中值爲0表示對應的key不是一個詞，但有更長的詞包括這個key；值爲1表示這是一個詞。

對於句子「百度面試題」，首先在hash_map中查找「百」，找到對應值爲0，繼續；查找「百度」，找到對應值爲1，說明這是一個詞，記下來並繼續；查找「百度面」，沒有找到，說明沒有更長的詞包含「百度面」。因此「百度」就是咱們分出來的第一個詞。

 

和字典法相比，hash_map法可能會用到更多的存儲空間（由於有些字，好比「百」字，都存儲了屢次。但這還取決於字典樹的具體實現），但程序設計會更加簡單，不容易出錯。

 

session和cache的區別是什麼？

session是針對單個鏈接（會話）來使用的，主要存儲和鏈接相關的上下文信息，好比登陸信息等等。

cache是應用程序級的，主要用來緩存計算結果，減輕服務器負擔，並加快響應速度。

 

百度面試題：找出數組中出現次數超過一半的數

答案：

建立一個hash_map，key爲數組中的數，value爲此數出現的次數。遍歷一遍數組，用hash_map統計每一個數出現的次數，並用兩個值存儲目前出現次數最多的數和對應出現的次數。

這樣能夠作到O(n)的時間複雜度和O(n)的空間複雜度，知足題目的要求。

可是沒有利用「一個數出現的次數超過了一半」這個特色。也許算法還有提升的空間。

答案2：

使用兩個變量A和B，其中A存儲某個數組中的數，B用來計數。開始時將B初始化爲0。

遍歷數組，若是B=0，則令A等於當前數，令B等於1；若是當前數與A相同，則B=B+1；若是當前數與A不一樣，則令B=B-1。遍歷結束時，A中的數就是要找的數。

這個算法的時間複雜度是O(n)，空間複雜度爲O(1)。

 

百度面試題：如何找出字典中的兄弟單詞

給定一個單詞a，若是經過交換單詞中字母的順序能夠獲得另外的單詞b，那麼定義b是a的兄弟單詞。如今給定一個字典，用戶輸入一個單詞，如何根據字典找出這個單詞有多少個兄弟單詞？

答案：

使用hash_map和鏈表。

首先定義一個key，使得兄弟單詞有相同的key，不是兄弟的單詞有不一樣的key。例如，將單詞按字母從小到大從新排序後做爲其key，好比bad的key爲abd，good的key爲dgoo。

使用鏈表將全部兄弟單詞串在一塊兒，hash_map的key爲單詞的key，value爲鏈表的起始地址。

開始時，先遍歷字典，將每一個單詞都按照key加入到對應的鏈表當中。當須要找兄弟單詞時，只需求取這個單詞的key，而後到hash_map中找到對應的鏈表便可。

這樣建立hash_map時時間複雜度爲O(n)，查找兄弟單詞時時間複雜度是O(1)。

 

網易面試題：new/delete和malloc/free的區別

new/delete：給定數據類型，new/delete會自動計算內存大小，並進行分配或釋放。若是是對類進行操做，new/delete還會自動調用相應的構造函數和析構函數。

malloc/free：沒有進行任何數據類型檢查，只負責分配和釋放給定大小的內存空間。

有些狀況下，new/delete和malloc/free都不能知足性能的要求，咱們須要自建內存分配來提升效率。好比，若是程序須要動態分配大量很小的對象，咱們能夠一次分配能夠容納不少小對象的內存，將這些小對象維護在鏈表中，當程序須要時直接從鏈表中返回一個。還有一點，new返回指定類型的指針；而malloc返回void*，必須強制類型轉化。

有個比較有意思的地方是:int *p=(void*)malloc(1);能夠編譯並運行。

 

網易面試題：沒有拷貝構造函數和重載＝運算符的string類

c++中，一個沒有拷貝構造函數和重載＝運算符的string類，會出現什麼問題，如何解決？

若是沒有定義拷貝構造函數和重載=運算符，則系統會自動生成逐位拷貝的函數。

當咱們用string初始化string時，（好比 string a("abc"); string b = a;），兩個對象會指向一樣的內存地址。在兩個對象的析構函數中，咱們會對同一個內存塊調用兩次刪除，致使不肯定的結果。

當咱們將一個string賦值給另一個string時，（好比 string a("abc"); string b(「cde"); b = a;）除了上面的屢次調用析構函數的問題外，因爲原來對象b指向的數據沒有被正確刪除，會致使內存泄漏。

 

解決辦法：

1. 添加這兩個函數。

2. 不使用這兩個函數。

- 不用string初始化string：可使用string a（」abc"); string b(a.c_str()); 代替。

- 不用string給string賦值，包括不能經過傳值方法傳遞string參數：儘可能使用指針。

 

網易面試題：寫一段程序，實現atoi(const char* s)方法

atoi用於將字符串轉換成爲整數。

好比 「123」 =》 123， 「-246」 =》 -246。

 

`   int atoi(const char*s) {

`     int result = 0;

`     bool is_plus = true;

`     if (*s == '+') {

`       ++s;

`     } else if (*s == '-') {

`       ++s;

`       is_plus = false;

`     }

`     while (*s >= '0' && *s <= '9') {

`       result = result * 10 + *s - '0';

`       ++s;

`     }

`     if (is_plus) {

`       return result;

`     } else {

`       return -result;

`     }

`   }

 

網易面試題：給出若干個單詞，組成字典，要求查找速度最快。

爲使查找速度最快，能夠要使用hash_map。

若是每一個單詞還有對應的解釋和例句，能夠將解釋和例句對應的指針存放在hash_map的值中。或許能夠嘗試使用 TRIE 結構。

 

迅雷面試題：門面模式的解釋、適用場合？

門面模式又被稱爲外觀模式，爲子系統中的一組接口提供一個一致的界面，該模式定義了一個高層接口，使得這個子系統更加容易使用。

舉個例子：在作項目或產品的過程當中進行跨部門合做的時候，每一個部門都有個相應的接口人，那麼咱們只需和對應部門的接口人交互便可。

 

適用場合：

爲一個複雜子系統提供一個簡單接口：子系統每每由於不斷演化而變得愈來愈複雜，使用門面模式可使得子系統更具備可複用性。

子系統的獨立性：引入門面模式將一個子系統與它的客戶端以及其餘子系統分離，能夠提升子系統的獨立性和可移植性。

層次化結構：在構建一個層次化的系統時，可使用 門面模式定義系統中每一層的入口。若是層與層之間是相互依賴的，則能夠限定它們僅經過門面進行通訊，簡化層與層之間的依賴關係。

 

迅雷面試題：AJAX的原理、如何實現刷新及其優勢

AJAX即「Asynchronous JavaScript and XML」（異步JavaScript和XML)，是指一種建立交互式網頁應用的網頁開發技術。

 

使用了AJAX技術的網頁，利用Javascript和服務器通訊，獲取數據，而後再經過修改網頁的DOM中的某些元素來實現刷新網頁的特定部分。

 

使用了AJAX技術後，因爲只須要更新網頁的一部分，而不是所有，因此和服務器交互的數據比較少。這就下降了服務器的負載，並提升了用戶端的響應速度。另外，AJAX並不須要在瀏覽器中安裝插件。

 

迅雷面試題：數組與鏈表的區別？

在數組中，元素在內存中連續存放。對於訪問操做，因爲元素類型相同，佔用內存相同，因此能夠經過數組的下標計算出元素所在的內存地址，便於快速訪問。但對於插入或刪除操做，須要移動大量元素，因此速度比較慢。

在鏈表中，元素在內存中沒有連續存放，而是經過元素中的指針將各個元素鏈接在一塊兒。對於訪問操做，須要從鏈表頭部開始順序遍歷鏈表，直到找到須要的元素，因此速度比較慢。對於插入或刪除操做，只需修改元素中的指針便可完成，速度比較快。

因此，若是須要頻繁訪問數據，不多插入刪除操做，則使用數組；反之，若是頻繁插入刪除，則應使用鏈表。

 

迅雷面試題：最快的排序法的性能，並列舉至少三個

最快的排序算法是O(N*lgN)。，快排序，堆排序，歸併排序

 

迅雷面試題：合併用戶基本信息和看電影的記錄

如何有效合併兩個文件：一個是1億條的用戶基本信息，另外一個是用戶天天看電影連續劇等的記錄，5000萬條。其中內存只有1G。

顯然內存不能同時存下全部的數據，因此考慮分而治之的思想。

假設1K Byte能夠保存一個用戶的基本信息和看電影記錄。咱們能夠將基本信息和看電影記錄都按照hash(user_name)%100的餘數各分紅100個小文件。利用1G內存，咱們能夠每次只處理一對小文件，而後將結果輸出到一個文件中便可。

在處理一對小文件時，能夠利用key爲用戶名的hash_map將基本信息和看電影記錄合併在一塊兒。

 

迅雷面試題：c語言中不一樣include方法的差異

#include "filename.h" 首先在程序原文件所在目錄下查找，若是找不到，再到系統目錄中查找。

#include <filename.h> 直接去系統目錄中查找。

 

在1億條用戶記錄裏，如何快速查詢統計出看了5個電影以上的用戶？

構建一個hash map，key爲用戶名，value爲已經看過的電影數量。

遍歷全部用戶記錄，而後根據用戶名和已經看過電影數量的狀況進行處理：

- 若是用戶名不在hash map中，則添加對應用戶名，並將值設爲1。

- 若是用戶名對應的值小於5，則將值加1。若是加1後值爲5，則輸出此用戶名。

- 若是用戶名對應的值等於5，則不進行任何操做。

 

oracle面試題：數據庫冷備份和熱備份的不一樣點以及各自的優勢

熱備份針對歸檔模式的數據庫，在數據庫仍舊處於工做狀態時進行備份。而冷備份指在數據庫關閉後，進行備份，適用於全部模式的數據庫。熱備份的優勢在於當備 份時，數據庫仍舊能夠被使用而且能夠將數據庫恢復到任意一個時間點。冷備份的優勢在於它的備份和恢復操做至關簡單，而且因爲冷備份的數據庫能夠工做在非歸 檔模式下，數據庫性能會比歸檔模式稍好。（由於沒必要將archive log寫入硬盤）

 

華爲面試題：IP，TCP和UDP協議的定義和主要做用

IP協議是網絡層的協議。IP協議規定每一個互聯網網上的電腦都有一個惟一的IP地址，這樣數據包就能夠經過路由器的轉發到達指定的電腦。但IP協議並不保證數據傳輸的可靠性。

TCP協議是傳輸層的協議。它向下屏蔽了IP協議不能可靠傳輸的缺點，向上提供面向鏈接的可靠的數據傳輸。

UDP協議也是傳輸層的協議。它提供無鏈接的不可靠傳輸。

 

華爲面試題：全局變量和局部變量有什麼區別

全局變量是整個程序均可訪問的變量，生存期從程序開始到程序結束；局部變量存在於模塊中(好比某個函數)，只有在模塊中才能夠訪問，生存期從模塊開始到模塊結束。

全局變量分配在全局數據段，在程序開始運行的時候被加載。局部變量則分配在程序的堆棧中。所以，操做系統和編譯器能夠經過內存分配的位置來知道來區分全局變量和局部變量。全局變量和局部變量的區別是在存儲器中位置不一樣，具體說，全局變量存儲在數據段中，局部變量通常來講在堆棧段

 

華爲面試題：析構函數和虛函數的用法和做用？

析構函數是在類對象消亡時由系統自動調用。主要用來作對象的清理工做，好比來釋放對象申請的動態空間。

基類中用virtual修飾的函數稱爲虛函數。在派生類中能夠對虛函數進行從新定義，這樣一樣的函數接口能夠在不一樣的派生類中對應不一樣的實現。當經過基類的指針來調用虛函數時，程序會根據指針實際指向的對象來決定調用哪一個實現。

 

華爲面試題：如何引用一個已經定義過的全局變量？

能夠用引用頭文件的方式，也可使用extern關鍵字。

用引用頭文件方式，若是將那個變量寫錯了，那麼在編譯期間會報錯。

用extern方式，若是將變量名寫錯了，那麼在編譯期間不會報錯，而在鏈接期間報錯。

 

華爲面試題：c語言中局部變量可否和全局變量重名？

局部變量能夠與全局變量同名。在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。要用全局變量，須要使用"::"。

對於有些編譯器而言，在同一個函數內能夠定義多個同名的局部變量，好比在兩個循環體內都定義一個同名的局部變量，而那個局部變量的做用域就在那個循環體內。

 

完美時空面試題：memcpy 和 memmove 有什麼區別？

memcpy和memmove都是將源地址的若干個字符拷貝到目標地址。

若是源地址和目標地址有重疊，則memcpy不能保證拷貝正確，但memmove能夠保證拷貝正確。

 

例如：

char src[20];

// set src

char* dst = src + 5;

此時若是要從src拷貝10個字符到dst，則麼memcpy不能保證拷貝正確，可是memmove能夠保證。

 

雅虎面試題：HTTP中Get和Post的區別

Get和Post都是瀏覽器向網頁服務器提交數據的方法。

Get把要提交的數據編碼在url中，好比 http://hi.baidu.com/mianshiti?key1=value1&key2=value2 中就編碼了鍵值對 key1，value1 和key2，value2。受限於url的長度限制，Get方法能傳輸的數據有限（不一樣瀏覽器對url長度限制不一樣，好比微軟IE設爲2048）。

Post把要提交的數據放在請求的body中，而不會顯示在url中，所以，也沒有數據大小的限制。

 

因爲Get把數據編碼在URL中，因此這些變量顯示在瀏覽器的地址欄，也會被記錄在服務器端的日誌中。因此Post方法更加安全。