第二章算法2.1

今天写了一下午，才写出这个，这还包括参考了大牛的代码。

数据结构啊，必须得学，得写，我不想当打字员！

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

//线性表的线性存储

/*
	两个线性表
	LA = {1, 3, 5, 7, 9};
	LB = {2, 4, 5, 8, 9, 10};	

	两个线性表取并集后 LA = {1, 3, 5, 7, 9, 2, 4, 8, 10};
	
	描述：
		取LB中的每一个元素与LA中每一个进行比较，如果每一个都不相同就把LB中的元素插入到LA中，否则
		进行LB中下一个元素比较。

	算法描述：
		
		void union(List &LA, List LB)
		{
				for(int j = 0; j < LB.length; j++)
				{
					if(Search(LB[j], LA) == 0)
						Insert(LA, LB[j]);
				}

		  
		}
*/

typedef int elemType;
struct List{
	elemType *elem;	//存储空间基址
	int length;		//当前长度
	int listsize;	//当前分配的存储容量

};

//获取表长
int ListLength(struct List *L)
{
	return L->length;
}

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


//初始化一个线性表，建立一个空表，最大容量为ms
void initList(struct List *L, int ms)
{	
	/* 检查ms是否有效， 无效就退出程序！*/
	if(ms <= 0){

		printf("listsize无效！");
		exit(1);
	}

	L->listsize = ms;
	L->length = 0;
	L->elem = malloc(ms * sizeof(elemType));

	if(L->elem == NULL){
		printf("内存空间分配失败！！");

		exit(1);
	}

	return;
}

//扩展空间为原来的两倍
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, elemType x)

{
	if(L->length == L->listsize)
	{
		//重新分配更大的存储空间

		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));

		}

	}

	return;
}

//线性表L中是否存在e元素，如果存在返回第一个存在的元素所在位置，不存在则返回0
int LocateElem(struct List *L, int e)
{

	int i;
	for(i = 0; i < L->length; i++)
	{
		if(getElem(*L, i+1) == e)
			return i+1;

	}

	return 0;
}

//取两个线性表的并集，并保存在L1中
void ListUnion(struct List *L1, struct List L2)
{
	int i;
	elemType e;
	for(i = 0; i < L2.length; i++)

	{
		e = getElem(L2, i+1);
		if(LocateElem(L1, e) == 0)
			insertLastList(L1, L2.elem[i]);

	}

	
}

int main()
{
	int i;
	int arr1[] = {1, 3, 5, 7, 9 };

	int arr2[] = {2, 4, 5, 8, 9, 10};
	int arr1_length = sizeof(arr1) / sizeof(int);
	int arr2_length = sizeof(arr2) / sizeof(int);
	int LA_length, LB_length;
	struct List LA, LB;
	
	initList(&LA, arr1_length);
	initList(&LB, arr2_length);
	
	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);
	
	printf("LA: ");
	traverseList(LA);
	
	printf("LB: ");

	traverseList(LB);

	ListUnion(&LA, LB);

	printf("LA: ");
	traverseList(LA);

	return 0;
}

输出结果是：