騰訊2014軟件開發筆試題目

騰訊2014軟件開發筆試題目

                                                                    -----9月21日，騰訊2014軟件開發校招-簡答題-廣州

簡答題：

1、請設計一個排隊系統，能夠讓每個進入隊伍的用戶都能看到自己在 中所處的位置和變化。隊伍可能隨時有人加入和退出，當有人退出影響到用戶的位置排名時需要即時反饋到用戶。

2、A、B兩個整數集合，設計一個算法求他們的交集，盡可能的高效。

（博主能力有限，不是所有題目都會求解，第1題不是我的擅長，這里貼出來讓大家知道騰訊的考題。我的重點放在第2題上面！）

 

第2題  題解（個人看法，僅供參考！）

思路1：排序法

　　對集合A和集合B進行排序（升序，用快排，平均復雜度O(N*logN)），設置兩個指針p和q，同時指向集合A和集合B的最小值，不相等的話移動*p和*q中較小值的指針，相等的話同時移動指針p和q，並且記下相等的數字，為交集的元素之一，依次操作，直到其中一個集合沒有元素可比較為止。

　　優點：操作簡單，容易實現。

　　缺點：使用的排序算法不當，會耗費大量的時間，比如對排好序的集合使用快排， 時間復雜度是O(N²)

　　這種算法是大家都能比較快速想到的辦法，絕大多數時間放在了對集合的排序上，快排的平均復雜度是O(N*logN)，對排好序的集合做查找操作，時間復雜度為O（N），當然這種算法肯定比遍歷要快多了。

code：

 

#include <stdio.h>
#include <stdlib.h>
#define M 8
#define N 5
int cmp(const void *a, const void *b)
{
    int *x = (int *)a;
    int *y = (int *)b;
    return (*x) - (*y);
}

int main(void)
{
    int A[] = {-1, 2 ,39 ,10, 6, 11, 188, 10};
    int B[] = {39 ,8 , 10, 6, -1};
    //對數組A和數組B進行快排
    qsort(A, M, sizeof(int), cmp);
    qsort(B, N, sizeof(int), cmp);
    //FindIntersection(A, B);
    int i = 0, j = 0;
    int cnt = 0;
    int result[M > N ? M : N];//保存集合的結果
    //設置i、j索引，分別指向數組A和B，相等則同時移動，不相等則移動較小值的索引
    while(i < M && j < N)
    {
        if(A[i] == B[j])
        {
            result[cnt] = A[i];
            i++;
            j++;
            cnt++;
        }
        else if(A[i] < B[j])
        {
            i++;
        }
        else
        {
            j++;
        }
    }
    for(i = 0; i < cnt; i++)
    {
        printf("%4d", result[i]);
    }
    return 0;
}

 

 

 

思路2：索引法

　　以空間換時間，把集合(感謝網友的指正，集合里面的元素是不重復的！)中的元素作為數組下表的索引。來看例子：      

A= {1 ,12, 13, 25}，那Asub[1] = 3,Asub[12] = 1 ,Asub[13] = 1 ,Asub[25] = 1 ;

B=｛1, 2,  3, 15 ,｝那Bsub[1] = 1; Bsub[2] = 1; Bsub[3] = 1; Bsub[15] = 1;

　　對元素少的集合掃一遍，發現Asub[1] = 3 和Bsub[1] = 1有相同的索引1，並且重復度為1，所以交集肯定包括{1, 1}; Bsub[2] = 1而Asub[2] = 0，表示無交集，依次類推，可以得到集合A和B的交集。

　　假設集合中存在負數，可以把集合分成正整數和負整數（加個負號變正整數）兩部分，解法同上！

　　優點：速度快，時間復雜度O(N)

　　缺點：空間消耗大，以空間換取時間

　　這是我看到題目第一個想到的算法，再來想到排序法，而集合壓縮是有感而發的，索引法的缺點是空間消耗多，原因是可能索引值太大，要申請很多的不必要的空間，這個缺點也是有克服的方法的，就是采用哈希查找，找到一個比較合適的哈希函數，把索引的值減小了，從而減少消耗的內存空間。比如哈希函數為f(x) = (x + MOD) % MOD （除留余數法，MOD為常數），還有平方取中法、折疊法等方法，然而，無論哈希函數設計有多么精細，都會產生沖突現象，也就是2個關鍵字處理函數的結果映射在了同一位置上，因此，有一些方法可以避免沖突。這里沒有仔細鑽研，只提供一些思路，有興趣的朋友可以繼續研究。

code：（我的代碼僅適用與正整數部分，未處理負數）

