数据结构与算法----单链表

最新推荐文章于 2024-05-07 01:55:24 发布
最新推荐文章于 2024-05-07 01:55:24 发布
阅读量917 收藏 9
点赞数 30
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/watermelon_c/article/details/121707264
版权
本文详细介绍了单链表的基础操作，包括节点创建、链表打印、尾部插入和删除（包括尾插、尾删、头插、头删），以及查找与修改功能。通过实例演示了如何在C语言中实现这些关键功能，适合初学者和进阶者学习数据结构算法。
摘要由CSDN通过智能技术生成

数据结构与算法–单链表

文章目录


完整代码见文末

创建节点

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

为了方便表示，再给结构体定义新的类型名

typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SListNode;

上一个结点存着下一个结点的地址

在这里插入图片描述

为了方便理解，下面先从链表的打印进行理解

链表的打印

基本思路：

  1. 定义一个新的指针指向头结点

    SListNode* cur = phead;

    在这里插入图片描述

  2. 打印当前cur指向结点的数值

    printf("%d->", cur->data);

  3. 此时cur需要打印下个结点的数据，那么就需要得到下个结点的地址

    cur = cur->next;

    在这里插入图片描述

链表打印函数完整代码如下

void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;			//再定义一个指针指向头结点
	while (cur != NULL)
	{
		printf("%d->", cur->data);	//cur指向结构体中的数字域
		cur = cur->next;			//cur指向下一个结点
	}
    printf("NULL");
}

链表的插入

尾插：在最后一个结点的后面插入一个新的结点

在这里插入图片描述

基本思路：

  1. 找到链表中最后一个结点的地址

​ 当tail 指向的下一个结点的地址不为NULL时，则当前结点不是尾结点,当tail 指向的下一个结点的地址为NULL时,找到尾结点 ,此时的tail存有尾结点的地址

​ 在这里插入图片描述

​ 该部分代码

    SListNode* tail = phead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}

  1. 插入新的数据

    1. 申请一个新的结点

      	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
	{
		printf("申请结点失败\n");
		exit(-1);
	}

	newNode->data = x;
	newNode->next = NULL;

    2. 插入

      tail->next = newNode;

      在这里插入图片描述

尾插法完整代码如下

调用该函数时，由于值传递无法改变实参的值， 因此要进行址传递，因此传入的是指针的地址，要用二级指针**p进行接收,对二级指针解引用就可得到原指针。
在这里插入图片描述

void SListPushBack(SListNode* *pphead, SListDataType x)
{
	SListNode* tail = *pphead;

	if (*pphead == NULL)    //头结点为空的情况
	{
		SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
		if (newNode == NULL)
		{
			printf("申请结点失败\n");
			exit(-1);
		}
		newNode->data = x;
		newNode->next = NULL;

		*pphead = newNode;
	}
	else				//头结点不为空的情况
	{
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
		if (newNode == NULL)
		{
			printf("申请结点失败\n");
			exit(-1);
		}
		newNode->data = x;
		newNode->next = NULL;

		tail->next = newNode;
	}
}

实际上，if和else中申请结点的代码段是相同的，由于后面还会用到相同的代码段，因此可将这段代码做成函数

