第三章 线性表的链式存储结构（单链表超详细讲解）

最新推荐文章于 2023-04-10 02:53:24 发布
最新推荐文章于 2023-04-10 02:53:24 发布
阅读量1.1k 收藏 10
点赞数 3
分类专栏： 第三章 线性表 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62822533/article/details/128351499
版权

3.6.1 线性表链式存储结构定义

目录

3.6.1 线性表链式存储结构定义

3.6.2 单链表的存储结构

 3.6.3 单链表基本操作的实现

（一）单链表的初始化

（二）判断链表是否为空

（三）销毁单链表

（四）清空单链表

（五）求单链表的表长

（六）取单链表中的第i个元素的内容

（七）按值查找——根据指定数据获取该数据所在的位置（地址）

（八）按值查找--根据指定数据获取该数据位置序号

（九）在L中第i个元素之前插入数据元素e

（十）删除--删除第i个结点

 （十一）头插法

  （十二）尾插法

3.6.3 全部代码

定义：n个结点链结成一个链表，即为线性表（\large a_{1},\large a_{2},a_{3},...,a_{n}）的链式存储结构。

数据域：存储数据元素信息； 指针域：存储直接后继位置的地址。

 结点：数据元素的存储映像，由数据域和指针域两部分组成。

链表：n个结点由指针链成的一个链表。

头指针、头结点和首元结点：

头指针：是指向链表中的第一个结点的指针

首元结点：是指链表中存储第一个数据元素 \large a_{1}的结点。

头结点：是在链表的首元结点之前附设的一个结点。

 空表：无头结点时，头指针为空时为空表；有头结点时，头结点的指针域为空时为空表。

3.6.2 单链表的存储结构

单链表：

带有头结点的单链表：

 

 空链表：

单链表的存储结构：

 3.6.3 单链表基本操作的实现

（一）单链表的初始化

Status lnitList_L(LinkList& L)
{
	L = (Lnode*)malloc(sizeof(Lnode));
	//两种初始化是一样的,都是指针类型
	//L = (LinkList)malloc(sizeof(Lnode));
	L->next = NULL;
	return OK;
}

（二）判断链表是否为空

算法思路：判断头结点指针域是否为空

int ListEmpty(LinkList L)
{
	if (L->next)
	{
		return 0;
	}
	else return 1;
}

（三）销毁单链表

 算法思路：从头指针开始，依次释放所有结点

Status DestroyList_L(LinkList &L)
{
	LinkList p;
	//Lnode *p;
	while (L)
	{
		p = L;//从头结点开始，L存放着头结点的地址
		L = L->next;//指向下一个结点
		free(p);//删除
	}
	return OK;
}

（四）清空单链表

算法思路：依次释放所有的结点，并将头指针域设置为空

Status ClearList(LinkList &L)
{
	Lnode* p, * q;//或者LinkList p, q;
	p = L->next;//头结点的next域存放着首元结点的地址
	while (p)
	{
		q = p->next;//q存放了要删除元素的下一个结点的地址
		free(p);
		p = q;
	}
	L->next = NULL;//头结点指针域为空
	return OK;
}

（五）求单链表的表长

算法思路：从首元结点开始，依次计数所有结点

Status ListLength_L(LinkList L)
{
	Lnode* p;//LinkList p
	p = L->next;//p指向第一个结点
	int count = 0;
	while (p)//遍历单链表，统计结点数
	{
		count++;
		p = p->next;
	
	}
	return count;
}

（六）取单链表中的第i个元素的内容

算法步骤：

1.从第1个结点（L->next）顺链扫描，用指针p指向当前扫描到的结点，p初值p=L->next。

2.j做计数器，累计当前扫描过的结点数，j初值为1；

3.当p指向扫描到的下一个结点时，计数器j加1；

4.当j==i时，p所指向的结点就是要找的第i个结点。

Status GetElem_L(LinkList L, int i, ElemType &e)//由变量e返回
{
	Lnode* p;
	int j = 0;
	p = L->next; j = 1;//初始化
	while (p && j < i)//向后扫描，直到p指向第i个元素或p为空
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)//第i个元素不存在
		return ERROR;
	e = p->data;//	取第i个元素
	return OK;
}

（七）按值查找——根据指定数据获取该数据所在的位置（地址）

