数据结构与算法学习笔记——线性表上

数据结构与算法学习笔记（C语言）

1.线性表的定义和抽象数据类型

1.线性表的定义：零个或多个数据元素的有限序列，当元素个数是零的时候，称为一个空表

特点：线性表中的元素只有唯一的“首元素”、“尾元素”，除了首、尾元素，其他元素有唯一的直接前驱和后继，首元素没有前驱，尾元素没有后继

2.线性表的抽象数据类型

ADT List {
	数据对象：D = {a1, a2, a3, ...}
	数据关系：R = {<a1, a2>, <a2,a3>, ...}
	/*<a, b>表示a, b的有序对*/
	基本操作：
	InitList(*L)
	/*初始化操作，构建一个空的线性表*/
	ClearList(*L)
	/*将一个线性表的元素清空*/
	DestroyList(*L)
	/*销毁线性表*/
	ListLength(L)
	/*返回线性表中元素的个数*/
	GetElem(L, i, *e)
	/*用e返回线性表L中第i个元素的值*/
	LocateElem(L, e)
	/*在线性表中查找与e值相等的元素*/
	ListInsert(*L, i, e)
	/*在L中第i个元素之前插入新的数据元素e*/
	ListDelete(*L, i, *e)
	/*删除L中第i个元素，并用e返回其值*/
	ListTraverse(L)
	/*遍历L中的数据元素*/
}ADT List

例如要合并线性表A和B，即把B中A不存在的元素插入A中

void union(List *La, List *Lb)
//挨个查找Lb中的元素，看是否在La中,若不在，插入之
{
	int La_len, Lb_len;
	int i; ElemType e;
	La_len = ListLength(La);
	Lb_len = ListLength(Lb);
	for (i = 1; i <= Lb_len; i++) {
		GetElem(Lb, i, &e); 
		/*取Lb中第i个数据元素赋给e*/
		if (!LocateElem(La, e))
			ListInsert(*La, ++La_len, e);
		/*若e不在La中，插入之*/
	}
}

分析：由于GetElem和ListInsert与表长无关，忽略GetElem和ListInsert所需的时间，需要遍历B中的元素，B中的每个元素都要与A中所有的元素比较，那么上述算法的时间复杂度为

		O(ListLength(A) * ListLength(B))

2.线性表的顺序存储结构

1.定义：线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表中的数据元素

在C语言中可以用一维数组来实现顺序存储结构
以下采用动态分配的一维数组

顺序存储结构的C语言代码如下

#define INIT_SIZE 100 //线性表存储空间初始分配量
#define INCREMENT 10 //线性表空间不够时，设定的分配增量
typedef int ElemType; //数据元素的数据类型，也可是char
typedef struct {
	ElemType *elem; //存储数据元素的数组空间基址
	int length; //线性表的当前长度
	int listsize; //当前分配的存储容量
}SqList;

2.初始化操作

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
Status InitSqList(SqList *L)
/*构造一个空的线性表*/
{
	L->elem = (ElemType *)malloc(INIT_SIZE * sizeof(ElemType)); 
	/*为数据元素申请存储空间*/
	if (!L->elem) exit(OVERLOW)
	/*存储空间分配失败*/
	L->length = 0;
	/*设置空表长度为0*/
	L->listsize = INIT_SIZE;
	/*设置线性表的初始存储容量*/
	return OK;
}

3.将一个线性表的元素清空

void ClearSqList(SqList *L)
{
	L->length = 0;
	/*长度置为0*/
}

4.销毁线性表

void DestroySqList(SqList*L)
{
	free(L->elem);
	/*将申请的内存释放掉*/
	L->elem = NULL;
	/*让指针指向NULL，这一步一定在free之后，
	否则系统将找不到分配的空间而无法回收，造成内存泄露*/
	L->length = 0;
	/*线性表当前长度置零*/
	L->listsize = 0;
	/*内存已经释放，分配的容量置零*/
}	

5.获取线性表的长度

int SqListLength(SqList L)
{
	return L.length
}

6.获取线性表中第i个元素的值

Status GetElem(SqList L, int i, ElemType *e)
{
	if (L.length = 0 || i < 1 || i > L.length)
	/*L为空表或者i的值不合理*/
		return ERROR;
	*e = L.elem[i-1];
	//elem[i]与*(elem + i)等价
	return OK;
}

7.找出线性表中和e相等的元素

#define NOT_FOUND 0
int LocateElem(SqList L, ElemType e)
{
	int i;
	/*查找线性表中和e相等的元素，用i返回它的位置*/
	for (i = 0; i < L.length; i++) {
		if (L.elem[i] = e)
			return i + 1;
	}
	return NOT_FOUND;
}

8.在线性表第i个位置之前插入元素

