数据结构————单链表

已于 2024-09-10 23:41:51 修改
阅读量1.2k 收藏 19
点赞数 17
文章标签： 数据结构
于 2024-09-09 23:42:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66847953/article/details/142071352
版权

目录

一、单链表的定义及其特点

定义

特点

二、单链表的实现

  准备工作：

1.单链表的创建

1.1头插法介绍

1.2尾插法介绍

总结：

2.单链表的初始化

3.单链表的求表长

4.单链表的销毁

5.单链表的插入

6.单链表的查找

 6.1按序查找

6.2按值查找

7.单链表的删除元素

全部代码：

结语： 

一、单链表的定义及其特点

定义

  单链表（Singly Linked List）是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。 

特点

  1. 动态存储：单链表的长度可以动态变化，可以根据需要动态地添加或删除节点。

  2. 非连续存储：节点在内存中的位置不需要连续，只需通过指针连接即可。

  3. 易于插入和删除：在单链表中插入或删除节点只需修改相应节点的指针，时间复杂度为O(1)，但前提是能够快速访问到要操作的节点或其前驱节点。

  4. 不支持随机访问：访问单链表中的特定节点需要从头节点开始逐个遍历，时间复杂度为O(n)。

  5. 额外空间存储指针：每个节点除了存储数据外，还需要额外的空间来存储指向下一个节点的指针。

  6. 头指针：单链表通常有一个头指针，用于访问链表的第一个节点。头指针可能指向头节点（头节点包含数据）或直接指向第一个实际数据节点（头节点不存储数据）。 

二、单链表的实现

  准备工作：

自定义数据元素类型：

typedef int ElemType;

结构体：

typedef struct LNode
{
	ElemType data;//数据域
	struct LNode* next;//指针域
}LinkNode;

1.单链表的创建

单链表的创建通常涉及两种主要的插入方法：头插法和尾插法。

1.1头插法介绍

定义

  头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点，然后更新头指针以指向新节点。

特点

  • 实现简单，插入操作时间复杂度为O(1)。
  • 但链表元素的顺序与插入顺序相反，如果需要保持原有顺序，需要在插入后进行反转

大致实现步骤：

  1. 创建新节点。
  2. 将新节点的next指针设置为头指针所指向的节点。
  3. 更新头指针，使其指向新节点。

代码：整体建立单链表，给定数组

void CreateListF(LinkNode *&L,ElemType a[],int n)
{
	LinkNode * s;  //新节点
	L = (LinkNode*)malloc(sizeof(LinkNode));//创建头节点
	L->next = NULL;//头节点初始化

	for (int i = 0; i < n; i++)
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));//新节点创建
		s->data = a[i];// 初始化
		s->next = L->next;
		L->next = s;
	}
}

1.2尾插法介绍

定义

  尾插法指的是在单链表的尾部插入节点。此方法下，新节点成为链表的最后一个节点。

特点

  • 插入操作的时间复杂度为O(n)，因为可能需要遍历整个链表。
  • 保持了数据的插入顺序，链表元素的顺序与插入顺序一致。

大致实现步骤：

  1. 创建新节点。
  2. 如果链表为空，新节点同时作为头节点和尾节点。
  3. 如果链表非空，遍历链表找到尾节点，将尾节点的next指针指向新节点。

代码：整体建立单链表，给定数组

//<2>尾插法建立单链表
void CreateListR(LinkNode*& L, ElemType a[], int n)
{
	LinkNode* r, * s;//尾指针和新的节点指针
	L = (LinkNode*)malloc(sizeof(LinkNode));
	r = L;   //r始终指向尾节点，初始指向L
	for (int i = 0; i < n; i++)
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));//新节点创建和初始化
		s->data = a[i];
		r->next = s;//将节点s插入到r后面
		r = s;
	}
	r->next = NULL;  //尾节点的next域置为NULL
}

总结：

 头插法和尾插法各有优劣，选择哪种方法取决于具体的应用场景。如果需要快速插入节点且不关心元素的顺序，头插法是更好的选择。反之，如果要保持元素的插入顺序，尾插法则更为合适。在实际应用中，根据需求灵活选择插入方法，可以更高效地创建和管理单链表。

