单链表的基本操作（带头结点与不带头结点）

已于 2023-07-07 15:34:17 修改
阅读量481 收藏 6
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2023-07-07 13:44:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46620129/article/details/130377514
版权

0.定义结点

typedef struct LNode｛
    ElemType data;
    struct LNode *next;
｝LNode, *LinkList;
//LNode表示节点，LinkList表示头指针

1.初始化

①带头结点

bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));//头指针指向头结点
    //判断是否分配成功
    if(L == NULL)
        return false;
    //初始化指向空
    L ->next = NULL;
    return true;
}

②不带头结点

bool InitList(LinkList &L){
    L = NULL;//初始化为空表，头指针指向空
    return true;
}

2.判空

①带头结点

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

②不带头结点

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

3.创建

3.1头插法(常应用于链表逆置)

①带头结点

LinkList List_HeadInsert(LinkList &L) {
	InitList(L);//初始化：创建头结点；初始化为空链表
	LNode *s;
	int x;
	scanf("%d", &x);
	while(x != 9999) {//输入9999表示结束
		s = (LNode*)malloc(sizeof(LNode));
		s -> data = x;
		s -> next = L -> next;
		L -> next = s;
		scanf("%d", &x);
	}
	return L;
}

②不带头结点

LinkList List_HeadInsert(LinkList &L) {
	InitList(L);//初始化：初始化为空链表
	LNode *s;
	int x;
	scanf("%d", &x);
	while(x != 9999) {//输入9999表示结束
		s = (LNode*)malloc(sizeof(LNode));
		s -> data = x;
		s -> next = L;
		L = s;
		scanf("%d", &x);
	}
	return L;
}

每个结点插入的时间复杂度为：O(1)
总时间复杂度：O(n)

3.2尾插法

①带头结点

LinkList List_TailInsert(LinkList &L) {
	InitList(L);//初始化：创建头结点；初始化为空链表
	LNode *s, *r = L;//r为表尾指针
	int x;
	scanf("%d", &x);
	while(x != 9999) {//输入9999表示结束
		s = (LNode*)malloc(sizeof(LNode));
		s -> data = x;
		r -> next = s;
		r = s;
		scanf("%d", &x);
	}
	r -> next = NULL;
	return L;
}

②不带头结点

LinkList List_TailInsert(LinkList &L) {
	InitList(L);//初始化：初始化为空链表
	LNode *s, *r = L;//r为表尾指针
	int x;
	scanf("%d", &x);
	while(x != 9999) {//输入9999表示结束
		s = (LNode*)malloc(sizeof(LNode));//创建新结点
		s -> data = x;
		if (L == NULL) {
			L = s;
			r = L;
		}
		else {
			r -> next = s;
			r = s;
		}
		scanf("%d", &x);
	}
	r -> next = NULL;
	return L;
}

由于附设了一个尾指针，时间复杂度与头插法相同。

4.查找

4.1按序查找

①带头结点

LNode *GetElem(LinkList L, int i) {
	//判断i是否合法
	if(i < 0)
		return NULL;
	int j = 0;
	LNode *p = L;//p指向第0个结点
	while(p != NULL && j < i){
		p = p -> next;
		j++;
	}
	return p;//i＞len或查找不成功时返回NULL
}

②不带头结点

LNode *GetElem(LinkList L, int i) {
	//判断i是否合法
	if(i < 1)
		return NULL;
	int j = 1;
	LNode *p = L;//p指向第1个结点
	while(p != NULL && j < i){
		p = p -> next;
		j++;
	}
	return p;//i＞len或查找不成功时返回NULL
}

4.2按值查找

①带头结点

LNode *LocateElem(LinkList L, ElemType e){
    LNode *p = L -> next ;//L指向头结点（第0个结点），p指向第1个结点
    while ( p != NULL && p -> data != e )
        p = p -> next;
    return p ;//查找失败返回NULL
 }

②不带头结点

LNode *LocateElem(LinkList L, ElemType e){
    LNode *p = L;//p指向第1个结点
    while ( p != NULL && p -> data != e )
        p = p -> next;
    return p ;//查找失败返回NULL
 }

查找的时间复杂度都为O(n)

5.插入

5.1 后插（将新结点插入到第i个位置上，即在第i-1个位置后面插入）

bool InsertNextNode(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;
}

①带头结点

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i ＜ 1)
        return false;
    LNode *p = GetElem(L, i-1);
    return InsertNextNode(p, e);
}

