学步园

题目描述：

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

输入：

输入可能包含多个测试样例。对于每个测试案例，输入的第一行为一个整数m (1<=m <=100)代表输入的正整数的个数。输入的第二行包括m个正整数，其中每个正整数不超过10000000。

输出：

对应每个测试案例，输出m个数字能排成的最小数字。

样例输入：

3
23 13 6
2
23456 56

样例输出：

13236
2345656

感觉很简单的题目，自己尝试了几个测试用例都对的，提交后 全部WRONG ANSWER

#include <cstdio>
#include <cstring>

typedef unsigned int u_int32_t;
typedef u_int32_t Compare(u_int32_t,u_int32_t);
#define MAX_BIT_COUNT 8



u_int32_t CompareTwoElementGetMax(u_int32_t first_arg,u_int32_t second_arg)
{
	u_int32_t first = first_arg;
	u_int32_t second = second_arg;
	u_int32_t first_bit_array[MAX_BIT_COUNT];
	u_int32_t second_bit_array[MAX_BIT_COUNT];
	u_int32_t first_bits_count = 0;
	u_int32_t second_bits_count = 0;
	short f = 0,s = 0;
	
	while(first)
	{
		first_bit_array[first_bits_count] = first%10;
		if(first_bit_array[0] != first_bit_array[first_bits_count])
		{
			f = 1;
		}
		first_bits_count++;
		first = first/10;
	}
	u_int32_t i = --first_bits_count;
	while(second)
	{
		second_bit_array[second_bits_count] = second%10;
		if(second_bit_array[0] != second_bit_array[second_bits_count])
		{
			s = 1;
		}		
		second_bits_count++;
		second = second/10;
	}
	u_int32_t j = --second_bits_count;
	if(f == 0 && s == 0)
	{
		return 0;
	}
	while(i<=MAX_BIT_COUNT || j<=MAX_BIT_COUNT)
	{
		while(first_bit_array[i] == second_bit_array[j] && i<=MAX_BIT_COUNT && j<=MAX_BIT_COUNT )
		{
			i--;
			j--;
		}
		if(i>MAX_BIT_COUNT&& j<=MAX_BIT_COUNT)
		{
			i = first_bits_count;
		}
		else if(j>MAX_BIT_COUNT && i<=MAX_BIT_COUNT)
		{
			j = second_bits_count;
		}
		else if(i>MAX_BIT_COUNT && j>MAX_BIT_COUNT)
		{
			return 0;
		}
		else 
		{
			if(first_bit_array[i] > second_bit_array[j])
			{
				return 1;
			}
			else
			{
				return 2;
			}
		}
	}
	printf("不可能到这里来\n");
	return 0;
}

u_int32_t CompareStringGetMin(char* first,char *second,u_int32_t string_size)
{
	for(u_int32_t i = 0;i < string_size;i++)
	{
		if(*(first+i) < *(second+i))
		{
			return 1;
		}
		else if(*(first+i) > *(second+i))
		{
			return 2;
		}
	}
	return 0;
}

u_int32_t CompareTwoElementGetMaxIndex(u_int32_t first_arg,u_int32_t second_arg)
{
	char first_second[2*MAX_BIT_COUNT];
	char second_first[2*MAX_BIT_COUNT];
	memset(first_second,0,sizeof(first_second));
	memset(second_first,0,sizeof(second_first));
	
	u_int32_t i = 2*MAX_BIT_COUNT-1;
	u_int32_t first = first_arg;
	u_int32_t second = second_arg;
	while(first_arg)
	{
		second_first[i] = first_arg%10 + '0';
		first_arg/=10;
		i--;
	}
	while(second_arg)
	{
		second_first[i] = second_arg%10 + '0';
		second_arg/=10;
		i--;
	}
	i = 2*MAX_BIT_COUNT-1;
	first_arg = first;
	second_arg = second;	
	while(second_arg)
	{
		first_second[i] = second_arg%10 + '0';
		second_arg/=10;
		i--;
	}
	while(first_arg)
	{
		first_second[i] = first_arg%10 + '0';
		first_arg/=10;
		i--;
	}
	i++;
	return CompareStringGetMin(first_second+i,second_first+i,2*MAX_BIT_COUNT);
}

