数据结构笔记13：小小指针，大有用处。（单链表的定义和基本操作的实现）

最新推荐文章于 2022-07-09 18:26:21 发布
最新推荐文章于 2022-07-09 18:26:21 发布
阅读量611 收藏 11
点赞数 6
分类专栏： 数据结构基础 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43193864/article/details/105692513
版权

单链表的定义和基本操作的实现

一、定义

1.定义单链表

typedef struct LNode {
	int data;
	struct LNode* next;
}LNode, * LinkList;

2.初始化单链表

①带头结点

bool InitList1(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
	{
		return false;
	}
	L->next = NULL;
	return true;
}

②不带头结点

bool InitList2(LinkList& L) {
	L = NULL;
	return true;
}

3.单链表判空

①带头结点

bool Empty1(LinkList L) {
	if (L->next == NULL) {
		return true;
	}
	else
	{
		return false;
	}
}

②不带头结点

bool Empty2(LinkList L) {
	if (L==NULL)
	{
		return  true;
	}
	else
	{
		return false;
	}
}

4.带头结点单链表与不带头结点单链表区别

  1. 不带头节点：此时头指针指向第一个节点
    　　h->a1->a2->a3->……　　　　　
    　　头指针存放的是第一个节点的地址，即h，也就是说（*h）表示的是第一个节点
  2. 带头结点：此时头指针指向头结点
    　　h->headnode->a1->a2->a3->……　　　　
    　　头指针存放的是头结点的地址，也就是说（*h）表示的是头结点
  3. 带头结点的优点：
    1、更快删除/插入第一个结点
    2、统一空表和非空表的处理

二、插入

1.按位序插入

①带头结点

平均时间复杂度O(n)

