单链表的应用（附代码）

最新推荐文章于 2024-08-02 17:06:55 发布
最新推荐文章于 2024-08-02 17:06:55 发布
阅读量424 收藏 6
点赞数 4
分类专栏： 暑期数据结构训练 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63074244/article/details/140412639
版权

链表

链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。其实链表可以想象为小火车，链表比顺序表具有更好的灵活性，只需要通过指针的改变就可以实现增删查改。

这是逻辑思维下链表的样子

代码构造：

struct SListNode
{
int data; //结点数据
struct SListNode* next; //指针变量⽤保存下⼀个结点的地址
};

节点

与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/结点”结点的组成主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。

具体分析

实现链表功能的几个步骤：申请新的节点，头插或者尾插，头删尾删，找到指定的节点，插入到指定位置的前一个或者后一个，最后销毁链表。

此处我们代码中会出现形参实参的传地址的调用，为了便于理解特意附了一个图片进行理解

传址调用实参形参示意图

 

申请节点：

slist* slistnewnode(typedata x)
{
	slist* node = (slist*)malloc(sizeof(slist));
	if (node == NULL)
	{
		perror("fail!!!");
		exit(1);
	}
	node->data = x;
	node->next = NULL;
	return node;
}

头插尾插：

//头插
void slistfrondpush(slist** s1, typedata x)
{
	//sl不能为空如果为空*s1无法解引用
	assert(s1);
	slist *newnode=slistnewnode(x);
	newnode->next = *s1;
	*s1 = newnode;
}
//尾插
void slistbackpush(slist** s1, typedata x)
{
	//尾插要考虑是这个链表是否为空
	//不为空要找到末尾元素
	assert(s1);
	slist* newnode = slistnewnode(x);
	if (*s1 == NULL)
	{
		*s1 = newnode;
	}
	else
	{
		slist* pcur = *s1;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}
头插示意图
尾插示意图

 尾插：要注意一点传入时，节点为空那就是尾插，不为空时寻找尾节点就行，然后进行插入。

头删尾删：

//尾删除
void slistbackpop(slist** sl)
{
	assert(sl && *sl);
	//当只有一个节点时的情况，第二种就是找到末尾的前一个位置
	slist* pcur=NULL;
	slist* next = *sl;
	if ((*sl)->next == NULL)
	{
		free(*sl);
		*sl = NULL;
	}
	else
	{
		while (next->next)
		{
			pcur = next;
			next = next->next;
		}
		pcur->next = NULL;
		free(next);
		next = NULL;
	}
}

 

找到指定的节点：

slist* slistfind(slist* sl, typedata x)
{
	assert(sl);
	slist* pcur = sl;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

 指定位置之前，之后插入

//在指定位置之前插入
void slistInter(slist** s1, slist* pos, typedata x)
{
	assert(s1);
	assert(pos);
	//当只有一个节点的时候此时在指定位置之前插入其实就是头插
	if (*s1 == pos)
	{
		slistfrondpush(s1, x);
	}
	else
	{
		slist* newnode = slistnewnode(x);
		slist* prev = *s1;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;

	}
	
}
//指定位置后插入元素
void slistInterafter(slist* pos, typedata x)
{
	assert(pos);
		slist* newnode = slistnewnode(x);
		newnode->next = pos->next;
		pos->next = newnode;
}

 

 删除pos后的节点

void slistEraseAfter(slist * pos)
{
		assert(pos && pos->next);
		slist* del = pos->next;
		pos->next = pos->next->next;
		free(del);
		del = NULL;
}

 

销毁链表：

void slistDestory(slist** s1)
{
	assert(s1 && *s1);
	slist* pcur = *s1;
	while (pcur)
	{
		slist* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*s1 = NULL;
}

代码展示

slist.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int typedata;
typedef struct slist
{
	typedata data;
	struct slist* next;
}slist;

//链表打印
void slistPrint(slist*sl);
//此处传参是用的二级指针;传值调用形参的改变不会影响实参
// s1-->&s
// *s1-->s
//链表的销毁
void slistDestory(slist** s1);
//节点的申请
slist * slistnewnode(typedata x);
//插入，尾插头插
void slistfrondpush(slist** s1, typedata x);
void slistbackpush(slist** s1, typedata x);
//删除，头删尾删
void slistfrondpop(slist** sl);
void slistbackdpop(slist** sl);
//查找元素
slist* slistfind(slist* sl, typedata x);
//指定位置前插入元素
void slistInter(slist** s1, slist* pos, typedata x);
//指定位置后插入元素
void slistInterafter(slist** s1, slist* pos, typedata x);
//删除pos节点
void slistErase(slist** sl, slist* pos);
//删除pos之后的节点
//void slistEraseAfter( slist* pos);

slist.c

#include"Slist.h"
void slistPrint(slist* sl)
{
	slist* pcur = sl;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
//
void slistDestory(slist** s1)
{
	assert(s1 && *s1);
	slist* pcur = *s1;
	while (pcur)
	{
		slist* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*s1 = NULL;
}
//实现插入的时候首先要申请一个节点
slist* slistnewnode(typedata x)
{
	slist* node = (slist*)malloc(sizeof(slist));
	if (node == NULL)
	{
		perror("fail!!!");
		exit(1);
	}
	node->data = x;
	node->next = NULL;
	return node;
}
void slistfrondpush(slist** s1, typedata x)
{
	//sl不能为空如果为空*s1无法解引用
	assert(s1);
	slist *newnode=slistnewnode(x);
	newnode->next = *s1;
	*s1 = newnode;
}
void slistbackpush(slist** s1, typedata x)
{
	//尾插要考虑是这个链表是否为空
	//不为空要找到末尾元素
	assert(s1);
	slist* newnode = slistnewnode(x);
	if (*s1 == NULL)
	{
		*s1 = newnode;
		
	}
	else
	{
		slist* pcur = *s1;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}
//头删，要考虑只有一个节点是的情况
void slistfrondpop(slist** sl)
{
	//头删要保证不能是一个空链表
	assert(sl && *sl);
	slist* next = (*sl)->next;
	free(*sl);
	*sl = next;
}
//尾删除
void slistbackpop(slist** sl)
{
	assert(sl && *sl);
	//当只有一个节点时的情况，第二种就是找到末尾的前一个位置
	slist* pcur=NULL;
	slist* next = *sl;
	if ((*sl)->next == NULL)
	{
		free(*sl);
		*sl = NULL;

	}
	else
	{
		while (next->next)
		{
			pcur = next;
			next = next->next;
		}
		pcur->next = NULL;
		free(next);
		next = NULL;
	}
}
//查找元素
slist* slistfind(slist* sl, typedata x)
{
	assert(sl);
	slist* pcur = sl;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
//在指定位置之前插入
void slistInter(slist** s1, slist* pos, typedata x)
{
	assert(s1);
	assert(pos);
	
	//当只有一个节点的时候此时在指定位置之前插入其实就是头插
	if (*s1 == pos)
	{
		slistfrondpush(s1, x);
	}
	else
	{
		slist* newnode = slistnewnode(x);
		slist* prev = *s1;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;

	}
	
}
//指定位置后插入元素
void slistInterafter(slist** s1, slist* pos, typedata x)
{
	assert(s1);
	assert(pos);

	//当只有一个节点的时候此时在指定位置之前插入其实就是头插
	if (*s1 == pos)
	{
		slistbackpush(s1, x);
	}
	else
	{
		slist* newnode = slistnewnode(x);
		slist* prev = *s1;
		while (prev!= pos)
		{
			prev = prev->next;
		}
		newnode->next = pos->next;
		prev->next = newnode;
	}
}
//删除pos节点
void slistErase(slist** sl, slist* pos)
{
	assert(sl && *sl);
	assert(pos);
	
	if (pos == *sl)
	{
		slistfrondpop(sl);
	}
	else 
	{
		slist* prev = *sl;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的节点
void slistEraseAfter(slist * pos)
{
		assert(pos && pos->next);
		slist* dl = pos->next;
		pos->next = pos->next->next;
		free(dl);
		dl = NULL;
}

test.c

#include"Slist.h"
void test01()
{
	slist *s=NULL;
	//*s第一个节点
	//s指向第一个节点的指针
	//&s指向第一个节点的指针的地址
	slistfrondpush(&s, 1);
	slistbackpush(&s, 2);
	slistbackpush(&s, 3);
	slistbackpush(&s, 4);
	slistbackpush(&s, 5);
	slistfrondpop(&s);
	
	slistbackpop(&s);
	
	
	slist *find=slistfind(s, 4);
	if (find == NULL)
	{
		printf("未找到！\n");
	}
	else
	{
		printf("找到了！\n");
	}
	slistInter(&s, find, 6);
	slistInterafter(&s, find, 6);
	slistPrint(s);
	slistErase(&s, find);
	//删除pos之后的节点
	slistEraseAfter(find);
	slistPrint(s);
	slistDestory(&s);
	
}
int main()
{
	test01();
	return 0;
}

总结

以上就是单链表所实现的功能，如有不全期待各位大佬的积极指正，最后期待各位大佬能留下一个三连支持博主一下。

菜菜想进步
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表操作实现getelem_获取单链表中的指定位置的元素
weixin_39637545的博客
12-20 4196
单链表作为一种数据结构，存取数据是其很基本的操作。今天我们来看一下，如何获取单链表指定位置的元素。在线性表的顺序存储结构中，我们要计算任意一个元素的存储位置是很容易的。因为线性表的顺序存储就是个数组嘛，比如要获取第5个元素，可以直接a[5]就行了。但是单链表就有点不一样，他不是简单的数组。在单链表中，由于第i个元素到底在哪是没办法一开始就知道，必须得从头开始找。我们可以先设计一下单链表实现获取第i...
数据结构课件附代码.zip
04-20
本压缩包"数据结构课件附代码.zip"提供了全面的学习资源，非常适合大学生以及准备面试和考研的人士进行学习。 1. **数据结构基础概念**：数据结构不仅仅是关于数据的存储，它还包括对这些数据的操作和访问策略。...
基于C语言实现单链表（附有两份完整的详细代码+仿真结果）
m0_66360845的博客
02-24 1075
链表是同数据类型的集合，不占用连续内存空间。适合分类存放空间上不连续但需要大量的连续存储空间（类似档案馆），缺点就是检索速度慢且耗费的时间不固定。本文以单链表来说明链表的使用，包括创建链表表头、创建节点、指定位置删除节点、遍历打印节点、头插法插入节点、尾插法插入节点的使用。
手撕数据结构01--单链表（附源码）
weixin_64593595的博客
07-22 1306
针对链表的各个方法做了全面的剖析
08_栈（附数组及单链表的java代码实现）
jrrhjww的博客
10-08 108
08_栈 一、问题引入 请输入一个表达式 计算式：[7x2x2-5+1-5+3-3]，点击计算（如图所示） 请问：计算机底层是如何运算得到结果的?注意不是简单的把算式列出运算,因为我们看这个算式7x2x2-5+1-5+3-3，但是计算机怎么理解这个算式的(对计算机而 言，它接收到的就是一个字符串)，我们讨论的就是这个问题 --> 栈 二、栈的介绍 ​ 1）栈的英文为(stack)； ​ 2）栈是一个先入后出(FILO-First In Last Out)的有序列表； ​ 3）栈(stack)是限制线
单链表|附完整源码—c语言版
fight_for1的博客
04-20 452
我们都知道数组在内存中是连续存储的，顺序表就是由链表存储的，它有一个其他数据结构都没有的优点——支持随机访问（就是利用下标访问元素），这可以让其支持一些排序算法的操作。但是顺序表也有一些如下缺点：1. 中间/头部的插入删除，时间复杂度为O(N)2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
C++线性表（单链表）的应用算法（附源码）
小张与BUG
11-03 3548
C++线性表（单链表）的应用算法 线性表（单链表）的应用算法： 构造一个递增有序的正整数链表，实现链表分解为一个奇数表和一个偶数表，之后再将两个链表合并一个递减链表。 运行截图 代码实现 /* 线性表（单链表）的应用算法： 构造一个递增有序的正整数链表，实现链表分解为一个奇数表和一个偶数表，之后再将两个链表合并一个递减链表。 */ #include <stdio.h> #include <stdlib.h> #include <string.h> struct S
C语言单链表详解（附加强练习）
mc10141222的博客
12-23 1205
c语言的单链表画图理解起来很简单，但是新手往往在代码实现这一块会卡很久，今天系统地整理了单链表基础操作的知识，记下这一篇笔记希望能够对刚开始学链表的人起到一些帮助。
数据结构之线性表(附代码)
2401_84048621的博客
04-21 969
int e = -1;//用变量e吧删除的元素带回来cout
数据结构之线性表（附代码）
热门推荐
千寻瀑
04-22 1万+
白话+图解 数据结构 之 线性表线性表思维导图:线性表定义（逻辑结构）：线性表的基本操作原型（严蔚敏版）：顺序表1、顺序表思维导图:2.顺序表的逻辑结构：3、顺序表基本操作的功能实现：1.线性表的静态定义：2.线性表的动态定义：3. 线性表的静态初始化：4. 线性表的动态初始化：5. 线性表的插入：6. 线性表的删除：7. 线性表的按位查找：8. 线性表的按值查找：4.顺序表的特点和优点：链表：1...
严蔚敏数据结构C语言版附源代码
05-12
1. **线性结构**：数组、链表（单链表、双向链表）、栈、队列。 2. **树形结构**：二叉树、平衡树（AVL树、红黑树）、堆（最大堆、最小堆）。 3. **图**：图的表示（邻接矩阵、邻接表）、图的遍历（深度优先搜索、...
约瑟夫环课程设计报告
01-10
需求分析阶段，明确了任务目标是通过建立单链表并将其转化为循环链表来模拟约瑟夫环问题。具体步骤包括： - 创建链表节点，存储用户输入的编号和密码。 - 使用循环语句输入每个人的密码，并与编号关联。 - 将链表...
职工工资管理系统 数据结构课程设计（源代码附实验报告）
09-10
总的来说，这个职工工资管理系统课程设计不仅涵盖了数据结构的基本应用，也体现了C++面向对象编程的精髓。通过实际项目，学生可以加深对理论知识的理解，提升编程技能，为未来从事软件开发工作打下坚实基础。
清华数据结构课件（附代码与答案）
04-18
压缩包中的代码实现和答案部分将帮助学习者更直观地理解这些理论知识，通过实例学习如何在编程语言中应用数据结构。这不仅可以加深对概念的理解，还能提高实际编程能力。对于每个数据结构和算法，都应有对应的代码...
数据结构与算法--栈
wumingzei的博客
08-02 738
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。允许插入和删除运算的一端称为栈顶（top），不允许插入和删除的另一端称为栈底（bottom）。在栈顶进行的插入操作称为入栈或进栈(push),在栈顶进行的删除操作称为出栈或退栈(pop)特点：后进先出（LIFO, Last In First Out）。栈的后进先出特性。顺序栈和链栈的入栈、出栈操作。栈在中缀表达式转换为后缀表达式中的应用。
数据结构(7):查找
qq_64279967的博客
07-31 243
适用于线性表！适用于 有序的顺序表！就是 二分法！mid的值算出来如果是小数 就向下取整！大多时候是高的但不是全部插入一个元素8会导致所有的元素向后移动！代价太大 所以可以用链式存储！数据结构应该怎末设计？因该采取什么样的查找算法 都是需要大家按照现实遇到的需求做下的决定！！！中序遍历就是 左中右！可以写出递增的序列！
【数据结构】——链式二叉树
最新发布
2402_82668782的博客
08-02 663
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 167
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
单链表应用实例代码C语言
03-25
以下是一个简单的单链表的应用实例代码，使用C语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct Node { int data; struct Node* next; } node; // 创建新节点 node* create_node(int data) { node* new = (node*)malloc(sizeof(node)); new->data = data; new->next = NULL; return new; } // 在链表末尾插入节点 void insert_node(node** head, int data) { node* new = create_node(data); if (*head == NULL) { *head = new; return; } node* current = *head; while (current->next != NULL) { current = current->next; } current->next = new; } // 删除指定值的节点 void delete_node(node** head, int data) { if (*head == NULL) { return; } if ((*head)->data == data) { node* temp = *head; *head = (*head)->next; free(temp); return; } node* current = *head; while (current->next != NULL && current->next->data != data) { current = current->next; } if (current->next != NULL) { node* temp = current->next; current->next = current->next->next; free(temp); } } // 打印链表 void print_list(node* head) { printf("Linked List: "); while (head != NULL) { printf("%d ", head->data); head = head->next; } printf("\n"); } int main() { node* head = NULL; insert_node(&head, 1); insert_node(&head, 2); insert_node(&head, 3); insert_node(&head, 4); insert_node(&head, 5); print_list(head); delete_node(&head, 3); print_list(head); delete_node(&head, 1); print_list(head); return 0; } ``` 该代码实现了一个单链表的基本操作，包括创建节点、在末尾插入节点、删除指定值的节点和打印链表。可以通过在 `main` 函数中调用这些函数来使用这个单链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值