数据结构 -＞链表（C语言实现）

最新推荐文章于 2022-06-02 07:02:43 发布
最新推荐文章于 2022-06-02 07:02:43 发布
阅读量584 收藏 10
点赞数 10
分类专栏： 初阶数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58666778/article/details/121383385
版权


链表的概念

1.官方的概念
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

2.我的总结：
链表就是一个可变的数据存储表，可以在他的基础上增删查改。不用像顺序表那样频繁增容，也不会浪费空间，操作更加明确。

如图就是一个简易的链表：
在这里插入图片描述

链表的实现

总体思路

首先就是要知道我们实现的链表是单向不带头非循环的链表，我们要建立工程文件，将定义和实现分离。也要知道链可以实现增删查改。首先得定义链表的每个节点：

//我们认为链表的数据类型是int型
typedef int SLTDatatype;

typedef struct SListNode
{
	struct SListNode* next;//指向下个节点的地址。
	SLTDatatype data;//存储的数据
}STNode;

头文件的主要接口有：

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

void SListPushBack(SLTNode** phead,SLTDatatype x);//尾插

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

void SListPushFront(SLTNode** phead, SLTDatatype x);//头插

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

SLTNode* CreateNewnode(SLTDatatype x);//建立一个新节点

SLTNode* SListFindNode(SLTNode* phead, SLTDatatype x);// 单链表查找,同时具有修改的功能

void SListInsertAfter(SLTNode* pos, SLTDatatype x);// 单链表在pos位置之后插入x

void SListEraseAfter(SLTNode* pos);// 单链表删除pos位置之后的值

void SListDestory(SLTNode** phead);// 单链表的销毁

void SListInsert(SLTNode** phead, SLTNode* pos, SLTDatatype x);//在pos之前插入

为什么要传二级指针呢？因为我们设计的链表是不带头的，如果我们传过来的是一级指针，那我们相当于是传的链表的拷贝，是不起作用的，如果有兴趣，可以看看函数栈帧的调用是怎么样的。这里附上链接：

函数栈帧详解

尾插

思路：因为链表不像是顺序表那样可以进行下标访问，所以我们需要找到尾，从而进行尾插，所以时间复杂度为O(N)。

注意 :
(1) 在尾插之前，我们需要建立一个新节点，我们可以知道，不管是在尾插头插还是在任意位置插入，都需要建立新节点，为了防止代码的冗余，我们可以封装一个函数叫BuySListNode。
(2) 尾插的时候如果链表为空，则直接将新建立的节点给给链表即可。

新节点的建立

代码：

SLTNode* CreateNewnode(SLTDatatype x)//建立一个新节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("molloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

代码：

void SListPushBack(SLTNode** phead, SLTDatatype x)//尾插
{
	//首先建立一个新节点
	assert(phead);
	SLTNode* newnode = CreateNewnode(x);

	//1.phead是否为空,若为空
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		//2.若不为空
		//(1).找到尾节点
		SLTNode* tail = *phead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		//(2).新节点
		tail->next = newnode;
	}
}

尾删

思路：尾删首先得判断链表是否为空，为空则断言暴力解决。第二就是判断链表是否只有一个节点，如果是只有一个节点则需要将链表置为空。如果链表的节点个数大于一，我们需要找到尾节点的前一个，在free最后一个节点以后，要将倒数第二个节点的next指向NULL。

代码：

void SListPopBack(SLTNode** phead)//尾删
{
	//判断链表是否为空
	assert(*phead != NULL);

	//特殊情况特别对待
	SLTNode* tail = *phead;
	SLTNode* next = (*phead)->next;
	if (next == NULL)
	{
		free(tail);
		*phead = NULL;
	}
	else
	{
		//删除最后一个节点必须要找到倒数第二个节点
		//free最后一个节点之后再把倒数第二个节点next置为空
		while (next->next != NULL)
		{
			tail = tail->next;
			next = next->next;
		}
		free(next);
		tail->next = NULL;
	}
}

