經典面試題（二）附答案 演算法+資料結構+程式碼 微軟Microsoft、谷歌Google、百度、騰訊

yangxi_001發表於2014-06-13
面試題演算法資料結構微軟ROS谷歌Go
1.正整數序列Q中的每個元素都至少能被正整數a和b中的一個整除，現給定a和b，需要計算出Q中的前幾項，

例如，當a=3，b=5，N=6時，序列為3，5，6，9，10，12

(1)、設計一個函式void generate（int a,int b,int N ,int * Q）計算Q的前幾項

(2)、設計測試資料來驗證函式程式在各種輸入下的正確性。

 

感覺有點類似歸併排序的Merge。有兩個陣列A、B。

陣列A存放：3*1、3*2、3*3…

陣列B存放：5*1、5*2、5*3…

有兩個指標 i, j，分別指向A、B的第一個元素。取Min( A[i], B[j] )，並將較小值的指標前移，然後繼續比較。

當然，程式設計實現的時候，完全沒有必要申請兩個陣列，用兩個變數就可以。

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void Generate( int a,int b,int N ,int * Q )  
  5. {     
  6.     int tmpA, tmpB;  
  7.     int i = 1;  
  8.     int j = 1;  
  9.   
  10.     for( int k=0; k<N; k++ )  
  11.     {  
  12.         tmpA = a * i;  
  13.         tmpB = b * j;  
  14.   
  15.         if( tmpA <= tmpB )  
  16.         {  
  17.             Q[k] = tmpA;  
  18.             i++;  
  19.         }  
  20.         else  
  21.         {  
  22.             Q[k] = tmpB;  
  23.             j++;  
  24.         }  
  25.     }  
  26. }  
  27.   
  28. int main()  
  29. {  
  30.     int Q[6];  
  31.     Generate( 3, 5, 6 ,Q );  
  32.     return 0;  
  33. }  

2.有一個由大小寫組成的字串，現在需要對他進行修改，將其中的所有小寫字母排在大寫字母的前面（大寫或小寫字母之間不要求保持原來次序），如有可能儘量選擇時間和空間效率高的演算法c語言函式原型void proc（char *str）

也可以採用你自己熟悉的語言

 

應該類似快排的partition。快排的partition也有兩種常見的實現：從左往右掃描、從兩頭往中間掃描。這裡使用從左往後掃描的方式。

字串在調整的過程中可以分成兩個部分：已排好的小寫字母部分、待調整的剩餘部分。用兩個指標i和j，其中i指向待調整的剩餘部分的第一個元素，用j指標遍歷待調整的部分。當j指向一個小寫字母時，交換i和j所指的元素。向前移動i、j，直到字串末尾。

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void Proc( char *str )  
  5. {  
  6.     int i = 0;  
  7.     int j = 0;  
  8.   
  9.     //移動指標i, 使其指向第一個大寫字母  
  10.     while( str[i] != '\0' && str[i] >= 'a' && str[i] <= 'z' ) i++;  
  11.   
  12.     if( str[i] != '\0' )  
  13.     {  
  14.         //指標j遍歷未處理的部分，找到第一個小寫字母       
  15.         for( j=i; str[j] != '\0'; j++ )  
  16.         {  
  17.             if( str[j] >= 'a' && str[j] <= 'z' )  
  18.             {  
  19.                 char tmp = str[i];  
  20.                 str[i] = str[j];  
  21.                 str[j] = tmp;  
  22.                 i++;                  
  23.             }             
  24.         }  
  25.     }     
  26. }  
  27.   
  28. int main()  
  29. {  
  30.     char data[] = "SONGjianGoodBest";  
  31.     Proc( data );     
  32.     return 0;  
  33. }  

 3.如何隨機選取1000個關鍵字。

給定一個資料流，其中包含無窮盡的搜尋關鍵字（比如，人們在谷歌搜尋時不斷輸入的關鍵字）。如何才能從這個無窮盡的流中隨機的選取1000個關鍵字？

 

說實話我不會做，是看網上的答案。感覺是對的，但又說不上為什麼。

思路是這樣的：

1.申請一個1000個元素的陣列，用於儲存最後選中的關鍵字

2.將資料流中前1000個直接放入陣列中

3.對於第n個元素（n>1000）, 以1000/n的概率隨機替換陣列中的一個元素

