数据结构-双向链表-C语言代码

已于 2022-09-28 15:42:05 修改
阅读量362 收藏
点赞数
文章标签： 链表 数据结构 c语言
于 2022-08-06 14:24:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_66518801/article/details/126189551
版权
本文详细介绍了双向链表的实现，包括结点定义、初始化、打印、节点操作（头插、头删、尾插、尾删）、查找、插入和删除，以及整个数据结构的销毁过程。通过实例代码展示了如何使用C语言实现一个完整的双向链表数据结构。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一、双向链表的实现

1.结点定义和头指针的创建

typedef int LTDataType; //把要存储的数据重新定义一下
typedef struct ListNode
{
	LTDataType data; //数据域
	struct ListNode* next;//定义一个指针
	struct ListNode* prev;
}LTNode;

2.初始化实现

//初始化
LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;
	return guard;
}

3.打印接口实现

//打印
void ListPrint(LTNode* phead)	//这里用一级指针，不需要修改头指针
{
	assert(phead);
	printf("phead<=>");//先打印哨兵头
	LTNode* cur = phead->next;
	while (cur != phead)//就一个头
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

4.开辟新的节点

//开辟结点接口
LTNode* BuyLTNode(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;
}

5.头插接口

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	//先开辟结点
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = phead->next;

	//先链接newnode 和 phead->next节点之间的关系
	newnode->next = first;
	first->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;

	//ListInsert(phead->next, x);	//或者直接调用插入
}

6.头删接口

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	LTNode* first = phead->next;
	LTNode* second = first->next;

	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;

	//ListErase (phead->next);//直接调用删除
}

7.尾插接口

//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	//assert(phead);
	先开辟结点
	//LTNode* newnode = BuyLTNode(x);
	先找尾,此时tail就是尾
	//LTNode* tail = phead->prev;

	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	ListInsert(phead, x);	//或者直接调用插入

}

8.尾删接口

//尾删
void ListPopBack(LTNode* phead)
{
	//assert(phead);
	//assert(!ListEmpty(phead));
	//LTNode* tail = phead->prev;
	//LTNode* prev = tail->prev;

	//prev->next = phead;
	//phead->prev = prev;
	//free(tail);
	//tail = NULL;

	ListErase(phead->prev);	//直接调用删除

}

9.查找接口实现

//查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	size_t n = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data = x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

10.在pos位置之前插入

//在Pos之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

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

}

11.删除pos位置

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

	prev->next = next;
	next->prev = prev;
	free(pos);
	pos = NULL;

}

12.销毁

//销毁
void ListDestory(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur!= phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

二、全部代码

1.SList.h

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


typedef int LTDataType; //把要存储的数据重新定义一下
typedef struct ListNode
{
	LTDataType data; //数据域
	struct ListNode* next;//定义一个指针
	struct ListNode* prev;
}LTNode;


//初始化
LTNode* ListInit();

//开辟结点接口
LTNode* BuyLTNode(LTDataType x);

//打印
void ListPrint(LTNode* phead);

//改变结构体指针，就要传指针的指针

//头插
void ListPushFront(LTNode* phead, LTDataType x);

//尾插
void ListPushBack(LTNode* phead, LTDataType x);

//尾删
void ListPopBack(LTNode* phead);

//头删
void ListPopFront(LTNode* phead);

bool ListEmpty(LTNode* phead);

//链的长度
size_t ListSize(LTNode* phead);

//查找
LTNode* ListFind(LTNode* phead, LTDataType x);


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

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

//销毁
void ListDestory(LTNode* phead);

2.SList.c

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

//初始化
LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;
	return guard;

}

//开辟结点接口
LTNode* BuyLTNode(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;
}

//打印
void ListPrint(LTNode* phead)	//这里用一级指针，不需要修改头指针
{
	assert(phead);
	printf("phead<=>");//先打印哨兵头
	LTNode* cur = phead->next;
	while (cur != phead)//就一个头
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	//先开辟结点
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = phead->next;

	//先链接newnode 和 phead->next节点之间的关系
	newnode->next = first;
	first->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;

	//ListInsert(phead->next, x);	//或者直接调用插入
}

