面試題33：把陣列排成最小的數

題目：輸入一個正整數陣列，把數組裡所有數字拼接起來排成一個數，列印能拼接出的所有數字中最小的一個。例如輸入陣列{3，32，321}，則打印出這3個數字能排成的最小數字321323。
分析：一個非常直觀的解決大數問題的方法就是把數字轉換成字串。另外，由於把數字m和n拼接起來得到mn和nm，它們的位數肯定是相同的，因此比較它們的大小隻需要按照字串大小的比較規則就可以了。

const int g_MaxNumberLength = 10;

char* g_StrCombine1 = new char[g_MaxNumberLength * 2 +1];
char
 
* g_StrCombine2 = new char[g_MaxNumberLength * 2 +1];

void PrintMinNumber(int* numbers, int length)
{
    if(numbers == NULL || length <= 0)
        return;

    char** strNumbers = (char**)(new int[length]);
    for(int i = 0;i<length ;++i)
    {
        strNumbers[i] = new char[g_MaxNumberLength + 1
 
];
        sprintf(strNumbers[i],"%d",numbers[i]);
    }

    qsort(strNumbers,length,sizeof(char*),compare);

    for(int i =0;i < length;++i)
        printf("%s",strNumbers[i]);
    printf("\n");

    for(int i = 0;i < length;++i)
        delete[] strNumbers[i];
    delete[] strNumbers;
}

int
 
 compare(const void* strNumber1,const void* strNumber2)
{
    strcpy(g_StrCombine1,*(const char**)strNumber1);
    strcat(g_StrCombine1,*(const char**)strNumber2);

    strcpy(g_StrCombine2,*(const char**)strNumber2);
    strcat(g_StrCombine2,*(const char**)strNumber1);

    return strcmp(g_StrCombine1,g_StrCombine2);
}

在上述程式碼中，我們先把陣列中的整數轉換成字串，在函式compare中定義比較規則，並根據該規則用規則用庫函式qsort排序。最後把排好序的陣列中的數字依次打印出來，就是該陣列中數字能拼接出來的最小數字。這種思路的時間複雜度和qsort的時間複雜度相同，也就是O(nlogn)，這比用n!的時間求出所有排列的思路要好很多。

面試題34： 醜數
題目：我們把只含因子2、3和5的數稱作醜數（Ugly Number）。求按從小到大的順序的第1500個醜數。例如6、8都是醜數，但14不是，因為它包含因子7。習慣上我們把1當做第一個醜數。

逐個判斷每個整數是不是醜數的解法，直觀但不夠高效

//判斷一個數是不是醜數
bool IsUgly(int number)
{
    while(number % 2 == 0)
        number /= 2;
    while(number % 3 == 0)
        number /= 3;
    while(number % 5 == 0)
        number /= 5;
    return (number == 1)?true:false;
}

//判斷每一個整數是不是醜數
int GetUglyNumber(int index)
{
    if(index <= 0)
        return 0;

    int number = 0;
    int uglyFound = 0;
    while(uglyFound < index)
    {
        ++number;

        if(IsUgly(number))
        {
            ++uglyFound;
        }
    }
    return number;
}

方法二：建立陣列儲存已經找到的醜數，用空間換時間的解法
根據醜數的定義，醜數應該是另一個醜數乘以2、3或者5的結果（1除外）。因此我們可以建立一個數組，裡面的數字是排好序的醜數，每一個醜數都是前面的醜數乘以2，3或者5得到的。
這種思路的關鍵在於怎樣確保數組裡面的醜數是排好序的。假設陣列中已經有若干個醜數排好序後存放在陣列中，並且把已有最大的醜數記作M，我們接下來分析如何生成下一個醜數。該醜數肯定是前面某一個醜數乘以2、3或者5的結果，所以首先考慮把已有的每個醜數乘以2。在乘以2的時候，能得到若干個小於或等於M的結果。由於是按照順序生成的，小於或者等於M肯定已經在陣列中了，我們不需要再次考慮；還會得到若干個大於M的結果，但我們只需要第一個大於M的結果，因為我們希望醜數是從小到大的順序生成的，其他更大的結果以後再說。我們把得到的第一個乘以2後大於M的結果記為M2。同樣，我們把已有的每一個醜數乘以3或5，能得到第一個大於M的結果M3和M5。那麼下一個醜數應該是M2、M3和M5這3個數的最小者。

int GetUglyNumber_Solution2(int index)
{
    if(index <= 0)
        return 0;

    int *pUglyNumbers = new int[index];
    pUglyNumbers[0]=1;
    int nextUglyIndex = 1;

    int *pMultiply2 = pUglyNumbers;
    int *pMultiply3 = pUglyNumbers;
    int *pMultiply5 = pUglyNumbers;

    while(nextUglyIndex < index)
    {
        int min =Min(*pMultiply2 * 2, *pMultiply3 * 3,*pMultiply5 * 5);
        pUglyNumbers[nextUglyIndex] = min;

        while(*pMultiply2 * 2 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply2;
        while(*pMultiply3 * 3 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply3;
        while(*pMultiply5 * 5 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply5;

        ++nextUglyIndex;
    }

    int ugly = pUglyNumbers[nextUglyIndex - 1];
    delete[] pUglyNumbers;
    return ugly;
}

int Min(int number1,int number2,int number3)
{
    int min = (number1 < number2) ? number1 :number2;
    min = (min < number3) ? min:number3;
    return min;
}

和第一種思路相比，第二種思路不需要在非醜數的整數上做任何計算，因此時間效率有明顯提升。但也需要指出，第二種演算法由於需要儲存已經生成的醜數，因此需要一個數組，從而增加了空間消耗。如果是求第1500個醜數，將建立一個容納1500個醜數的陣列，這個陣列佔記憶體6KB。而第一種思路沒有這樣的記憶體開銷。總的來說，第二種思路相當於用較小的空間消耗換取了時間效率的提升。

參考資料《劍指Offer》