這個就能保證每個元素都以1000/n的概率被選中。哎，為什麼？先放這吧，以後再說。 

4.判斷一個自然數是否是某個數的平方。說明：當然不能使用開方運算。 

也就是判斷一個自然數是否是完全平方數。

方法一：從1開始逐個嘗試，即判斷1*1，2*2，3*3…,演算法複雜度O( N^0.5 )

方法二：相當於在1…N之間找一個數x，使x*x = N。這樣看就是一個查詢問題，所以用折半查詢。演算法複雜度O( logN )。

方法三：使用完全平方數的性質：每個完全平方數都可以表示成一系列奇數的和。

不妨這樣簡單理解一下：

設x是一個完全平方數，即 x = a^2，所以

a^2 = ( a – 1 +1 )^2 = (a-1)^2 + 2( a – 1 ) + 1

               =( (a-2) + 1 )^2 + 2( a – 1 ) + 1

               =(a-2)^2 + ( 2( a – 2 ) + 1 ) + (2( a – 1 ) + 1 )

即 x = 1 + 3 + 5 + … + (2( a – 1 ) + 1 )

故x可以表示為一系列奇數的和. 

因此判斷完全平方數的演算法：x – 1 – 3 – 5…即從x中連續不斷的減去一個奇數，如果結果可以為0，則x是完全平方數。否則，不是。演算法複雜度O(N )，當然由於這裡做的全部是減法，可能也回比較快。

5.給定能隨機生成整數1到5的函式，寫出能隨機生成整數1到7的函式。 

關鍵是要保證每個數字產生的概率相等。

把能隨機生成整數1到5的函式記為R15。

我的想法是：把R15呼叫6次，然後統計這6次中，某個數字出現的次數。比如，統計1出現的次數。1的次數[0, 6],然後給次數加一，就可以隨機生成1到7之間的整數。

網上的解法：首先，呼叫7次R15。然後，取最大值對應的下標，由這些值構成了一個新陣列。然後繼續呼叫R15，直到最後只剩下一個數字。

{ 1，2，3，4，5，6，7 }

 5，3，1，5，2，4，5

{ 1， ， ，4， ， ，7 }

 4， ， ，1， ， ，3

{ 1 } 

6.1024! 末尾有多少個？ 

求末尾0個數，也就是對1024！進行因子分解，求因子中10的個數。在進一步，因子中10的個數，就相當與質因子中2*5的個數。因為質因子5的個數比2少，所以也就是求1024！中質因子5的個數。

1，2，3，…，1024中哪些數都含有質因子5？主要有以下幾類：

第一類：5的倍數，1024/5 = 204個

第二類：25的倍數，1024/25 = 40個

第三類：125的倍數，1024/125 = 8個

第四類：625的倍數，1024/625 = 1個

則，總的因子5的個數：204 + 40 + 8 + 1 = 253

當然，為什麼加起來就是最後的答案？這個不難，自己想想吧。 

7. 有個海盜，按照等級從5到1排列，最大的海盜有權提議他們如何分享枚金幣。

但其他人要對此表決，如果多數反對，那他就會被殺死。

他應該提出怎樣的方案，既讓自己拿到儘可能多的金幣又不會被殺死？

（提示：有一個海盜能拿到98%的金幣）

 

      很有意思的一個題。嘿嘿，不會做，也還是看網上答案的。

      當有5個人時，等級為5的海盜，等級最高，他來分配。分配時要考慮兩個問題：利益最大、不被殺死。至於他的分配方案會不會招來殺身之禍，完全取決於其他4個人的反應。所以考慮，4個人的情況。

      當有4個人時，等級為4的海盜，等級最高，他來分配。至於他的分配方案會不會招來殺身之禍，完全取決於其他3個人的反應。所以考慮，3個人的情況。

…

       當有2個人時，等級為2的海盜，等級最高，他來分配。這時他就可以肆無忌憚的分配了。分配方案：100，0。即給自己100枚金幣，給等級為1的海盜0枚金幣。雖然對等級為1的海盜來說很不公平，但是他反對也沒用，因為只有兩個人，他佔不了大多數。

       再來考慮三個人的問題。當有3個人時，等級為3的海盜，等級最高，他來分配。他只要在前兩個人中爭取一個人就行。分配方案：99，0，1。這樣等級為1的海盜肯定不會反對，因為比2個人的時候分的多。只有等級為2的海盜反對，但是沒有用

