双向链表的实现

已于 2025-07-03 11:53:30 修改
阅读量255 收藏 4
点赞数 5
CC 4.0 BY-SA版权
文章标签： 链表 数据结构
于 2025-07-03 11:53:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_62473190/article/details/149090872

目录

一、双向链表的结构

二、双向链表的实现

2.1 双向链表的初始化LTInit

2.2 双向链表的打印LTPrint

2.3 双向链表的判空LTEmpty

2.4 尾插LTPushBack

2.5 尾删LTPopBack

2.6 头插LTPushFront

2.7 头删LTPopFront

2.8 查找LTFind

2.9 插入LTInsert

2.10 删除LTErase

2.11 销毁LTDestroy

三、顺序表和和链表的优缺点分析

四、代码

4.1 ListNode.h

4.2 ListNode.c

4.3 test.c

一、双向链表的结构

双向链表的结构如下图所示：

二、双向链表的实现

2.1 双向链表的初始化LTInit

实现代码如下：

LTNode* BuyNode(LTDataType x) {
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL) {
		perror("BuyNode()::malloc");
		exit(1);
	}
	newnode->next = newnode;
	newnode->prev = newnode;
	newnode->data = x;
	return newnode;
}
LTNode* LTInit() {
	return BuyNode(0);
}

2.2 双向链表的打印LTPrint

实现代码如下：

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

}

2.3 双向链表的判空LTEmpty

实现代码如下：

bool LTEmpty(LTNode* phead) {
	if (phead->next == phead) {
		return true;
	}
	else {
		return false;
	}
}

2.4 尾插LTPushBack

实现代码如下：

LTNode* BuyNode(LTDataType x) {
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL) {
		perror("BuyNode()::malloc");
		exit(1);
	}
	newnode->next = newnode;
	newnode->prev = newnode;
	newnode->data = x;
	return newnode;
}
void LTPushBack(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyNode(x);
	LTNode* tail = phead->prev;

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

}

2.5 尾删LTPopBack

实现代码如下：

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(LTEmpty(phead) != true);
	LTNode* tail = phead->prev;
	LTNode* pretail = tail->prev;
	pretail->next = phead;
	phead->prev = pretail;
	free(tail);
}

2.6 头插LTPushFront

实现代码如下：

LTNode* BuyNode(LTDataType x) {
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL) {
		perror("BuyNode()::malloc");
		exit(1);
	}
	newnode->next = newnode;
	newnode->prev = newnode;
	newnode->data = x;
	return newnode;
}
void LTPushFront(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next = newnode;
	newnode->next->prev = newnode;
}

2.7 头删LTPopFront

实现代码如下：

void LTPopFront(LTNode* phead) {
	assert(phead);
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next->prev = phead;
	free(del);
}

2.8 查找LTFind

实现代码如下：

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

2.9 插入LTInsert

实现代码如下：

void LTInsert(LTNode* pos, LTDataType x){
	assert(pos);
	LTNode* newnode = BuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next = newnode;
	newnode->next->prev = newnode;

}

2.10 删除LTErase

实现代码如下：

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

2.11 销毁LTDestroy

实现代码如下：

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

三、顺序表和和链表的优缺点分析

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

四、代码

4.1 ListNode.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	LTDataType data;
	struct ListNode* next;
}LTNode;

//void LTInit(LTNode** pphead);
LTNode* LTInit();
void LTDestroy(LTNode* phead);
void LTPrint(LTNode* phead);
bool LTEmpty(LTNode* phead);

void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);

void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
void LTErase(LTNode* pos);
LTNode* LTFind(LTNode* phead, LTDataType x);

4.2 ListNode.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"ListNode.h"
LTNode* BuyNode(LTDataType x) {
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL) {
		perror("BuyNode()::malloc");
		exit(1);
	}
	newnode->next = newnode;
	newnode->prev = newnode;
	newnode->data = x;
	return newnode;
}
LTNode* LTInit() {
	return BuyNode(0);
}
void LTDestroy(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur!=phead) {
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	phead->next = phead;
	phead->prev = phead;
}
void LTPrint(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead) {
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");

}
bool LTEmpty(LTNode* phead) {
	if (phead->next == phead) {
		return true;
	}
	else {
		return false;
	}
}

