第十六~第二十章：全排列，跳臺階，奇偶排序，第一個只出現一次等問題

引言

    最近這幾天閒職在家，一忙著投簡歷，二為準備面試而蒐集整理各種面試題。故常常關注個人所建的Algorithms1-14群內朋友關於筆試，面試，宣講會，offer，薪資的討論以及在群內釋出的各種筆/面試題，常感言道：咱們這群人之前已經在學校受夠了學校的那種應試教育，如今出來找工作又得東奔西走去參加各種筆試/面試，著實亦不輕鬆。幻想，如果在企業與求職者之間有個中間面試服務平臺就更好了。

    ok，閒話少扯。在上一篇文章中，已經說過，“個人正在針對那100題一題一題的寫文章，多種思路，不斷優化，即成程式設計師程式設計藝術系列。”現本程式設計藝術系列繼續開始創作，你而後自會和我有同樣的感慨：各種面試題千變萬化，層出不窮，但基本型別，解決問題的思路基本一致。

    本文為程式設計師程式設計藝術第十六章~第二十章，包含以下5個問題：

1. 全排列；
2. 跳臺階；
3. 奇偶排序；
4. 第一個只出現一次的字元；
5. 一致性雜湊演算法。

    同時，本文會在解答去年微軟面試100題的部分題目時，儘量結合今年最近各大IT公司最新的面試題來講解，兩相對比，彼此對照，相信你會更加贊同我上面的話。且本文也不奢望讀者能從中學到什麼高深技術之類的東西，只求讀者看此文看著舒服便可，通順流暢以致一口氣讀完而無任何壓力。ok，有任何問題，歡迎不吝指正。謝謝。

第十六章、全排列問題

53.字串的排列。
題目：輸入一個字串，打印出該字串中字元的所有排列。
例如輸入字串abc，則輸出由字元a、b、c 所能排列出來的所有字串
abc、acb、bac、bca、cab 和cba。

    分析：此題最初整理於去年的微軟面試100題中第53題，第二次整理於微軟、Google等公司非常好的面試題及解答[第61-70題] 第67題。無獨有偶，這個問題今年又出現於今年的2011.10.09百度筆試題中。ok，接下來，咱們先好好分析這個問題。

• 一、遞迴實現
  從集合中依次選出每一個元素，作為排列的第一個元素，然後對剩餘的元素進行全排列，如此遞迴處理，從而得到所有元素的全排列。以對字串abc進行全排列為例，我們可以這麼做：以abc為例
  固定a，求後面bc的排列：abc，acb，求好後，a和b交換，得到bac
  固定b，求後面ac的排列：bac，bca，求好後，c放到第一位置，得到cba
  固定c，求後面ba的排列：cba，cab。程式碼可如下編寫所示：

1. template <typename T>  
2. void CalcAllPermutation_R(T perm[], int first, int num)  
3. {  
4.     if (num <= 1) {  
5.         return;  
6.     }  
7.     for (int i = first; i < first + num; ++i) {  
8.         swap(perm[i], perm[first]);  
9.         CalcAllPermutation_R(perm, first + 1, num - 1);  
10.         swap(perm[i], perm[first]);  
11.     }  
12. }  

1. void Permutation(char* pStr, char* pBegin);  
2. void Permutation(char* pStr)  
3. {  
4.       Permutation(pStr, pStr);  
5. }  
6. void Permutation(char* pStr, char* pBegin)  
7. {  
8.     if(!pStr || !pBegin)  
9.         return;  
10.     if(*pBegin == '\0')  
11.     {  
12.         printf("%s\n", pStr);  
13.     }  
14.     else  
15.     {  
16.         for(char* pCh = pBegin; *pCh != '\0'; ++ pCh)  
17.         {  
18.             // swap pCh and pBegin  
19.             char temp = *pCh;  
20.             *pCh = *pBegin;  
21.             *pBegin = temp;  
22.             Permutation(pStr, pBegin + 1);    
23.             // restore pCh and pBegin  
24.             temp = *pCh;  
25.             *pCh = *pBegin;  
26.             *pBegin = temp;  
27.         }  
28.     }  
29. }  

