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

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

3.线性表的链式存储结构

前言：前面线性表的顺序存储结构有着明显的不足，在执行插入和删除操作时需要移动大量的元素

设想一个记录着我国大陆14亿5万多人个人信息的顺序表，现在要在第一个位置插入一条记录，那么需要移动14亿多条记录，需要耗费很长的时间

线性表的链式存储结构将弥补顺序存储结构的这一不足，下面将加以介绍

1.定义：n个节点链接成一个链表，即为线性表的链式存储结构

节点由两部分组成
数据域：存储数据元素的信息
指针域：存储直接后继的位置

由于此链表的每个节点只包含一直指针域，故又称线性链表或者单链表，这说明还有其他链表，是的，将在之后加以介绍

1.1头指针和头节点：
头指针指示链表中第一个节点的位置，而整个链表的存取必须从头指针开始进行。由于最后一个节点没有直接后继，则最后一个节点的指针域为NULL

有时为了使对链表的操作更加方便，我们会设置一个头节点，头节点放在第一个结点之前

如果对添加头节点的做法感到迷惑，不要紧，后面将会体验到加入头节点之后，对单链表的操作带来的便利

头节点的数据域可以不存储任何信息，也可以存储线性表的长度等附加信息，头节点的指针域存储指向首元节点的指针，加入头节点后，头指针即指向头节点

想象你的面前通过一辆火车，火车头和车厢、车厢与车厢之间通过铁钩链接，火车头是头节点，火车车厢是普通节点，第一节车厢是首元节点，灭霸一把抓住火车头把火车甩飞出去，这就说明，把控住头节点，这个链表就没跑了

1.2对于单链表，我们可以用C语言的结构体指针描述

/*线性表的单链表存储结构*/
typedef struct Node {
	ElemType data;
	struct Node *next;
}Node, *LinkList;

LinkList为 Node * 类型，也就是指向节点的指针类型
之后的处理中，我们把LinkList声明的变量作为链表头指针
指向普通节点的指针用 Node * 声明，这样比较清晰

再次看下线性表的抽象数据类型

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

接下来用单链表对线性表的抽象数据类型进行实现

1.初始化单链表

/*创建一个空的链表*/
Status InitLinkList(Linklist *L)
{
	*L = (LinkList)malloc(sizeof(Node));
	if(!(*L)) exit(OVERFLOW);
	/*空链表只有一个头节点，且指针域为NULL*/
	(*L)->next = NULL;
	return OK;
}

2.清空单链表

void ClearLinkList(LinkList *L)
{
	Node *p, *q;
	/*p指向首元节点*/
	p = (*L)->next;
	/*若还没到表尾，则执行下面的循环*/
	while (p) {
		q = p->next;
		free(p);
		/*设置q防止free(p)之后，找不到单链表余下的节点*/
		p = q;
	}
	/*再把头节点的指针域置空*/
	(*L)->next = NULL;
	return OK;
}

3.销毁单链表

void DestroyLinkList(LinkList *L)
{
	Node *p, *q;
	/*p指向首元节点*/
	p = (*L)->next;
	/*若还没到表尾，则执行下面的循环*/
	while (p) {
		q = p->next;
		free(p);
		p = q;
	}
	/*释放完普通节点的空间后，释放头节点的空间*/
	free(*L);
	/*修改*L指向为NULL*/
	*L = NULL;
}

注意：free()函数只是把指针申请的空间释放掉，也就是把空间的使用权交还给操作系统或者编译器，*L仍然指向原来申请的存储空间，避免再操作那一片空间，可以把指针的指向修改为NULL;

4.返回单链表中元素个数

int LinkListLength(LinkList L)
/*注意是元素个数，头节点数据域中没有存储元素*/
{
	int i = 0;
	Node *p;
	p = L->next;
	while(p) {
		++i;
		p = p->next;
	}
	return i;
}

5.用e返回单链表中第i个元素的值

Status GetElem(LinkList L, int i, ElemtType *e)
{
	int j = 1;
	Node *p;
	p = L->next;
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR;
	/*上面的if判断说明第i个元素不存在*/
	/*即表长小于 i 或者 i < 1*/
	*e = p->data;
	return OK;
}

6.确定和e相等的元素在单链表中的位置

