数据结构与算法学习笔记(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))
而且不需要另建新表的节点空间,只需要让元素重新链接