• 二、字典序排列
  把升序的排列（當然，也可以實現為降序）作為當前排列開始，然後依次計算當前排列的下一個字典序排列。
  對當前排列從後向前掃描，找到一對為升序的相鄰元素，記為i和j（i < j）。如果不存在這樣一對為升序的相鄰元素，則所有排列均已找到，演算法結束；否則，重新對當前排列從後向前掃描，找到第一個大於i的元素k，交換i和k，然後對從j開始到結束的子序列反轉，則此時得到的新排列就為下一個字典序排列。這種方式實現得到的所有排列是按字典序有序的，這也是C++ STL演算法next_permutation的思想。演算法實現如下：

1. template <typename T>  
2. void CalcAllPermutation(T perm[], int num)  
3. {  
4.     if (num < 1)  
5.         return;  
6.     while (true) {  
7.         int i;  
8.         for (i = num - 2; i >= 0; --i) {  
9.             if (perm[i] < perm[i + 1])  
10.                 break;  
11.         }  
12.         if (i < 0)  
13.             break;  // 已經找到所有排列
14.         int k;  
15.         for (k = num - 1; k > i; --k) {  
16.             if (perm[k] > perm[i])  
17.                 break;  
18.         }  
19.         swap(perm[i], perm[k]);  
20.         reverse(perm + i + 1, perm + num);  
21.     }  
22. }  

第十七章、跳臺階問題

27.跳臺階問題
題目：一個臺階總共有n 級，如果一次可以跳1 級，也可以跳2 級。
求總共有多少總跳法，並分析演算法的時間複雜度。

    分析：在九月騰訊，創新工場，淘寶等公司最新面試十三題中第23題又出現了這個問題，題目描述如下：23、人人筆試1：一個人上臺階可以一次上1個，2個，或者3個，問這個人上n層的臺階，總共有幾種走法？咱們先撇開這個人人筆試的問題（其實差別就在於人人筆試題中多了一次可以跳三級的情況而已），先來看這個第27題。

    首先考慮最簡單的情況。如果只有1級臺階，那顯然只有一種跳法。如果有2級臺階，那就有兩種跳的方法了：一種是分兩次跳，每次跳1級；另外一種就是一次跳2級。

    現在我們再來討論一般情況。我們把n級臺階時的跳法看成是n的函式，記為f(n)。當n>2時，第一次跳的時候就有兩種不同的選擇：一是第一次只跳1級，此時跳法數目等於後面剩下的n-1級臺階的跳法數目，即為f(n-1)；另外一種選擇是第一次跳2級，此時跳法數目等於後面剩下的n-2級臺階的跳法數目，即為f(n-2)。因此n級臺階時的不同跳法的總數f(n)=f(n-1)+(f-2)。

    我們把上面的分析用一個公式總結如下：
        /     1                              n=1
f(n)=      2                              n=2
        \  f(n-1) + f(n-2)            n>2

    原來上述問題就是我們平常所熟知的Fibonacci數列問題。可編寫程式碼，如下：

1. long long Fibonacci_Solution1(unsigned int n)  
2. {  
3.     int result[2] = {0, 1};  
4.     if(n < 2)  
5.         return result[n];  
6.     return Fibonacci_Solution1(n - 1) + Fibonacci_Solution1(n - 2);  
7. }  

     那麼，如果是人人筆試那道題呢?一個人上臺階可以一次上1個，2個，或者3個，豈不是可以輕而易舉的寫下如下公式：

        /      1                                      n=1
f(n)=      2                                      n=2

              4                                      n=3       //111, 12, 21, 3
        \  f(n-1)+(f-2)+f(n-3)            n>3

    行文至此，你可能會認為問題已經解決了，但事實上沒有：

1. 用遞迴方法計算的時間複雜度是以n的指數的方式遞增的，我們可以嘗試用遞推方法解決。具體如何操作，讀者自行思考。
   
