深入浅出C语言——C语言实现链表

已于 2023-05-16 23:47:24 修改
阅读量231 收藏 7
点赞数 8
分类专栏： 数据结构 C语言 文章标签： 链表 数据结构 c语言
于 2022-08-31 16:42:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55051736/article/details/126625591
版权

文章目录

一、链表

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

链表的特点

  1. 链式结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 现实中的结点一般都是从堆上申请出来的。
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

链表的分类

  1. 单向带头循环
  2. 单向带头非循环
  3. 单向不带头循环
  4. 单向不带头非循环
  5. 双向带头循环
  6. 双向带头非循环
  7. 双向不带头循环
  8. 双向不带头非循环

常用链表

  虽然有这么多链表，但是实际中最常用的是单向不带头非循环链表和双向带头循环链表。单向不带头非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。双向带头循环链表结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。

在这里插入图片描述

二、单向不带头非循环链表的实现

/******************************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;

SLTNode* BuySListNode(SLTDataType x);
void SListPrint(SLTNode* phead);
void SListPushBack(SLTNode** pphead, SLTDataType x);
void SListPushFront(SLTNode** pphead, SLTDataType x);
void SListPopBack(SLTNode** pphead);
void SListPopFront(SLTNode** pphead);
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

// 在pos位置之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);

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

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

/******************************SList.c********************************/
#include "SList.h"
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead; //我们在遍历链表的时候习惯新定义一个指针去遍历，不去改变它的头结点指针，		
	while (cur != NULL)	  //防止后续会再使用 但是这里后续不再使用，影响不大 但是还是建议定义一个指针
	{
		printf("%d->", cur->data);
		cur = cur->next; //结构体指针赋值给结构体指针
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//要改变实参才需要传二级指针
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySListNode(x);

	// 1.空
	// 2.非空
	if (*pphead == NULL)
	{
		*pphead = newnode;//形参不影响实参，所以这里要传 结构体指针变量的地址。*pphead就是phead
	}
	else
	{
		// 找尾节点 
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//newnode是局部结构体指针变量，出了作用域销毁
		tail->next = newnode;//但是这里存的是结构体节点的地址，节点在堆中，出了作用域不销毁
	}
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;	//形参不影响实参，所以这里要传 结构体指针变量的地址。*pphead就是phead
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//删除的时候，链表中一定不能是空链表
	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{	
		//找尾的前一个节点
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	//保存下一个链表的节点结构体
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//传过来的实参不需要改变，所以不需要再传实参的地址过来，这里只需要要用实参的类型 SLTNode* 接收即可
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;//把节点返回可以修改节点的数据

		cur = cur->next;
	}

	return NULL;
}

//有可能是头插，所以要传二级
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pphead);
	// 头插
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		//找pos位置的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//链接起来
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		//找pos位置前一个的链表节点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//链接
		prev->next = pos->next;
		//free掉
		free(pos);
		pos = NULL; //pos是形参，置空其实没有用，没意义
	}
}

// 单链表在pos位置之后插入x —— O(1)的算法
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	// 不在乎链接顺序
	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;
	// pos newnode next
	pos->next = newnode;
	newnode->next = next;
}

// 删除单链表中pos位置之后的节点
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
		return;

	SLTNode* next = pos->next;
	pos->next = next->next;

	free(next);
	next = NULL;
}
/*******************************test.c********************************/
int main()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);

	SLTNode* ret = SListFind(plist, 3);
	if (ret)
	{
		printf("找到了\n");
		ret->data = 30;
	}
	SListPrint(plist);


	SLTNode* pos = SListFind(plist, 4);
	if (pos)
	{
		SListInsert(&plist, pos, 40);
	}
	SListPrint(plist);
	return 0;
}

三、双向带头循环链表的实现

/******************************DList.h********************************/
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//将数据类型重命名方便更改
typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;  //存储下一个节点的地址
	struct ListNode* prev;	//存储上一个节点的地址
	LTDataType data;		//存储vaule
}LTNode;

//创建一个新的节点
LTNode* BuyListNode(LTDataType x);

// 双向链表初始化
LTNode* ListInit();

// 双向链表打印
void ListPrint(LTNode* phead);

// 双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x);

// 双向链表头插
void ListPushFront(LTNode* phead, LTDataType x);

// 双向链表尾删
void ListPopBack(LTNode* phead);

// 双向链表头删
void ListPopFront(LTNode* phead);

// 判断链表是否为空
bool ListEmpty(LTNode* phead);

// 双向链表查找
LTNode* ListFind(LTNode* plist, LTDataType x);

// 在pos位置之前插入x
void ListInsert(LTNode* pos, LTDataType x);

//  删除pos位置的节点
void ListErase(LTNode* pos);

// 双向链表销毁
void ListDestory(LTNode* plist);

/******************************DList.c********************************/

//创建一个新的节点
LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}



// 双向链表初始化
LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
/*或者用双指针的方法定义初始化函数
// 双向链表初始化
void ListInit(LTNode** phead)
{
	assert(*phead);
	assert(phead);
	//带头节点的链表的最大特点便在于初始化头结点,省去了插入，删除过程中判断是否改变头指针的工作
	*phead = (LTNode*)malloc(sizeof(LTNode));
	(*phead)->next = *phead;
	(*phead)->prev = *phead;
}
*/

// 双向链表打印
void ListPrint(LTNode* phead)
{
	assert(phead);

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

// 双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x)//有哨兵位的头节点，，不需要改变头节点，所以不需要二级指针
{
	assert(phead);
	ListInsert(phead, x);//在哨兵位的前一个位置插入x就是尾插
}

// 双向链表头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);//在哨兵位的后一个插入x就是头插
}

