链表

最新推荐文章于 2024-07-22 19:36:52 发布
最新推荐文章于 2024-07-22 19:36:52 发布
阅读量30 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68146877/article/details/131967811
版权

前言

  • 由于顺序表中存在缺陷或者不能适用其他情况，所以进一步去学习链表。

概念

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

结构

  • 链表有好几种结构，这里学习的是最基础的 无头+单向+非循环的链表，这几个词可以暂时忽略
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;
  • 逻辑结构: 为方便理解、使用的想象出的结构，可以形象的表达出链表的特点，可以搭配物理逻辑理解。
    在这里插入图片描述
  • 物理结构： 链表实际在内存中存储的形式
    在这里插入图片描述
  • 上图的代码解释
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;

int main() {
	//这里是从后向前创建，之后会实现接口函数，就是正常顺序
    SListNode plist3;	//创建结构体变量plist3
    plist3.data = 3;	//plist3的data设值
    plist3.next = NULL;	//由于plist3之后没有数据，所以下一个节点指针设空

    SListNode plist2;	//创建结构体变量plist2
    plist2.data = 2;	//plist2的data设值
    plist2.next = &plist3;	//plist2的next指向plist3，所以取plist3的地址赋值给plist2.next

    SListNode plist1;	//创建结构体变量plist1
    plist1.data = 1;	//plist1的data设值
    plist1.next = &plist2;	//plist1的next指向plist2

	//这样就可以通过plist1找到plist2、plist3
	SListNode* p2 = plist1.next; // *p2现在就是&plist2(plist2的结构体指针),但通常不会这么手动赋值下一个节点
	
	//更多是这样使用
	SListNode* cur = &plist1;	//现在cur是plist1的结构体指针
	cur = cur->next;	//等同于 cur = plist1.next 现在cur就是plist2的结构体指针
	
	//通过cur来遍历链表
	while(cur != NULL)
	{
		//cur->data = ...	更改当前节点数据
		cur = cur->next;
	}
    return 0;
}

对比

  • 顺序表

      • 优点：
        支持随机访问(下标访问)，存取速度高效。
        空间利用率高。（局部性原理，连续存放，命中率高）
      • 缺点：
        不利于插入和删除操作。
        空间不足就需要扩容，扩容是繁琐且有消耗。

  • 链表

      • 优点：
        链表的插入和删除操作的效率较高，可以把通过地址直接改变节点的指向。
        更合理地使用空间，不需要的空间、节点直接删除释放。
        基本上没有空间限制，只与内存空间大小有关。
      • 缺点：
        占用额外的空间以存储指针(浪费空间，不连续存放，malloc开辟，空间碎片多) 。
        不能进行索引/随机访问，查找时，需要循环链表访问，需要从开始节点一个一个节点去查找元素访问。

接口函数

  • 接口链表

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);

// 单链表打印
void SListPrint(SListNode* plist);

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);

// 单链表的尾删
void SListPopBack(SListNode** pplist);

// 单链表头删
void SListPopFront(SListNode** pplist);

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);

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

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

// 单链表的销毁
void SListDestroy(SListNode** plist);

  • 创建节点(BuySListNode)

顺序表的每个节点都是动态开辟的，为了方便使用，所以写成函数

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* new_node = (SListNode*)malloc(sizeof(SListNode));	//动态申请空间
	assert(new_node);	//断言malloc是否成功
	new_node->data = x;		//插入数据
	new_node->next = NULL;		//next置空
	return new_node;	//返回节点的指针
}

  • 链表打印(SListPrint)

    打印链表数据
// 单链表打印
void SListPrint(SListNode* plist)
{
	//assert(plist);		//断言指针
	SListNode* cur = plist;
	while (cur)		//当前节点不为空的时候打印数据
	{
		printf("%d ", cur->data);
		cur = cur->next;		//把下一个节点的指针赋值给cur
	}
}

  • 链表尾插(SListPushBack)

    在链表的最后一个节点后插入一个节点
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);		//断言指针

	SListNode* new_node = BuySListNode(x);		//创建新节点
	if (!(*pplist))		//当链表为空时(*pplist==NULL)
	{
		*pplist = new_node;		//直接将新创建的节点指针赋值给*pplist
	}
	else		//当链表不为空时
	{
		SListNode* tail = *pplist;		//为了方便使用，将*pplist赋值给tail，接下来就不需要对二级指针操作

		while (tail->next != NULL)		//当tail->next保存了指针时进入循环，直到找到最后一个有数据的节点
		{
			tail = tail->next;			//将下一个节点指针赋值给tail
		}

		tail->next = new_node;			//将新创建的节点指针赋值给tail->next，就是插入到最后一个节点后
	}
}

  • 链表头插(SListPushFront)

    在链表第一个节点之前插入一个节点
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);		//断言指针

	SListNode* new_node = BuySListNode(x);		//创建新节点

	new_node->next = *pplist;		//将链表的第一个节点指针赋值给new_node->next
	*pplist = new_node;				//将new_node赋值给*pplist, new_node现在就是链表第一个节点
}

  • 链表尾删(SListPopBack)

    将链表最后一个节点删除
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* tail = *pplist;
	if (!tail->next)		//当链表只有一个节点时
	{
		free(tail);			//释放空间
		*pplist = NULL;		//将链表置空
	}
	else		//当链表有两个及以上节点时
	{
		while (tail->next->next)		//当tail下一个节点的next不为空时
		{
			tail = tail->next;			//将tail下一个节点赋值给tail
		}

		//当tail下一个节点的next为空时，那么tail的下一个节点就是最后一个节点
		free(tail->next);		//释放掉tail的下一个节点
		tail->next = NULL;		//tail的next置空
	}
}

  • 链表头删(SListPopBack)

    将链表第一个节点删除
// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* head = (*pplist)->next;		//将链表第一个节点的next赋值给head，head将是链表新的第一个节点
	free(*pplist);		//释放掉第一个节点
	*pplist = head;		//将head作为链表第一个节点
}

  • 链表查找(SListFind)

    查找链表中 x 数据的节点，返回节点的指针
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);		//断言指针
	SListNode* cur = plist;		
	while (cur)		//当cur不为空时
	{
		if (cur->data == x)		//如果cur->data等于x
		{
			return cur;			//返回当前节点指针
		}
		else		//不等就向后寻找
			cur = cur->next;
	}
	return NULL;		//链表没有x，返回空指针
}

  • 指定位置后插入

    配合查找使用，在pos后插入一个节点
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);		//断言指针
	SListNode* new_node = BuySListNode(x);		//创建新节点
	new_node->next = pos->next;					//将pos下一个节点的指针赋值给new_node->next
	pos->next = new_node;						//将new_node赋值给pos的next
}

  • 指定位置后删除

    配合查找使用，删除pos后第一个节点
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);		//断言指针
	assert(pos->next);	//断言pos不是最后一个节点

	SListNode* next = pos->next->next;		//保存pos之后的第二个节点指针
	free(pos->next);		//释放pos之后的第一个节点空间
	pos->next = next;		//将pos的下一个节点设置为之前保存的next
}

  • 链表销毁

    链表每个节点都是动态开辟的，所以需要一个一个释放掉
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* cur = *pplist;
	while (cur)		//当链表不为空时
	{
		SListNode* next = cur->next;		//保存下一个节点指针
		free(cur);	//释放当前节点空间
		cur = next;		//将下一个节点设置为当前节点
	}
	*pplist = NULL;		//将链表置空
}

完整代码

  • “SeqList.h”

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

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);

// 单链表打印
void SListPrint(SListNode* plist);

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);

// 单链表的尾删
void SListPopBack(SListNode** pplist);

// 单链表头删
void SListPopFront(SListNode** pplist);

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);

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

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

// 单链表的销毁
void SListDestroy(SListNode** plist);

  • “SeqList.c”

#define _CRT_SECURE_NO_WARNINGS
#include "SList.h"

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* new_node = (SListNode*)malloc(sizeof(SListNode));	//动态申请空间
	assert(new_node);	//断言malloc是否成功
	new_node->data = x;		//插入数据
	new_node->next = NULL;		//next置空
	return new_node;	//返回节点的指针
}


// 单链表打印
void SListPrint(SListNode* plist)
{
	//assert(plist);		//断言指针
	SListNode* cur = plist;
	while (cur)		//当前节点不为空的时候打印数据
	{
		printf("%d ", cur->data);
		cur = cur->next;		//把下一个节点的指针赋值给cur
	}
}


// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);		//断言指针

	SListNode* new_node = BuySListNode(x);		//创建新节点
	if (!(*pplist))		//当链表为空时(*pplist==NULL)
	{
		*pplist = new_node;		//直接将新创建的节点指针赋值给*pplist
	}
	else		//当链表不为空时
	{
		SListNode* tail = *pplist;		//为了方便使用，将*pplist赋值给tail，接下来就不需要对二级指针操作

		while (tail->next != NULL)		//当tail->next保存了指针时进入循环，直到找到最后一个有数据的节点
		{
			tail = tail->next;			//将下一个节点指针赋值给tail
		}

		tail->next = new_node;			//将新创建的节点指针赋值给tail->next，就是插入到最后一个节点后
	}
}


// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);		//断言指针

	SListNode* new_node = BuySListNode(x);		//创建新节点

	new_node->next = *pplist;		//将链表的第一个节点指针赋值给new_node->next
	*pplist = new_node;				//将new_node赋值给*pplist, new_node现在就是链表第一个节点
}

// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* tail = *pplist;
	if (!tail->next)		//当链表只有一个节点时
	{
		free(tail);			//释放空间
		*pplist = NULL;		//将链表置空
	}
	else		//当链表有两个及以上节点时
	{
		while (tail->next->next)		//当tail下一个节点的next不为空时
		{
			tail = tail->next;			//将tail下一个节点赋值给tail
		}

		//当tail下一个节点的next为空时，那么tail的下一个节点就是最后一个节点
		free(tail->next);		//释放掉tail的下一个节点
		tail->next = NULL;		//tail的next置空
	}
}


// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* head = (*pplist)->next;		//将链表第一个节点的next赋值给head，head将是链表新的第一个节点
	free(*pplist);		//释放掉第一个节点
	*pplist = head;		//将head作为链表第一个节点
}


// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);		//断言指针
	SListNode* cur = plist;		
	while (cur)		//当cur不为空时
	{
		if (cur->data == x)		//如果cur->data等于x
		{
			return cur;			//返回当前节点指针
		}
		else		//不等就向后寻找
			cur = cur->next;
	}
	return NULL;		//链表没有x，返回空指针
}


// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);		//断言指针
	SListNode* new_node = BuySListNode(x);		//创建新节点
	new_node->next = pos->next;					//将pos下一个节点的指针赋值给new_node->next
	pos->next = new_node;						//将new_node赋值给pos的next
}


// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);		//断言指针
	assert(pos->next);	//断言pos不是最后一个节点

	SListNode* next = pos->next->next;		//保存pos之后的第二个节点指针
	free(pos->next);		//释放pos之后的第一个节点空间
	pos->next = next;		//将pos的下一个节点设置为之前保存的next
}


// 单链表的销毁
void SListDestroy(SListNode** pplist)
{
	assert(pplist);		//断言指针
	assert(*pplist);		//断言指针
	SListNode* cur = *pplist;
	while (cur)		//当链表不为空时
	{
		SListNode* next = cur->next;		//保存下一个节点指针
		free(cur);	//释放当前节点空间
		cur = next;		//将下一个节点设置为当前节点
	}
	*pplist = NULL;		//将链表置空
}
HHHH_HAN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
C语言实现静态链表
08-18
C语言实现静态链表 C语言实现静态链表是指在C语言中使用静态数组来实现链表结构的方法。静态链表是一种特殊的链表结构，它的内存是事先分配好的，链表的每个结点都是一个固定长度的结构体，而不是像动态链表那样...
C语言链表超详解
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表基础知识详解（非常详细简单易懂）
qq_61672347的博客
07-10 16万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
Python链表
sikh_0529的博客
09-12 1万+
链表是一系列数据元素，通过链接连接在一起。 每个数据元素都以指针的形式包含到另一个数据元素的连接。 Python在其标准库中没有链接列表。 我们使用前一章讨论的节点概念来实现链表的概念。 我们已经知道如何创建节点类以及如何遍历节点的元素。 在本章中，将学习链表的类型:单链表。 在这种类型的数据结构中，任何两个数据元素之间只有一个链接。 创建一个链表并使用一些方法来插入，更新和从列表中移除元素。通过使用在上一章中学习的节点类来创建链表。创建一个对象并创建另一个类来使用这个节点对象。 通过节点对象传递适当的值来
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
链表逆置详细讲解（图文）
qq_51366188的博客
02-26 3万+
链表逆置   前言 链表逆置是初学时有困扰到我的难点. 由于链表头结点可放可不放数据，所以写代码时候**->next**用的云里雾里。 这里讲解头结点与第一结点区分的情况，即头结点你把它看作这个 链表的“文件名” 就行。 若头结点为L，则第一结点为L->next。   代码 void listReverse(linkedList &L) { node *p,*s; //1. p = L->next; L->next = NULL; while
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
合并链表_合并链表_
10-03
合并链表是一个常见的数据结构问题，它涉及到对链表的操作，特别是涉及排序和连接操作。在本场景中，我们有两个非递减有序的链表A和B，目标是创建一个新的链表C，这个新链表C同样是非递减有序的。下面我们将详细探讨...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
计数，桶与基数排序
m0_68142120的博客
07-19 823
要进行 i(最高位的位数) 趟排序 ， 每趟排序需要将元素分派到k个桶，所以每趟排序的时间复杂度为O(n+k) 走i趟时间复杂度就为O(i(n+k)) 但桶的个数通常是固定的，执行的躺数一般又较小，所以基数排序的。如果待排序的元素数量很大，这可能会占用较多的内存空间。再次遍历待排序数组，对于数组中的每个元素，将其值减去最小值（为了使得计数数组的下标从0开始），并将计数数组中对应下标的值加1。如果待排序数组中的元素是负数，或者元素的取值范围较大，计数排序可能不适用，因为它需要额外的空间来存储计数数组。
数组算法--基本查找
2303_78660417的博客
07-20 390
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1084
可以参考以下视频。
数据结构---二叉树
最新发布
weixin_47808575的博客
07-22 167
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
C语言实现链表结构
"链表结点的类型定义是链式数据结构的基础，本文将介绍如何在C++中定义链表结点以及链表的基本操作。" 链表是一种非连续存储的数据结构，其中的元素并不像数组那样在内存中连续排列，而是通过指针相互连接。在C++中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值