2. 有一種方法，能在O(logn)的時間複雜度內求解Fibonacci數列問題，你能想到麼?
   
   

   第十八章、奇偶調序

   54.調整陣列順序使奇數位於偶數前面。
   題目：輸入一個整數陣列，調整陣列中數字的順序，使得所有奇數位於陣列的前半部分，
   所有偶數位於陣列的後半部分。要求時間複雜度為O(n)。

   分析：

   1. 你當然可以從頭掃描這個陣列，每碰到一個偶數時，拿出這個數字，並把位於這個數字後面的所有數字往前挪動一位。挪完之後在陣列的末尾有一個空位，這時把該偶數放入這個空位。由於碰到一個偶數，需要移動O(n)個數字，只是這種方法總的時間複雜度是O(n^２)，不符合要求，pass。
      
   2. 很簡單，維護兩個指標，一個指標指向陣列的第一個數字，向後移動；一個個指標指向最後一個數字，向前移動。如果第一個指標指向的數字是偶數而第二個指標指向的數字是奇數，我們就交換這兩個數字。
      
       思路有了，接下來，寫程式碼實現：
   1. //思路，很簡答，倆指標，一首一尾  
   2. //如果第一個指標指向的數字是偶數而第二個指標指向的數字是奇數，  
   3. //我們就交換這兩個數字  
   4. // 2 1 3 4 6 5 7   
   5. // 7 1 3 4 6 5 2  
   6. // 7 1 3 5 6 4 2  
   7. //如果限制空間複雜度為O（1），時間為O（N），且奇偶數之間相對順序不變，就相當於正負數間順序調整的那道題了。  
   8. //[email protected] zhedahht。  
   9. void Reorder(int *pData, unsigned int length, bool (*func)(int));  
   10. bool isEven(int n);  
   11. void ReorderOddEven(int *pData, unsigned int length)  
   12. {  
   13.     if(pData == NULL || length == 0)  
   14.         return;  
   15.     Reorder(pData, length, isEven);  
   16. }  
   17. void Reorder(int *pData, unsigned int length, bool (*func)(int))  
   18. {  
   19.     if(pData == NULL || length == 0)  
   20.         return;  
   21.     int *pBegin = pData;  
   22.     int *pEnd = pData + length - 1;  
   23.     while(pBegin < pEnd)  
   24.     {  
   25.         // if *pBegin does not satisfy func, move forward  
   26.         if(!func(*pBegin))   //偶數  
   27.         {  
   28.             pBegin ++;  
   29.             continue;  
   30.         }  
   31.         // if *pEnd does not satisfy func, move backward  
   32.         if(func(*pEnd))      //奇數  
   33.         {  
   34.             pEnd --;  
   35.             continue;  
   36.         }  
   37.         // if *pBegin satisfy func while *pEnd does not,  
   38.         // swap these integers  
   39.         int temp = *pBegin;  
   40.         *pBegin = *pEnd;  
   41.         *pEnd = temp;  
   42.     }  
   43. }  
   44. bool isEven(int n)  
   45. {  
   46.     return (n & 1) == 0;  
   47. }  
       細心的讀者想必注意到了上述程式註釋中所說的“如果限制空間複雜度為O（1），時間為O（N）就相當於正負數間順序調整的那道題了”，沒錯，它與個人之前整理的一文中的第5題極其類似：5、一個未排序整數陣列，有正負數，重新排列使負數排在正數前面，並且要求不改變原來的正負數之間相對順序 比如： input: 1,7,-5,9,-12,15 ans: -5,-12,1,7,9,15 要求時間複雜度O(N),空間O(1) 。（此題一直沒看到令我滿意的答案，一般達不到題目所要求的：時間複雜度O(N),空間O(1)，且保證原來正負數之間的相對位置不變）。    如果你想到了絕妙的解決辦法，不妨在本文評論下告知於我，或者來信指導（[email protected]），謝謝。

   第十九章、第一個只出現一次的字元

   第17 題：題目：在一個字串中找到第一個只出現一次的字元。如輸入abaccdeff，則輸出b。    分析：這道題是2006 年google 的一道筆試題。它在今年又出現了，不過換了一種形式。即最近的搜狐筆試大題：陣列非常長，如何找到第一個只出現一次的數字，說明演算法複雜度。此問題已經在程式設計師程式設計藝術系列第二章中有所闡述，在此不再作過多講解。

   程式碼，可編寫如下：

   1. #include <iostream>  
   2. using namespace std;  
   3. //查詢第一個只出現一次的字元，第1個程式  
   4. //[email protected] Sorehead && July  
   5. //July、updated，2011.04.24.  
   6. char find_first_unique_char(char *str)  
   7. {  
   8.     int data[256];  
   9.     char *p;  
   10.     if (str == NULL)  
   11.         return '\0';  
   12.     memset(data, 0, sizeof(data));    //陣列元素先全部初始化為0  
   13.     p = str;  
   14.     while (*p != '\0')  
   15.         data[(unsigned char)*p++]++;  //遍歷字串，在相應位置++，（同時，下標強制轉換）  
   16.     while (*str != '\0')  
   17.     {  
   18.         if (data[(unsigned char)*str] == 1)  //最後，輸出那個第一個只出現次數為1的字元  
   19.             return *str;  
   20.         str++;  
   21.     }  
   22.     return '\0';  
   23. }  
   24. int main()  
   25. {  
   26.     char *str = "afaccde";  
   27.     cout << find_first_unique_char(str) << endl;  
   28.     return 0;  
   29. }  
     當然，程式碼也可以這麼寫（測試正確）： 
   1. //查詢第一個只出現一次的字元，第2個程式  
   2. //[email protected] yansha  
   3. //July、updated，2011.04.24.  
   4. char FirstNotRepeatChar(char* pString)  
   5. {  
   6.     if(!pString)  
   7.         return '\0';  
   8.     const int tableSize = 256;  
   9.     int hashTable[tableSize] = {0}; //存入陣列，並初始化為0  
   10.     char* pHashKey = pString;  
   11.     while(*(pHashKey) != '\0')  
   12.         hashTable[*(pHashKey++)]++;  
   13.     while(*pString != '\0')  
   14.     {  
   15.         if(hashTable[*pString] == 1)  
   16.             return *pString;  
   17.         pString++;  
   18.     }  
   19.     return '\0';  //沒有找到滿足條件的字元，退出  
   20. }  

   第二十章、一致性雜湊演算法

   tencent2012筆試題附加題
       問題描述： 例如手機朋友網有n個伺服器，為了方便使用者的訪問會在伺服器上快取資料，因此使用者每次訪問的時候最好能保持同一臺伺服器。
   已有的做法是根據ServerIPIndex[QQNUM%n]得到請求的伺服器，這種方法很方便將使用者分到不同的伺服器上去。但是如果一臺伺服器死掉了，那麼n就變為了n-1，那麼ServerIPIndex[QQNUM%n]與ServerIPIndex[QQNUM%（n-1）]基本上都不一樣了，所以大多數使用者的請求都會轉到其他伺服器，這樣會發生大量訪問錯誤。

       問： 如何改進或者換一種方法，使得：
   （1）一臺伺服器死掉後，不會造成大面積的訪問錯誤，
   （2）原有的訪問基本還是停留在同一臺伺服器上；
   （3）儘量考慮負載均衡。（思路：往分散式一致雜湊演算法方面考慮。）

   1. 最土的辦法還是用模餘方法：做法很簡單，假設有N臺伺服器，現在完好的是M（M<=N),先用N求模，如果不落在完好的機器上，然後再用N-1求模，直到M.這種方式對於壞的機器不多的情況下，具有更好的穩定性。
      
   2. 一致性雜湊演算法。

       下面，本文剩下部分重點來講講這個一致性雜湊演算法。
   

   應用場景

       在做伺服器負載均衡時候可供選擇的負載均衡的演算法有很多，包括：  輪循演算法（Round Robin）、雜湊演算法（HASH）、最少連線演算法（Least Connection）、響應速度演算法（Response Time）、加權法（Weighted ）等。其中雜湊演算法是最為常用的演算法.

       典型的應用場景是： 有N臺伺服器提供快取服務，需要對伺服器進行負載均衡，將請求平均分發到每臺伺服器上，每臺機器負責1/N的服務。

       常用的演算法是對hash結果取餘數 (hash() mod N)：對機器編號從0到N-1，按照自定義的hash()演算法，對每個請求的hash()值按N取模，得到餘數i，然後將請求分發到編號為i的機器。但這樣的演算法方法存在致命問題，如果某一臺機器宕機，那麼應該落在該機器的請求就無法得到正確的處理，這時需要將當掉的伺服器從演算法從去除，此時候會有(N-1)/N的伺服器的快取資料需要重新進行計算；如果新增一臺機器，會有N /(N+1)的伺服器的快取資料需要進行重新計算。對於系統而言，這通常是不可接受的顛簸（因為這意味著大量快取的失效或者資料需要轉移）。那麼，如何設計一個負載均衡策略，使得受到影響的請求儘可能的少呢？
       在Memcached、Key-Value Store、Bittorrent DHT、LVS中都採用了Consistent Hashing演算法，可以說Consistent Hashing 是分散式系統負載均衡的首選演算法。

   Consistent Hashing演算法描述

       下面以Memcached中的Consisten Hashing演算法為例說明。

       consistent hashing 演算法早在 1997 年就在論文 Consistent hashing and random trees中被提出，目前在 cache 系統中應用越來越廣泛；

   1 基本場景

   比如你有 N 個 cache 伺服器（後面簡稱 cache ），那麼如何將一個物件 object 對映到 N 個 cache 上呢，你很可能會採用類似下面的通用方法計算 object 的 hash 值，然後均勻的對映到到 N 個 cache ；

   hash(object)%N

   一切都執行正常，再考慮如下的兩種情況；

   1. 一個 cache 伺服器 m down 掉了（在實際應用中必須要考慮這種情況），這樣所有對映到 cache m 的物件都會失效，怎麼辦，需要把 cache m 從 cache 中移除，這時候 cache 是 N-1 臺，對映公式變成了 hash(object)%(N-1) ；
   2. 由於訪問加重，需要新增 cache ，這時候 cache 是 N+1 臺，對映公式變成了 hash(object)%(N+1) ；

       1 和 2 意味著什麼？這意味著突然之間幾乎所有的 cache 都失效了。對於伺服器而言，這是一場災難，洪水般的訪問都會直接衝向後臺伺服器；再來考慮第三個問題，由於硬體能力越來越強，你可能想讓後面新增的節點多做點活，顯然上面的 hash 演算法也做不到。

         有什麼方法可以改變這個狀況呢，這就是consistent hashing。

   2 hash 演算法和單調性

   　 Hash 演算法的一個衡量指標是單調性（ Monotonicity ），定義如下：

   　 單調性是指如果已經有一些內容通過雜湊分派到了相應的緩衝中，又有新的緩衝加入到系統中。雜湊的結果應能夠保證原有已分配的內容可以被對映到新的緩衝中去，而不會被對映到舊的緩衝集合中的其他緩衝區。

       容易看到，上面的簡單 hash 演算法 hash(object)%N 難以滿足單調性要求。

   3 consistent hashing 演算法的原理

       consistent hashing 是一種 hash 演算法，簡單的說，在移除 / 新增一個 cache 時，它能夠儘可能小的改變已存在 key 對映關係，儘可能的滿足單調性的要求。

       下面就來按照 5 個步驟簡單講講 consistent hashing 演算法的基本原理。

   3.1 環形hash 空間

       考慮通常的 hash 演算法都是將 value 對映到一個 32 為的 key 值，也即是 0~2^32-1 次方的數值空間；我們可以將這個空間想象成一個首（ 0 ）尾（ 2^32-1 ）相接的圓環，如下面圖 1 所示的那樣。

   
   

   3.2 把物件對映到hash 空間

       接下來考慮 4 個物件 object1~object4 ，通過 hash 函式計算出的 hash 值 key 在環上的分佈如圖 2 所示。

   hash(object1) = key1;

   … …

   hash(object4) = key4;
   
   

   3.3 把cache 對映到hash 空間

       Consistent hashing 的基本思想就是將物件和 cache 都對映到同一個 hash 數值空間中，並且使用相同的hash 演算法。

       假設當前有 A,B 和 C 共 3 臺 cache ，那麼其對映結果將如圖 3 所示，他們在 hash 空間中，以對應的 hash值排列。

   hash(cache A) = key A;

   … …

   hash(cache C) = key C;

   
   

   說到這裡，順便提一下 cache 的 hash 計算，一般的方法可以使用 cache 機器的 IP 地址或者機器名作為hash 輸入。

   3.4 把物件對映到cache

       現在 cache 和物件都已經通過同一個 hash 演算法對映到 hash 數值空間中了，接下來要考慮的就是如何將物件對映到 cache 上面了。

       在這個環形空間中，如果沿著順時針方向從物件的 key 值出發，直到遇見一個 cache ，那麼就將該物件儲存在這個 cache 上，因為物件和 cache 的 hash 值是固定的，因此這個 cache 必然是唯一和確定的。這樣不就找到了物件和 cache 的對映方法了嗎？！

       依然繼續上面的例子（參見圖 3 ），那麼根據上面的方法，物件 object1 將被儲存到 cache A 上； object2和 object3 對應到 cache C ； object4 對應到 cache B ；

   3.5 考察cache 的變動

       前面講過，通過 hash 然後求餘的方法帶來的最大問題就在於不能滿足單調性，當 cache 有所變動時，cache 會失效，進而對後臺伺服器造成巨大的衝擊，現在就來分析分析 consistent hashing 演算法。

   3.5.1 移除 cache

       考慮假設 cache B 掛掉了，根據上面講到的對映方法，這時受影響的將僅是那些沿 cache B 順時針遍歷直到下一個 cache （ cache C ）之間的物件，也即是本來對映到 cache B 上的那些物件。

       因此這裡僅需要變動物件 object4 ，將其重新對映到 cache C 上即可；參見圖 4 。

   
   

   3.5.2 新增 cache

       再考慮新增一臺新的 cache D 的情況，假設在這個環形 hash 空間中， cache D 被對映在物件 object2 和object3 之間。這時受影響的將僅是那些沿 cache D 逆時針遍歷直到下一個 cache （ cache B ）之間的物件（它們是也本來對映到 cache C 上物件的一部分），將這些物件重新對映到 cache D 上即可。

       因此這裡僅需要變動物件 object2 ，將其重新對映到 cache D 上；參見圖 5 。
   
   

   4 虛擬節點

   考量 Hash 演算法的另一個指標是平衡性 (Balance) ，定義如下：

   平衡性

   　　平衡性是指雜湊的結果能夠儘可能分佈到所有的緩衝中去，這樣可以使得所有的緩衝空間都得到利用。

       hash 演算法並不是保證絕對的平衡，如果 cache 較少的話，物件並不能被均勻的對映到 cache 上，比如在上面的例子中，僅部署 cache A 和 cache C 的情況下，在 4 個物件中， cache A 僅儲存了 object1 ，而 cache C 則儲存了 object2 、 object3 和 object4 ；分佈是很不均衡的。

       為了解決這種情況， consistent hashing 引入了“虛擬節點”的概念，它可以如下定義：

   “虛擬節點”（ virtual node ）是實際節點在 hash 空間的複製品（ replica ），一實際個節點對應了若干個“虛擬節點”，這個對應個數也成為“複製個數”，“虛擬節點”在 hash 空間中以 hash 值排列。

       仍以僅部署 cache A 和 cache C 的情況為例，在圖 4 中我們已經看到， cache 分佈並不均勻。現在我們引入虛擬節點，並設定“複製個數”為 2 ，這就意味著一共會存在 4 個“虛擬節點”， cache A1, cache A2 代表了 cache A ； cache C1, cache C2 代表了 cache C ；假設一種比較理想的情況，參見圖 6 。

   
   

    此時，物件到“虛擬節點”的對映關係為：

   objec1->cache A2 ； objec2->cache A1 ； objec3->cache C1 ； objec4->cache C2 ；

       因此物件 object1 和 object2 都被對映到了 cache A 上，而 object3 和 object4 對映到了 cache C 上；平衡性有了很大提高。

       引入“虛擬節點”後，對映關係就從 { 物件 -> 節點 } 轉換到了 { 物件 -> 虛擬節點 } 。查詢物體所在 cache時的對映關係如圖 7 所示。
   
   

     “虛擬節點”的 hash 計算可以採用對應節點的 IP 地址加數字字尾的方式。例如假設 cache A 的 IP 地址為202.168.14.241 。

       引入“虛擬節點”前，計算 cache A 的 hash 值：

   Hash(“202.168.14.241”);

       引入“虛擬節點”後，計算“虛擬節”點 cache A1 和 cache A2 的 hash 值：

   Hash(“202.168.14.241#1”);  // cache A1

   Hash(“202.168.14.241#2”);  // cache A2