考慮四個人的情況。分配方案：99，0，1，0。等級為4、2的海盜滿意。

五個人的情況。分配方案：98，0，1，0，1。

8.給定一個集合A=[0,1,3,8](該集合中的元素都是在，之間的數字，但未必全部包含)，指定任意一個正整數K，請用A中的元素組成一個大於K的最小正整數。

比如，A=[1,0] K=21 那麼輸出結構應該為100。

 

首先，計算正整數K的位數。假設k有m位。把用A中的元素組成一個大於K的最小正整數記為x。那麼x就有m位或者m+1位。

根據K的最高位，在A中選數字。分兩種情況：A中的數字都比k的最高位小、A中至少有一個數字等於大於k的最高位。

1.A中的數字都比k的最高位小，則x有m+1位。這時，只要用A中的數字組成一個m+1位的最小正整數即可。

2.A中至少有一個數字等於大於k的最高位。這時x的最高位就是不小於K最高位的最小數字。然後，用同樣的方法繼續比較下一位。

程式設計實現：很煩，寫的都想吐血了。

[cpp] view plaincopy
  1. #include <iostream>  
  2. #include <algorithm>  
  3. using namespace std;  
  4.   
  5. //target為int值，最多是10位數  
  6. const int MAX_INT_CNT = 20;  
  7.   
  8. int NearestInt( int target, int *data, int size )  
  9. {     
  10.     int ans = 0;  
  11.       
  12.     //計算target的位數  
  13.     int cnt = 0;      
  14.     int tmp = target;  
  15.     while( tmp > 0 )   
  16.     {  
  17.         cnt++;  
  18.         tmp /= 10;  
  19.     }  
  20.   
  21.     //將target轉換為字串  
  22.     char des[MAX_INT_CNT];  
  23.     itoa( target, des , 10 );  
  24.     string strTarget( des );  
  25.   
  26.     //對陣列排序  
  27.     sort( data, data+size );  
  28.   
  29.     int flag = 0;     
  30.     int i, j;  
  31.     for( i=0; i<cnt; i++ )  
  32.     {  
  33.         ans *= 10;  
  34.         //遍歷陣列，找到一個合適的元素  
  35.         for( j=0; j<size && flag==0; j++ )  
  36.         {  
  37.             if( strTarget[i] == data[j] )  
  38.             {                             
  39.                 ans += data[j];  
  40.                 break;                                            
  41.             }  
  42.             if( strTarget[i] < data[j] )  
  43.             {  
  44.                 ans += data[j];  
  45.                 flag = 1;  
  46.                 break;  
  47.             }  
  48.         }  
  49.         if( j >= size ) flag = 2;  
  50.         //flag == 2表示前面的數字都相等，只要後面的多一位就行  
  51.         if( flag == 2 )  
  52.         {  
  53.             if( i == 0 )  
  54.             {  
  55.                 //找到一個非0元素  
  56.                 for( j=0; j<size; j++ )  
  57.                 {  
  58.                     if( data[j] > 0 )break;   
  59.                 }                 
  60.                 ans += data[j];  
  61.             }  
  62.             else   
  63.                 ans += data[0];  
  64.         }         
  65.         //flag == 1表示前面的數字比較大，後面的取最小的數字即可         
  66.         if( flag == 1 ) ans += data[0];   
  67.     }  
  68.     //如果前面的數字都相等  
  69.     if( flag == 2 )  
  70.     {  
  71.         ans *= 10;  
  72.         ans += data[0];  
  73.     }     
  74.     return ans;  
  75. }  
  76.   
  77.   
  78. int main()  
  79. {  
  80.     int data[] = { 0, 1, 3, 8 };  
  81.       
  82.     cout << NearestInt( 21, data, 4 ) << endl;  
  83.     return 0;  
  84. }  

9. 用C語言實現一個revert函式，它的功能是將輸入的字串在原串上倒序後返回。 

基本的字串操作。應該沒有什麼問題，比起連結串列的反轉簡單多了。

[cpp] view plaincopy
  1. char* Revert( char *str )  
  2. {  
  3.     if( str != NULL )  
  4.     {  
  5.         char *begin = str;  
  6.         char *end = str;  
  7.         while( *end != '\0' ) end++;  
  8.         end--;  
  9.   
  10.         while( begin != end )  
  11.         {  
  12.             char tmp = *begin;  
  13.             *begin = *end;  
  14.             *end = tmp;  
  15.   
  16.             begin++;  
  17.             end--;  
  18.         }  
  19.     }  
  20.     return str;  
  21. }  