2.单链表的初始化

  创建一个头结点，并将其头结点的next域置空

void  InitList(LinkNode*&L)
{
	L = (LinkNode*)malloc(sizeof(LinkNode));
	L->next = NULL;
}

3.单链表的求表长

 用p指向头结点，用n来累计数据节点的个数，n初始值为0；

int ListLength(LinkNode *L)
{
	int n = 0;
	LinkNode* p = L;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}

4.单链表的销毁

实现步骤：

1.  pre 和 p指向相邻的节点，初始pre 指向头结点，p指向首个数据节点。

2.p不为空时循环，释放pre节点，然后pre 和p 俩个节点后移。

3. 循环结束后pre指向尾节点，将其释放

代码：

/*【3】基本运算 ----销毁*/
void DestoryList(LinkNode*& L)
{
	LinkNode* pre = L;
	LinkNode* p = L->next;//pre指向p的前驱节点
	while (p != NULL)  //遍历单链表L
	{
		free(pre);//释放前驱节点
		pre = p;  //移动
		p = pre->next; 
	}
	free(pre);  //循环结束，p为NULLL,pre指向尾节点，释放它
}

5.单链表的插入

 给定单链表L ,在第i个位置插入节点s，值为e。

实现步骤：

1.在单链表L中找到第i-1个结点，由p指向他

2.若存在该结点，将值为e的s结点插入p节点的后面。

代码：

/*【7】基本运算 ----插入   在第i个位置前面插入节点， p指向第i-1个节点，将s节点插入p后面 */  
bool ListInsert(LinkNode*& L, int i, ElemType e)
{
	int j = 0;
	if (i <= 0)return false;
	LinkNode* s, * p=L;
	while (j < i-1 && p != NULL)//寻找i-1的节点，然后由p指向它
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//未找到·返回false
	{
		return  false;
	}
	else
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));
		s->data = e;
		s->next = p->next;//将新节点插入到p之后（i-1的节点）
		p->next = s;
		return true;
	}
}

6.单链表的查找

 6.1按序查找

实现步骤：

1. p指向头结点，用j来累计遍历过的数据结点的个数（初始值为0)，当j<i且不为空时循环：j增1,p指向下一个结点。

2. 循环结束后有两种情况，若为空，表示单链表L中没有第i个数据结点（参数i错误），返回false；否则找到第i个数据结点力，提取它的值并返回true。

代码：