算法步骤：

1.从第一个结点起，依次和e相比较。
2.如果找到一个其值与e相等的数据元素，则返回其在链表中的“位置” 或地址；
3.如果查遍整个链表都没有找到其值和e相等的元素，则返回0或"NULL”

Lnode* LocateElem_L(LinkList L, ElemType e)
{
	Lnode* p;//LinkList p
	p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;//返回地址
}

（八）按值查找--根据指定数据获取该数据位置序号

int LocateElem_L1(LinkList L, ElemType e)
{
	Lnode* p; int j = 0;
	p = L->next; j = 1;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)
		return j;
	else
		return 0;

}

（九）在L中第i个元素之前插入数据元素e

算法步骤：

 

Status Listlnsert_L(LinkList& L, int i, ElemType e)
{
	Lnode* p;
	Lnode* s;
	int j = 0;
	p = L;
	j = 0;
	while (p && j < i - 1)//寻找第i-1个结点，p指向i-1结点
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)//i大于表长+1或小于1，插入的位置非法
		return ERROR;
	s = (Lnode*)malloc(sizeof(Lnode));//或s=new LNode,生成新节点s
	s->data = e;//生成新结点s，将结点s的数据置为e
	s->next = p->next;//将保存的下一个结点的地址赋给新结点
	p->next = s;//把新结点的地址赋给前一个元素的指针域
}

（十）删除--删除第i个结点

算法步骤：

Status ListDelete_L(LinkList& L, int i, ElemType& e)
{
	Lnode* p;
	Lnode* q;
	int j = 0;
	while (p->next && j < i - 1)//寻找第i个结点，并令p指向其前驱
	{
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i - 1)
		return ERROR;
	q = p->next;//临时保存被删除结点的地址以备释放
	p->next = p->next->next;//==q->next,指向被删除结点的下一个结点
	e = q->data;//保存删除结点的数据域
	free(q);//释放删除结点的空间
	return OK;

}

单链表的查找、插入、删除算法时间效率分析：

1．查找:

  • 因线性链表只能顺序存取，即在查找时要从头指针找起，查找的时间复杂度为O(n)。

2.插入和删除:

  • 因线性链表不需要移动元素，只要修改指针，一般情况下时间复杂度为O(1)。
  • 但是，如果要在单链表中进行前插或删除操作，由于要从头查找前驱结点，所耗时间复杂度为O(n)。

 （十一）头插法

1.从一个空表开始，重复读入数据;
2．生成新结点，将读入数据存放到新结点的数据域中

3．从最后一个结点开始，依次将各结点插入到链表的前端

void CreateList_H(LinkList &L, int n)
{
	Lnode* p;
	L = (Lnode*)malloc(sizeof(Lnode));//	L = new Lnode;
	L->next = NULL;//先建立一个代头结点的单链表
	int i = 0;
	for (i = n; i > 0; --i)
	{
		p = (Lnode*)malloc(sizeof(Lnode));//生成一个新结点
		scanf("%d", &p->data);//输入元素值，根据要元素的类型来
		p->next = L->next;//插入到表头
		L->next = p;

	}
}

  （十二）尾插法

 

void CreateList_R(LinkList& L, int n)
{
	Lnode* p;
	Lnode* r;
	L = (Lnode*)malloc(sizeof(Lnode));//	L = new Lnode;
	L->next = NULL;//先建立一个代头结点的单链表
	r = L;//尾指针r指向头结点
	int i = 0;
	for (i = 0; i < n; ++i)
	{
		p = (Lnode*)malloc(sizeof(Lnode));//生成一个新结点
		scanf("%d", &p->data);//输入元素值，根据要元素的类型来
		r->next = p;//插入到表尾
		r = p;//r指向新的尾结点
	}
}

3.6.3 全部代码

#include<stdio.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;//ElemType取决于我们要存储元素的类型
typedef struct Lnode {
	ElemType data;//结点的数据域
	struct Lnode* next;//结点的指针域
}Lnode,*LinkList;//LinkList为指向结构体Lnode的指针类型
//定义链表L：LinkList L==Lnode* L;
//定义结点指针p:LNode *p==LinkList p;