//新结点申请函数
SListNode* BuySListNode(SListDataType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
	{
		printf("申请结点失败\n");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;  //新结点指向NULL

	return newNode;
}

则尾插法的代码简化为

void SListPushBack(SListNode* *pphead, SListDataType x)//传入指针的地址
{
	SListNode* newNode = BuySListNode(x);  //申请结点

	if (*pphead == NULL)
	{
		*pphead = newNode;     //头结点即为新结点
	}
	else
	{
		//找尾
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newNode;
	}
}
尾删

分三种情况：

  1. 链表为空
  2. 只有一个节点
  3. 有一个以上结点

对于第三种情况，当把结点free掉后，该结点的前一个节点未能指向NULL，因此该节点还能被访问,造成错误，要解决这种情况，不仅要找到尾结点，还要找到尾结点的前一个结点，那就要再定义多一个指针，在对尾结点进行删除之前，用于保存tail的的前一个结点

在这里插入图片描述

尾删完整代码如下
void SListPopBack(SListNode** pphead)
{
	if (*pphead == NULL)	//链表为空
	{
		return;
	}
	else if((*pphead)->next==NULL)	//只有一个结点
	{
		free(*pphead);		//删除结点
		*pphead = NULL;		//头指针置空
	}
	else	//有一个以上结点
	{
		SListNode* prev = NULL;
		SListNode* tail = *pphead; //找尾
		while (tail->next != NULL)
		{
			prev = tail;       //用于保存tail指向的上一个结点
			tail = tail->next;
		}

		free(tail);
		prev->next = NULL;
	}
}
头插

基本思路：

  1. 开辟一个新节点并指向原来头节点的地址

  2. 再让头指针指向新的头结点

    在这里插入图片描述

头删

分类：

  1. 链表空

  2. 只有一个结点

  3. 一个以上结点

    当第一个结点的内存释放后，第二个结点的地址也就找不到了，此时头指针就无法指向第二个结点，因此要定义一个新的指针来事先保存第二个结点的地址

    在这里插入图片描述

头删完整代码如下
void SListPopFront(SListNode** pphead)
{
	//链表空
	if (*pphead == NULL)
	{
		return;
	}
	//只有一个结点和一个以上结点方法相同
	else
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead=next;
	}
}

查找&修改

SListNode* SListFind(SListNode* phead, SListDataType x)
{
	SListNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

查找到后，可对该值进行更改

SListNode* pList = NULL;

	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 3);
	SListPushBack(&pList, 4);
	SListPrint(pList);

SListNode* pos = SListFind(pList, 3);
	if (pos)
	{
		pos->data = 30;
	}
	SListPrint(pList);

在指定位置结点后面插入

例如在第二个结点后插入（pos=2)
基本思路

  1. 找到选定位置的结点

  2. 创建新结点

  3. 新结点先保存选定位置节点的下个结点的地址，选定位置结点再保存新结点的地址，顺序不能调换，否则新结点无法保存后面一个结点点的地址

    正确代码：

    newNode->next=pos->next;
pos->next=newNode;

    在这里插入图片描述

完整代码：
void SListInsertAfter(SListNode* pos, SListDataType x)
{
	assert(pos); //断言

	SListNode* newNode = BuySListNode(x);
	newNode->next = pos->next; //新结点指向后一个结点
	pos->next = newNode;		//前一个结点指向新结点
}

删除指定位置结点后面的一个结点

例如删除第二个结点(pos=1)：
基本思路

  1. 找到选定位置的结点

  2. 当前结点保存将要删除的结点后一个结点的地址

  3. 删除结点

    在这里插入图片描述

完整代码：
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	if (pos->next)  //要删除结点不为空
	{
		SListNode* next = pos->next; //pos的下一个结点
		SListNode* nextnext = next->next; //pos的下一个的下一个结点
		pos->next = nextnext;  //上面的定义只是为了方便理解，其实也可以直接写pos->next = pos->next->next
		free(next);
	}
}

单链表完整代码

SList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef int SListDataType;

//结点
typedef struct SListNode
{
	SListDataType data;
	struct SListNode* next;
}SListNode;

void SListPushBack(SListNode** pphead, SListDataType x);
void SListPopBack(SListNode** pphead);
void SListPushFront(SListNode** pphead, SListDataType x);
void SListPopFront(SListNode** pphead);
void SListInsertAfter(SListNode* pos, SListDataType x);
SListNode* SListFind(SListNode* phead, SListDataType x);
void SListPrint(SListNode* phead);
SListNode* BuySListNode(SListDataType x);

SList.c

#include "SList.h"