// 双向链表尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->prev);
}

// 双向链表头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

// 判断链表是否为空
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

// 双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 在pos位置之前插入x
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);//空指针断言
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);

	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}

//  删除pos位置的节点
void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;
	free(pos);
}
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur!=phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;//这里没什用，除非传二级指针，建议在调用的时候，destroy后在调用的写phead = NULL
}

四、顺序表和链表的区别

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

顺序表优点

  1. 按下标进行随机访问
  2. CPU高速缓存命中率高

顺序表缺点

  1. 空间不够需要增容，有一定的性能消耗和空间浪费
  2. 头部或者尾部插入数据，需要挪动数据，效率比较低

链表优点

  1. 按需申请内存，需要一个数据，就申请一块内存，也不存在空间浪费
  2. 任意位置O(1)时间删除数据 链表缺点： 不支持下标的随机访问

总结

  这两个数据结构是相辅相成的，互相弥补对方的缺点，具体看场景的需要。

程序员丶Alex
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
用c语言写链表
Mr_fanna的博客
02-08 2811
数据结构——链表的学习（链表的构建、初始化、插入和删除等基本操作）
C语言的链表实现
weixin_73728044的博客
10-16 1525
C语言各种链表学习记录
一文解决用C语言实现一个链表（全都是细节）
胡坚涛的博客
01-06 1642
链表是指数据使用一个一个的结点连接起来的数据结构，这样的数据结构中不像顺序表一样，顺序表中不同的数据在内存中的存储空间是相邻的，链表中的相邻结点在内存中的存储位置是没有任何关系的，每一个链表都是由许多的结点组成的，而一个链表，我们需要一个对应的头指针来管理这个链表，也就是说，如果我们拥有一个链表的头指针，那么我们就可以拿到这个链表中的所有的结点，在此基础上，如果我们还学会对链表中的结点进行一些常见的操作（增删查改），那么我们就可以熟练使用链表来解决现实中的问题了
C语言系列(7) --- C语言之链表的实现
Fug_Lee的博客
05-21 1212
一：链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 二：链表的结构 （1）单链表 （2）带头结点的单链表 （3）双向链表 （4）循环单链表 （5）双向循环链表 注释： （1）无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 （2）带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代
链表（c语言实现）
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
泛型链表——C语言实现
01-24
使用C语言实现的“泛型链表”，该链表为循环双链表，它的设计参考了C++的STL容器库中的容器list及泛型算法的接口，并使用迭代器来遍历链表。使用时只需要include头文件即可，隐藏了List类型的具体实现。用户并不需要...
c语言链表的基本操作实现
最新发布
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
C语言链表实现的贪吃蛇小游戏 .zip
03-16
C语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC语言链表实现的贪吃蛇小游戏。.zipC...
c语言单链表的实现及测试
07-20
定义了单链表的基本操作，并在主函数中测试了所有定义的操作。
c语言链表实现简单的学生信息管理系统
04-21
c语言实现， 链表初学使用， 文件读写， 已通过测试
数据结构——C语言实现链表
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
C语言来实现链表创建
热门推荐
xinzhilinger的博客
10-11 3万+
前言 链表是数据结构中很重要的内容，要想学会数据结构，首先要了解链表 链表的基本知识 1，链表的构成 链表是由一个头指针和一个个节点构成的，如图： 而节点则是一个个结构体，包含数据域和指针域两部分，其中，指针域存储的是指向下一个节点的指针 2，对于链表的操作 1，创建链表 2，初始化链表 3，遍历链表 4，对于链表进行增删查等操作 C语言对于链表的代码的实现 1，创建结构体并命名 创建链表前需要先创建结构体作为节点和头指针： typedef struct Node //typedef方法函数可以对于st
数据类型——链表的简单实现（C语言实现链表）
weixin_72883322的博客
12-27 676
本博客讲述了链表是什么以及链表要如何实现，用一个使用案例带大家初步了解链表数据结构
【 数据结构 】单链表的实现 - 详解（C语言版）
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
用C语言实现单链表操作
xuzhougeng blog
02-02 6570
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
【数据结构与算法】双向通用链表的功能实现
qmxxd
07-30 99
.h文件 #ifndef LIST_H #define LIST_H #include <stdio.h> #include <stdbool.h> #define swap(a,b) {typeof(a) t=a; a=b; b=t;} typedef struct Node { void* data; struct Node* prev; struct Node* next; }Node; typedef struct List { Node* head; siz
c语言链表实现
小小
07-11 942
c 语言实现链表
c语言链表的简单实现
12-28
链表是一种常见的数据结构，用于存储和组织数据。在C语言中，链表可以通过结构体和指针来实现。下面是一个简单的C语言链表的实现示例： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点的结构体 typedef struct Node { int data; // 数据 struct Node* next; // 指向下一个节点的指针 } Node; // 在链表末尾插入新节点 void insert(Node** head, int data) { // 创建新节点 Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; // 如果链表为空，将新节点设置为头节点 if (*head == NULL) { *head = newNode; } // 否则，找到链表末尾并插入新节点 else { Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = newNode; } } // 打印链表中的所有节点 void printList(Node* head) { Node* current = head; while (current != NULL) { printf("%d ", current->data); current = current->next; } printf("\n"); } int main() { Node* head = NULL; // 头节点初始化为空 // 插入节点 insert(&head, 1); insert(&head, 2); insert(&head, 3); // 打印链表 printList(head); return 0; } ``` 这个示例演示了如何创建一个简单的链表，并在链表末尾插入新节点。然后，通过遍历链表并打印每个节点的数据，展示了链表中的所有节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序员丶Alex

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

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

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

打赏作者

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

抵扣说明：

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

余额充值