//单链表的初始化
Status lnitList_L(LinkList &L)
{
	L = (Lnode*)malloc(sizeof(Lnode));
	//两种初始化是一样的,都是指针类型
	L = (LinkList)malloc(sizeof(Lnode));
	L->next = NULL;
	return OK;
}

//判断链表是否为空
int ListEmpty(LinkList L)
{
	if (L->next)
	{
		return 0;
	}
	else return 1;
}
//单链表的销毁，销毁后不存在
Status DestroyList_L(LinkList &L)
{
	LinkList p;
	//Lnode *p;
	while (L)
	{
		p = L;//从头结点开始，L存放着头结点的地址
		L = L->next;//指向下一个结点
		free(p);//删除
	}
	return OK;
}
//清空单链表（头指针和头结点都存在）
Status ClearList(LinkList &L)
{
	Lnode* p, * q;//或者LinkList p, q;
	p = L->next;//头结点的next域存放着首元结点的地址
	while (p)
	{
		q = p->next;//q存放了要删除元素的下一个结点的地址
		free(p);
		p = q;
	}
	L->next = NULL;//头结点指针域为空
	return OK;
}
//求单链表的表长
Status ListLength_L(LinkList L)
{
	Lnode* p;//LinkList p
	p = L->next;//p指向第一个结点
	int count = 0;
	while (p)//遍历单链表，统计结点数
	{
		count++;
		p = p->next;
	
	}
	return count;
}


//取单链表中第i个元素的内容
Status GetElem_L(LinkList L, int i, ElemType &e)//由变量e返回
{
	Lnode* p;
	int j = 0;
	p = L->next; j = 1;//初始化
	while (p && j < i)//向后扫描，直到p指向第i个元素或p为空
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)//第i个元素不存在
		return ERROR;
	e = p->data;//	取第i个元素
	return OK;
}

//按值查找--根据指定数据获取该数据所在的位置（地址）
Lnode* LocateElem_L(LinkList L, ElemType e)
{
	Lnode* p;//LinkList p
	p = L->next;
	while (p && p->data != e)
	{
		p = p->next;
	}
	return p;//返回地址
}
//按值查找--根据指定数据获取该数据位置序号
int LocateElem_L1(LinkList L, ElemType e)
{
	Lnode* p; int j = 0;
	p = L->next; j = 1;
	while (p && p->data != e)
	{
		p = p->next;
		j++;
	}
	if (p)
		return j;
	else
		return 0;

}

//在L中第i个元素之前插入数据元素e
Status Listlnsert_L(LinkList& L, int i, ElemType e)
{
	Lnode* p;
	Lnode* s;
	int j = 0;
	p = L;
	j = 0;
	while (p && j < i - 1)//寻找第i-1个结点，p指向i-1结点
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)//i大于表长+1或小于1，插入的位置非法
		return ERROR;
	s = (Lnode*)malloc(sizeof(Lnode));//或s=new LNode,生成新节点s
	s->data = e;//生成新结点s，将结点s的数据置为e
	s->next = p->next;//将保存的下一个结点的地址赋给新结点
	p->next = s;//把新结点的地址赋给前一个元素的指针域
}

//删除--删除第i个结点
Status ListDelete_L(LinkList& L, int i, ElemType& e)
{
	Lnode* p;
	Lnode* q;
	p = L->next;
	int j = 0;
	while (p->next && j < i - 1)//寻找第i个结点，并令p指向其前驱
	{
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i - 1)
		return ERROR;
	q = p->next;//临时保存被删除结点的地址以备释放
	p->next = p->next->next;//==q->next,指向被删除结点的下一个结点
	e = q->data;//保存删除结点的数据域
	free(q);//释放删除结点的空间
	return OK;

}
//打印单链表
void printLinkList(LinkList L)
{
	Lnode* p;
	p = L->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		
		p = p->next;

	}
	printf("\n");
	
}

//头插法
void CreateList_H(LinkList& L, int n)
{
	Lnode* p;
	L = (Lnode*)malloc(sizeof(Lnode));//	L = new Lnode;
	L->next = NULL;//先建立一个代头结点的单链表
	int i = 0;
	for (i = n; i > 0; --i)
	{
		p = (Lnode*)malloc(sizeof(Lnode));//生成一个新结点
		scanf("%d", &p->data);//输入元素值，根据要元素的类型来
		p->next = L->next;//插入到表头
		L->next = p;

	}
}

