首页 > 资讯 > 后端开发 > 其他教程 >老生常谈C语言链表小结

912

分享到

老生常谈C语言链表小结

2024-04-02 19:04:59 912人浏览安东尼

摘要

目录链表的概念及结构概念结构链表的分类单链表的实现（无头）双向链表的实现总结:链表和顺序表的区别链表的概念及结构概念链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的

链表的概念及结构

概念

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

结构

代码


struct Slist
{
	int* a;
	struct Slist* next;
};

逻辑结构:

在这里插入图片描述

物理结构：

在这里插入图片描述

注意:

从上图可以看出，链式结构在逻辑上是连续的，但是在物理上是不一定是连续的。
这些结点一般是从堆上申请出来的。
从堆上申请的空间，是按照一定的策划来分配的，两次申请的空间可能连续，大概率是不连续的。

链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向
①单向

在这里插入图片描述

②双向

在这里插入图片描述

2.带头或者不带头
①带头

在这里插入图片描述

②不带头

在这里插入图片描述

3.循环或者非循环
①循环

在这里插入图片描述

②非循环

在这里插入图片描述

虽然有这么多种结构的链表，但是我们实际中最常用的只有两种结构:
1. 无头单向非循环链表

在这里插入图片描述

2.带头双向循环链表

在这里插入图片描述

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

单链表的实现（无头）

单链表结构


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
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestory(SListNode** pplist);

功能实现


SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		exit(-1);
	}
	newnode->data = x;
	return newnode;
}

void SListPrint(SListNode* plist)
{
	if (plist == NULL)
	{
		printf("NULL\n");
		return;
	}
	else
	{
		while (plist)
		{
			printf("%d->", plist->data);
			plist = plist->next;
		}
		printf("NULL\n");
	}
}

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* tail = *pplist;
	SListNode* newnode = BuySListNode(x);
	newnode->next = NULL;
	if (tail == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

void SListPopBack(SListNode** pplist)
{
	assert(*pplist);
	SListNode* tail = *pplist;
	SListNode* Pretail = NULL;
	if (tail->next == NULL)
	{
		*pplist = NULL;
		return;
	}
	else
	{
		while (tail->next)
		{
			Pretail = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		Pretail->next = NULL;
	}
}

void SListPopFront(SListNode** pplist)
{
	assert(*pplist);
	SListNode* front = *pplist;
	*pplist = front->next;
	free(front);
	front = NULL;
}

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);
	SListNode* pos = plist;
	while (pos && pos->data != x)
	{
		pos = pos->next;
	}
	return pos;
}

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* node = pos->next;
	pos->next = node->next;
	free(node);
}

void SListDestory(SListNode** pplist)
{
	SListNode* node = *pplist;
	SListNode* PreNode = NULL;
	while (node)
	{
		PreNode = node->next;
		free(node);
		node = PreNode;
	}
}

双向链表的实现

双向链表的结构


SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		exit(-1);
	}
	newnode->data = x;
	return newnode;
}

void SListPrint(SListNode* plist)
{
	if (plist == NULL)
	{
		printf("NULL\n");
		return;
	}
	else
	{
		while (plist)
		{
			printf("%d->", plist->data);
			plist = plist->next;
		}
		printf("NULL\n");
	}
}

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* tail = *pplist;
	SListNode* newnode = BuySListNode(x);
	newnode->next = NULL;
	if (tail == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

void SListPopBack(SListNode** pplist)
{
	assert(*pplist);
	SListNode* tail = *pplist;
	SListNode* Pretail = NULL;
	if (tail->next == NULL)
	{
		*pplist = NULL;
		return;
	}
	else
	{
		while (tail->next)
		{
			Pretail = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		Pretail->next = NULL;
	}
}

void SListPopFront(SListNode** pplist)
{
	assert(*pplist);
	SListNode* front = *pplist;
	*pplist = front->next;
	free(front);
	front = NULL;
}

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);
	SListNode* pos = plist;
	while (pos && pos->data != x)
	{
		pos = pos->next;
	}
	return pos;
}

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* node = pos->next;
	pos->next = node->next;
	free(node);
}