void LTPushBack(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyNode(x);
	LTNode* tail = phead->prev;

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

}
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(LTEmpty(phead) != true);
	LTNode* tail = phead->prev;
	LTNode* pretail = tail->prev;
	pretail->next = phead;
	phead->prev = pretail;
	free(tail);
}

void LTPushFront(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next = newnode;
	newnode->next->prev = newnode;
}
void LTPopFront(LTNode* phead) {
	assert(phead);
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next->prev = phead;
	free(del);
}
LTNode* LTFind(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位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x){
	assert(pos);
	LTNode* newnode = BuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next = newnode;
	newnode->next->prev = newnode;

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

4.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"ListNode.h"
void test01()//测试尾插
{
	LTNode* phead = LTInit();
	LTPushBack(phead, 1);
	LTPushBack(phead, 2);
	LTPushBack(phead, 3);
	LTPushBack(phead, 4);
	LTPrint(phead);
	LTDestroy(phead);
}
void test02()//测试尾删
{
	LTNode* phead = LTInit();
	LTPushBack(phead, 1);
	LTPushBack(phead, 2);
	LTPushBack(phead, 3);
	LTPushBack(phead, 4);
	LTPrint(phead);//1 2 3 4
	LTPopBack(phead);
	LTPrint(phead);//1 2 3
	LTPopBack(phead);
	LTPrint(phead);//1 2
	LTPopBack(phead);
	LTPrint(phead);//1
	LTPopBack(phead);
	LTPrint(phead);//NULL
	LTDestroy(phead);

}
void test03()//测试头插
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTPrint(phead);//4 3 2 1

}
void test04()//测试头删
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTPrint(phead);//4 3 2 1
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
	LTPopFront(phead);
	LTPrint(phead);
}
void tect05()//测试查找
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTNode* ret = LTFind(phead, 4);
	if (ret == NULL) {
		printf("找不到\n");
	}
	else {
		printf("找到了\n");
	}
	ret = LTFind(phead, 9);
	if (ret == NULL) {
		printf("找不到\n");
	}
	else {
		printf("找到了\n");
	}


}
void test06()//测试插入
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTNode* ret = LTFind(phead, 4);
	LTInsert(ret, 99);
	LTPrint(phead);
	ret = LTFind(phead, 1);
	LTInsert(ret, 88);
	LTPrint(phead);
	ret = LTFind(phead, 3);
	LTInsert(ret, 77);
	LTPrint(phead);

}
void test07()//测试删除
{
	LTNode* phead = LTInit();
	LTPushFront(phead, 1);
	LTPushFront(phead, 2);
	LTPushFront(phead, 3);
	LTPushFront(phead, 4);
	LTNode* ret = LTFind(phead, 4);
	LTErase(ret);
	LTPrint(phead);
	ret = LTFind(phead, 3);
	LTErase(ret);
	LTPrint(phead);
	ret = LTFind(phead, 2);
	LTErase(ret);
	LTPrint(phead);
	ret = LTFind(phead, 1);
	LTErase(ret);
	LTPrint(phead);

}
int main() {
	//test01();//测试尾插
	//test02();//测试尾删
	//test03();//测试头插
	//test04();//测试头删
	//tect05();//测试查找、
	//test06();//测试插入
	//test07();//测试删除
	return 0;
}