10.用C語言實現函式void * memmove(void*dest, const void *src, size_t n)。memmove函式的功能是拷貝src所指的記憶體內容前n個位元組到dest所指的地址上。 


其實就是自己寫一個memcpy函式。注意下面三種情況：

指標為空

兩個指標間距過小( 如dest = 10010, src =10020, n = 20 )

void*的轉換

[cpp] view plaincopy
  1. void* Memmove( void *dest, const void *src, size_t n )  
  2. {  
  3.     char *cDest = (char*) dest;  
  4.     char *cSrc = (char*) src;  
  5.       
  6.     assert( cDest != NULL && cSrc != NULL );  
  7.     assert( cDest >= cSrc + n || cSrc >= cDest + n );  
  8.   
  9.     while( n-- )    *cDest++ = *cSrc++;   
  10.     return dest;      
  11. }  

11.有一根釐米的細木杆，在第3釐米、7釐米、11釐米、17釐米、23釐米這五個位置上各有一隻螞蟻。木杆很細，同時只能通過一隻螞蟻。開始時，螞蟻的頭朝左還是朝右是任意的，它們只會朝前走或調頭，但不會後退。當任意兩隻螞蟻碰頭時，兩隻螞蟻會同時調頭朝反方向走。假設螞蟻們每秒鐘可以走一釐米的距離。

編寫程式，求所有螞蟻都離開木杆的最小時間和最大時間。

 

        不知這題是想考什麼。

        題目的難點在於：初始狀態，螞蟻的方向任意。因為只有5個螞蟻，每隻螞蟻的方向只有左、右兩種選擇，因此5只螞蟻的初始方向有2^5 = 32種情況。

        沒有想到什麼好的演算法，只能列舉所有情況。對每種情況，模擬螞蟻的爬杆過程：沿初始方向前進、每秒更新一次螞蟻的位置、更新完成後進行碰撞檢測。當所有螞蟻都爬出細杆後，就可以得到所需時間。最後，在所有的初始情況下，求最小時間和最大時間。索性資料量很小，時間可以接受。

[cpp] view plaincopy
  1. const int LEFT = 0;  
  2. const int RIGHT = 1;  
  3.   
  4. //記錄每個螞蟻的初始方向  
  5. int dir[5];  
  6. //記錄每個螞蟻的初始位置  
  7. int pos[5];  
  8. //記錄每個螞蟻是否爬出了細杆  
  9. bool isFinish[5];  
  10.   
  11. void Init( int  i )  
  12. {  
  13.     //初始化螞蟻的方向  
  14.     int tmp = i;  
  15.     int mask = 0x0001;  
  16.     for( int j=0; j<5; j++ )  
  17.     {  
  18.         dir[j] = ( tmp & mask ) ? RIGHT : LEFT;  
  19.         tmp >>= 1;          
  20.     }  
  21.   
  22.     //初始化螞蟻的位置  
  23.     pos[0] = 3;  
  24.     pos[1] = 7;  
  25.     pos[2] = 11;  
  26.     pos[3] = 17;  
  27.     pos[4] = 23;  
  28.   
  29.     //初始化螞蟻的狀態標誌  
  30.     memset( isFinish, false, sizeof(isFinish) );  
  31. }  
  32.   
  33. void AntTime( int &maxTime, int &minTime )  
  34. {  
  35.     int max = 0;  
  36.     int min = 10000000;  
  37.   
  38.     //依次處理32種情況  
  39.     for( int i=0; i<32; i++ )  
  40.     {  
  41.         Init( i );    
  42.   
  43.         //記錄已經爬出細杆的螞蟻個數  
  44.         int cnt = 0;  
  45.   
  46.         //每秒檢測一次  
  47.         int time;         
  48.         for( time=1; ; time++ )  
  49.         {  
  50.             //更新螞蟻位置  
  51.             for( int j=0; j<5; j++ )  
  52.             {  
  53.                 if( !isFinish[j] )  
  54.                 {  
  55.                     if( dir[j] == LEFT )  
  56.                         pos[j]--;  
  57.                     else  
  58.                         pos[j]++;  
  59.                 }                 
  60.             }  
  61.               
  62.             //檢測螞蟻是否已爬出細杆  
  63.             for( int m=0; m<5; m++ )  
  64.             {  
  65.                 if( !isFinish[m] && ( pos[m] < 0 || pos[m] > 23 ) )  
  66.                 {  
  67.                     isFinish[m] = true;  
  68.                     cnt++;  
  69.                 }  
  70.             }  
  71.   
  72.             //如果所有的螞蟻都已經爬出細杆，則跳出  
  73.             if( cnt >= 5 ) break;              
  74.               
  75.             //如果相撞，則掉頭  
  76.             for( int k=0; k<5; k++ )  
  77.             {  
  78.                 if( !isFinish[k] )  
  79.                 {  
  80.                     if( ( k == 0 && pos[k] == pos[k+1] ) || ( k == 5 && pos[k] == pos[k-1] ) ||  
  81.                         ( ( k > 0 && k < 5 ) && ( pos[k] == pos[k+1] || pos[k] == pos[k-1] ) )  
  82.                       )  
  83.                     {  
  84.                         dir[k] = ( dir == LEFT ) ? RIGHT : LEFT;  
  85.                     }  
  86.                 }                                 
  87.             }  
  88.         }  
  89.   
  90.         if( time > max ) max = time;  
  91.         if( time < min ) min = time;  
  92.     }  
  93.     maxTime = max;  
  94.     minTime = min;  
  95. }  