//尾插法
void CreateList_R(LinkList& L, int n)
{
	Lnode* p;
	Lnode* r;
	L = (Lnode*)malloc(sizeof(Lnode));//	L = new Lnode;
	L->next = NULL;//先建立一个代头结点的单链表
	r = L;//尾指针r指向头结点
	int i = 0;
	for (i = 0; i < n; ++i)
	{
		p = (Lnode*)malloc(sizeof(Lnode));//生成一个新结点
		scanf("%d", &p->data);//输入元素值，根据要元素的类型来
		p->next = NULL;
		r->next = p;//插入到表尾
		r = p;//r指向新的尾结点
	}
}
int main()
{
	ElemType e;

	LinkList L;

	lnitList_L(L);
	CreateList_R(L, 6);
	printLinkList(L);
	
	printf("%d\n", ListLength_L(L));
	ListDelete_L(L, 2, e);
	printf("e的值为 % d\n", e);
	printf("%d\n", ListLength_L(L));
	Listlnsert_L(L, 2, 10);
	printLinkList(L);


}

﹏陈、词
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（四） — 线性表之链式存储
dashifu11111的博客
03-26 2922
一、线性表的链式存储结构 1、线性表链式存储结构定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。 以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外， 还要存储它的后继元素的存储地址。 因此，为了...
数据结构课件：第2章 线性表3习题.pptx
05-31
线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。 8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。 错误。线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储...
[数据结构]线性表链式结构及基本操作
weixin_43717520的博客
04-06 1476
链表
数据结构 线性表-单链表的定义及基本操作
Mi-ronin的博客
03-16 2462
文章目录一.引入二.线性表链式存储结构的定义2.1 顺序结构和链式结构的区别2.2结点定义 一.引入 对于线性表来说，有顺序存储结构，然而顺序结构是有缺点的：插入和删除时需要移动大量元素；因此我们需要解决这一系列问题，线性表的链式存储结构刚好解决了这些问题。 二.线性表链式存储结构的定义 2.1 顺序结构和链式结构的区别 在顺序结构中，每个数据元素只需要存数据元素信息就可以了，在链式结构中，除了要存储元素信息外，还要存储后继元素的存储地址，因此，我们引入了结点。 2.2结点定义 为了表示每个数据元素 a 与
数据结构线性表超详细整理（存取、插入、删除/顺序存储结构/链式存储结构/静态链表/循环链表/双向链表）
weixin_45709829的博客
10-26 3272
3.1 线性表的定义 定义：零个或者多个数据元素的有限序列 第一个元素无前驱，最后一个元素无后继 线性表元素的个数n(n>=0)定义为线性表的长度，n=0时为空表 排列的必须是相同的数据类型 在较复杂的线性表中，一个数据元素可以由若干个数据项组成 元素之间的是一对一的关系 3.2 线性表的抽象数据类型 ADT 线性表(List) Data 每个元素的类型均为DataType Operation InitList(*L):初始化操作，建立一个空的线性表 ListEmpt
线性表的链式存储——表长、查找、插入、删除
qq_54731568的博客
02-22 412
线性表的链式存储——表长、查找、插入、删除
数据结构实例教程（C语言版）：第2章 线性表的结构分析与应用.ppt
06-24
在C语言版的数据结构实例教程中，线性表的逻辑结构和两种存储方式——顺序存储和链式存储——被详细地讲解。 线性表的基本运算包括表的初始化（InitList）、求表长（ListLength）、获取指定位置的元素（GetNode）、...
数据结构课件、代码第2章线性表2-71-3.ppt
09-28
本课件主要讲解了线性表的链式存储结构，这是相对于顺序存储结构（数组）的一种存储方式，它更加灵活，但可能在访问效率上稍逊一筹。 在链式存储结构中，每个数据元素称为结点，不仅包含实际的数据，还包含了指向下...
数据结构算法图解-第二章图例.docx
12-09
第三部分：单链表的结点结构和操作 单链表是线性表的一种实现方式。单链表的结点结构如图2-6所示，结点结构包括数据域和指针域。单链表的操作包括插入、删除和查找等。插入操作的示意图如图2-11和图2-12所示，删除...
北邮数据结构实验 第一次实验 线性表.pdf
11-10
实验内容提供了五种线性表的链式存储结构供选择：带头结点的单链表、不带头结点的单链表、循环链表、双链表和静态链表。每种结构都需要实现线性表的基本功能，包括： 1. 构造：头插法和尾插法创建线性表，保持元素...
初学数据结构——从零开始的数据结构学习第五天（线性表的链式存储方式）
最新发布
Lazy_ChessPlayer的博客
04-10 2235
本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望留下一个赞。由于博主只是一名大一新生，如果博文中出现错误，欢迎指正。如果想要转载，附上链接就行。线性表中各个数据元素在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像。一种头尾相接的链表（即：表中最后一个结点的指针域指向头结点，整个链表形成一个环）在单链表的每个结点单再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。
线性表的定义 超详细！
qq_42890853的博客
06-16 3494
#include<stdio.h> #define maxsize 100//设置最大线性表的数据元素 //线性表是指的逻辑结构，各个元素类型相同且元素个数是有限的 //1.1线性表之顺序表的结构体定义 typedef struct { int data[maxsize]; //存放顺序表元素的数组 存放数据为整型 int length; //当前顺序表是否的长度 }sqlist; //1.2线性表之顺序表的一般定义，直接利用数组 int A[maxsize]; //表
什么是线性表
m0_56609339的博客
09-25 1991
线性表
【数据结构 by 解学武】线性表简介
萌宅鹿的技术小屋
09-03 1230
什么是线性表顺序存储结构和链式存储结构前驱和后继 通过前面的学习我们知道，具有“一对一”逻辑关系的数据，最佳的存储方式是使用线性表。那么，什么是线性表呢？ 线性表，全名为线性存储结构。 使用线性表存储数据的方式可以这样理解，即 “把所有数据用一根线儿串起来，再存储到物理空间中” 。 如图 1 所示，这是一组具有“一对一”关系的数据，我们接下来采用线性表将其储存到物理空间中。 首先，用“一根线儿”...
链表——约瑟夫环
qq_45767547的博客
03-30 2880
南昌航空大学实验报告 课程名称： 数据结构与算法 实验名称： 实验二 线性表的链式存储结构 班 级： XXX 学生姓名： XXX 学号： XXXXX 指导教师评定： XXX 签 名: XXX 一、实验目的 本实验是有关线性表的链式存储结构的应用，通过C语言中提供的结构指针来存储线性表，利用malloc函数动态地分配存储空间。 通过对本实验的学习，可以理...
【数据结构合集】线性表的链式存储
程序员好冰的博客
03-25 108
单链表的创建、插入、删除及合并等操作。
线性表的链式存储
qq_47896523的博客
09-15 404
在链表的第一个结点之前附设一个头结点（头指针）head指向第一个结点。头结点的数据域可以不存储任何信息
单链表（数据结构）
小的博客
08-02 8539
链表链表概念空表的表示单链表的实现单链表的建立1.头插法2.尾插法 链表概念 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相邻。 1. 相关术语 结点：数据元素的存储映像。由数据域和指针域两部分组成。 数据域：存放数据 指针域：存放指向下个结点的地址 链表：n个结点由指针链组成一个链表 2.头指针、头结点、首元结点 头指针:是指向链表中第一个结点的指针 头结点：是在链表的首元结点之前附设的一个结点 首元节点：是指链表中存储第一个数
数据结构--线性表的链式存储
XUN__MLF的博客
02-24 2190
链式存储相关术语： 数据域：存储元素数值数据 指针域：存储直接后继结点的存储位置 结点：数据元素的存储映像。又1数据域和指针域两部分组成 链表：n个结点由指针链组成一个链表 单链表，双链表，循环链表 结点只有一个指针域的链表，称为单链表或线性链表 结点有两个指针域的链表，称为双链表 首尾相接的链表称为循环链表 头指针、头结点、和首元结点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中
线性表与链式存储：单链表、循环链表与双向链表解析
本文档主要讲解了线性表的不同链式表示和实现，包括单链表、循环链表和...这篇文档深入浅出地阐述了线性表的链式存储结构，特别是单链表、循环链表和双向链表的特点、操作和实现，为理解和应用这些数据结构提供了基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值