单链表的简单操作

最新推荐文章于 2023-10-15 16:16:56 发布
最新推荐文章于 2023-10-15 16:16:56 发布
阅读量118 收藏
点赞数 2
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66054454/article/details/128765493
版权

目录

单链表介绍

代码实现

1.头文件内容

2.函数具体操作

1.打印

2.申请节点

3.尾插

4.头插

5.头删

6.尾删

7.查找

8.插入

9.删除

10.销毁 

全部代码实现

单链表介绍

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

单链表主要就是逻辑结构和物理结构

 每一个节点都是一个结构体，存放的是一个值和一个地址，这个值由自己决定，地址存放的是下一个节点的地址或者是NULL，这样就可以将一个个单独的节点结构体通过结构体嵌套的方式来链接起来，构成单链表。物理结构可以更加直观的表示其结构。

图1(逻辑结构)

 

图2(物理结构)

代码实现

1.头文件内容

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

typedef int SLTDataType;   //重命名数据类型，方便修改
 
typedef struct SLTNode     //重命名节点类型
{
	SLTDataType data;
	struct SLTNode* next; //结构体的嵌套使得链表链接
}SLTNode;

//打印
void SListPrint(SLTNode* phead);

//申请节点
SLTNode* BuyListNode(SLTDataType x);

//尾插
void SListPushBack(SLTNode** pphead,SLTDataType x);

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);

//头删
void SListPopFront(SLTNode** pphead);

//尾删
void SListPopBack(SLTNode** phead);

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos,SLTDataType x);

//删除
void SListErase(SLTNode** pphead, SLTNode* pos);

//销毁
void SListDestory(SLTNode** pphead);

2.函数具体操作

  对于有些函数例如这里的插入需要传二级指针，原因是形参是实参的拷贝，因为参数和函数主体中都是一级指针所以改变之后到了main函数中是没有用的，就像交换两个值需要传一级指针是一样的，但是这里的已经是一级指针实现函数了，所以传参需要用二级指针，也需要用二级指针来接收。

1.打印

SList.h

void SListPrint(SLTNode* phead);

SList.c

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead; //创建一个结构体指针和头节点指向内容一样
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next; //对整个链表遍历
	}
	printf("NULL\n");
}

2.申请节点

SList.h

SLTNode* BuyListNode(SLTDataType x);

SList.c

SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//动态内存申请一个结构体节点
	newnode->data = x;    //data值为x
	newnode->next = NULL; //next先置为NULL
	return newnode;
}

3.尾插

SList.h

void SListPushBack(SLTNode** pphead, SLTDataType x);

SList.c

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead!=NULL);//断言判断pphead

	SLTNode* newnode = BuyListNode(x); //申请一个节点
	if (*pphead == NULL)  //判断链表是否为空，插入方式就不同
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;  //遍历尾节点
		}
		tail->next = newnode;
	}
}

4.头插

SList.h

void SListPushFront(SLTNode** pphead, SLTDataType x);

SList.c

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);//申请节点
	newnode->next = *pphead;
	*pphead = newnode;
}

5.头删

SList.h

void SListPopFront(SLTNode** pphead);

SList.c

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	SLTNode* next = (*pphead)->next; //这里*和->都是解引用操作，需要用括号确定优先级
	free(*pphead);
	*pphead = next;
}

6.尾删

SList.h

void SListPopBack(SLTNode** pphead);

SList.c

void SListPopBack(SLTNode** pphead)
{
	assert(*pphead != NULL);
	if ((*pphead)->next == NULL) //判断是否是一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else // 两个节点以上的情况
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

test.c

//头插尾插 头删尾删
void Test1()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPrint(plist);
}
int main()
{
	Test1();
	return 0;
}

运行结果

 

7.查找

SList.h

SLTNode* SListFind(SLTNode* phead, SLTDataType x);

SList.c

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

test.c

void Test2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 3); //查找值为3的节点
	int i = 1;
	while (pos) //可以将链表中的3都找到，并且打印出来
	{
		printf("第%d个pos节点：%p->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 3);
	}

	//修改
	pos = SListFind(plist, 2);
	if (pos)
	{
		pos->data = 20;  //先用查找函数找到这个值在将其data值改为要修改的值
	}
	SListPrint(plist);
}

8.插入

SList.h

