[oj.leetcode] #179 - LargestNumber, 如何在7ms内跑完 221个测试用例

题目：已知一个整型数组，如何排列使得最后组成一个最大整数，输出这个整数的字符串，假设都是非负。

比如[3, 30, 34, 5, 9], 结果应该是 9534330

这里选用C++。

第一感觉应该是跟排序相关，稳妥方案是快速排序quick sort. 每两个数之间比较时，应从最高位开始，一位一位进行比较，将某一位更大的数排在前面。当然需要考虑当一个数是另一个数前缀时的情况，之后再说。

由于每两个数作比较时，每一位都可能参与比较，那么整型类型就显得很麻烦了，总不能一个数在每次比较时都去一位一位剥离出来。显然字符串是个好选择，比如将 123 转化成“123”， 那么我们可以在O(1)的时间内得到第i位[i]. 

慢着，多想一下，我们应该选用C风格字符串char*, 还是C++字符串string类型呢？对于[i] 操作显然没差别。问题在于之后的快速排序，因为是原地排序，所以会用到大量的交换函数，那么这里 char* 比 string 就有优势了，所以这里我选择C风格字符串char*。

继续思考两个数比较的问题，对于一个是另一个前缀，比如“12“, 与 “121“, 仔细想想，这其实是个递归，直到比较结束。

“12” ？ “121”

a. "12" == "12(1)"

b. "12" ? "1" => "1" == "1"

c. "2" ? "1"    =>  "2" > "1"

所以，12 应该排在121前面，我们应该得到12121。

到此为止，我们已经把问题拆解的差不多了，另外还有些边缘情况，比如数组全0，仅一个非0等等。

完整的C++代码如下：

class Solution{public:    string largestNumber(vector<int> &num){        int n = num.size();        if(n < 1)    return string();        vector<int> vec;        char* seq[n];        int lengths[n];        int L = 0;    // total length of all char*        bool allZero = true;        for(int i=0; i<n; i++){ // init char* for int element            int val = num[i];            if(val == 0){                vec.push_back(0);            }else{                allZero = false;                while(val > 0){  // save 123 in vector<> as 3,2,1                    vec.push_back(val % 10);                    val /= 10;                }            }            int l = vec.size();            char* curr = new char[l+1];            curr[l] = '\0';            for(int j=0; j < l; j++){  // save reversed vec in curr                curr[j] = '0' + vec[l-1 - j];            }            seq[i] = curr;            lengths[i] = l;            L += l;            vec.clear();        }        if(allZero){  // all zero case is special            for(int i=0; i<n; i++){                delete[] seq[i];                seq[i] = 0;            }            return string("0");        }        quick_sort(seq, n, lengths);        // generate string from seq[]        char result[L+1];        result[L] = '\0';        int t = 0;        for(int i=0; i<n; ++i){            for(int j=0; j < lengths[i]; ++j){                result[t++] = seq[i][j];            }        }        for(int i=0; i<n; i++){            delete[] seq[i];            seq[i] = 0;        }        return string(result);    }private:    int compDeciFromHigh(char* decL, int nL, char* decR, int nR){        int i=0;        while(i < nL && i < nR){            if(decL[i] != decR[i]){                return decL[i] > decR[i] ? 1 : -1;            }            i++;        }        int res = 0;        if(nL == nR)    return res;        int deltaLen = max(nL, nR) - i;  // i == min(nL, nR)        // next: compare the tail of long str and the short str        if(i == nL){  // left str is short            res = compDeciFromHigh(decL, nL, decR + nL, deltaLen);        }else{  // right str is short            res = compDeciFromHigh(decL + nR, deltaLen, decR, nR);        }        return res;    }    void quick_sort(char* seq[], int n, int* lengths){        if(n < 2)    return;        int p = 0, q = -1, t = n-1;        while(p < t){            if(compDeciFromHigh(seq[p], lengths[p],                    seq[t], lengths[t]) > 0){  // move higher decimal ahead                q++;                swap_chpp(&(seq[q]), &(seq[p]));                swap_ip(lengths + q, lengths + p);            }            p++;        }        q++;        swap_chpp(&(seq[q]), &(seq[t]));        swap_ip(lengths + q, lengths + t);        quick_sort(seq, q, lengths);        quick_sort(seq + (q+1), n-1 - q, lengths + (q+1));        return;    }    void swap_chpp(char **p, char **q){        char *tmp = *p;        *p = *q;        *q = tmp;        tmp = 0;    }    void swap_ip(int *p, int *q){        int tmp = *p;        *p = *q;        *q = tmp;    }};

代码有点长。除了开始阶段，要对每一个整型数转化得到字符串，另外我还用了一个数组来专门存放每个C风格字符串的长度，这样也好过回头用strlen() 再去量一遍每个的长度，代价就是在排序时，每次交换元素，也要对相应的长度元素作交换。

虽然看起来有点罗嗦，但事实证明一点一滴的优化都是值得的。最后这份代码实现在oj.leetcode的线上测试中，只用了7ms跑完了全部221个测试用例，这个成绩在所有提交代码中几乎也就是最好的了，有图为证:)

Ps, 对我而言，这份代码很好的诠释了C++语言相比于java/python在性能上的巨大优势。