//申请结点
SListNode* BuySListNode(SListDataType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
	{
		printf("申请结点失败\n");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;  //新结点指向NULL

	return newNode;
}

//尾插
void SListPushBack(SListNode* *pphead, SListDataType x)//传入指针的地址
{
	SListNode* newNode = BuySListNode(x);  //申请结点

	if (*pphead == NULL)
	{
		*pphead = newNode;     //头结点即为新结点
	}
	else
	{
		//找尾
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newNode;
	}
}

//尾删
void SListPopBack(SListNode** pphead)
{
	if (*pphead == NULL)	//链表为空
	{
		return;
	}
	else if((*pphead)->next==NULL)	//只有一个结点
	{
		free(*pphead);		//删除结点
		*pphead = NULL;		//头指针置空
	}
	else	//有一个以上结点
	{
		SListNode* prev = NULL;
		SListNode* tail = *pphead; //找尾
		while (tail->next != NULL)
		{
			prev = tail;       //用于保存tail指向的上一个结点
			tail = tail->next;
		}

		free(tail);
		prev->next = NULL;
	}
}

//头插
void SListPushFront(SListNode** pphead,SListDataType x)
{
	SListNode* newNode = BuySListNode(x);
	newNode->next = *pphead;
	*pphead = newNode;	
}

//头删
void SListPopFront(SListNode** pphead)
{
	//链表空
	if (*pphead == NULL)
	{
		return;
	}
	//只有一个结点和一个以上结点方法相同
	else
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead=next;
	}
}

//查找
SListNode* SListFind(SListNode* phead, SListDataType x)
{
	SListNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

//在指定位置结点后面插入
void SListInsertAfter(SListNode* pos, SListDataType x)
{
	assert(pos);

	SListNode* newNode = BuySListNode(x);
	newNode->next = pos->next;
	pos->next = newNode;
}

//删除指定位置结点后面的一个结点
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	if (pos->next)  //要删除结点不为空
	{
		SListNode* next = pos->next; //pos的下一个结点
		SListNode* nextnext = next->next; //pos的下一个的下一个结点
		pos->next = nextnext;  //上面的定义只是为了方便理解，其实也可以直接写pos->next = pos->next->next
		free(next);
	}
}

//打印
void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;			//再定义一个指针指向头结点
	while (cur != NULL)
	{
		printf("%d->", cur->data);	//cur指向结构体中的数字域
		cur = cur->next;			//cur指向下一个结点
	}
	printf("NULL");
	printf("\n");
}

text.c

#include "SList.h"
void TestSList1()
{
	SListNode* pList = NULL;

	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 3);
	SListPushBack(&pList, 4);
	SListPrint(pList);

	SListPopBack(&pList);
	SListPopBack(&pList);
	SListPopBack(&pList);
	SListPopBack(&pList);
	SListPopBack(&pList);
	SListPrint(pList);

	SListPushFront(&pList, 1);
	SListPushFront(&pList, 2);
	SListPushFront(&pList, 3);
	SListPushFront(&pList, 4);
	SListPushFront(&pList, 5);
	SListPrint(pList);

	SListPopFront(&pList);
	SListPopFront(&pList);
	SListPopFront(&pList);
	SListPopFront(&pList);
	SListPopFront(&pList);
	SListPopFront(&pList);
	SListPrint(pList);

}

void TestSList2()
{
	SListNode* pList = NULL;

	SListPushBack(&pList, 1);
	SListPushBack(&pList, 2);
	SListPushBack(&pList, 3);
	SListPushBack(&pList, 4);
	SListPrint(pList);

	SListNode* pos = SListFind(pList, 3);
	if (pos)
	{
		pos->data = 30;
	}
	SListPrint(pList);
}