//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

SList.c

//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	//链表为空相当于头插
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//先要找到pos的前一个位置
		SLTNode* posPrew = *pphead;
		while (posPrew->next != pos)
		{
			posPrew = posPrew->next;//通过pos前一个位置posPrew来实现对pos位置的操作
		}
		posPrew->next = newnode;
		newnode->next = pos;
	}
}

test.c

void Test3()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist,2);
	if (pos)
	{
		SListInsert(&plist, pos, 10);
	}
	SListPrint(plist);

9.删除

SList.h

void SListErase(SLTNode** pphead, SLTNode* pos);

SList.c

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	if (*pphead = pos)  //这里判断如果只有一个节点的一种情况
	{
		*pphead = pos->next;
		free(pos);
		pos = NULL;
	}
	else
	{
		SLTNode* prev = *pphead; //找到pos前面的一个节点来对pos实现删除
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

test.c

void Test3()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist,2);
	if (pos)
	{
		SListInsert(&plist, pos, 10);
	}
	SListPrint(plist);

	SListErase(&plist, plist);
	SListPrint(plist);
}
int main()
{
	Test1();
	//Test2();
	//Test3();
	return 0;
}

插入删除的运行结果

10.销毁 

SList.h

void SListDestory(SLTNode** pphead);

SList.c

void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

全部代码实现

SList.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLTDataType;
 
typedef struct SLTNode
{
	SLTDataType data;
	struct SLTNode* next;
}SLTNode;

//打印
void SListPrint(SLTNode* phead);

//申请节点
SLTNode* BuyListNode(SLTDataType x);

//尾插
void SListPushBack(SLTNode** pphead,SLTDataType x);

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);

//头删
void SListPopFront(SLTNode** pphead);

//尾删
void SListPopBack(SLTNode** phead);

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos,SLTDataType x);

//删除
void SListErase(SLTNode** pphead, SLTNode* pos);

//销毁
void SListDestory(SLTNode** pphead);

 

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//打印
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//申请节点
SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead!=NULL);

	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//头插
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

//头删
void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}


//尾删
void SListPopBack(SLTNode** pphead)
{
	assert(*pphead != NULL);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	//链表为空相当于头插
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//先要找到pos的前一个位置
		SLTNode* posPrew = *pphead;
		while (posPrew->next != pos)
		{
			posPrew = posPrew->next;
		}
		posPrew->next = newnode;
		newnode->next = pos;
	}
}

//删除
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	if (*pphead = pos)
	{
		*pphead = pos->next;
		free(pos);
		pos = NULL;
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//销毁
void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

 

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//头插尾插 头删尾删
void Test1()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPrint(plist);
}

//查找 修改
void Test2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 3);
	int i = 1;
	while (pos)
	{
		printf("第%d个pos节点：%p->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 3);
	}

	//修改
	pos = SListFind(plist, 2);
	if (pos)
	{
		pos->data = 20;
	}
	SListPrint(plist);
}

//插入 删除
void Test3()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist,2);
	if (pos)
	{
		SListInsert(&plist, pos, 10);
	}
	SListPrint(plist);

	SListErase(&plist, plist);
	SListPrint(plist);
}
int main()
{
	//Test1();
	//Test2();
	Test3();
	return 0;
}

 