双向链表实现
hxy1625309592的博客
12-15 2241
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
带头双向链表实现(带图详解)
fw5884179的博客
08-07 692
带头双向链表实现
双向链表实现栈
m0_56398287的博客
10-03 1542
双向链表来实现栈
双向链表实现贪吃蛇
jyx1572676601的博客
10-11 1170
#define _CRT_SECURE_NO_WARNINGS 1 #define __STDC_WANT_LIB_EXT1_ 1 #pragma warning(disable : 4996) #include<stdio.h> #include<string.h> #include <stdio.h> #include <conio.h> #include<time.h> #include<windows.h> typedef s.
C语言实现双向链表
2401_86557724的博客
09-13 2465
本章使用C语言实现了数据结构中的双向链表，对于数据结构的初学者来说有一定难度，但对于提升对链表的理解来说意义非凡，值得我们亲自去实现。
基于 HashMap 和 双向链表实现 LRU
ikun的博仔的博客
06-26 1258
基于HashMap和双向链表实现LRU
【数据结构】双向链表实现
m0_73367097的博客
03-26 1765
双向链表的定义与实现
基于双向链表实现的栈
Gee_Zer的博客
08-15 4259
看了LinkedList的源码，明白了LinkedList底层使用的是双向链表，一直想找个机会实现一下双向链表，今天写到力扣的每日一题20.有效的括号，正好此题需要使用到栈，所以借此机会来自己实现一下基于双向链表实现的栈，实现栈之前要了解以下知识 1.什么是双向链表 双向链表是指一个节点有一个数据域，两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，现在将指向上一个节点的指针域命名为pre，将指向下一个节点的指针域命名为next，节点命名为node，一个合格的双向链表如下图所示 中间的nod
用双向链表实现栈（C）
u014801954的博客
05-15 5505
目录 一.结构定义： 二.结构操作 三.测试代码 四.运用
使用线程安全型双向链表实现简单 LRU Cache 模拟
热门推荐
苏州程序大白的博客
11-16 1万+
使用线程安全型双向链表实现简单 LRU Cache 模拟目录????博主介绍前言1、动机1.1、要解决的问题2、系统设计2.1、系统总体框架2.2、系统功能模块2.3 系统整体流程3、数据结构设计4、关键技术与系统实现4.1、生成访问序列4.2 各进程的推进4.3、修改链表结构的相关方法实现4.4、访问链表的相关方法实现4.5、应用封装层的实现4.6、统计缓冲区命中率5、系统运行结果5.1、运行环境5.2、运行与测试结果5.2.1、运行结果5.2.2、链表方法测试6、调试与改进????作者相关的文章、资源分
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
双向链表实现贪吃蛇游戏（C语言版）
12-26
在本文中，我们将深入探讨如何使用C语言和双向链表实现经典的贪吃蛇游戏。双向链表是一种数据结构，它允许我们在列表中的任何位置轻松地插入和删除元素，这使得它成为实现动态游戏世界，如贪吃蛇，的理想选择。 1. ...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
数据结构预备知识
2301_80037974的博客
07-26 1429
本文介绍了学习数据结构前的三个必备知识：集合框架、复杂度和泛型。Java集合框架是存储管理数据的容器，包含重要接口和实现类。数据结构是计算机存储组织数据的方式，与算法相辅相成。复杂度分析包括时间复杂度（衡量运行速度）和空间复杂度（衡量额外空间使用），常用大O表示法计算。泛型实现了类型参数化，通过擦除机制在编译时进行类型检查，包括泛型类、泛型方法和类型边界等概念，提高了代码的复用性和安全性。掌握这些基础知识对后续数据结构学习至关重要。
数据结构（5）单链表算法题（中）
seanmooPercy的博客
07-29 680
提到回文结构，我们会很自然地想到去定义两个指针，一个指向头，一个指向尾，比较两个值是否相等，再让头指针往后走，尾指针往前走。既然在链表中我们无法判断是否回文，那我们创建一个新数组，把链表的值遍历到新数组中，在数组中判断回文结构不就可以了吗？（题目说了保证链表长度小于等于900）导致代码冗余的根本原因就在于我们创建的是一个空的新链表，因此要进行if…至于新的非空链表的val值是什么，我们不用在乎，因为这个非空链表起的是一个占位置的作用（在后续的链表学习中，这种起到占位置作用的节点，我们称之为“哨兵位”）。
哈希表应用（map,set共同作用）
2401_86637905的博客
07-27 308
接下来的问题就是如何实现这个滑动窗口，先将0到k的数字和个数存入map中，再通过向后滑动判断出去的数字与进入的数字，根据不同情况更改set中的值，但别忘了判断结束后也要更改map中的值。这道题就是将滑动窗口大小为k的数字与个数存入map中，再将map中值为1的数字存入set中。键与值的类型都为int,键指的是数字，值指的是数字出现的个数。map<int,int>m是。set<int>s是。
数据结构——单链表1
最新发布
2302_80045891的博客
07-30 183
概念：链表是一种，数据元素的是通过链表中的次序实现的。
数据结构（7）单链表算法题OVA
seanmooPercy的博客
07-30 149
算法题：随机链表的复制
C语言双向链表实现通讯录详解
在本项目中，将通过双向链表实现一个通讯录功能，允许用户添加、删除、查找和显示联系人信息。每一个联系人信息可以包括姓名、电话号码、电子邮件地址等字段，这些信息将被封装在一个结构体中，作为链表节点的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值