void q_sort(char* arr[], const int len) {
 
    typedef struct _Range {
        int start, end;
    } Range;
 
    Range new_Range(int s, int e) {
        Range r;
        r.start = s;
        r.end = e;
        return r;
    }
 
    if (len <= 0)
        return;
 
    Range r[len];
    int p = 0;
    r[p++] = new_Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end)
            continue;
        char* mid = arr[range.end], * cp;
        int left = range.start, right = range.end - 1;
        while (left < right) {
            while (GTR(mid, arr[left]) && left < right)
                left++;
            while (!GTR(mid, arr[right]) && left < right)
                right--;
            cp = arr[left], arr[left] = arr[right], arr[right] = cp;
        }
        if (!GTR(mid, arr[left]))
            cp = arr[left], arr[left] = arr[range.end], arr[range.end] = cp;
        else
            left++;
        r[p++] = new_Range(range.start, left - 1);
        r[p++] = new_Range(left + 1, range.end);
    }
}
 
int GTR(char* s1, char* s2) {
 
    char * p1 = s1, * p2 = s2;
 
    while (1) {
 
        if (!*p1 && !*p2) return 1;
 
        if (!*p1) p1 = s2;
 
        if (!*p2) p2 = s1;
 
        if (*p1 > *p2)
            return 1;
        else if (*p1 < *p2)
            return 0;
        else p1++, p2++;
 
    }
}
 
char* largestNumber(int* nums, int numsSize) {
 
    char strs [numsSize][11], * strPtrs[numsSize], * cp1, * cp2, * strRet = malloc(10 * numsSize + 1), ch;
 
    int i, j, k, t;
 
    for (i = 0; i < numsSize; i++) {
 
        t = *(nums + i);
        j = 0;
        k = -1;
 
        // digits convert to string
        do {
            strs[i][j++] = '0' + t % 10;
        } while ((t /= 10) > 0);
        strs[i][j] = '\0';
 
        // reverse string
        *(strPtrs + i) = cp1 = *(strs + i);
        while (--j > ++k)
            * (cp1 + j) ^= *(cp1 + k), * (cp1 + k) ^= *(cp1 + j), * (cp1 + j) ^= *(cp1 + k);
 
    }
 
    q_sort(strPtrs, numsSize);
 
    // printf("After q_sort\n");
    // for (i = numsSize - 1; i >= 0; i--) printf("%s\n", strPtrs[i]);
 
    cp2 = strRet;
 
    if (strPtrs[numsSize - 1][0] == '0') {
        *strRet = '0';
        *(strRet + 1) = '\0';
        return strRet;
    }
 
    for (i = numsSize - 1; i >= 0; i--) {
 
        cp1 = *(strPtrs + i);
        while (ch = *(cp1++)) *(cp2++) = ch;
 
    }
    *cp2 = '\0';
 
    return strRet;
}COPY

1、用结构体 struct_num 保存数字和进位，排序时用 (long long) 数值比较大小，等到输出时再转为字符串
2、分设 10 个数组 hash 表，用于保存由 0-9 开头的数字组成的数组，这样只需要对 1-9 各组单独排序即可
3、函数自实现/内联，就题解题，节省函数调用开销COPY

/**
 * @param {number[]} nums
 * @return {string}
 */
var largestNumber = function(nums) {
    
 
nums = nums.map(function(num) {
  return '' + num;
});
    
 
    var rs=[],re=[],p=0;
    rs[p] = 0;
    re[p++]= nums.length-1;
 
    var ss,ee,t;
    while (p) {
 
        ss = rs[--p];
        ee = re[p];
 
        if (ss >= ee)
            continue;
 
        var mid = nums[ee];
 
        var left = ss, right = ee - 1;
        while (left < right) {
            while (nums[left] + mid > mid + nums[left] && left < right)
                left++;
            while (mid + nums[right] >= nums[right] + mid && left < right)
                right--;
            t = nums[left];
            nums[left] = nums[right];
            nums[right] = t;
        }
        if (mid + nums[left] >= nums[left] + mid) {
            t = nums[left];
            nums[left] = nums[ee];
            nums[ee] = t;
        } else
            left++;
 
        rs[p] = ss;
        re[p++] = left - 1;
 
        rs[p] = left + 1;
        re[p++] = ee;
 
    }
    if (nums[0] == 0) return '0';
    return nums.join('');
};COPY

char outStr[];
int CompNums(const void* a, const void* b){
	char* str1=*(char**)a;
	char* str2=*(char**)b;
	int i, L1=strlen(str1), L2=strlen(str2);
	for(i=0; i<10; i++){
		if(*str1=='\0'){str1-=L1;}
		if(*str2=='\0'){str2-=L2;}
		if(*str1 != *str2){break;}
		str1++, str2++;
	}
	return *str2-*str1;
}
char* largestNumber(int* nums, int numsSize) {
	int i;
	outStr[0]=0;
	char* p[numsSize];
	for(i=0; i<numsSize; i++){p[i]=(char*)malloc(sizeof(char)*16);sprintf(p[i], "%d\0", nums[i]);}	
	qsort(p, numsSize, sizeof(char*), CompNums);
	for(i=0; i<numsSize; i++){strcat(outStr, p[i]);}
	return outStr[0]=='0'?"0":outStr;
}COPY