hhhc.
关注
C语言单链表，能直接运行的代码！
weixin_43213137的博客
03-20 641
C语言单链表，实现增删改查 不废话 直接上代码，COPY就能运行 #include <stdio.h> #include <stdlib.h> /** *定义数据元素 */ typedef struct{ int id; char * name; char * gender; int age; }ElemType; typedef str...
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
以下是一个简单的单链表节点类和链表类的实现： ```java public class ListNode { int val; // 节点值 ListNode next; // 指向下一个节点的引用 ListNode(int x) { val = x; } // 构造函数 } public class ...
单链表的基本操作
weixin_45646463的博客
12-22 412
一、向链表中插入数据 首先先创建一个节点，判断头节点是否为空，如果为空的话就将将新节点付给头节点，如果不为空的话遍历找出尾节点，将新节点赋给为节点的后继节点。 public class Node { Node next = null; int data; public Node(int data) { this.data = data; } } *****************...
实验报告 基于C语言的数据结构单链表的操作（含完整代码运行截图）
weixin_47758084的博客
03-25 2310
②链式存储，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针，相较于顺序存储，插入或删除元素时很方便，使用灵活。（7）编写查找函数int ListLocate(ListItem x,List L)，该函数在链表中查找值为x的元素，没找到返回0，否则返回对应位置。（4）编写删除函数ListItem ListDelete(int k,List L)，实现在单链表L中删除位置k处的元素。typedef struct llist{/* 单链表类型 */
单链表的基本操作及实现详解
ENSHADOWER的博客
10-01 2783
链表是最基本的线性数据结构之一，单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。  一、单链表的概述     1.单链表的分类           单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。           单链表分为两种：无头单链表和有头单链表。        ...
JAVA单链表的简单操作（递增单链表插入数据，链表逆置，链表逆序合成）
12-21
本文主要探讨了在单链表中执行三个基本操作：有序插入、链表逆置以及两个有序链表的合并。 1. **有序插入**： 给定一个按整数值递增排序的带头结点的动态单链表L，我们需要在链表中插入值为x的结点，保持链表的...
Java单链表基本操作的实现
09-02
本篇文章将深入探讨Java中的单链表及其基本操作的实现。单链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的引用。 在Java中，我们可以创建一个`Node`类来表示链表中的节点。每个...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
基于Java实现的单链表基本操作之链表分割.zip
04-26
单链表是一种简单但非常重要的线性数据结构，其中每个元素（称为节点）包含数据以及指向下一个节点的引用。本篇文章将深入探讨如何在Java中实现单链表的基本操作，特别是链表的分割。 首先，我们需要理解单链表的...
单链表的插入操作 为啥运行不了啊？？？
weixin_41861062的博客
03-18 327
#include &lt;iostream&gt;using namespace std;struct Node{ int data; struct Node *next;};int main(){ Node *L = { NULL }; int n; cin &gt;&gt; n; L-&gt;next = NULL; for (int i = 0; i &lt; n; i++) { Node...
【数据结构】单链表的基本操作
qq_45004609的博客
10-17 358
以链式结构存储的线性表称为链表； 链式存储结构是用一组任意的存储单元来存储线性表的结点； 在链式存储结构中，存储单元可以是相邻的，也可以是不相邻的 相邻的存储单元中的数据不一定是相邻的结点 单链表的结点结构：结点之间的逻辑关系是由结点中的指针指示的（如图） 单链表的优缺点 单链表(链式存储)：每个结点除了存放数据元素外，还要存储指向下一个节点的指针 优点：不要求大片连续空间，改变容量方便 缺点：不可随机存取，要耗费一定空间存放指针 单链表的基本操作—头插法 代码部分 #include<st
数据结构之链表 - 超详细的教程，手把手教你认识并运用链表
ミカミミミ博客
09-03 4176
数据结构之链表 - 超详细的教程，手把手教你认识并运用链表！
单链表的操作（超详细），保证你看完不后悔
热门推荐
princekin
04-22 3万+
编程实现单链表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
单链表的创建及相关操作——入门级
qq_21493707的博客
03-14 1400
本文我们将学习单链表的创建以及相关操作。使用c语言实现，结尾有全部代码。 （仅供正在学习的朋友参考，如有错误的地方，欢迎评论指出。）
数据结构实验报告二__单链表的基本操作__学生管理系统（单链表版）
VLOKL的博客
03-28 4498
数据结构实验报告（单链表的基本操作）（学生管理系统）（单链表版）
数据结构实验之单链表----单链表的基本操作
2201_75867204的博客
08-22 2452
单链表
链表入门：“单链表“的基本操作详解(C语言)
Mzyh的博客
10-15 5331
使用C语言编写代码，实现数据结构中单链表的各种操作，动画演示，详细分析代码。
链表的基本操作
eminemi的博客
07-13 7333
链表的基本操作包括建立（批量存入数据）、打印（输出所有数据）、删除（在批量数据中删除指定数据）、插入（在批量数据中添加一个数据）等。
C语言实现单链表基本操作
"这篇资源是关于单链表的基础操作实现，包括插入、查找、删除和创建等关键功能。代码经过验证可以正常运行。" 在计算机科学中，链表是一种线性数据结构，其中的元素不按顺序存储在内存中，而是通过指针链接。单链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值