void SListDestory(SListNode** pplist)
{
	SListNode* node = *pplist;
	SListNode* PreNode = NULL;
	while (node)
	{
		PreNode = node->next;
		free(node);
		node = PreNode;
	}
}

双向链表的功能


//创建链表返回头结点
LTNode* ListInit();
// 双向链表销毁
void ListDestory(LTNode* phead);
// 双向链表打印
void ListPrint(LTNode* phead);

// 双向链表尾插
void ListPushBack(LTNode* phead, LTDateType x);
// 双向链表尾删
void ListPopBack(LTNode* phead);
// 双向链表头插
void ListPushFront(LTNode* phead, LTDateType x);
// 双向链表头删
void ListPopFront(LTNode* phead);
// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDateType x);
// 双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDateType x);
// 双向链表删除pos位置的节点
void ListErase(LTNode* pos);

功能实现


LTNode* ListInit()
{
	//哨兵位头结点
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	if (phead == NULL)
	{
		printf("开辟空间失败!!!\n");
		exit(-1);
	}
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead;
	LTNode* p = NULL;
	LTNode* tail = phead->prev;
	while (cur != tail)
	{
		p = cur;
		cur = cur->next;
		free(p);
	}
	free(tail);
}

void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* front = phead->next;
	while (front != phead)
	{
		printf("%d ", front->data);
		front = front->next;
	}
	printf("\n");
}

void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("开辟空间失败!!\n");
		exit(-1);
	}
	newnode->data = x;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
	LTNode* tail = phead->prev;
	LTNode* TailFront = tail->prev;
	TailFront->next = phead;
	phead->prev = TailFront;
	free(tail);
}

void ListPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* next = phead->next;
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("开辟空间失败!!\n");
		exit(-1);
	}
	newnode->data = x;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
	LTNode* head = phead->next;//头结点
	phead->next = head->next;
	head->next->prev = phead;
	free(head);
}

LTNode* ListFind(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void ListInsert(LTNode* pos, LTDateType x)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("开辟空间失败!!\n");
		exit(-1);
	}
	newnode->data = x;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

总结:链表和顺序表的区别

不同点顺序表链表存储空间上物理上一定连续逻辑上连续，物理上不一定连续随机访问支持不支持任意位置上插入或者删除元素可能需要移动元素，效率低下只需修改指针指向插入动态顺序表，空间不够时需要扩容没有容量的概念应用场景元素高效存储+频繁访问任意位置插入和删除频繁

到此这篇关于C语言链表的文章就介绍到这了,更多相关C语言链表内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 老生常谈C语言链表小结

本文链接: https://www.lsjlt.com/news/156779.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

老生常谈C语言链表小结

目录链表的概念及结构概念结构链表的分类单链表的实现（无头）双向链表的实现总结:链表和顺序表的区别链表的概念及结构概念链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的...

99+

2024-04-02
C语言函数指针的老生常谈

目录函数指针函数指针的应用函数指针作为参数实例（qsort函数）总结函数指针本质上是一个指针，只不过指向函数而已。编译器在编译期间对函数开辟了一块空间，而这快空间的开始地址，就...

99+

2024-04-02
老生常谈C语言中指针的使用

目录前提一.指针基础1.1 变量指针1.2 数据指针1.3 指针的本质1.4 指针数组1.5 指针的移动1.5 Scanf函数的解释二.指针的进阶玩法2.1 二维指针2.2 结构体指...

99+

2024-04-02
老生常谈C++ 中的继承

目录继承1.1 继承的概念1.2 继承的定义1.2.1 定义格式2 基类(父类)对象和派生类(子类)对象之间的赋值转换 3 继承中的作用域4 派生类(子类)的默认成员函数5...

99+

2024-04-02
老生常谈C++explicit关键字

目录显式和隐式的区别总结explicit 关键字用于显式声明一个类构造函数是显式而非隐式的，从而禁用类构造函数的隐式自动类型转换。类构造函数默认情况下即声明为implici...

99+

2023-03-24

C++ explicit关键字 C++ explicit
老生常谈c++中的静态成员

引言有时候需要类的一些成员与类本身相关联，而不是与类的每个对象相关联。比如类的所有对象都要共享的变量，这个时候我们就要用到类的静态成员。声明类的静态成员声明静态成员的方法是使用...

