算法2.2

	孤独的我，只有学习来打发时间了。
	做其他的事会让我感觉到更加无聊。

#include <stdio.h>

#include <stdlib.h>

/*
	LA = {3, 5, 8, 11};
	LB = {2, 6, 8, 9, 11, 15, 20};
	将LA、LB取并集按非递减有序排列创建线性表LC
	则LC = {2, 3, 5, 6, 8, 8, 9, 11, 11, 15, 20};

	描述：
		获取LA中第一个元素与LB中的第一个进行比较，将较小的插入到LC中，较小的表索引位置加1，继续进行比较，
		若成为较小的就插入，且向后移动，直到其中一个表到了表尾。然后把未索引完的全部插入到LC中。

	算法描述：
		void MergeList(List LA, List LB, List LC)
		{
			int i, j;
			for(i = 0, j = 0; i < LA.length && j < LB.length;)
			{
				eA = getElem(LA, i+1);
				eB = getElem(LB, j+1);
				if(eA <= eB)
				{
					i++;
					insertList(LC, eA);
				}
				else {
					j++;
					insertList(LC, eB);
				}
			}
			
			if(i<LA.length)
			{
				eA = getElem(LA, i+1);
				for(; i<LA.length; i++)
					insertList(LC, eA);
			}
			else{
				eB = getElem(LB, j+1);
				for(; j<LB.length; j++)
					insertList(LB, eB);
			}
		  
		}
*/

typedef int elemType;
struct List{
	elemType *elem;
	int length;
	int listsize;
};

//创建一个空的线性表，并初始最大长度
void InitList(struct List *L, int ms)
{
	L->elem = malloc(ms * sizeof(elemType));
	if(L->elem == NULL){
		printf("内存分配失败！！");
		exit(1);
	}
	L->listsize = ms;
	L->length = 0;

	return 0;
}


//获取线性表指定位置上的元素
elemType getElem(struct List L, int pos)
{
	return L.elem[pos-1];
}

//获取线性表的长度
int ListLength(struct List L)
{
	return L.length;
}

//动态扩增线性表的长度，扩大为原来的一倍
void againMalloc(struct List *L)
{
	elemType *p = realloc(L->elem, 2 * L->listsize * sizeof(elemType));
	if(p == NULL){
		printf("内存扩充失败！！！");
		exit(1);
	}

	L->elem = p;
	L->listsize = 2 * L->listsize;

	return ;
}

//往线性表的表尾插入元素
void InsertLastList(struct List *L, int x)
{
	if(L->listsize == L->length)//如果当前长度等于了最大长度，那就扩充
		againMalloc(L);

	L->elem[L->length] = x;
	
	(L->length)++;
	return;
}

//遍历线性表中的内容
void traverseList(struct List L)
{
	int i;
	for(i = 0; i<L.length; i++)
	{
		if(i != L.length - 1)
			printf("%d -> ", getElem(L, i+1));
		else{
			printf("%d\n", getElem(L, i+1));
		}

	}
}

//取两集合并集保存在LC中
void MergeList(struct List L1, struct List L2, struct List *L3)
{
	int i, j;
	int e1, e2;
	int	L1_length = ListLength(L1);
	int	L2_length = ListLength(L2);

	for(i = 0, j = 0; i < L1_length && j < L2_length;)
	{
		e1 = getElem(L1, i+1);
		e2 = getElem(L2, j+1);
		if(e1 < e2)
		{
			InsertLastList(L3, e1);
			i++;
		} else{
			InsertLastList(L3, e2);
			j++;
		}
	}

	if(i < L1_length)
	{
		for(; i < L1_length; i++)
		{
			e1 = getElem(L1, i+1);
			InsertLastList(L3, e1);
		}
	} else{
		for(; j < L2_length; j++)
		{
			e2 = getElem(L2, j+1);
			InsertLastList(L3, e2);
		}
	
	}
	return;

}

int main()
{
	int i;
	int arr1[4] = {3, 5, 8, 11};
	int arr2[7] = {2, 6, 8, 9, 11, 15, 20};
	int arr1_length = sizeof(arr1) / sizeof(int);
	int arr2_length = sizeof(arr2) / sizeof(int);
	struct List LA, LB, LC;
	int LA_length, LB_length;

	InitList(&LA, arr1_length);
	InitList(&LB, arr2_length);
	InitList(&LC, 1);
	

	for(i = 0; i < arr1_length; i++)
	{
		InsertLastList(&LA, arr1[i]);
	}
	
	for(i = 0; i < arr2_length; i++)
	{
		InsertLastList(&LB, arr2[i]);
	}
	
	LA_length = ListLength(LA);
	LB_length = ListLength(LB);

	traverseList(LA);
	traverseList(LB);
	MergeList(LA, LB, &LC);
	traverseList(LC);
	return 0;
}

运行结果：

3 -> 5 -> 8 -> 11
2 -> 6 -> 8 -> 9 -> 11 -> 15 -> 20
2 -> 3 -> 5 -> 6 -> 8 -> 8 -> 9 -> 11 -> 11 -> 15 -> 20
Press any key to continue