/*
    Tencent: A、B兩個整數集合，設計一個算法求他們的交集，盡可能的高效
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 6
#define N 5
int Mymin(int a, int b)
{
    return a < b ? a : b;
}
int main(void)
{
    int A[] = {1, 10, 12, 23, 5, 45};
    int B[] = {1, 10, 12, 123, 52};

    //find MaxNumber in A
    int ifindA = 0;
    int MaxInA = A[0];
    for(ifindA = 0; ifindA < M; ifindA++)
    {
        MaxInA = MaxInA > A[ifindA] ? MaxInA : A[ifindA];
    }
    //find MaxNumber in B
    int ifindB = 0;
    int MaxInB = 0;
    for(ifindB = 0; ifindB < M; ifindB++)
    {
        MaxInB = MaxInB > A[ifindB] ? MaxInB : A[ifindB];
    }

    int *AsubPositive = (int *)malloc(sizeof(int) * (MaxInA + 1));
    int *BsubPositive = (int *)malloc(sizeof(int) * (MaxInB + 1));
    memset(AsubPositive, 0, sizeof(int) * (MaxInA + 1));
    memset(BsubPositive, 0, sizeof(int) * (MaxInB + 1));


    //COPY Positive and Negative numbers of A
    int i = 0;
    for(i = 0; i < M; i++)
    {
        AsubPositive[A[i]]++;
    }
    //COPY Positive and Negative numbers of B
    int j = 0;
    for(j = 0; j < N; j++)
    {
        BsubPositive[B[j]]++;
    }

    int  k = 0;
    int icount = 0;
    //掃描AsubNegative和BsubPositive
    printf("the Intersection of A and B is : { ");
    for(k = 0; k < M; k++)
    {
        //有交集輸出該數
        icount = Mymin(AsubPositive[A[k]], BsubPositive[A[k]]);
        if(icount == 1)
        {
            printf("%-3d",A[k]);
        }
        A[k] = 0;
    }
    printf(" }");
    return 0;
}

 

 

思路3：集合壓縮

 

　　對於一個集合來說，我們很容易就可以得到集合的最大值和最小值，假設集合A的最大值和最小值分別為MaxInA，MinInA；假設集合B的最大值和最小值分別為MaxInB，MinInB；那么集合A的所有元素一定在閉區間【MinInA, MaxInA】里面，集合B的所有元素一定在閉區間【MinInB, MaxInB】里面，從這兩個集合里面我們可以作如下判斷：（集合A和集合B都在鏈表中！此算法使用鏈表結構，操作起來比數組更方便）

　　1. 若MinInA == MinInB或者MaxInA == MaxInB，那么MinInA 或者MaxInA （相等的那個數）就一定在交集里面，存入交集（可以用數組存），刪除鏈表中相應的結點；若不想等則跳到第3步；

　　2. 重新找到集合A和B中的最大值和最小值MinInA 、MaxInA 、MinInB、MaxInB；跳回第1步；

　　3. 更新區間（交集的區間），區間的更新如下：區間下界為Lower = max(MinInA, MinInB)，上屆為Upper = min(MaxInA , MaxInB)，那么剩下的交集一定在閉區間【Lower ,Upper】里面，按照這個區間來剔除掉集合A和集合B中不符合條件的元素，剔除結束后，若其中一個集合為空，跳到第4步，否則返回第2步；

　　4. 程序結束，退出！

　　這種適用於集合里面數值比較散亂，最大值最小值差值比較大的情況！算法的思想在於不斷減小搜索的范圍，時間的消耗主要在查找集合的最大值和最小值上，我們來看一個例子，集合A= {1, 3, 10, 100, 123, 0, 6} ,B = {3, 2, 10, 23, -1},

　　集合A的閉區間【0， 123】，集合B的區間【-1，23】,交集的閉區間就為【0，23】，按照這個區間，剔除集合A中的｛ 100, 123｝，剔除集合B的｛-1｝，集合A=｛1, 3, 10, 0, 6｝集合B=｛3, 2, 10, 23｝，沒有相等的，繼續縮小范圍，為【2，10】，這時MaxInA == MaxInB，滿足條件，把10存入交集數組中，剔除兩個集合的結點；集合變為A= ｛3，6｝集合B={3}，滿足MinInA == MinInB或者MaxInA == MaxInB，把3存入交集數組中，集合B為空，結束！如圖：

　　對於第三個方法，我只是把算法的思想做了一下總結，並沒有編寫代碼運行調試並與其他算法做比較！比較過的朋友，歡迎告知三種算法的優劣性！

題目部分摘取自july CSDN網站：http://blog.csdn.net/v_july_v/article/details/11921021 

 

后記：　　

　　只要是算法，就無法同時解決時間復雜度和空間復雜度這一矛盾，我們只能具體問題具體分析，根據實際情況選取最合適的算法，盡量保持程序高效的執行效率！我的寫代碼能力和算法能力只能算初學者級別，所以在貼出的代碼中可能有許多漏洞，朋友們若是有什么建議，請多多給與我更多的指教！在這里發表一下自己的看法，多謝支持！