最大数（回顾等级：值得，已达最优解）
来源：自己LeetCode刷题
usa
long cmp(const void* e1, const void* e2)
{
int* p1=(int*)e1;
int* p2=(int*)e2;
long n1=10;
long n2=10;
while(*p1>=n1)
{
n1*=10;
}
while(*p2>=n2)
{
n2*=10;
}
return ((*p2)*n1+*p1)-((*p1)*n2+*p2);
}
char* largestNumber(int* nums, int numsSize)
{
qsort(nums,numsSize,sizeof(int),cmp);
char* ans=(char*)malloc(sizeof(char)*1010);
memset(ans,0,sizeof(char)*1010);
int k=0;
if (nums[0]==0)
{
ans[0]='0';
return ans;
}
for (int i=0;i<numsSize;i++)
{
sprintf(ans+k,"%d",nums[i]);
k=strlen(ans);
}
return ans;
}
- 这道题的逻辑是这样子的，首先我们想到的是要对这个数组进行排序，那么究竟依据什么样的排序规则呢？
- 我们希望满足对于排序后的数组当中的每一个数，从左到右它的最高位数字都是递减的，当出现最高位数字相同的情况，那么就比较次高位，以此类推，直到出现递减态势（对于更特殊的情况，如：4,43 4,45，自己去想），这就是我们希望排序后这个数组的样子。
- 在c语言当中要实现如此自由的排序只能用qsort，与此同时，我得写一个比较函数用来比较对于相邻两个数它们之间排序后的前后顺序关系。这个就是精华所在，见图
- 这边的一个数据类型的控制与sprintf都是亮点所在。
合并区间（回顾等级：不值得，已达最优解）
来源：自己LeetCode刷题
usa
int cmp(const void* e1, const void* e2)
{
int** pp1=(int**)e1;
int** pp2=(int**)e2;
int gap=(*pp1)[0]-(*pp2)[0];
if (gap==0)
{
return (*pp1)[1]-(*pp2)[1];
}
return gap;
}
int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes)
{
qsort(intervals,intervalsSize,sizeof(int*),cmp);
int* tmp1=(int*)malloc(sizeof(int)*intervalsSize*2);
int q=0;
int** ans=(int**)malloc(sizeof(int*)*intervalsSize);
int k=0;
int start=intervals[0][0];
int end=intervals[0][1];
for (int i=1;i<intervalsSize;i++)
{
int newstart=intervals[i][0];
int newend=intervals[i][1];
if (newstart>end)
{
ans[k++]=(int*)malloc(sizeof(int)*2);
ans[k-1][0]=start;
ans[k-1][1]=end;
start=newstart;
end=newend;
tmp1[q++]=2;
}
else
{
end=newend>end?newend:end;
}
}
ans[k++]=(int*)malloc(sizeof(int)*2);
ans[k-1][0]=start;
ans[k-1][1]=end;
tmp1[q++]=2;
*returnColumnSizes=tmp1;
*returnSize=k;
return ans;
}
重新排列单词间的空格（回顾等级：不值得，已达最优解）
来源：自己LeetCode刷题
char * reorderSpaces(char * text)
{
int sz=strlen(text);
int NumOfWord=0;
int NumOfSpace=0;
int arr[55]={0};
int flag=0;
for (int i=0;i<sz;i++)
{
if (text[i]!=' ' && flag==0)
{
arr[NumOfWord]=i;
flag=1;
}
else if (text[i]==' ')
{
if (flag==1)
{
NumOfWord++;
}
NumOfSpace++;
flag=0;
}
}
if (text[sz-1]!=' ')
{
NumOfWord++;
}
int gap=0;
if (NumOfWord!=1)
{
gap=NumOfSpace/(NumOfWord-1);
}
char* ans=(char*)malloc(sizeof(char)*(sz+5));
int k=0;
for (int i=0;i<NumOfWord;i++)
{
int num=arr[i];
while(text[num]!=' ' && text[num]!='\0')
{
ans[k++]=text[num];
num++;
}
if (i!=NumOfWord-1)
{
for (int j=0;j<gap;j++)
{
ans[k++]=' ';
}
}
}
for (int i=0;i<NumOfSpace-gap*(NumOfWord-1);i++)
{
ans[k++]=' ';
}
ans[k++]='\0';
return ans;
}
按奇偶排序数组 II（回顾等级：不值得，已达最优解）
来源：自己LeetCode刷题
usa
int* sortArrayByParityII(int* nums, int numsSize, int* returnSize)
{
int even=0;
int odd=1;
while(even<=numsSize-1 && odd<=numsSize-1)
{
while(even <= numsSize-1 && nums[even]%2==0)
{
even+=2;
}
while(odd <= numsSize-1 && nums[odd]%2==1)
{
odd+=2;
}
if (even>=numsSize || odd>=numsSize)
{
break;
}
int tmp=nums[even];
nums[even]=nums[odd];
nums[odd]=tmp;
even+=2;
odd+=2;
}
*returnSize=numsSize;
return nums;
}
数组形式的整数加法（回顾等级：可以，已达最优解）
来源：自己LeetCode刷题
usa
int* addToArrayForm(int* num, int numSize, int k, int* returnSize)
{
int* ans= (int*)malloc(sizeof(int)*(10>numSize?10:numSize+1));
int q=0;
for (int i=numSize-1;i>=0;i--)
{
int sum = num[i]+k%10;
k/=10;
if (sum>9)
{
sum%=10;
k++;
}
ans[q++]=sum;
}
while(k>0)
{
ans[q++]=k%10;
k/=10;
}
int left=0;
int right=q-1;
while(left<right)
{
int tmp=ans[left];
ans[left]=ans[right];
ans[right]=tmp;
left++;
right--;
}
*returnSize=q;
return ans;
}
- 这是方法1， 逐位相加法
int* addToArrayForm(int* num, int numSize, int k, int* returnSize)
{
int* ans =(int*)malloc(sizeof(int)*(10>numSize?10:numSize+1));
int q=0;
int i=numSize-1;
while(i>=0)
{
num[i]+=k;
ans[q++]=num[i]%10;
k=num[i]/10;
i--;
}
while (k>0)
{
ans[q++]=k%10;
k/=10;
}
int left=0;
int right=q-1;
while(left<right)
{
int tmp=ans[left];
ans[left]=ans[right];
ans[right]=tmp;
left++;
right--;
}
*returnSize=q;
return ans;
}
