数据结构——单链表专题

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量1k 收藏 15
点赞数 22
分类专栏： 数据结构 文章标签： 数据结构 c语言 开发语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52550678/article/details/136137977
版权

目录

1. 链表的概念及结构

在顺序表中存在一定的问题：

  1. 顺序表的中间/头部插入、删除需要挪动数据
  2. 扩容存在性能的消耗
  3. 会有空间的浪费

而链表是独立的节点组成

链表概念：链表是一种物理存储结构上非连续、非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表、顺序表都是线性表

逻辑结构一定是线性的
物理结构不一定是线性的

在这里插入图片描述

图中指针变量plist保存的是第一个节点的地址，我们称plist此时“指向”第一个节点，如果我们希望plist“指向第二个节点时，只需要修改plist保存的内容为0x0012FFA0

为什么还需要指针变量来保存下一个节点的位置？

链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），我们需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

链表是由一个一个的节点组成的
一个节点由两部分组成：要存储的数据+指针

int a = 1;
int* pa = &a;

节点结构的定义

struct SListNode{
int data;
struct SListNode* next;
}

在这里插入图片描述

链表结构体的打印方式：

在这里插入图片描述

补充说明：

  1. 链式机构在逻辑上是连续的，在物理结构上不一定连续
  2. 节点一般是从堆上申请的
  3. 从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续

2. 实现单链表

初始化

typedef int SLTDataType;
//链表是由节点组成的
typedef struct SListNode
{
	SLTDataType data;//节点数据
	struct SListNode* next;//指针变量保存下一个节点的地址
}SLTNode;

尾插

//公共部分，开辟一个新的节点
SLTNode* SLBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLBuyNode(x);

	//链表为空，新节点作为phead
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}

	//链表不为空，找尾结点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptril就是尾结点,将尾结点指向newnode
	ptail->next = newnode;
}

在这里插入图片描述

在这里插入图片描述

头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLBuyNode(x);

	//newnode  *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

在这里插入图片描述

尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);

	//链表不能为空
	assert(*pphead);//指向第一个节点的地址

	//链表不为空
	//链表只有一个节点/多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	
	prev->next = NULL;
	//销毁尾结点
	free(ptail);
	ptail = NULL;
}

在这里插入图片描述

头删

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);

	//链表不能为空
	assert(*pphead);

	//让第二个节点称为新的头
	SLTNode* next = (*pphead)->next;//->优先级高于*
	//把旧的头节点释放掉
	free(*pphead);
	*pphead = next;
}

在这里插入图片描述

查找

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(*pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到当前数据
	return NULL;
}

在这里插入图片描述

在指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	//链表不能为空
	assert(*pphead);

	//pos刚好是头结点
	if (pos == *pphead)
	{
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头结点的情况
	SLTNode* newnode = SLBuyNode(x);
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//找到了
	prev->next = newnode;
	newnode->next = pos;
}

在这里插入图片描述

在指定位置之后插入数据

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLBuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}

在这里插入图片描述

删除指定位之前的节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos)
	{
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;

}

在这里插入图片描述

删除指定位置之后pos节点

//删除指定位置之后pos节点
void SLTEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

}

在这里插入图片描述

销毁链表

//销毁链表
void SListDesTory(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

在这里插入图片描述

3. 完整代码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
#include <stdio.h>

//void SlistTest1()
//{
//	//一般不会这样去创建链表，这里只是为了给大家展示链表的打印
//	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
//	node1->data = 1;
//	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
//	node2->data = 2;
//	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
//	node3->data = 3;
//	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
//	node4->data = 4;
//
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//
//	SLTNode* plist = node1;//定一个指针指向第一个节点
//	SLTPrint(plist);
//}



void SlistTest2()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 0);
	SLTPrint(plist);


	//SLTPushFront(&plist, 2);
	//SLTPushFront(&plist, 3);
	//SLTPrint(plist);


	SLTPopBack(&plist);
	SLTPrint(plist);
}