②不带头结点

bool ListInsert(LinkList &L, int i, ElemType e) {
    if(i ＜ 1)
        return false;
    if(i == 1){//插入第1个结点操作不同
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s -> data = e;
        s -> next = L;
        L = s;
        return true;
    }
    LNode *p = GetElem(L, i-1);
    return InsertNextNode(p, e);
}

后插的时间复杂度:O(n)

5.2对给定结点p的前插

方案1：转化为上一结点的后插

需要给定头指针，从头开始找到上一结点。

①带头结点
bool InsertPriorNode(LinkList L, LNode *p, ElemType e){
    LNode *q = L;
    while(q -> next != q)
        q = q -> next;
    return InsertNextNode(q, e);
}
②不带头结点
bool InsertPriorNode(LinkList L, LNode *p, ElemType e){
    LNode *q = L;
    if(p == q){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s -> data = e;
        s -> next = L;
        L = s;
        return true;
    }
    while(q -> next != q)
        q = q -> next;
    return InsertNextNode(q, e);
}

时间复杂度：O(n)

方案2：后插再交换位置

有无头结点相同

bool InsertPriorNode(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;
}

时间复杂度：O(1)

6.删除

6.1删除第i个结点

bool DeleteNextNode(LNode *p, ElemType &e){
   //i值不合法
   if(p == NULL || p -> next == NULL)
       return false;
   LNode *q = p -> next;
   e = q -> data;
   p -> next = q -> next;
   free(q);
   return true;
   
}

①带头结点

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1)
       return false;
    LNode *p = GetElem(L, i-1)
    return DeleteNextNode(p, e);
}

②不带头结点

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1)
        return false;
    if(i == 1){
    	LNode *q = L;
    	e = q -> data;
    	L = q -> next;
        free(q);
        return true;
    }
    LNode *p = GetElem(L, i-1)
    return DeleteNextNode(p, e);
}

6.2删除给定结点p

方案1：找到前驱结点，执行删除操作

需要给定头指针，从头开始找到上一结点。

①带头结点
bool DeleteNode(LNode *p, ElemType &e){
    LNode *q = L;
    while(q -> next != q)
        q = q -> next;
    return DeleteNextNode(q, e);
}
②不带头结点
bool DeleteNode(LNode *p, ElemType &e){
    LNode *q = L;
    if(p == q){
        L = p -> next;
        free(p);
        return true;
    }
    while(q -> next != q)
        q = q -> next;
    return DeleteNextNode(q, e);
}

时间复杂度：O(n)

方案2：将p结点的后继结点赋予自身，删除后继结点

有无头结点相同

bool DeleteNode(LNode *p, ElemType &e){
    if(p == NULL )
    	return false;
    e = p -> data;
    LNode *q = p -> next;
    if(q == NULL )
    	free(p);
    	return true;
    p -> data = q -> data;
    p -> next = q -> next;
    free(q);
    return true;
}

时间复杂度：O(1)

7.求表长

①带头结点

int Length(LinkList L){
    int len = 0;
    if(L == NULL)
		return false;
    while(L->next){
        len++;
        L = L -> next;
    }
    return len;
}

②不带头结点

int Length(LinkList L){
    int len = 0;
    if(L == NULL)
		return false;
    while(L){
        len++;
        L = L -> next;
    }
    return len;
}

时间复杂度：O(n)

7.销毁

有无头结点相同

void DestroyList(LinkList &L){
	LNode *q;
	while(L){
		q = L;
   		L= L -> next
   		free(q);
	}
	L = NULL;
}

时间复杂度：O(n)

