顺序表的基本操作--不使用额外辅助空间去重合并两个顺序表

题目

有两个递增有序顺序表A和B，其中A的容量大于A+B。请把A和B按序合并后放在A中，A和B中若有重复元素，合并后只存1次，然后输出顺序表的内容。元素由用户从键盘输入。

代码：

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>

typedef int Elemtype;
//创建整型数组结构体类型
struct Array {
	int cnt;//数组中的有效元素个数
	int len;//数组的长度
	Elemtype* elem;//数组的首元素的地址，即数组的地址,  注意地址是整型，一般只占4个字节
};

void init_arry(struct Array*, int);		//数组初始化,定义了数组类型
void show_arry(struct Array*);			//输出数组元素
bool is_empty(struct Array*);			//判断数组是否为空
bool is_full(struct Array*);			//判断数组是否为满
bool append_arry(struct Array*, int);				//增加数组元素
void sort_arry(struct Array*);			//对数组元素排序

//数组初始化,定义了数组类型
void init_arry(struct Array* pArr, int lenth)//传入数组的地址和希望创建数组的长度
{
	//给数组动态分配一整块连续的能够存放lenth个元素的内存
	pArr->elem = (Elemtype*)malloc(sizeof(Elemtype) * lenth);/*创建一个整型的数组*/
	if (NULL == pArr->elem)
	{
		printf("动态内存分配未成功，数组创建失败！\n");
		exit(-1);
	}
	else//内存分配成功，对数组结构体进行初始化
	{
		pArr->cnt = 0;//数组刚开始的有效元素个数为0
		pArr->len = lenth;//创建的数组的能够存储元素的个数
	}
	return;
}
//判断数组是否为满
bool is_full(struct Array* pArr)
{
	if (pArr->cnt == pArr->len)
	{
		//printf("该数组已满！\n");
		return true;
	}
	else
	{
		return false;
	}
}
//判断数组是否为空
bool is_empty(struct Array* pArr)
{
	if (pArr->cnt == 0)
	{
		//printf("该数组为空！\n");
		return true;
	}
	else
	{
		return false;
	}
}

//增加数组元素
bool append_arry(struct Array* pArr, int val)
{
	if (is_full(pArr))
	{
		printf("is_full()数组内存已满，无法继续追加元素！\n");
		return false;
	}
	else
	{
		pArr->elem[pArr->cnt] = val;//数组的有效元素位置赋值一个整型元素val
		pArr->cnt++;//追加一个元素成功后，数组有效元素个数自增
		return true;
	}

}

//对数组元素进行升序排序
void sort_arry(struct Array* pArr)
{
	int i, j;
	int t;

	//选择升序排序	
	for (i = 0; i < pArr->cnt-1; i++)
	{
		for (j = i + 1; j < pArr->cnt; j++)
		{
			if (pArr->elem[i] > pArr->elem[j])
			{
				t = pArr->elem[i];
				pArr->elem[i] = pArr->elem[j];
				pArr->elem[j] = t;
			}
		}
	}
	
	return;
}

//输出数组所有效元素
void show_arry(struct Array* pArr)
{
	if (is_empty(pArr))
	{
		printf("show_arry数组为空,输出失败！\n");
		return;
	}

	int i;
	for (i = 0; i < pArr->cnt; i++)
	{
		printf("%d ", pArr->elem[i]);
	}
	printf("\n");

	return;
}

void combine(struct Array* A, struct Array* B)
{
	Elemtype * C = (Elemtype*)realloc(A->elem, sizeof(Elemtype) * (A->len + B->len + 2));
	if (C)
	{
		A->elem = C;
		int i, j, k;
		for (i = 0; i < A->cnt; i++)
			A->elem[A->cnt - 1 - i + B->cnt] = A->elem[A->cnt - 1 - i];

		i = B->cnt, j = 0, k = 0;
		
		
		while (i < A->cnt+B->cnt && j < B->cnt)
		{
			if (k == 0 || (A->elem[i] != A->elem[k - 1] && B->elem[j] != A->elem[k - 1]))
				A->elem[k++] = A->elem[i] < B->elem[j] ? A->elem[i++] : B->elem[j++];
			else
			{
				if (A->elem[i] == A->elem[k - 1])
					i++;
				if (B->elem[j] == A->elem[k - 1])
					j++;
			}
		}
		while (i < A->cnt + B->cnt)
			if (A->elem[i] != A->elem[k - 1])
				A->elem[k++] = A->elem[i++];
			else
				i++;
		while (j < B->cnt)
			if (B->elem[j] != A->elem[k - 1])
				A->elem[k++] = B->elem[j++];
			else
				j++;
		A->cnt = k;
	}
	return;
}

int main()
{
	//声明一个整型数组，数组的类型可以在inin_arry()函数内部自行定义，此程序已默认定义为int类型数组
	struct Array A,B;
	int n;
	printf("请输入顺序表A的元素个数：");
	scanf("%d", &n);
	init_arry(&A, n);
	int i,e;
	for (i = 0; i < n; i++)
	{
		scanf("%d", &e);
		append_arry(&A, e);
	}
	printf("请输入顺序表B的元素个数：");
	scanf("%d", &n);
	init_arry(&B, n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &e);
		append_arry(&B, e);
	}

	//排序
	sort_arry(&A);
	sort_arry(&B);
	//合并
	combine(&A, &B);
	//输出结果		
	printf("合并后：");
	show_arry(&A);

	return 0;
}

运行结果：