编程的大佬们，c语言数据结构题目，写起来比较麻烦，但是要帮帮我啊

C语言程序：

#include 
#include 
#include 

#define MAX 33

char signs[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char *octs[] = {"000", "001", "010", "011", "100", "101", "110", "111"};
char *hexes[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};

/* 十进制数转换为二进制数（字符串表示） */
char *decToBin(long num);

/* 十进制数转换为八进制数（字符串表示） */
char *decToOct(long num);

/* 十进制数转换为十六进制数（字符串表示） */
char *decToHex(long num);

/* 二进制数转换为八进制数（字符串表示） */
char *binToOct(char *source);

/* 二进制数转换为十进制数（字符串表示） */
long binToDec(char *source);

/* 二进制数转换为十六进制数（字符串表示） */
char *binToHex(char *source);

/* 八进制数转换为二进制数（字符串表示） */
char *octToBin(char *source);

/* 八进制数转换为十进制数（字符串表示） */
long octToDec(char *source);

/* 八进制数转换为十六进制数（字符串表示） */
char *octToHex(char *source);

/* 十六进制数转换为十进制数（字符串表示） */
char *hexToBin(char *source);

/* 十六进制数转换为八进制数（字符串表示） */
char *hexToOct(char *source);

/* 十六进制数转换为十进制数（字符串表示） */
long hexToDec(char *source);

/* 返回ch字符在sign数组中的序号 */
int getIndexOfSigns(char ch);

/* 返回source字符串在octs数组中的序号 */
int getIndexOfOcts(char *source);

/* 返回source字符串在hexes数组中的序号 */
int getIndexOfHexes(char *source);

/* 去掉字符串最左边的'0' */
char *ltrim(char *source);

int main()
{
	long dec = 123456789;
	char *bin = "111010110111100110100010101";
	char *oct = "726746425";
	char *hex = "75BCD15";

	printf("10进制数：\t%ld\n", dec);
	printf("2进制数：\t%s\n", decToBin(dec));
	printf("8进制数：\t%s\n", decToOct(dec));
	printf("16进制数：\t%s\n", decToHex(dec));
	printf("\n");

	printf("2进制数：\t%s\n", bin);
	printf("8进制数：\t%s\n", binToOct(bin));
	printf("10进制数：\t%ld\n", binToDec(bin));
	printf("16进制数：\t%s\n", binToHex(bin));
	printf("\n");

	printf("8进制数：\t%s\n", oct);
	printf("2进制数：\t%s\n", octToBin(oct));
	printf("10进制数：\t%ld\n", octToDec(oct));
	printf("16进制数：\t%s\n", octToHex(oct));
	printf("\n");

	printf("16进制数：\t%s\n", hex);
	printf("2进制数：\t%s\n", hexToBin(hex));
	printf("8进制数：\t%s\n", hexToOct(hex));
	printf("10进制数：\t%ld\n", hexToDec(hex));	
	printf("\n");

	return 0;
}

/* 十进制数转换为二进制数（字符串表示） */
char *decToBin(long num)
{
	char *arr;
	char temp;
	int i, n;

	arr = (char *)malloc(sizeof(char) * MAX);
	n = 0;
	while(num > 0)
	{
		arr[n++] = num % 2 + '0';
		num /= 2;
	}

	for(i=0; i	{
		temp = arr[i];
		arr[i] = arr[n-1-i];
		arr[n-1-i] = temp;
	}
	arr[n] = '\0';

	return arr;
}

/* 十进制数转换为八进制数（字符串表示） */
char *decToOct(long num)
{
	char *arr;
	char temp;
	int i, n;

	arr = (char *)malloc(sizeof(char) * MAX);
	n = 0;
	while(num > 0)
	{
		arr[n++] = num % 8 + '0';
		num /= 8;
	}

	for(i=0; i	{
		temp = arr[i];
		arr[i] = arr[n-1-i];
		arr[n-1-i] = temp;
	}
	arr[n] = '\0';

	return arr;
}

/* 十进制数转换为十六进制数（字符串表示） */
char *decToHex(long num)
{
	char *arr;
	char temp;
	int i, n;

	arr = (char *)malloc(sizeof(char) * MAX);
	n = 0;
	while(num > 0)
	{
		arr[n++] = signs[num % 16];
		num /= 16;
	}

	for(i=0; i	{
		temp = arr[i];
		arr[i] = arr[n-1-i];
		arr[n-1-i] = temp;
	}
	arr[n] = '\0';

	return arr;
}

/* 二进制数转换为八进制数（字符串表示） */
char *binToOct(char *source)
{
	int i, j = 0, len;
	int d;				/* source的长度不是3的倍数时需要补齐的长度 */
	char str[4];
	char *arr;
	char temp[MAX];

	arr = (char *)malloc(sizeof(char) * MAX);
	len = strlen(source);
	d = (3 - len % 3) % 3;

	for(i=0; i	{
		temp[i] = '0';
	}
	for(i=d; i	{
		temp[i] = *(source+i-d);
	}
	temp[i] = '\0';
	len = strlen(temp);

	for(i=0; i	{
		str[0] = *(temp + i);
		str[1] = *(temp + i + 1);
		str[2] = *(temp + i + 2);
		str[3] = '\0';
		arr[j++] = getIndexOfOcts(str) + '0';
	}
	arr[j] = '\0';

	return arr;
}

/* 二进制数转换为十进制数（字符串表示） */
long binToDec(char *source)
{
	long sum = 0;
	long t = 1;
	int i, len;

	len = strlen(source);
	for(i=len-1; i>=0; i--)
	{
		sum += t * (*(source + i) - '0');
		t *= 2;
	}	

	return sum;
}

/* 二进制数转换为十六进制数（字符串表示） */
char *binToHex(char *source)
{
	int i, j = 0, len;
	int d;				/* source的长度不是4的倍数时需要补齐的长度 */
	char str[5];
	char *arr;
	char temp[MAX];

	arr = (char *)malloc(sizeof(char) * MAX);
	len = strlen(source);
	d = (4 - len % 4) % 4;

	for(i=0; i	{
		temp[i] = '0';
	}
	for(i=d; i	{
		temp[i] = *(source+i-d);
	}
	temp[i] = '\0';
	len = strlen(temp);

	for(i=0; i	{
		str[0] = *(temp + i);
		str[1] = *(temp + i + 1);
		str[2] = *(temp + i + 2);
		str[3] = *(temp + i + 3);
		str[4] = '\0';
		arr[j++] = signs[getIndexOfHexes(str)];
	}
	arr[j] = '\0';

	return arr;
}

/* 八进制数转换为二进制数（字符串表示） */
char *octToBin(char *source)
{
	char *arr;
	int i, len;

	arr = (char *)malloc(sizeof(char) * MAX);
	len = strlen(source);
	arr[0] = '\0';

	for(i=0; i	{
		strcat(arr, octs[*(source + i) - '0']);
	}

	return ltrim(arr);
}

/* 八进制数转换为十进制数（字符串表示） */
long octToDec(char *source)
{
	long sum = 0;
	long t = 1;
	int i, len;

	len = strlen(source);
	for(i=len-1; i>=0; i--)
	{
		sum += t * (*(source + i) - '0');
		t *= 8;
	}	

	return sum;
}

/* 八进制数转换为十六进制数（字符串表示） */
char *octToHex(char *source)
{
	char *arr;

	arr = (char *)malloc(sizeof(char) * MAX);

	arr = octToBin(source);

	arr = binToHex(arr);

	return arr;
}

/* 十六进制数转换为二进制数（字符串表示） */
char *hexToBin(char *source)
{
	char *arr;
	int i, len;

	arr = (char *)malloc(sizeof(char) * MAX);
	len = strlen(source);
	arr[0] = '\0';

	for(i=0; i	{
		strcat(arr, hexes[getIndexOfSigns(*(source + i))]);
	}

	return ltrim(arr);
}

/* 十六进制数转换为八进制数（字符串表示） */
char *hexToOct(char *source)
{
	char *arr;

	arr = (char *)malloc(sizeof(char) * MAX);

	arr = hexToBin(source);

	arr = binToOct(arr);

	return arr;
}

/* 十六进制数转换为十进制数（字符串表示） */
long hexToDec(char *source)
{
	long sum = 0;
	long t = 1;
	int i, len;

	len = strlen(source);
	for(i=len-1; i>=0; i--)
	{
		sum += t * getIndexOfSigns(*(source + i));
		t *= 16;
	}	

	return sum;
}

/* 返回ch字符在sign数组中的序号 */
int getIndexOfSigns(char ch)
{
	if(ch >= '0' && ch <= '9')
	{
		return ch - '0';
	}
	if(ch >= 'A' && ch <='F') 
	{
		return ch - 'A' + 10;
	}
	if(ch >= 'a' && ch <= 'f')
	{
		return ch - 'a' + 10;
	}
	return -1;
}

/* 返回source字符串在octs数组中的序号 */
int getIndexOfOcts(char *source)
{
	int i, j;

	for(i=0; i<8; i++)
	{
		for(j=0; j<3; j++)
		{
			if(*(source+j) != *(*(octs + i) + j))
			{
				break;
			}
		}
		if(j >= 3)
		{
			return i;
		}
	}

	return -1;
}

/* 返回source字符串在hexes数组中的序号 */
int getIndexOfHexes(char *source)
{
	int i, j;

	for(i=0; i<16; i++)
	{
		for(j=0; j<4; j++)
		{
			if(*(source+j) != *(*(hexes + i) + j))
			{
				break;
			}
		}
		if(j >= 4)
		{
			return i;
		}
	}

	return -1;
}

/* 去掉字符串最左边的'0' */
char *ltrim(char *source)
{
	int i, d, len;
	len = strlen(source);

	for(i=0; i
	if(i <= 0)
	{
		return source;
	}

	d = i;
	for(i=d; i<=len; i++)
	{
		*(source + i - d) = *(source + i);
	}

	return source;
}