Status SqListInsert(SqList *L, int i, ElemType e)
{
	int j; ElemType *new_elem;
	if (i < 1 || i > L->length + 1) return ERROR;
	/*插入位置不合理*/
	if (L->length == INIT_SIZE) {
	/*线性表当前存储空间已满，需要重新分配空间*/
		new_elem = (ElemType *)realloc(L->elem, (L->listsize + INCREMENT) * sizeof(ElemType));
		/*空间分配失败*/
		if (!new_elem) exit(OVERFLOW);
		/*新的空间基址*/
		L->elem = new_elem;
		/*存储容量增加*/
		L->listsize += INCREMENT;
	}
	/*如果插入的位置不在表尾*/
	if (i <= L->length) {
		/*将要插入的位置之后的元素后移一位*/
		for (j = L->length - 1; j >= i - 1; j--) 
		/*注意后移从后向前，不然前面的元素覆盖后面的元素*/
			L->elem[j + 1] = L->elem[j];
	}
	/*将新元素插入*/
	L->elem[i - 1] = e;
	/*表长加一*/
	L->length++;
	return OK;
}			

9.删除线性表第i个位置的元素

Status SqListDelete(SqList *L, int i, ElemType *e)
{
	int j;
	if (i < 1 || i > L->length) return ERROR;
	/*删除位置不合理*/
	if (L->length == 0) return ERROR;
	/*空表无法执行删除操作*/
	*e = L->elem[i - 1];
	/*用e接收删除位置的元素*/
	for (j = i; j <= L->length - 1; j++) {
		/*将删除位置之后的元素全部前移一位*/
		L->elem[j - 1] = L->elem[j];
	}
	L->length--;
	/*删除后表长减一*/
	return OK;
}

10.遍历线性表中的元素

void SqListTraverse(SqList L)
{
	int i;
	for (i = 0; i < L.length; i++) {
		/*打印表中的元素，并以空格分隔*/
		printf("%d ", L.elem[i]);
	}
	printf("\n");
	return 0;
}

11.实例：将两个元素从小到大排列好的线性表合并，合并后的线性表元素依然非递减排列

算法一：

void MergeList(SqList La, SqList Lb, SqList *Lc)
{
	int La_len, Lb_len;
	int i = j = 1, k = 0;
	ElemType *ai, *bj;
	/*初始化线性表Lc*/
	InitSqList(& Lc);
	La_len = SqListLength(La); Lb_len = SqListLength(Lb);
	while ((i <= La_len) && (j <= Lb_len)) {
	/*若La, Lb非空，则分别从第一个元素开始，
	依次获取La, Lb中的元素,分别放在ai, bj中*/
		GetElem(La, i, &ai); GetElem(Lb, j, bj);
		
		/*比较ai, bj的大小，将小的放入线性表Lc中*/
		if (ai <= bj) {
		/*若ai较小，那么将ai放入Lc中，递增计数变量i，
		以获取La中的下一个元素*/
			SqListInsert(&Lc, ++k, ai); ++i;
		}
		else {
		/*若bj较小，那么将bj放入Lc中，递增计数变量j，
		以获取Lb中的下一个元素*/
			SqListInsert(&Lc, ++k, bj); ++j;
		}
	}//while
	while (i <= La_len) {
	//如果La中剩余元素，则将剩余元素插入Lc
		GetElem(La, i++, &ai);
		SqListInsert(&Lc, ++k, ai);
	}
	while (j <= Lb_len) {
	//如果Lb中剩余元素，则将剩余元素插入Lc
		GetElem(Lb, j++, &bj);
		SqListInsert(&Lc, ++k, bj);
	}
}

分析此算法，第一个while循环，依次取出La, Lb中的元素进行比较，执行的步骤数是较短的表长的2倍，当while循环结束时，其中较短的表的元素已经访问完了，下面的两个while循环只会执行一个，就是把较长的表的剩余元素依次插入Lc中，那么，时间复杂度为

		O(ListLength(La) + ListLength(Lb))

算法二：

void MergeList(SqList La, SqList Lb, SqList *Lc) 
{
	ElemType *pa, *pb, *pc;
	ElemType *pa_last, *pb_last;
	/*分别让pa，pb, pc指向La, Lb, Lc元素的首地址*/
	pa = La.elem; pb = Lb.elem;
	/*另一种方法初始化Lc*/
	Lc->listsize = Lc->length = La.length + Lb.length;
	/*为Lc申请等于La + Lb表长的存储容量，恰好容纳La和Lb中所有的元素*/
	pc = Lc->elem = (ElemType *)malloc(Lc->listsize * sizeof(ElemType));
	if (!Lc->elem) exit(OVERFLOW);
	//分别让pa_last, pb_last指向La, Lb元素的尾地址
	pa_last = La.elem + La.length - 1;
	pb_Last = Lb.elem + Lb.length - 1;
	while (pa <= pa_last && pb <= pb_last) {
		/*归并，将La, Lb中较小的元素插入Lc中*/
		if (*pa <= *pb) *pc++ = *pa++;
		else *pc++ = *pb++;
	}
	/*若La中有剩余元素，则插入之*/
	while (pa <= pa_last) *pc++ = *pa++;
	/*若Lb中有剩余元素，则插入之*/
	while (pb <= pb_last) *pc++ = *pb++;
}

分析：这个算法其实和上一个算法本质相同，分别依次遍历La, Lb中的元素，插入其中较小的，然后将较长的表中剩余的元素插入，即完成合并，时间复杂度也是

		O(ListLength(La) + ListLength(Lb))

与开篇归并乱序的线性表的算法相比

O(ListLength(La) + ListLength(Lb))相比于
O(ListLength(La) * ListLength(Lb))效率大幅度提升，
所以，执行归并线性表的操作，应该先对表中的元素进行排序!