平人的进步日常
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
带头结点和不带头结点的单链表的尾插法以及各种操作
ERIC的编程之路
08-15 1万+
一.带头结点的单链表 先说一下create()建立的链表，采用cycle的方式。 /************************************************************* 带头结点的单链表13-1-1ex3.cpp 1.建立单链
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3217
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
数据结构：单链表——带头结点与不带头结点步骤详解
qq_41623154的博客
04-19 9160
单链表：带头结点与不带头结点详解 这两天回顾下链表的知识，关于单链表带头结点和不带头结点有点迷糊了，就去网上查询了下，结果查完心态都炸了。看的整个人更懵逼了！！！ 网上大部分对于带头结点和不带头结点的文章，对不带头结点的链表的表头插入结点的代码，都是错的。我简单截几个图： 正确的步骤应该如下 x->next = head;//此处x是待插入结点 head = x; 下面我们讲下具体...
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 8696
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
数据结构-单链表（带头结点与不带头结点表示）
Yyan7777的博客
02-13 3837
单链表是线性表的链式存取结构；是用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的；
单链表：带头结点和不带头结点 总结
热门推荐
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
03-25 1万+
写在前面：        一直以来，带头结点和不带头节点的单链表的操作实现困扰着我。在没有理解和实现之前，光凭思考真的是很难理解清楚 1.两者之间代码的差异； 2.带不带头结点的区别； 3.带头结点之后，什么情况下形参必须传二级指针（或者一级指针的引用）；       ...
带头结点单链表 和 不带头结点单链表的区别
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
逆置单链表c语言不带头节点,单链表-不带头结点
weixin_30456235的博客
05-21 906
链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。链表中数据元素的构成每个元素本身由两部分组成：本身的信息，称为“数据域”；指向直接后继的指针，称为“指针域”。这两部分信息组成数据元素的存储结构，称之为“结点”。n个结点通过指针域相互链接，组成一个链表。typedef int...
基于C语言实现单链表(不带头结点)
03-28
本教程将详细讲解如何在C语言中实现一个不带头结点的单链表，包括链表的基本操作如创建、插入、删除、遍历等。 首先，我们需要定义链表节点的结构体。在C语言中，结构体是一种自定义的数据类型，可以用来封装多种...
不带头结点的单链表c语言,不带头结点的单链表的实现（C语言）
weixin_42297675的博客
05-21 1635
不带头结点的单链表的实现(C语言)不带头结点的单链表的实现(C语言)链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表(单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作...
C语言实现单链表（带头结点）的基本操作
03-25
这里我们将深入探讨如何在C语言中实现一个带头结点的单链表，包括其创建、插入、删除、遍历和打印等基本操作。 首先，我们需要定义链表的节点结构。带头结点的链表会在链表的开头有一个特殊的节点，它的数据部分...
单链表（带头结点）的基本操作
H643511的博客
09-27 6223
带头结点的单链表的基本操作基本概念单链表的定义初始化单链表单链表表长头插法建立单链表的操作尾插法建立单链表的操作按元素查找按位置查找单链表插入数据删除数据判空操作输出清空表 基本概念 线性表的链式存储又称单链表，它是通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。 单链表的定义 定义该结点的数据和后继的指针的地址 typedef struct LNode { LNode* next; ElemType
带头结点单链表、不带头结点单链表（头指针单链表）
weixin_50539337的博客
12-01 9858
1、头结点和头指针实现的区别 1.1记录链表的类型不同： 头指针是一个4字节的指针，记录第一个存储数据的结点的地址。 头结点是一个结构体变量，使用这个变量的next域来记录第一个存储数据的结点的地址，头结点的data域可以使用联合体的方式记录链表的长度。 1.2各个操作方法的定义不同 如果是头指针实现，则方法中国接受这个链表的类型必须是二级指针。 头指针实现使用一级指针就OK。 2、单链表 链表和顺序表的区别： （1）链表在逻辑存储上是连续的，在物理存储上是不连续的。 （2）单链表属于链表中的一种，每一个存
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 900
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1063
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 304
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
数据结构-栈、队列-详解
2401_86587256的博客
09-04 1151
数据结构初阶部分，栈和队列的详解
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 658
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
数据结构——单链表实现和注释浅解
最新发布
hedhjd的博客
09-07 212
【代码】数据结构——单链表实现和注释浅解。
带头结点的单链表和不带头结点的单链表
10-20
单链表是一种常见的数据结构，它由若干个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。带头结点的单链表和不带头结点的单链表的区别在于是否在链表的开头设置一个头结点。 带头结点的单链表在链表的开头设置一个头结点，头结点的数据域可以为空，头结点的指针域指向链表的第一个节点，这样可以使得所有节点的操作都可以统一处理，而且可以避免一些特殊情况的处理。例如，当链表为空时，带头结点的单链表的头指针不为空，而不带头结点的单链表的头指针为空，这样就可以避免一些特殊情况的处理。 不带头结点的单链表没有头结点，链表的第一个节点就是首元结点，这样可以节省一个节点的空间，但是在进行一些操作时需要特殊处理，例如在链表的开头插入一个节点时，需要特殊处理。 总之，带头结点的单链表和不带头结点的单链表各有优缺点，具体使用哪种方式取决于具体的应用场景和需求。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值