//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	//assert(phead);
	先开辟结点
	//LTNode* newnode = BuyLTNode(x);
	先找尾,此时tail就是尾
	//LTNode* tail = phead->prev;

	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	ListInsert(phead, x);	//或者直接调用插入

}

//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	LTNode* first = phead->next;
	LTNode* second = first->next;

	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;

	//ListErase (phead->next);//直接调用删除
}

//尾删
void ListPopBack(LTNode* phead)
{
	//assert(phead);
	//assert(!ListEmpty(phead));
	//LTNode* tail = phead->prev;
	//LTNode* prev = tail->prev;

	//prev->next = phead;
	//phead->prev = prev;
	//free(tail);
	//tail = NULL;

	ListErase(phead->prev);	//直接调用删除

}

bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

//求链长
size_t ListSize(LTNode* phead)
{
	assert(phead);

	size_t n= 0;
	LTNode* cur = phead->next;
	while (cur!=phead)
	{
		++n;
		cur = cur->next;
	}
	return n;
}

//查找
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	size_t n = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data = x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//在Pos之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

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

}

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;
	free(pos);
	pos = NULL;

}

//销毁
void ListDestory(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur!= phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

3.Test.c

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

void TestList1()
{
	//头指针
	LTNode* plist =ListInit(); //plist永远指着第一个哨兵头
	//尾插
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

	//头插
	ListPushFront(plist, 10);
	ListPushFront(plist, 20);
	ListPushFront(plist, 30);
	ListPushFront(plist, 40);
	ListPrint(plist);
	//尾删
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);

	//头删
	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

}

void TestList2()
{
	LTNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListDestory(plist);
	plist = NULL;
}