#define NOT_FOUND 0
int LocateElem(LinkList L, ElemType e)
/*找到的话返回是第几个元素，否则返回0*/
{
	int i = 0;
	Node *p;
	p = L->next;
	while (p && p->data != e)
	{
		++i;
		p = p->next;
	}
	if (!p) return NOT_FOUND;
	return i;
}	

7.向链表插入元素

Status LinkListInsert(LinkList *L, int i, ElemType e)
{
	int j = 1;
	Node *p, *s;
	p = *L;
	/*这里是从头节点开始，j为表长加 1*/
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR;
	/*表长 + 1 < i 或者 i < 1*/
	s = (Node *)malloc(sizeof(Node));
	/*以下代码插入新节点s，即使是在首元节点前插入*/
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}	

这里可以看到，因为头节点的存在，使得在首元节点前插入节点和在其他位置插入节点没有区别，加入没有头节点，那么需要将在首元节点前插入的情况单独考虑

8.删除第i个元素的节点，用e接收其数据元素

Status LinkListInsert(LinkList *L, int i, ElemType *e)
{
	int j = 1;
	Node *p, *q;
	p = *L;
	while (p->next && j < i) {
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i) 
	/*表长小于i 或者 i < 1*/
		return ERROR;
	/*p->next指示要删除的节点位置*/
	q = p->next;
	/*获取节点数据元素*/
	*e = q->data;
	/*删除节点*/
	p->next = q->next;
	/*释放节点*/
	free(q);
	return OK;
}
	

这里同样可以看出来，多亏头节点的存在，使得删除首元节点的操作和删除其他节点并无二致，因为头节点的存在使得首元有了“直接前驱”，而尾节点因为C语言中NULL的存在，天然有个虚拟的“直接后继”

9.遍历链表中的元素

void LinkListTraverse(LinkList L)
{
	Node *p;
	p = L->next;
	while (p) {
	/*元素之间用空格分隔，纯属个人习惯*/
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

10.头插法创建单链表

/*这里假设数据元素为字符类型,并且存储空间充足*/
typedef char ElemType;
void CreateLinkList_Head(LinkList *L, int n)
{
	Node *p;
	int i;
	char ch;
	/*初始化，建立一个只有头节点的空表*/
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	/*依次生成新结点，插入到表头*/
	for (i = 0; i < n; i++) {
		scanf("%c", &ch);
		/*也可以用getchar()读取字符*/
		p = (Node *)malloc(sizeof(Node));
		p->data = ch;
		p->next = (*L)->next;
		(*L)->next = p;
	}
}	

11.尾插法创建单链表

/*这里假设数据元素为字符类型,并且存储空间充足*/
typedef char ElemType;
void CreateLinkList_Tail(LinkList *L, int n)
{
	Node *p, *q;
	int i;
	char ch;
	/*初始化，建立一个只有头节点的空表*/
	*L = (LinkList)malloc(sizeof(Node));
	p = *L;
	/*p始终为指向尾节点的指针*/
	for (i = 0; i < n; i++) {
		scanf("%c", &ch);
		/*也可以用getchar()读取字符*/
		q = (Node *)malloc(sizeof(Node));
		q->data = ch;
		/*p的next指针指向新节点，新节点加入表中，成为表尾*/
		p->next = q;
		/*之后p指针移动到新节点的位置，即表尾的位置*/
		p = q;
	}
	/*链表创建结束*/
	p->next = NULL;
}

12.实例：将两个有序链表合并为一个有序链表

void MergList(LinkList *La, LinkList *Lb, LinkList *Lc) {
	/*La, Lb按照元素值非递减排列*/
	Node *pa, *pb, *pc;
	/*让pa, pb分别指向La, Lb的首元节点*/
	pa = (*La)->next; pb = (*Lb)->next;
	pc = *Lc = *La;
	/*用La的头节点作为Lc的头结点，pc指向Lc的头节点以使用尾插法*/
	while (pa && pb) {
	/*将La, Lb中较小的元素插入到Lc中*/
		if (pa->data <= pb->data) {
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}//while
	/*插入La或Lb中剩余段, 剩余段有尾节点, 不需要其他处理*/
	pc->next = pa ? pa : pb;
	/*释放Lb的头节点*/
	free(*Lb);
}	

容易看出，上述算法的
时间复杂度为O(ListLength(La) + ListLength(Lb))
而且不需要另建新表的节点空间，只需要让元素重新链接