//在第i个位置插入元素e
typedef  int Elemtype ;
bool ListInsert(LinkList& L, int i, Elemtype e) {
	if (i < 1) {
		return false;
	}	
	LNode* p;
	int j = 0;//表示当前p指向的是第几个结点
	p = L;
	while (p != NULL && j < i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p=NULL)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

②不带头结点

不带头结点的表插入数据时需要对i=1的时候特殊处理

//在第i个位置插入元素e
typedef  int Elemtype ;
bool ListInsert(LinkList& L, int i, Elemtype e) {
	if (i < 1) {
		return false;
	}
	if (i == 1)
	{
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p;
	int j = 1;//表示当前p指向的是第几个结点
	p = L;
	while (p != NULL && j < i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p = NULL)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

2.指定结点的后插元素操作

在p结点之后插入元素e
时间复杂度O(1)

bool InsertNextElem(LNode *p, Elemtype e){
	if (p==NULL)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s==NULL)
	{
		return false;
	}
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

3.指定结点的前插元素操作

在p结点之前插入元素e
时间复杂度O(1)

bool InsertPriorElem(LNode* p, Elemtype e) {
	if (p == NULL)
	{
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

4.指定结点前插入结点操作

将s结点插入到p之前
时间复杂度O(1)

bool InsertPriorNode(LNode *p, LNode *s) {
	if (p==NULL || s==NULL)
	{
		return false;
	}
	s->next = p->next;
	p->next = s;
	Elemtype e = p->data;
	p->data= s->data;
	p->data = e;
	return true;
}

三、删除

1.按位序删除

按位序删除（带头结点）
时间复杂度O(n)
删除第i个元素的值，用e带回此值

bool ListDelElem(LinkList& L, int i, Elemtype e) {
	if (i < 1) {
		return false;
	}
	LNode* p;
	int j = 0;//表示当前p指向的是第几个结点
	p = L;
	while (p != NULL && j < i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p = NULL)
	{
		return false;
	}
	if (p->next==NULL)
	{
		return false;
	}
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

2.指定结点的删除

bool DelNode(LNode* p) {
	if (p==NULL)
	{
		return false;
	}
	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}

注意：
如果p恰好是最后一个节点，则此法失效，因为p->next=NULL。

这时应另寻它法，给定头指针。找到p的前一个元素，进行删除操作。

四、查找

1.按位查找

时间复杂度O(n)

LNode* GetElem(LinkList L, int i) {
	if (i<0)
	{
		return NULL;
	}
	LNode* p;
	int j = 0;
	p = L;//L先指向头结点（第0个结点，不存数据）
	while (p!=NULL&&j<i)
	{
		p = p->next;
		j++;
	}
	return p;
}

注意：
顺序表中按位查找是随机访问，时间复杂度为O(1)

2.按值查找

时间复杂度O(n)

LNode* LocateElem(LinkList L, int e) {
	LNode* p = L->next;
	while (p!=NULL&&p->data!=e)//从第一个节点开始查找data域为e的点
	{
		p = p->next;
	}
	return p;//存在e值返回结点指针，不存在返回NULL
}

五、求链表长度

时间复杂度O(n)

int length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next!=NULL)
	{
		p = p->next;
		len++;
	}
	return len;
}

六、单链表的建立

1.头插法

将输入的数据插入到链表的表头，读入数据的顺序与生成链表中的元素相反，L->next=NULL，防止它指向空间中的脏数据。

时间复杂度O(n)

重要应用：链表的原地逆置

LinkList List_HeadInsert(LinkList& L) {
	LNode* s;
	int x;
	L = (LinkList)malloc(sizeof(LNode));//创建头结点
	L->next = NULL;//初始化链表
	scanf_s("%d", &x);
	while (x != 00) {//输入00结束
		s= (LNode *)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf_s("%d", &x);
	}
	return L;
}

2.尾插法

将输入的数据插入到链表的表尾，读入数据的顺序与生成链表中的元素相同

时间复杂度O(n)

**注意：**必须增加一个尾指针，使其始终指向当前链表的尾结点，便于下一个数的插入。

LinkList List_TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));//创建头结点
	LNode* s, * r = L;
	scanf_s("%d", &x);
	while (x != 00) {//输入00结束
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;//r指向新的表尾结点
		scanf_s("%d", &x);
	}
	r->next = NULL;//尾结点指针置空
	return L;
}

七、总结

  1. 上述实现了单链表的插入、删除、查找、建立等基础方法
  2. 注意链表带头结点和不带头结点的区别
  3. 对指针的运用和while循环的理解
  4. 理解之后，将基础方法写在头文件里，后续深层次的算法实现，只调用封装函数即可。

…

老铁们，创作不易，顺便点个赞呗，可以让更多的人看到这篇文章，激励一下我这个小白。

From zero To one
关注
专栏目录
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1219
数据结构：单链表的基本操作
C/C++编程笔记：如何使用C++实现单链表？单链表类型定义和基本结构
致力于C语言C++知识分享！
08-10 2036
如何弥补顺序表的不足之处？ 第一次学习线性表一定会马上接触到一种叫做顺序表（顺序存储结构），经过上一篇的分析顺序表的优缺点是很显然的，它虽然能够很快的访问读取元素，但是在解决如插入和删除等操作的时候，却需要移动大量的元素，效率较低，那么是否有一种方法可以改善或者解决这个问题呢？ 首先我们需要考虑，为什么顺序表中的插入删除操作会涉及到元素的移动呢？ 好家伙，问题就是围绕着顺序表的最大的特点出现的——顺序存储，相邻放置元素，也就是说每个元素都是根据编号一个一个挨着的，这就导致了 插入或删除后，为了仍然
单链表的插入第i个元素
weixin_42050661的博客
08-28 5105
单链表的插入 单链表第i个数据插入结点的算法思路： 1.声明一结点p指向链表头结点,初始化j从1开始; 2.当j<i时,就遍历链表,让p的指针向后移动,不断指向下一结点,j累加1; 3.若到链表末尾p为空,则说明第立个元素不存在;否则杳找成功,在糸统中生成一个空结点S 4.将数据元素e赋值给s->data;然后单链表的插入语句; //假设存储元素e的节点为s，要实现s插入到ai和a...
在单链表（带头结点）中的第i个位置前面插入一个新结点的初始化问题
Youthenen的博客
04-02 9992
想要在链表第i个元素前面插入新结点，则需要将指针指向第i-1个元素，从而将其next域中保存的第i个元素地址赋值给新结点，实现链接。 void InserttoList(LinkList head,int i,int number) { LinkList p= head; //p 和 j 的初始化问题 int j = 0; while(p && j<i-1) {...
单链表的相关操作（定义，初始化，插入，删除，查找，求表长）
weixin_45837835的博客
04-03 1522
单链表的相关操作定义一个单链表不带头节点的单链表带头结点的单链表按位序插入（带头结点）按位序插入（不带头结点）指定结点的后插操作指定结点的前插操作按位序删除（带头结点） 定义一个单链表 typedef struct LNode { ElemType data; struct LNode* next; }LNode, * LinkList; 不带头节点的单链表 bool InitList(LinkList& L) { L = NULL; //空表，防止脏数据 return true; } b
数据结构：单向链表及其基本操作
JimmyC18的博客
08-28 934
1. 单向链表介绍 链表的定义：是一种物理存储结构上非连续、非顺序的存储结构，数据元素（结点）的逻辑顺序是通过链表中的指针链接次序实现的。 注：结点包含两个域：数据域和指针域； 链表的特点： 存储单元可以是可连续的，也可以是不连续的； 作插入和删除操作时，不需要移动元素，仅需修改指针； 不可随机存取； 单向链表：链表的每一个结点中只包含一个指针域，如下图所示： 其中，单向链表的第一个结点之前附设的结点，称为头结点head;链表的结点位置从0开始，例如第一个结点再链表中所对应的位置pos=0. 2
【数据结构】对于单链表中头结点和头指针的理解
拔丝芋头真好吃的博客
03-20 5297
要点： 头指针表明了链表的起点，可以唯一确定一个单链表。 头指针指向的是链表的第一个结点，其指针域储存的是第一个结点在内存中的位置。 头结点是单链表的第一个结点，若单链表有头结点，则头指针指向头结点，若单链表没有头结点，则头指针指向第一个结点。 一个单链表可以没有头结点，但是不能没有头指针。 头结点的数据域可以不储存任何数据。 如下图： （转自：https://blog.csdn.net/qq_35514178/article/details/102636001?utm_medium=distribu
数据结构学习笔记——单链表
12-21
数据结构是计算机科学中至关重要的基础概念，它们用于有效地组织和管理数据，以便进行高效的存储、检索和操作。本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构...
【数据结构详细学习笔记2】单链表的定义和表示
longbow_nice的博客
07-09 2233
单链表基础知识，单链表代码实现，实现单链表遇到问题
数据结构学习笔记-单链表
最新发布
02-16
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和组织数据，以便进行各种操作。在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下...
数据结构-单链表详解
快乐的小小程序猿
09-21 6800
#include <stdio.h> #include <malloc.h> /** * 定义结点类型结构体，有一个data域和一个next域 */ typedef struct LNode { int data; struct LNode* next; }LNode, * LinkList; /** * 初始化，生成带有头结点的单链表 * @param L ...
如何使用一个指针来实现双向链表操作
chiichen的专栏
08-08 6959
1、使用的数学基础和基本数据结构及关系： x ^ y ^ y = x ^ ( y ^ y ) = x ^ 0 = x 双指针双向链表结点： struct double_link_list { struct double_link_list *next;
单链表
薄荷糖
05-21 2762
单链表的结点存储结构定义如下:typedef struct Node{Datatype data;struct Node *next;}LNode,*LinkList;LNode是结点类型，LinkList指向Lnode类型结点的指针类型，即LinkList等同于LNode*要完成申请一块LNode类型的存储单元的操作，则需执行如下语句：p=（LinkList）malloc（sizeof（LNod...
数据结构笔记10：求两个升序序列的中位数的三种方法（归并排序你会用了吗？）
亦木的博客
04-15 7292
题目：一个长度为L (L>=1)的升序序列S，处在第[L/2]个位置的数称为S的中位数。例如，若序列S1=(11, 13, 15, 17, 19)，则S1的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2= (2, 4，6，8, 20)，则S1和S2的中位数是11。现在有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的...
数据结构笔记12：在含n个整数的数组中找未出现的最小正整数
亦木的博客
04-18 6155
【2018年408统考真题】 题目：给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5, 3, 2, 3}中未出现的最小正整数是1；数组{1, 2, 3}中未出现的最小正整数是4。 1、第一种方法（暴力搜寻） 算法思想： 最小正整数是1，从1开始增加，每个正整数都在数组中找是否有这个数，没有则输出 算法时间复杂度是O(n^2)，空...
数据结构笔记11：C语言实现查找一个无序序列中的主元素（三种不同方法，你值得拥有）
亦木的博客
04-16 5515
问题：（2013年408统考真题） 已知一个整数序列A=（a0，a1，…，an-1），其中0≤ai<n(0≤i<n)。若存在ap1=ap2=…=apm=x且m>n/2（0≤pk<n，1≤k≤m），则称x为A的主元素。例如A=(0，5，5，3，5，7，5，5)，则5为主元素；又如A=(0，5，5，3，5，1，5，7)，则A中没有主元素，假设A中的n个元素保存在一个一维数组中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值