void TestList3()
{
	LTNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

}
int main()
{
	//TestList3();
	//TestList3();
	TestList2();

	return 0;
}
Srtive
关注
C语言数据结构-链表
2302_81072215的博客
11-26 1795
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
数据结构-双向链表的基本操作 （c语言实现）
weixin_59799963的博客
10-19 3691
1.创造一个节点,函数实现 DListNode* BuyListNode(Datetype x) { DListNode*node = (DListNode*)malloc(sizeof(DListNode)); node->date = x; node->next = NULL; node->prev = NULL; return node; } 2. 初始化 DListNode* DListInit() { DListNode*plist = BuyListNod
数据结构源代码之双向链表
07-17
继数据结构源代码之单链表后，双线性链表的C代码实现
数据结构：双向链表
m0_62600887的博客
05-03 496
照搬代码 #include <stdio.h> #include <malloc.h> /** * Double linked list of integers. The key is char. */ typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; } DLNode, *DLNodePtr; /
数据结构代码-双向链表
dc15822445347的专栏
11-22 391
/* * 文 件 名: DoublyLink.java * 描 述: 双向链表节点 * 修改时间: 2012-11-22 */ package linklist; /** * 双向链表的节点 */ public class DoublyLink { int iData; double dData; public DoublyLink previou
数据结构（C语言） 双向链表源码
m0_48446168的博客
10-13 564
双向链表 （一）定义 typedef struct DuLNode{ ElemType data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinkList; （二）增 ListInsert_DuL Status ListInsert_DuL(DuLinkList &L, int i, ElemType e) { // 在带头结点的双链循环线性表L的第i个元素...
数据结构 双向链表 实现 纯代码
qq_29796781的博客
08-15 379
双向链表 操作函数原型声明 node_t * init(); //显示双向链表内容 void display(node_t *head); //在双向链表中查找第I个节点存放的地址 node_t *find(node_t *head,int i); //在双向链表中第I个节点后插入值为x的节点 node_t *insert(node_t *head,datatype x,int i); //在...
数据结构-双向链表
04-14
双向链表是一种特殊的数据结构，它在编程中具有重要的应用。本文将深入探讨双向链表的概念，实现，以及如何进行基本操作。 双向链表，顾名思义，是一种链式存储结构，其中每个节点包含两个指针，一个指向前一个节点...
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.youkuaiyun.com/songshuai0223/category_9742561.html。
数据结构-链表的C语言使用
03-25
在C语言中，双向链表的节点定义会包含两个指针：`struct Node {int data; struct Node* next; struct Node* prev;}`。这种链表结构在需要频繁地进行逆序访问或插入删除操作时非常有用。 4. **循环链表**： 循环...
数据结构中的双向链表的代码实现
12-29
数据结构中的双向链表的代码实现，对初学者有帮助
数据结构 双向链表详解和代码演示
菜鸟心声：学的不仅是技术，更是梦想！
12-06 462
双向链表详解1.双向链表介绍1.1单向链表的缺点1.2双向链表2.应用示例2.1题目要求2.2代码实现2.2结果展示 1.双向链表介绍 1.1单向链表的缺点 1）单向链表的查找方向只能是一个方向 2）不能自我删除，必须要辅助节点进行遍历，才可以删除 1.2双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个[指针]，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 分析：双向链表的遍历，添加，修改，删除的操作思路 1）遍历方向可
数据结构---双向链表（附代码
最新发布
2302_81153999的博客
05-17 442
传一级存在的问题是，当phead置为NULL后，实参plist不会被修改为NULL，LTDestory和LTErase参数为什么不传二级指针？带头：指的是链表中有哨兵位节点，该 哨兵位节点 即 头节点。理论上是要传二级指针的，因为我们需要让形参的改变影响到实参。哨兵位节点不存储任何有效元素，只是站在这里“放哨的”“哨兵位”存在的意义： 遍历循环链表避免死循环。因此解决办法是：调用完方法后，手动将实参置为空。2.双向链表(带头双向循环链表) 结构。：尾节点的next指针指向头节点。：单向不带头不循环链表。
Java LinkedList指南
weixin_34358092的博客
01-22 167
1. 介绍 LinkedList是一个双向链表, 实现了List和Deque接口。它实现所有可选的list操作，并且存储对象可以为null。 2. 特点 LinkedList具有以下特点： 查到列表中的元素，需要从头至尾的遍历列表 没有同步 它的Iterator和ListIterator迭代器是快速失败的（这意味着在迭代器创建之后，如果...
数据结构之双链表(C语言代码)
y2629924166的博客
03-24 1428
双向链表 一、什么是双向链表 双向链表又称双链表，是链表的一种，和单链表一样，也是把多个结构体节点用结构体指针连接起来，只不过单链表只有一个指向下一个节点的结构体指针，而双链表有两个结构体指针分别指向上一个节点和下一个节点。 二、双向链表的特点 1、双链表和单链表一样，没有固定的长度，可以自由增加节点 2、双链表有两个指针域，一个用于指向前一个节点，另一个用于指向下一个节点 3、由于有指向前一个节点的指针域，双链表可以很好的支持逆序输出 三、双向链表和单向链表的区别 单链表只有一个指针域，用于指向
数据结构之双向链表（C语言实现）
qq_57312085的博客
08-04 696
双向链表的几种插入，删除，指定位置输出 双向链表的长相 双向链表由前驱指针和后项指针还有数据域组成，把节点之间的前后指针相连接形成链表 双向链表节点的封装 双向链表与单链表相比，仅多了一个前驱指针 typedef struct Node { int data;//内容 struct Node* frontNode;//前驱指针 struct Node* nextNode;//后项指针 }*LPNODE; 双向链表的特点在于可以从左到右，也可以从右到左输出链表，因此.
数据结构（双向链表）（C语言）
x18261294286的博客
08-10 1310
利用C语言实现双向链表的基本功能： 头文件： //LinkList.c #ifndef _LINKLIST_H #define _LINKLIST_H #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef s...
数据结构之双向链表
qq_44962429的博客
01-01 136
单向链表的缺点分析: 1)单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找. 2)单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除,所以前面我们单链表删除节点,总是找到temp,remp是待删除节点的前一个节点. 双向链表分析 (1)遍历:遍历和单链表一样,只是可以向前,也可以向后. (2)添加(添加到双向链表的最后): 1):先找到双向链表的最后一个节点. 2...
双链表源代码c语言,C语言数据结构双链表
weixin_33378570的博客
05-21 135
#include #include #include #include struct node {int data;int key;struct node *next;struct node *prev;};//this link always point to first Linkstruct node *head = NULL;//this link always point to last ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值