12.請定義一個巨集，比較兩個數a、b的大小，不能使用大於、小於、if語句 

這裡有兩種做法：正數的絕對值等於本身、兩數相減判斷符號位 

[cpp] view plaincopy
  1. #define MAX( a, b ) ( fabs( a, b ) == ( (a) - (b) ) ? (a) : (b) )  
  2. #define MMAX( a, b ) ( ( ( (a) - (b) ) & ( 1 << 31 ) ) ? (a) : (b) )  

13.兩個數相乘，小數點後位數沒有限制，請寫一個高精度演算法

 

14.有A、B、C、D四個人，要在夜裡過一座橋。他們通過這座橋分別需要耗時1、2、5、10分鐘，只有一支手電，並且同時最多隻能兩個人一起過橋。請問，如何安排，能夠在17分鐘內這四個人都過橋？

 

        這題想想不難，就不知道具體程式設計應該怎麼實現，能想到的就是DFS。這裡的17分鐘應該就是最短時間了。先不管程式設計實現了，說說具體的思路吧

首先，要到對岸，每次不能只過一個人。因為這個人拿了手電，其他人都過不了。這樣，每次過橋，必須兩個人。兩個人過去，其中一個人再拿了手電回來。那選哪兩個人過去，哪個人再回來？當然是時間最小的啦。所以，5分鐘的人和10分鐘的人結伴過河，這樣可以把5分鐘的時間淹沒在10分鐘內，共需10鍾就可以完成。在讓時間最小的人拿了手電回去，那自然選1分鐘的人了。也就是說，1分鐘的人必須在5、10之前到達對岸。

         這樣，整個過程就是：1、2先到對岸（2Min），2拿了手電返回（2Min），5、10再結伴過橋（10Min），1拿手電返回（1Min），最後1、2結伴過橋（2Min），總共剛好17分鐘。 

15.有12個小球,外形相同,其中一個小球的質量與其他11個不同，給一個天平,問如何用3次把這個小球找出來，並且求出這個小球是比其他的輕還是重

 

        很久以前的題了，估計大多數人都見過。類似折半查詢的方法，把問題的規模以O( lgn )的速度減小。12---6---3---1。當剩3個時，問題最精妙，這時有三種狀態可利用：天平左半、天平右邊、不在天平兩端。這提示我們，其實27個小橋也可以用這個方法。27---9----3----1，即稱3次就可以完成。

        其實，這裡可以總結一個規律：( 3^(n-1), 3^n ]內的數都只需n次就可以完成。即，10、11、12、….、27個球都只用3次就可以。