头插

void SListPushFront(SLTNode** phead, SLTDatatype x)//头插
{
	assert(phead);
	SLTNode* newnode = CreateNewnode(x);
	newnode->next = *phead;
	*phead = newnode;
}

头删

void SListPopFront(SLTNode** phead)//头删
{
	assert(phead && *phead);
	SLTNode* tmp = (*phead)->next;
	free(*phead);
	*phead = tmp;
}

查找

思路：查找就是遍历链表，找到就返回当前节点的地址。

SLTNode* SListFindNode(SLTNode* phead, SLTDatatype x)// 单链表查找
{
	assert(phead);
	SLTNode* tmp = phead;
	while (tmp != NULL)
	{
		if (tmp->data == x)
		{
			return tmp;
		}
		tmp = tmp->next;
	}
	return NULL;
}

其余接口

void SListInsertAfter(SLTNode* pos, SLTDatatype x)// 单链表在pos位置之后插入x
{
	assert(pos);
	SLTNode* newnode = CreateNewnode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListEraseAfter(SLTNode* pos)// 单链表删除pos位置之后的值
{
	assert(pos && pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
}


void SListDestory(SLTNode** phead)// 单链表的销毁
{
	assert(phead);
	SLTNode* next = *phead;
	while (next != NULL)
	{
		next = next->next;
 		free(*phead);
		*phead = next;
	}
	*phead = next;
}


void SListInsert(SLTNode** phead, SLTNode* pos, SLTDatatype x)//在pos之前插入
{
	assert(phead);
	assert(pos);
	SLTNode* newnode = CreateNewnode(x);
	if (pos == *phead)
	{
		newnode->next = *phead;
		*phead = newnode;
	}
	else
	{
		SLTNode* prev = *phead;
		SLTNode* tail = (*phead)->next;
		while (tail != NULL && tail != pos)
		{
			prev = prev->next;
			tail = tail->next;
		}
		if (tail == NULL)
		{
			printf("Do not have pos\n");
			return;
		}
		else
		{
			prev->next = newnode;
			newnode->next = tail;
		}
	}
}

所有代码

SList.h
#pragma once 

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

typedef int SLTDatatype;

typedef struct SListNode
{
	SLTDatatype data;
	struct SListNode* next;
}SLTNode;



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

void SListPushBack(SLTNode** phead,SLTDatatype x);//尾插

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

void SListPushFront(SLTNode** phead, SLTDatatype x);//头插

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

SLTNode* CreateNewnode(SLTDatatype x);//建立一个新节点

SLTNode* SListFindNode(SLTNode* phead, SLTDatatype x);// 单链表查找,同时具有修改的功能

void SListInsertAfter(SLTNode* pos, SLTDatatype x);// 单链表在pos位置之后插入x

void SListEraseAfter(SLTNode* pos);// 单链表删除pos位置之后的值

void SListDestory(SLTNode** phead);// 单链表的销毁

void SListInsert(SLTNode** phead, SLTNode* pos, SLTDatatype x);//在pos之前插入
SList.c
#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"
 
SLTNode* CreateNewnode(SLTDatatype x)//建立一个新节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("molloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}


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


void SListPushBack(SLTNode** phead, SLTDatatype x)//尾插
{
	//首先建立一个新节点
	assert(phead);
	SLTNode* newnode = CreateNewnode(x);

	//1.phead是否为空,若为空
	if (*phead == NULL)
	{
		*phead = newnode;
	}
	else
	{
		//2.若不为空
		//(1).找到尾节点
		SLTNode* tail = *phead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		//(2).新节点
		tail->next = newnode;
	}
}


void SListPopBack(SLTNode** phead)//尾删
{
	//判断链表是否为空
	assert(*phead != NULL);

	//特殊情况特别对待
	SLTNode* tail = *phead;
	SLTNode* next = (*phead)->next;
	if (next == NULL)
	{
		free(tail);
		*phead = NULL;
	}
	else
	{
		//删除最后一个节点必须要找到倒数第二个节点
		//free最后一个节点之后再把倒数第二个节点next置为空
		while (next->next != NULL)
		{
			tail = tail->next;
			next = next->next;
		}
		free(next);
		tail->next = NULL;
	}
}


void SListPushFront(SLTNode** phead, SLTDatatype x)//头插
{
	assert(phead);
	SLTNode* newnode = CreateNewnode(x);
	newnode->next = *phead;
	*phead = newnode;
}


void SListPopFront(SLTNode** phead)//头删
{
	assert(phead && *phead);
	SLTNode* tmp = (*phead)->next;
	free(*phead);
	*phead = tmp;
}


SLTNode* SListFindNode(SLTNode* phead, SLTDatatype x)// 单链表查找
{
	assert(phead);
	SLTNode* tmp = phead;
	while (tmp != NULL)
	{
		if (tmp->data == x)
		{
			return tmp;
		}
		tmp = tmp->next;
	}
	return NULL;
}


void SListInsertAfter(SLTNode* pos, SLTDatatype x)// 单链表在pos位置之后插入x
{
	assert(pos);
	SLTNode* newnode = CreateNewnode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListEraseAfter(SLTNode* pos)// 单链表删除pos位置之后的值
{
	assert(pos && pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
}


void SListDestory(SLTNode** phead)// 单链表的销毁
{
	assert(phead);
	SLTNode* next = *phead;
	while (next != NULL)
	{
		next = next->next;
 		free(*phead);
		*phead = next;
	}
	*phead = next;
}


void SListInsert(SLTNode** phead, SLTNode* pos, SLTDatatype x)//在pos之前插入
{
	assert(phead);
	assert(pos);
	SLTNode* newnode = CreateNewnode(x);
	if (pos == *phead)
	{
		newnode->next = *phead;
		*phead = newnode;
	}
	else
	{
		SLTNode* prev = *phead;
		SLTNode* tail = (*phead)->next;
		while (tail != NULL && tail != pos)
		{
			prev = prev->next;
			tail = tail->next;
		}
		if (tail == NULL)
		{
			printf("Do not have pos\n");
			return;
		}
		else
		{
			prev->next = newnode;
			newnode->next = tail;
		}
	}
}

谢谢大家!!!

zhzhyyds
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
C语言数据结构之链表
qq_53918454的博客
10-19 5203
从某个节点前面插入新节点比从后面插入要多进行一次判断，判断是否为头节点，另一个要注意的地方就是while里的判断条件是用p->next来判断的，这是因为我们可以通过p来找到p的后一个，但是找不到p的前一个，所以这里我们灵活变换一下，代码实现逻辑和从后面插入大同小异。删除一个节点实现逻辑也很好理解，肯定也是要不断遍历，找到对应节点后把原本指向它的结构体指针指向它的下一个，然后按道理我们要把它free掉，上面的代码就是实现尾插法创建链表，这种方式创建出链表中节点的顺序也就是我们正常所认为的顺序，最先的就是头。
C语言--单链表中重复元素的删除
m0_73770012的博客
05-03 1504
C语言--单链表中重复元素的删除 按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。
数据结构学习笔记——线性表之单链表（c语言实现）
luotuoxiansheng的博客
10-31 4984
1.概念 链式存储结构：是指把数据元素存放在任意内存未被占用的存储单元里，这组存储单元可以是连续的，也可以是不连续的。 大概就是这样： 因此，为了表示每个数据元素a1，与其直接后继数据元素 a2 之间的逻辑关系，对数据元素a来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。 对此有如下几个概念： 数据域 指针域 指针(链) 头指针 存储数据...
数据结构：链表实现（c）
weixin_44525246的博客
03-05 592
链表为数据存储常用方法，以下是基于C语言实现普通单向链表。其他双向链表循环链表在此基础上做些许变化。关于是否使用表头的问题，本链表不包含表头，表头可记录链表信息，能降低使用复杂性，按需使用。 声明部分： #ifndef _LIST_H #define _LIST_H typedef int ELEMENT; //define whatever your want type enum { ERROR = 0, SUCSSE }; typedef struct {
链表的基本操作--c语言
qq_51533157的博客
06-25 5928
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
最新发布
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
数据结构-链表的C语言使用
03-25
数据结构-链表的用法，单链表，带头节点链表，循环链表等，C语言code
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
(C语言数据结构)单链表
09-16
C语言实现单链表 Init(初始化) Length(当前结点个数) AddEnd(尾部添加) AddFirst(首部添加) Insert(插入) * Delete(删除) Find(查找返回) ShowAll(显示所有元素) Destory(销毁链表)
C++ 单链表基本操作分析与实现
tomcat_kk的博客
12-05 4123
链表 　　链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。   创建头节点 　　手动new一个新的Node，
C语言——链表
热门推荐
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
【数据结构】链表-C语言版
局部变量和全局变量
01-17 691
顺序表缺点 顺序表随机访问很方便，但是也会有不足啊： （1）挪动数据时间开销较大：头部/中间的插入删除，需要挪动后面的所有数据，时间复杂度为O(N) （2）增容有代价：增容需要重新申请空间，拷贝数据，释放旧空间，系统消耗不小 （3）空间浪费：增容一般增至原来的2倍大空间，会有空间浪费，假如当前容量为100，满了以后增容到200，再继续插入了5个数据，后面没有插入数据了，这就浪费了95个空间。 不存在扩容代价、不存在空间浪费、按需申请空间、头部或者中间插入数据而不需要挪动数据的链表可以解决以上问
C语言的三种整型数据类型：int、short int和long int
飞奔的火鸟
03-15 4091
int数据类型的位数为16位，short int数据类型的位数也是16位。而long int的位数为32位，可用来存储比较大的整数。 short int 和 long int可以缩写为short 和 long。              C语言中的整型数据类型int、short int 和 long int   名称 全称类型说明符 缩写类型说明符       位数           ...
数据结构与算法之有序链表去重
RangeYan
03-05 4585
1. 有序链表，需要将链表中重复的节点合并为一个节点（例如：[1,2,3,3,3,5,7,8,8,9,13,14]） 合并为[1,2,3,5,7,8,9,13,14]) struct ListNode { int val; ListNode* next; } ListNode* uniq_list(ListNode* head) { if(head == Null || head ->
整数数据类型
实践求真知
04-03 4019
一数据类型基本介绍 二整数类型 1基本介绍 简单的说，就是用于存放整数值的，比如 0、-1、2345等。 2整数的类型 三整型使用细节 1Golang 整数类型分：有符号和无符号，intunit的大小和系统有关。 2Golang的整型默认声明为int型。 3如何在程序查看某个变量的字节大小和数据类型 4Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。如，年龄。 5bit：计...
链表常见操作：有序链表合并去重
CCPP Blog
05-20 6132
两个升序链表合并，并要求去掉重复元素 。 分析： 如何使链表本身是有序的，这个我们可以在加入元素的过程中做到 合并，并去掉重复元素，这个是难点 思路：主要思想类似于直接插入排序和归并排序。 指针p指向list1，指针q指向list2，由于list1已经有序，我们只需要把q指向的节点插入一个原本有序的表，这不就是直接插入排序算法吗？当然，得把p移动到合适位置。 再由于list2也已经有序，因此插入过程中p不需回溯，只需不断地往后移动，这不就是归并排序吗？如果q指向节点的值域和p指向节点的值域相同，则应该丢掉此
C语言链表详解
qq_28576837的博客
06-02 4808
C语言链表详解
数据结构之---c语言实现串的块链存储表示
05-14
串是一种特殊的线性表，由于它的不可改变性质使得我们需要一种...总之，块链存储表示是一种实现串存储的有效方式，通过c语言的数据结构实现，我们可以更深入地理解串的特性和实现原理，掌握更为灵活多样的串存储方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值