/<2>按序号求线性表中的元素，给定单链表L,查找第i个节点的元素值，提取到e，存在返回true 否则返回false
bool GetElem(LinkNode* L, int i, ElemType& e)
{
	LinkNode* p = L;//p指向头结点i，j置为0，即头节点序号为0
	int j = 0;
	if (i < 0)return false;
	while (j < i && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//不存在第 i 个数据节点，返回false
	{
		return false;
	}
	else//存在，取值 并返回true
	{
		e = p->data;
		return true;
	}
}

6.2按值查找

 在单链表L中从头开始找到第一个值域为e的结点，找到返回逻辑序号，否则返回0

实现步骤： 

代码：

//<1>按元素查找节点的序号  给定单链表 L 查找值为e的节点的序号i，存在返回该序号，否则返回0
int  LocateElem(LinkNode* L, ElemType e)
{
	LinkNode* p = L->next;
	int n = 1;  //逻辑序号，首节点位置为1
	while (p->next != NULL && p->data != e)//查找该节点
	{
		n++;
		p = p->next;
	}
	if (p == NULL)//不存在元素为e的节点
	{
		return 0;
	}
	else   //存在，返回逻辑序号n
	{
		return n;
	}
}

7.单链表的删除元素

  给定单链表L，删除第i个节点，并将删除节点的值带回，p指向第i-1个节点,q为第i个节点，*/

实现步骤：

1.在单链表L中找到第i一1个结点，由p指向它。

2.若存在这样结点，且也存在后继结点（由q指向它），则删除通过结点pq所指的结点，返回true；否则回false,表示参数i错误。

代码：

/*【8】基本运算  ---- 删除  ，给定L，删除第i个节点，并将删除节点的值带回p指向第i-1个节点,q为第i个节点，*/
bool ListDelete(LinkNode*& L, int i, ElemType& e)
{
	int j = 0;
	LinkNode* q, * p = L;
	if (i <= 0)return false;
	while (j < i - 1 && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//没有找到第i-1个节点 返回false
	{
		return false;
	}
	else//找到第i-1和节点 ，进行删除操作
	{
		q = p->next;//q指向第i个节点
		if (q == NULL)return false;  //这个容易忽略，我们也因该判断第i个元素是否为空
		e = q->data;
		p->next = q->next;
		free(q);
		return true;
	}
}

全部代码：

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

typedef int ElemType;

typedef struct LNode
{
	ElemType data;//数据域
	struct LNode* next;//指针域
}LinkNode;

/*【1】整体建立单链表  给定数组a[n] */
//<1>头插法建立单链表
void CreateListF(LinkNode *&L,ElemType a[],int n)
{
	LinkNode * s;  //新节点
	L = (LinkNode*)malloc(sizeof(LinkNode));//创建头节点
	L->next = NULL;//头节点初始化

	for (int i = 0; i < n; i++)
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));//新节点创建
		s->data = a[i];// 初始化
		s->next = L->next;
		L->next = s;
	}
}
//<2>尾插法建立单链表
void CreateListR(LinkNode*& L, ElemType a[], int n)
{
	LinkNode* r, * s;//尾指针和新的节点指针
	L = (LinkNode*)malloc(sizeof(LinkNode));
	r = L;   //r始终指向尾节点，初始指向L
	for (int i = 0; i < n; i++)
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));//新节点创建和初始化
		s->data = a[i];
		r->next = s;//将节点s插入到r后面
		r = s;
	}
	r->next = NULL;  //尾节点的next域置为NULL
}
/*【2】基本运算 ----初始化*/
void  InitList(LinkNode*&L)
{
	L = (LinkNode*)malloc(sizeof(LinkNode));
	L->next = NULL;
}
/*【3】基本运算 ----销毁*/
void DestoryList(LinkNode*& L)
{
	LinkNode* pre = L;
	LinkNode* p = L->next;//pre指向p的前驱节点
	while (p != NULL)  //遍历单链表L
	{
		free(pre);//释放前驱节点
		pre = p;  //移动
		p = pre->next; 
	}
	free(pre);  //循环结束，p为NULLL,pre指向尾节点，释放它
}
/*【4】基本运算 ----求表的长度*/
int ListLength(LinkNode *L)
{
	int n = 0;
	LinkNode* p = L;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	return n;
}
/*【5】基本运算 ----输出线性表*/
void printLinkNode(LinkNode* L)
{
	LinkNode* p = L->next;//指向头节点的下一个节点，头节点不存放数据
	while (p!= NULL)
	{
		printf("%d->", p->data);
		p = p->next;
	}
	printf("end\n");
}
/*【6】基本运算 ----查找 */
//<1>按元素查找节点的序号  给定单链表 L 查找值为e的节点的序号i，存在返回该序号，否则返回0
int  LocateElem(LinkNode* L, ElemType e)
{
	LinkNode* p = L->next;
	int n = 1;  //逻辑序号，首节点位置为1
	while (p->next != NULL && p->data != e)//查找该节点
	{
		n++;
		p = p->next;
	}
	if (p == NULL)//不存在元素为e的节点
	{
		return 0;
	}
	else   //存在，返回逻辑序号n
	{
		return n;
	}
}
//<2>按序号求线性表中的元素，给定单链表L,查找第i个节点的元素值，提取到e，存在返回true 否则返回false
bool GetElem(LinkNode* L, int i, ElemType& e)
{
	LinkNode* p = L;//p指向头结点i，j置为0，即头节点序号为0
	int j = 0;
	if (i < 0)return false;
	while (j < i && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//不存在第 i 个数据节点，返回false
	{
		return false;
	}
	else//存在，取值 并返回true
	{
		e = p->data;
		return true;
	}
}
/*【7】基本运算 ----插入   在第i个位置前面插入节点， p指向第i-1个节点，将s节点插入p后面 */  
bool ListInsert(LinkNode*& L, int i, ElemType e)
{
	int j = 0;
	if (i <= 0)return false;
	LinkNode* s, * p=L;
	while (j < i-1 && p != NULL)//寻找i-1的节点，然后由p指向它
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//未找到·返回false
	{
		return  false;
	}
	else
	{
		s = (LinkNode*)malloc(sizeof(LinkNode));
		s->data = e;
		s->next = p->next;//将新节点插入到p之后（i-1的节点）
		p->next = s;
		return true;
	}
}
/*【8】基本运算  ---- 删除  ，给定L，删除第i个节点，并将删除节点的值带回p指向第i-1个节点,q为第i个节点，*/
bool ListDelete(LinkNode*& L, int i, ElemType& e)
{
	int j = 0;
	LinkNode* q, * p = L;
	if (i <= 0)return false;
	while (j < i - 1 && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)//没有找到第i-1个节点 返回false
	{
		return false;
	}
	else//找到第i-1和节点 ，进行删除操作
	{
		q = p->next;//q指向第i个节点
		if (q == NULL)return false;  //这个容易忽略，我们也因该判断第i个元素是否为空
		e = q->data;
		p->next = q->next;
		free(q);
		return true;
	}
}
int main()
{
	int a[5];
	int b[5] = { 1,2,3,4,5 };
	for (int i = 0; i < 5; i++)
	{
		scanf_s("%d", &a[i]);
	}

	//用数组创建单链表
	LinkNode * L1;
	LinkNode * L2;
	CreateListF(L1, a,5); //头插法
	CreateListR(L2, b,5);//尾插法
	printLinkNode(L1);//输出单链表
	printLinkNode(L2);//输出单链表


	//按值查找，返回序号
	printf("L2 's number 5 is in the %d position\n", LocateElem(L2, 5));
	printf("L2 's number 3 is in the %d position\n", LocateElem(L2, 3));
	//按序号查找元素值
	int e1, e2;
	if(GetElem(L1,5,e1))
	{
		printf("The value at the 5 position of the L1 is %d\n", e1);
	}
	if (GetElem(L1, 1, e2))
	{
		printf("The value at the 1 position of the L1 is %d\n", e2);
	}


	//插入元素,插入到第i 个位置
	ListInsert(L1,5,6);
	printLinkNode(L1);//输出单链表

	ListInsert(L2, 1, 2);
	printLinkNode(L2);//输出单链表
	//删除元素
	int e = 0;
	if (ListDelete(L1,5,e))
	{
		printf("删除成功，删除的值为%d\n",e);
	}
	else
	{
		printf("删除失败，节点不存在");
	}
	printLinkNode(L1);//输出单链表

	DestoryList(L1);
	DestoryList(L2);
	return 0;
}

结语： 

  单链表的实现，不仅是一次理论与实践的完美结合，更是一个程序员逻辑思维与动手能力的双重考验。通过对单链表的深入理解与实现，我们不仅掌握了数据结构的精髓，更在编程的道路上迈出了坚实的一步。未来，无论是面对复杂的数据处理，还是高效算法的设计，单链表都将成为我们手中得心应手的工具，助力我们在编程的世界里自由翱翔。

lancyu
关注
单链表的实现
编程入门指南
05-25 317
单链表的实现单链表基本概念单链表的实现基本结构初始化操作添加元素插入元素删除元素查找元素完整测试用例 单链表基本概念 单链表是一种单向的线性表,不需要连续的存储空间.插入删除操作不需要移动元素,只需要改变指针.但是访问元素不是随机的,必须从表头开始依次向后搜索.访问时间和访问位置有关. 单链表的实现 基本结构 typedef struct SeqList{ ElemType dat...
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
单项链表编程
谢文浩博客
08-04 266
单向链表编程思路： 1.创建一个链表，大小自定义 2.打印链表内容 3.删除指定节点 4.插入节点 5.释放链表 #include #include #include typedef int datatype; typedef struct node{         datatype data;         struct node
数据结构之单链表
最新发布
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-10 432
SListNode;
链表编程实战（一）：单链表
marc07的博客
03-17 653
笔者这几天都在学习链表知识，分别进行了单链表编程和双链表编程。本文仅用于笔者个人学习，如读者想具体了解链表，请参考其他作者。本文内容为本人单链表编程代码，下一篇文章为双链表编程。 ps:本文函数名使用中文拼音命名，仅用于方便个人学习，实际项目编程中请勿使用拼音命名方法。 链表编程学习：单链表 #include  #include  #include  更正说明：现在才发现博客会屏蔽一
编程实现单链表的排序
qinhan728的专栏
09-05 732
#include #include using namespace std; typedef struct student{ int data; struct student * next; } node; node* create() { node *head, *p, *s; int x, cycle = 1; head = (node *)malloc(sizeof(no
编程实现一个单链表的建立
Pollow_的博客
09-17 1143
typedef struct node { int data; node *next; } node; //单链表的创建 node *create() { int i = 0; //链表中数据的个数 node *head, *p,*P int...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
JAVA数据结构——单链表的操作.docx
07-11
单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在给定的文档中，主要介绍了如何在Java中实现单链表的操作。以下是详细的知识点解析： 1. **节点类(Node....
单链表——数据结构——cht讲算法.mp4
07-26
cht讲算法。 讲解单链表。 配套习题建议上acwing官网查看哦~~~~ 欢迎下载！ 免费，无需积分~
编程实现一个单链表及其功能
weixin_36722447的博客
03-21 236
node* create() { node *head = nullptr, *p = nullptr, *s = nullptr; int x, cycle = 1; head = (node*)malloc(sizeof(node)); if (nullptr != head) { p = head; } else { return head; } whil...
自主编程实现单链表
perfect-顾（coder）的博客
07-20 264
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结 点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单 元，指针就是连接每个结点的地址数据。       下面是实现单链表的编程代码： #include #include #define OK
编程_链表
JH0lmes的博客
09-22 257
从头到尾打印链表 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 Java /** * public class ListNode { * int val; * ListNode next = null; * * ListNode(int val) { * this.val = val; * ...
【链表】单链表的介绍和基本操作（C语言实现）【保姆级别详细教学】
后端开发为主+人工智能
11-21 6289
单链表的基本操作【超详细备注和解释】 先赞后看好习惯 打字不容易，这都是很用心做的，希望得到支持你 大家的点赞和支持对于我来说是一种非常重要的动力 看完之后别忘记关注我哦！️️️ 强烈建议本篇收藏后再食用 文章目录单链表基本介绍基本结构与顺序表的区别以及学习单链表的必要性单链表的实现结点的定义以及头指针的创建单链表的遍历（打印接口的实现）【重点】开辟结点接口尾插接口尾删接口头插接口头删结构查找接口在pos位置后插入结点删除pos位置后的结点思考测试代码和头文件代码完整展示test.cSList.h尾声
单链表的代码实现 C/C++
qq_43609939的博客
12-29 281
静态链表 #include<iostream> using namespace std; struct Node { int num; //数据域 struct Node *next; //指针域 该指针指向结构体类型 }; int main() { //创建三个结点 struct Node Node1 = { 1, ...
C语言编程练习之单链表基本操作
crus的博客
08-03 334
1.打印链表（PrintList） 2.建立链表（CreateList） 3.链表末尾插入节点（InsertList） 4.链表中删除指定节点（DeleteNode） 5.找链表中第一个出现的最小节点（FindMin） #include "stdio.h" typedef struct node { int data; struct node* ...
单链表的简单操作之输出
热门推荐
努力学习的大小宝
03-07 2万+
一、链表的输出 链表的输出就是一次输出链表中各个结点的数据或输出某个结点的数据。 输出单链表的程序设计思想如下： 定义一个结点结构体指针变量p 让p指向链表的第一个结点即头指针所指向的结点 使用当型循环，循环的条件是p所指向的结点成员point不是NULL，在循环体中执行的下面的操作： （1）输出指针变量p所指向结点的数据 （2）让指针变量p指向链表的下一个结点 ...
单链表基本操作的实现——输出
qq_57867712的博客
11-06 1246
//输出 void OutputList(LinkList &L) { LinkList p=L->next;//指向首元结点 while(p!=NULL)//当前结点不为空 { cout<<p->date<<endl;//输出当前结点数据 p=p->next;//P指向下一结点 } } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值