99+

2024-04-02
C语言结构体使用之链表

目录一、结构体的概念二、结构体的用法三、结构体数组和指针四、结构体指针五、包含结构体的结构体六、链表七、静态链表八、动态链表一、结构体的概念比如说学生的信息，包含了学生名称、学号、...

99+

2024-04-02
浅谈C语言结构体

目录前言什么是结构体结构体类型的声明结构的自引用结构体变量的定义和初始化结构体的使用结构体内存对齐结构体传参总结前言在C语言中，除了内置的许多数据类型，C语言还为我们提供了自定义的...

99+

2024-04-02
C语言数据结构之双链表&循环链表&静态链表详解

目录单链表 VS 双链表双链表双链表的初始化（带头结点）双链表的插入双链表的删除双链表的遍历循环单链表循环双链表循环双链表的初始化循环双链表的插入循环双链表的删除静态链表什么是静态链...

99+

2024-04-02
C语言链表与单链表详解

链表是什么及链表的优势链表是一种介于数组的另外一种数据结构：我们知道数组可以存放很多的元素，这些元素都是呈线性排列，也就是一个挨着一个连续存放但是当元素足够多时，还能继续正常的...

99+

2024-04-02
C语言结构体链表和指针实现学生管理系统

目录一、需求分析二、整体设计三、详细设计学生档案管理子系统学生成绩管理子系统四、代码实现本文实例为大家分享了C语言结构体链表和指针实现学生管理系统的具体代码，供大家参考，具体内容如下...

99+

2024-04-02
C语言数据结构之顺序表和单链表

一、顺序表的创建、删除和插入 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> struct sqlist { ...

99+

2024-04-02
C语言链表实现贪吃蛇小游戏

本文实例为大家分享了C语言链表实现贪吃蛇游戏的具体代码，供大家参考，具体内容如下项目名称：贪吃蛇小游戏运行环境： Linux 编程语言： C语言主要语法：链表，指针，函数 ...

99+

2024-04-02
数据结构C语言链表的实现介绍

目录前言函数1. 链表初始化2. 计算链表长度3. 打印链表4.计算链表长度5. 删除链表中指定位置节点6. 向链表中指定位置插入节点7. 全代码+运行效果前言需要用到的函数库 ...

99+

2024-04-02
C语言数据结构与算法之单链表

目录基本概念读取数据元素获取第i个结点的数据元素插入数据元素初始化链表打印链表顺序表查空顺序表的删除删除第i个结点及其数据元素情况1：当删除的是第一个元素情况2：除第一个结点外完...

99+

2024-04-02
C语言数据结构与算法之链表(二)

目录引入模拟链表介绍插入代码实现代码实现引入在上一节的学习中我们介绍了C语言如何实现链表，但是，在这一章，我们将抛开令人头秃的指针和结构体，我们将另外使用一种数组来实现的方式，...

99+

2024-04-02
C语言数据结构与算法之链表(一)

目录引言链表的相关思考链表结点结构建立链表实现插入操作完整代码引言在存储一大波数的时候，我们通常使用的是数组，但是数组有时候又会显得不够灵活，比如下面这个例子：有一串已经排序好的...

99+

2024-04-02
C语言数据结构之单链表的实现

目录一.为什么使用链表二.链表的概念三.链表的实现3.1 创建链表前须知3.2 定义结构体3.3 申请一个节点3.4 链表的头插3.5 链表的尾插3.6 链表的尾删3.7 链表的头删...

99+

2024-04-02
C语言链表实现学生成绩管理系统

目录一、课程设计题目及内容二、主要设计思路三、程序源码及具体注释（1）预处理指令（2）类型定义（3）函数原型（4）main函数定义（5）其他函数定义四、运行示例五、注意事...

99+

2024-04-02
C语言实现学生信息管理系统(链表)

目录1.头文件和预处理2.定义学生结构体的数据结构3.定义每条记录或节点的数据结构4.函数接口代码.1）.定义提示菜单2）.增加学生记录3）.输入学号接口·4）.遍历表...

99+

2024-04-02