void SlistTest3()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 0);
	SLTPrint(plist);

	//头删
	SLTPopFront(&plist);
	SLTPrint(plist);

	//查找
	SLTNode* FindRet = SLTFind(&plist, 0);
	if (FindRet)
	{
		printf("找到了\n");
	}
	else {
		printf("未找到\n");
	}

	SLTInsert(&plist, FindRet, 100);
	SLTPrint(plist);

	SLTInsertAfter(FindRet, 200);
	SLTPrint(plist);

	//删除指定位置的节点
	SLTErase(&plist, FindRet);
	SLTPrint(plist);

	//销毁节点
	SListDesTory(&plist);
}

int main()
{
	SlistTest3();
	//SlistTest2();
	//SlistTest1();
	return 0;
}

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
#include <assert.h>


//链表的打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}


SLTNode* SLBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLBuyNode(x);

	//链表为空，新节点作为phead
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}

	//链表不为空，找尾结点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptril就是尾结点,将尾结点指向newnode
	ptail->next = newnode;
}


//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);

	SLTNode* newnode = SLBuyNode(x);

	//newnode  *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}


//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);

	//链表不能为空
	assert(*pphead);//指向第一个节点的地址

	//链表不为空
	//链表只有一个节点/多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	
	prev->next = NULL;
	//销毁尾结点
	free(ptail);
	ptail = NULL;
}


//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);

	//链表不能为空
	assert(*pphead);

	//让第二个节点称为新的头
	SLTNode* next = (*pphead)->next;//->优先级高于*
	//把旧的头节点释放掉
	free(*pphead);
	*pphead = next;
}


//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(*pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到当前数据
	return NULL;
}


//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	//链表不能为空
	assert(*pphead);

	//pos刚好是头结点
	if (pos == *pphead)
	{
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头结点的情况
	SLTNode* newnode = SLBuyNode(x);
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//找到了
	prev->next = newnode;
	newnode->next = pos;
}


//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLBuyNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}


//删除指定位之前的节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos)
	{
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;

}


//删除指定位置之后pos节点
void SLTEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}