int main()
{
	TestSList1();
	TestSList2();

	return 0;
}
大拨鼠
关注
专栏目录
数据结构与算法---单链表
weixin_51451819的博客
08-16 247
单链表 单链表的逻辑结构： 单链表在内存中的存储： 小结： 1）链表是以结点的方式来存储，是链式存储 2）每个结点包括data域和next域（指向下一个结点） 3）链表的各个结点不一定是链式存储，逻辑结构上连续，物理结构上不一定连续 4）根据实际需求来确定链表是否需要头结点 单链表的创建和遍历 添加操作： // 添加结点到链表（直接添加到链表的最后） public void add(HeroNode heronode) { // 因为头结点不能动,辅助指针帮忙遍历 HeroN
数据结构与算法-单链表的排序
04-21
数据结构与算法-单链表的排序
数据结构与算法——单链表
程序员吴师兄的博客
06-17 701
点击蓝色“五分钟学算法”关注我哟加个“星标”，一起学算法1 数组1.1 数组含义 数组：相同元素构成有序的元素集合。数组中存储的元素类型是一致的，数组也是学习编程时最先接...
【数据结构与算法】深入理解 单链表
最新发布
2302_78391795的博客
05-07 1373
单链表是一种基本的线性数据结构，它通过链式存储方式而非连续的内存位置来存储元素。（逻辑上连续，物理上不一定连续）在单链表中，每个元素（或称为节点）包含两部分：数据域和指针域。 数据域用于存储实际的数据，而指针域则存储指向下一个节点的地址。 这样，每个节点都链接到列表中的下一个节点，形成一个链条。 本篇文章要介绍的是无头结点，单向，不循环链表，即通常我们所熟知单链表，以下如无特殊说明，均代表此含义。
数据结构与算法之单链表
hcyxsh的博客
02-25 561
数据结构与算法之单链表 1、链表介绍 链表是有序的列表，但是它在内存中是存储如下 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 （1） 第一种
数据结构和算法-单链表
weixin_49429082的博客
12-05 197
单链表及其应用
数据结构与算法-单链表的创建与操作
04-21
单链表的所有操作都有，文件里有两个头文件，一个cpp文件（运行时记得将最底下两个h文件单独拿出来）,非常整齐，说明也十分详细！
数据结构与算法--单链表
m0_49513457的博客
04-21 107
数据结构与算法--单链表单链表:代码 单链表: 链表是以节点（对象）的方式来存储，是链式存储 每个节点包含data 域 ，next 域 ：指向下一个节点 链表的各个节点不一定是连续存储， 链表分 有 带头节点的链表 和 没有带头节点的链表，根据实际的需求来确定 代码 /* * 单链表：是以对象存储的。对象链式存储： * 有头节点：add() 里面由一个不能移动的头节点带头， 添加新节点，经过一个辅助节点（temp = head）的next 连接新的节点， * 然后辅助节点temp往后移动（tem
数据结构与算法~数据结构之单链表
yucan1234的博客
09-20 108
总结下来主要的难度是确定当前的是否是最后一个元素，很多时候要将这种情况区分开来处理，有点麻烦。 其实链表的处理自我感觉还是比较简单的 public class test { public static void main(String[] args){ SingleLinkedListHead head=new SingleLinkedListHead(); head.add( new StudentNode( 1,"张三" ) ); head
数据结构与算法(C)—单链表
liyuewuwunaile的博客
07-28 231
数据结构与算法—链表
数据结构与算法 :单链表
weixin_47769332的博客
08-27 326
数据结构与算法 :单链表 1.单链表的概念 链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 2.结构 每个结点包含data域，next域。 ┌───┬───┐ │data │next │ └───┴───┘ data域–存放结点值的数据域 next域–存放结点的直接后继的地址（位置）的指针域（链域） 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的，每个结点只有一个链域的链表
数据结构与算法 _ 单链表
qq_41764645的博客
11-01 259
一、线性表和单链表的关系 1、线性表 线性表是信息表的一种形式，表中数据元素之间满足线性关系（或线性结构），是一种最基本、最简单的数据结构类型。 线性表的定义及运算： 线性表的定义是描述其逻辑结构，而运算是讨论在线性表上进行的查找、插入、删除等操作。 定义：线性表（Linear List）是包含若干数据元素的一个线性序列，记为：L=(...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、删除、查找等基本操作。
数据结构与算法-单链表
nameofworld的博客
05-01 897
本文包括单链表的添加删除修改链表（Linked List）链表是有序列表，但在内存中存储情况如下比如这里的头指针是150，我们就找到地址为150的这行，即data域是a1，它的next域是110，那么就指向地址为110的这行，它的data域是a2，next域是180，那么就指向地址为180的这行，data域是a3.以此类推。它的每个节点并不是连续存储的。就是地址不是连续的。
评论 29
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大拨鼠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值