16.在一個檔案中有10G 個整數，亂序排列，要求找出中位數。記憶體限制為2G。只寫出思路即可。 

       海量資料處理的問題。10G個數，中位數就是第5G、第5G+1個數。回想一下，一般情況下求中位數的做法：類似於快排的partition，找到一個數，使比它小的數的個數佔到總數的一半就行。所以，可以把數值空間分段，然後統計每一段中資料的個數，這樣就可以很容易的確定中位數在那一段。找個該段後，資料量已經急劇減小了，剩下的問題就好處理了。這種方法可以說是桶排序的思想，也可以說是hash的思想。下面具體分析一下：

        因為要統計每一段中資料的個數，所以可以用一個unsigned int型。unsigned int一般佔4個位元組，可以計數到2^32-1，大約是4G。題目中有10G個數，如果有很多數落在同一個段中，unsigned int肯定不夠用。所以，這裡的計數用要8位元組的long long。即，相當於有一個陣列，陣列是long long性，陣列的每一個元素，代表了一個資料段內的資料個數。這個陣列有多大？為了充分利用2G記憶體，陣列大小2G/8 = 256M。即，有陣列long long cnt[256M].

        假設題目中的10G個數都是4位元組的int。如何把這10G個整數，對映到cnt[256M]的陣列中。可以使用計算機中的虛擬地址到實體地址的轉換。取int的高28位作為陣列下標的索引值，這樣就可以完成對映。

整個演算法的流程：

掃描10G個整數，對每個整數，取高28位，對映到陣列的某個元素上

給陣列的這個元素加1，表示找到一個屬於該資料段的元素

掃描完10G個整數後，陣列cnt中就記錄了每段中元素的個數

從第一段開始，將元素個數累計，直到值剛好小於5G，則中位數就在該段

這時對10G個整數再掃描一遍，記錄該段中每個元素的個數。直至累計到5G即可。 

17..一個檔案中有40億個整數，每個整數為四個位元組，記憶體為1GB，寫出一個演算法：求出這個檔案裡的整數裡不包含的一個整數 

方法一：

使用點陣圖。4位元組的int，有4G個不同的值。每個值，對應1bit，則共需4G/8 = 512M

記憶體。初始狀態，對512M的點陣圖清零。然後，對這40億個整數進行統計。如果某個值出現了，那麼就把這個值對應的bit置位。最後，掃描點陣圖，找到一個沒有被置位的bit即可。

方法二：

分段統計。Long long cnt[512M/8=64M]對應數值空間的64M個資料段。每個資料段包含64個不同值，用一個long long作為這個資料段內的點陣圖，點陣圖佔64M*8=512M。

這樣掃描一遍40億個整數後，從陣列中找到一個計數小於64的元素，然後檢視它的點陣圖，找出未出現的元素。

方法二平均效能應該比方法一快，但它佔的記憶體很恐怖。其實，這兩種方法都不是很實際，總共1G的記憶體，演算法就消耗512M甚至1G，那剩下的系統程式怎麼辦？OS都跑不起來了吧。 

18.騰訊伺服器每秒有2w個QQ號同時上線，找出5min內重新登入的qq號並列印出來。

        這應該是道面試題，面試官隨口問了一下。主要是看思路吧。

        最簡單的想法：直接用STL的set。從某一時刻開始計時，每登陸一個QQ，把它放入set，如果已存則直接列印。直到5min後，就可以over了。下面來簡單分析一下演算法的負複雜度：

空間複製度：用str儲存每個QQ號，假設QQ號有20位，理想情況下每個QQ佔20Byte。則5min內的QQ：2w * 60 * 5 = 600w個，需要的儲存空間600w * 20byte = 12000w byte = 120M，這樣的儲存應該可以忍受吧。

時間複雜度：STL的set是用二叉樹（更確切的說是：紅黑樹）實現的，查詢效率是O( lgn )，應該還是挺快的吧。

 

        呃，有人說不讓用STL。那就自己設計一個資料結構唄。該用什麼資料結構呢？想了想，還是繼續用樹，這裡用一個trie tree吧。節點內容包括QQ號、指向子節點的指標（這裡有10個，認為QQ由0---9的數字組成）。登陸時間要不要？考慮這樣一個問題：是否需要把所有的QQ都儲存在記憶體中？隨著時間的增加，登陸的QQ會越來越多，比較好的方法是把長時間不登陸的QQ釋放掉。所以需要記錄登陸時間，以便於釋放長期不登陸的QQ。

[cpp] view plaincopy
  1. struct TrieNode  
  2. {  
  3.     string qq;  
  4.     int lastLoginTime;  
  5.     TrieNode *next[10];  
  6. };  

我們的trie上的操作主要有兩個：查詢並插入、刪除。也就是說，這顆樹是不斷動態變化的，我們需要維護它。

相關文章