//销毁链表
void SListDesTory(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

SList.h

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>


typedef int SLTDataType;
//链表是由节点组成的
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;


//链表的打印
void SLTPrint(SLTNode* phead);

//链表的头插和尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//链表的头删和尾删
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除指定位置之前pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除指定位置之后pos节点
void SLTEraseAfter(SLTNode** pphead, SLTNode* pos);



//销毁链表
void SListDesTory(SLTNode** pphead);

4. 链表的分类

链表的结构非常多样，一下情况组合组合起来就有8种链表结构：

在这里插入图片描述
链表说明：

在这里插入图片描述

在单链表中，“头结点”的“头”和“带头”链表是两个概念
单链表中提到的“头结点”指的是第一个有效的节点
“带头”链表里的“头”指的是无效的节点

虽然链表的种类非常之多，但是使用比较多的只有两种：单链表（不带头单向不循环链表）和双向链表（带头双向循环链表）

凡人多烦事~
关注
  • 22
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
数据结构：线性表————单链表专题
2302_76674204的博客
04-12 819
教你一步一步写代码
初阶数据结构——链表专题——单链表详解
2302_80023639的博客
03-01 778
我们设想一个场景：假如现在有一排连在一起的房间，而我们现在在第一个房间里，每个房间都有一扇通往下一个房间的门，但是上了锁，每个锁都不一样，如下：问：我们如何从第一间房间走到最后一间房间呢？答：在每一间房间里都放上通往下一间房间的钥匙就可以了链表的核心原理就是如此我们的链表里面不仅存着其应该带的数值，还存放着指向下一个节点的地址，地址连着地址，就像一根链子一样把数据都串起来，所以才叫链表至此，我们单链表的相关知识就讲完啦！！接下来为各位带来的是双链表的相关知识。
三分钟让你掌握数据结构——单链表
暴躁小吕的博客
10-22 667
上一篇博客讲了什么是顺序表，顺序表的增删改查等基本操作功能，但是顺序表有以下缺点：1.中间/头部的插入删除，时间复杂度为O(N)2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间如何解决这些缺点呢？我们就要讲到链表了。
《简明数据结构》链表专题编程测验题2——单链表删除元素及逆置
Raider1的博客
01-04 323
试题描述先将键盘输入的k(k>3)个整数依次存入单链表，输出该单链表，然后删除倒数第3个位置的整数，最后将其余整数逆序输出。思路分析 1.套用尾插法建立带头结点的单链表模板 //尾插法建立带头结点的链表 LinkList CreateFromTail() /*将新增的字符追加到链表的末尾*/ { LinkList L; Node *r, *s; int flag = 1; L = (Node *)malloc(sizeof(Node)); /*为头结点分配存储空间*/
猴子也能看懂的Java数据结构与算法——单链表元素删除解析及高频面试题
wyx1473343124的博客
07-21 382
这里我们使用双指针法，先让快慢指针步差为K+1，然后快慢指针同步移动，这样当快指针指向链表末尾的null时（你也可以理解成链表最后一个元素是倒数第1节点，最后一个元素的null指针域是倒数第0节点），即快指针指向倒数第0个节点时，因为步差K+1,所以这时慢指针指向倒数第K+1个节点，也就是前驱节点。那回到之前所说的，把cur.next.next赋值给cur.next，这也就是说，让cur.next也指向后继结点。//如果值相同，则删除cur.next, cur不移动，和下一个cur.next继续比较。
《简明数据结构》链表专题编程测验题3——单链表重新排列
Raider1的博客
01-04 233
试题描述给定一个单链表L1->L2->...->Ln-1->Ln，请编写程序将链表重新排列为L3->...->Ln->L1->L2。思路分析套用尾插法建立带头结点的单链表模板//尾插法建立带头结点的单链表LinkList CreateFromTail() /*将新增的字符追加到链表的末尾*/{LinkList L;Node *r, *s; int flag = 1;L = (Node *)malloc(sizeof(Node)); /*为头结点分配存储空间*/
《简明数据结构》链表专题编程测验题7——克隆单链表
Raider1的博客
01-04 239
试题描述 从键盘顺序输入不少于3个整数，存储在单链表中。然后将该单链表进行克隆，把克隆产生的新链表链接到原来的单链表后面。要求打印出复制之前的单链表和复制之后的单链表。 样例输入 1 2 3 4 5 6样例输出 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6语言 C思路分析 1. 利用尾插法建立一个带头结点的单链表，套用尾插法建立带头结点的单链表模板； LinkList CreateFromTail1() /*将新增的字符追加到链表的末尾*/ { LinkList L;
数据结构——栈和队列
一只向入研坑的程序猿
04-25 206
数据结构——栈和队列
数据结构——栈和队列（详解）
2302_80023639的博客
03-09 752
栈，一种仅允许在一端进，一端出的结构如上图所示，进数据和出数据的一端叫做栈顶，而相反的一段则叫做栈底数据从栈顶入，从栈顶出我们可以以吃货的视角打开栈：栈就像一个肉串，串肉要从尖的一段串进去，同时也是从尖的一端被吃掉我们还能发现，先被串进去的肉，会最后被吃掉栈也是如此，符合FILO原则，FILO就是 first in last out，翻译过来就是先进后出就像我们日常生活中的排队一样，队列就是从一端进，从另一端出。
JAVA数据结构——单链表的操作.docx
07-11
JAVA数据结构——单链表的操作 单链表的操作 方法一： package ch02; (1)建立结点类Node.java public class Node { public Object data;//存放结点数据值 public Node next;//存放后继结点 //无参构造函数 public ...
数据结构——单链表.zip
09-16
完全实现严蔚敏数据结构教材中的单链表，可测试。包含初始化，插入，删除，连接等操作
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1591
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 743
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 735
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 407
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val;... TreeNode(int x) : val(x), left(NULL), right(NULL) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值