void MergeArray(u_int32_t *first,u_int32_t array_size1,u_int32_t *second,u_int32_t array_size2,Compare my_compare)
{
	u_int32_t result;
	u_int32_t i = 0,j = 0,k = 0;
	u_int32_t target_array[array_size1+array_size2];
	while(i < array_size1&&j < array_size2)
	{
		result = my_compare(*(first+i),*(second+j));
		if(result == 0)
		{
			*(target_array+k) = *(first+i);
			k++;
			*(target_array+k) = *(second+j);
			k++;
			i++;
			j++;
		}
		else if(result == 1)
		{
			*(target_array+k) = *(first+i);
			k++;
			i++;			
		}
		else if(result == 2)
		{
			*(target_array+k) = *(second+j);
			k++;
			j++;		
		}
	}
	while(i < array_size1)
	{
			*(target_array+k) = *(first+i);
			k++;
			i++;			
	}
	while(j < array_size2)
	{
			*(target_array+k) = *(second+j);
			k++;
			j++;		
	}
	i = 0;
	while(i < array_size1)
	{
		*(first+i) = *(target_array+i);
		i++;
	}
	j = 0;
	while(j < array_size2)
	{
		*(second+j) = *(target_array+i);
		i++;
		j++;
	}	
	return;	
}

u_int32_t CompareTwoUnsignedInt(u_int32_t first_arg,u_int32_t second_arg)
{
	if(first_arg == second_arg)
	{
		return 0;
	}
	else if(first_arg < second_arg)
	{
		return 1;
	}
	return 2;
}

void MergeSort(u_int32_t *target_array,u_int32_t array_size)
{
	u_int32_t step = 2;
	u_int32_t begin;
	while(step<=array_size)
	{
		for(begin = 0;begin+step <= array_size;begin = begin+step)
		{
			MergeArray(target_array+begin,step/2,target_array+begin+step/2,step/2,CompareTwoElementGetMaxIndex);
		}
		if(begin!=array_size)
		{
			MergeArray(target_array+begin,(array_size - begin)/2,target_array+begin+(array_size - begin)/2,array_size-(array_size - begin)/2,CompareTwoElementGetMaxIndex);
		}
		step = step*2;
	}
	MergeArray(target_array,step/2,target_array+step/2,array_size-step/2,CompareTwoElementGetMaxIndex);
	//MergeArray(target_array,step/2,target_array+step/2,array_size-step/2,CompareTwoUnsignedInt);
	return;
}

void PrintArrayInFormatString(u_int32_t* target_array,u_int32_t array_size)
{
	u_int32_t tmp;
	char num[MAX_BIT_COUNT];
	memset(num,0,sizeof(num));
	char num_string[100*MAX_BIT_COUNT];
	memset(num_string,0,sizeof(num_string));
	for(u_int32_t i = 0,j = MAX_BIT_COUNT-1; i < array_size;i++,j = MAX_BIT_COUNT-1)
	{
		tmp = *(target_array+i);
		while(tmp)
		{
			num[j] = tmp%10+'0';
			tmp = tmp/10;
			j--;
		}
		strcat(num_string,num+j+1);
	}
	printf("%s\n",num_string);
}

int main()
{
	u_int32_t m;
	while(scanf("%u",&m)!=EOF)
	{
		u_int32_t target_array[m];
		for(u_int32_t i = 0; i<m; i++)
		{
			scanf("%u",&target_array[i]);
		}
		MergeSort(target_array,m);
		
		u_int32_t i = 0;
		while(i<m)
		{
			printf("%u",target_array[i]);
			i++;
		}
		printf("\n");
		PrintArrayInFormatString(target_array,m);
	}
	return 0;
}