带头双向循环链表的代码实现

最新推荐文章于 2024-05-08 19:05:58 发布
最新推荐文章于 2024-05-08 19:05:58 发布
阅读量64 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72487560/article/details/128302014
版权

        上一章我们对单链表的简单功能做了代码实现，但对于单链表不适合存储的一些缺点，这一章我们来实现另一种常见的链式结构---带头双向循环链表。

文章目录

  • 前言
  • 双向循环链表的初始化
  • 双向循环链表的打印
  • 双向循环链表新的结点
  • 双向循环链表尾插
  • 双向循环链表头插
  • 双向循环链表尾删
  • 双向循环链表头删
  • 双向循环链表查找
  • 双向循环链表的指定位置前插入
  • 双向循环链表的指定位置删除
  • 双向循环链表销毁
  • 头文件代码
  • 源文件代码
  • 链表与顺序表区别总结

前言

         上一章我们介绍了单链表的增删查改等简单功能，链表的划分大致有是否带哨兵位的头结点，是否双向，是否循环，这章我们介绍带头双向循环链表（如下图所示），看起来虽然很复杂，但是实现起来其实比单链表还要简单，因为它有着结构上的优势，在存储或者增删查改中都有着自己的优势，在以下代码实现中大家就能感受到。

（本篇参考比特科技学习）

typedef struct listNode {
	dataType val;
	struct listNode* next;
	struct listNode* prev;
}listNode;

 

        双向循环链表带头且每个结点可以指向下一个结点也可以指向上一个结点，最后一个结点指向头结点，头结点也指向最后一个结点，如果只有头结点自己，它自己指向自己。 

 双向循环链表的初始化

listNode* listInit() {
	listNode* phead = (listNode*)malloc(sizeof(listNode));
	phead->prev = phead;
	phead->next = phead;
	return phead;
}

         初始化就是直接开辟一个新结点自己指向自己，这里面的值不重要，因为它就起到一个头结点的作用。

双向循环链表的打印

void listPrint(listNode* phead) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		printf("%d ", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

        打印直接传链表头结点，让cur等于头结点的next每次往后走，不是头结点就打印，到了就结束。 

 双向循环链表新的结点

listNode* buyListNode(dataType val) {
	listNode* newnode = (listNode*)malloc(sizeof(listNode));
	newnode->val = val;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

        因为头插尾插随即插入都需要开辟新结点，所以封装一下。 

双向循环链表尾插

void listNodePushBack(listNode* phead, dataType val) {
	assert(phead);
	/*listNode* newnode = buyListNode(val);
	listNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;*/

	listNodeInsert(phead->prev,val);
}

        注释掉的是我们不用insert优化自己写的，下面介绍完insert我们可以用insert来优化头插尾插。不用insert尾插思路也很简单，创建一个tail记录phead的上一个结点也就是现在的尾结点，让这个新结点的prev指向原来尾结点，再让原来尾结点指向这个新结点，再让新结点跟头结点相互存一下地址即可，即使是空链表只有一个头结点这样依然可行。 

双向循环链表头插

void listNodePushFront(listNode* phead, dataType val) {
	assert(phead);
	/*listNode* newnode = buyListNode(val);
	listNode* headNext = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = headNext;
	headNext->prev = newnode;*/

	listNodeInsert(phead->next, val);
}

        头插思路也一样，为了保持代码可读性，我们先把头结点存的next用一个临时表量存起来，然后新链表跟头结点互存地址，跟headNext互存地址，如果原本是空链表，那么这个headNext还是头结点，也不会出现问题。

双向循环链表尾删

void listNodePopBack(listNode* phead) {
	assert(phead && (phead->next != phead));
	/*listNode* newTail = phead->prev->prev;
	free(phead->prev);
	newTail->next = phead;
	phead->prev = newTail;*/

	listNodeDelete(phead->prev);
}

         尾删就需要判断一下是不是空链表了，我们总不能把哨兵位的头结点删了。只需要断言一下头结点的next是不是它自己就行。这个时候就凸显出来这种结构的优势了，既然是尾删，那么新的尾就是头结点的prev的prev，如果就一个，那么新的尾就是头结点也不会出问题，这个时候我们只需要把原来的尾free掉，把头结点指向新的尾，再把新的尾指向头结点即可。

双向循环链表头删

void listNodePopFront(listNode* phead) {
	assert(phead && (phead->next != phead));
	/*listNode* newHead = phead->next->next;
	free(phead->next);
	newHead->prev = phead;
	phead->next = newHead;*/

	listNodeDelete(phead->next);
}

        头删的思路跟尾删几乎一样，不再赘述。 

双向循环链表查找

listNode* listNodeFind(listNode* phead, dataType val) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		if (cur->val == val) return cur;
		cur = cur->next;
	}
	return NULL;
}

         定义一个cur存头结点下一个结点，循环走直到遇到头结点说明找了一遍这时还没有找到返回空。如果找到了直接返回cur，没有找到往后挪。

双向循环链表的指定位置前插入

void listNodeInsert(listNode* pos, dataType val) {
	assert(pos);
	listNode* newnode = buyListNode(val);
	listNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

        在指定位置前插入其实脑子里想一想就很简单，只需要搞出一个新结点，让本来前面那个跟新结点互相存址，再让这个跟新结点互相存址即可。为了保持可读性，我们先定义好前面那个结点posPre这样代码看起来直接就能明白啥意思。就算是链表中只有哨兵位的头，那么插入进来的结点也是和头结点互相存址的。 

双向循环链表的指定位置删除

void listNodeDelete(listNode* pos) {
	assert(pos);
	listNode* posPrev = (pos)->prev;
	listNode* posNext = (pos)->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;
}

        删除的思路也很简单，我们直接定义这个位置前后的两个结点，让前后两个结点互指，再把中间这个要删的free就行。 同样就算链表中除了头只有一个结点也可以成功删除，最后还是头自己指向自己。

双向循环链表销毁

void listDestroy(listNode* phead) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		listNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	free(phead);
}

        销毁这里我们没有传二级指针，因为整个代码传的几乎都是一级指针，为了保持一致性我们可以这里传一级然后在外面将phead搞为空指针。 

头文件代码

#pragma once

#define _CRT_NO_SECRUE_WARNINGS

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

typedef int dataType;

typedef struct listNode {
	dataType val;
	struct listNode* next;
	struct listNode* prev;
}listNode;

//双向循环链表的初始化
listNode* listInit();

//双向循环链表的打印
void listPrint(listNode* phead);

//双向循环链表新的结点
listNode* buyListNode(dataType val);

//双向循环链表的尾插
void listNodePushBack(listNode* phead, dataType val);

//双向循环链表的头插
void listNodePushFront(listNode* phead, dataType val);

//双向循环链表的尾删
void listNodePopBack(listNode* phead);

//双向循环链表的头删
void listNodePopFront(listNode* phead);

//双向循环链表的查找
listNode* listNodeFind(listNode* phead, dataType val);

//双向循环链表的指定位置前插入
void listNodeInsert(listNode* pos, dataType val);

//双向循环链表的指定位置删除
void listNodeDelete(listNode* pos);

//双向循环链表的销毁
void listDestroy(listNode* phead);

源文件代码 

#include "list.h"

listNode* listInit() {
	listNode* phead = (listNode*)malloc(sizeof(listNode));
	phead->prev = phead;
	phead->next = phead;
	return phead;
}

listNode* buyListNode(dataType val) {
	listNode* newnode = (listNode*)malloc(sizeof(listNode));
	newnode->val = val;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

void listPrint(listNode* phead) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		printf("%d ", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

void listNodePushBack(listNode* phead, dataType val) {
	assert(phead);
	/*listNode* newnode = buyListNode(val);
	listNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;*/

	listNodeInsert(phead->prev,val);
}

void listNodePushFront(listNode* phead, dataType val) {
	assert(phead);
	/*listNode* newnode = buyListNode(val);
	listNode* headNext = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = headNext;
	headNext->prev = newnode;*/

	listNodeInsert(phead->next, val);
}

void listNodePopBack(listNode* phead) {
	assert(phead && (phead->next != phead));
	/*listNode* newTail = phead->prev->prev;
	free(phead->prev);
	newTail->next = phead;
	phead->prev = newTail;*/

	listNodeDelete(phead->prev);
}

void listNodePopFront(listNode* phead) {
	assert(phead && (phead->next != phead));
	/*listNode* newHead = phead->next->next;
	free(phead->next);
	newHead->prev = phead;
	phead->next = newHead;*/

	listNodeDelete(phead->next);
}

listNode* listNodeFind(listNode* phead, dataType val) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		if (cur->val == val) return cur;
		cur = cur->next;
	}
	return NULL;
}

void listNodeInsert(listNode* pos, dataType val) {
	assert(pos);
	listNode* newnode = buyListNode(val);
	listNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

void listNodeDelete(listNode* pos) {
	assert(pos);
	listNode* posPrev = (pos)->prev;
	listNode* posNext = (pos)->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;
}

void listDestroy(listNode* phead) {
	assert(phead);
	listNode* cur = phead->next;
	while (cur != phead) {
		listNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	free(phead);
}

链表与顺序表区别总结

顺序表：

优点：

  1. 支持随机访问，可以用二分，排序等算法
  2. CPU高速缓存的利用率更高

缺点：

  1. 插入删除数据的效率较低，时间复杂度为O(N)
  2. 在物理结构上是连续存储的，空间不够了需要增容，增容会有一定消耗，增容空间大了还需要找更大空间并把已有数据拷贝，为避免频繁扩容一般都按两倍增容，但用不完也会导致一定的空间浪费

链表（双向带头循环链表）：

优点：

  1. 可以在任意位置插入删除，时间复杂度为O(N)
  2. 可以按需申请释放空间，不会导致空间浪费

缺点：

  1. 不支持随机访问，二分，排序等算法不适用
  2. 每存一个值的同时还需要存其他结点的地址，会有一定消耗
  3. CPU高速缓存命中率更低
Loveyoyo️
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回...
带头双向循环链表的实现
南猿北者博客
11-08 611
对于链表来说，不只有单链表这一个品种；链表有很多种形态按方向分：单向、双向按带不带头：带头、不带头按循环：循环、不循环1、单向或则双向：2、带头或者不带头：组合排列一下的话，链表一共有8种形态！！！今天我们就来学习一下结构最复杂的带头双向循环链表！！！；虽然名字听上去比较复杂，但是实现起来比单链表（全名：不带头、不循环、单向链表）更加简单，也不需要过多考虑特殊情况；两种链表的比较：（上面是单链表，下面是带头双向循环链表）
线性表之带头双向循环链表
m0_62171658的博客
03-06 1270
初学者必备：线性表之带头双向循环链表接口实现和一些链表必备思想
数据结构-带头双向循环链表的基本实现（C语言，简单易懂，含全部代码）
阿龙的博客
04-26 2193
【数据结构基础入门】带头双向循环链表的概念、结构和接口实现
数据结构-带头双向循环链表
m0_61433144的博客
07-18 1383
链表的种类非常丰富，有带头结点的或不带头结点的，有单向的或双向的，有循环的或非循环的，这样组合起来有2*2*2=8种链表结构。头结点与头指针的概念：不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头链表中第一个结点，该结点通常不存储数据。 引入头结点可以带来两个优点：1.由于第一个数据结点的位置被存储在头结点的指针域中，因此在链表的第一个位置上的操作和在链表其他位置上的操作一致，无须进行特殊处理。2.无论链表是否为空，其头指针都指向头结点，因此空表与非空表的处理也得到统一。........
【数据结构】双向链表（带头双向循环链表）——超详细代码
qq_59702185的博客
08-15 1732
在上一篇文章我们已经介绍了链表的分类，链表的种类非常多，分为带头还是不带头、单向的还是多向的、单向还是双向循环……上一节我们学习了不带头单向的不循环的链表，这一节，我们主要实现带头双向循环的链表。如果我们把这两种结构的链表掌握的话，那么所有类型的链表我们都可以自己实现了带头双向链表有一个数据域和两个指针域。指针域一个是前驱指针，指向前一个节点，一个是后继指针，指向后一个节点。//前驱节点 struct ListNode * next;//后继节点 LTDataType data;//数据域 };...
带头双向循环链表（C语言实现）
xiaoming1999的博客
03-26 1464
带头双向循环链表概念及结构 概念：带头双向循环链表结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。 带头双向循环链表的实现 List.h代码实现 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int LTDataTyp
【数据结构初阶】链表（下）——带头双向循环链表的实现
m0_70811813的博客
11-07 325
带头双向循环链表的实现、无头单向非循环链表和带头双向循环链表的对比、链表和顺序表的对比
如何实现带头双向循环链表
qq_64657314的博客
12-09 161
C语言实现带头双向循环链表的创建，尾插尾删，头插头删，查找，插入，删除操作。
【数据结构】带头双向循环链表
Welcome home | Jian Liao 's blog
03-15 1869
前面学习了单链表的结构，并且做了些许单链表的OJ练习，相信大家已经对单链表的结构了如指掌。因此，本章带来了与单链表同源的但拥有不同的结构的链表带头双向循环链表供大家学习。可能大家听到带头双向循环链表这个名字，就会认为该结构很复杂（的确很复杂，是链表当中结构最复杂的），肯定比单链表要难许多，说实在的，如果没有前面单链表的铺垫，直接上这个结构，那肯定挺难的。但现在我们有了单链表的基础，并且做了挺多单链表的题了，也就不用怕了。实际上，带头双向循环链表只是看起来难，听起来难，但它实现起来，比单链表简单多了。
循环链表和双向链表.ppt
09-20
带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家...
C语言使用非循环双向链表实现队列
12-22
第二，大家在很多书上看到的是使用单链表实现队列，我这里将会使用带头结点尾结点的非循环双链表实现，虽然多维护了两个节点和指针域，但是在链表头尾进行插入删除的时候不需要遍历链表了，队列操作变得非常
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
双向带头循环链表
C语言：指针（1）
最新发布
2301_80416749的博客
05-08 1129
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为⽆具体类型的指针（或者叫泛型指 针），这种类型的指针可以⽤来接受任意类型地址。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址.const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。
从C向C++17——常见算法
墨城烟柳ベ旧人殇的博客
05-06 743
C++STL常见算法
C语言：__attribute__((packed))
qq_26226375的博客
05-08 318
在使用结构体的时候，经常要。但是按照C语言的规则，会对不同类型的数据类型进行。有时候就会造成一些问题，如果不需要使用自动对齐的功能，就需要使用到本章的关键字。
有用的C 预定义的宏：__DATE__,__TIME__,__FILE__,__LINE__
qq_34503002的博客
05-07 312
有用的C 预定义的宏：__DATE__,__TIME__,__FILE__,__LINE__
java实现带头双向循环链表(附完整源码)
06-08
以下是Java实现带头双向循环链表的完整源码，供参考： ``` public class DoublyCircularLinkedList<T> { private Node<T> head; // 头节点 // 节点类 private static class Node<T> { T data; Node<T> prev; Node<T> next; Node(T data) { this.data = data; this.prev = null; this.next = null; } } // 构造函数 public DoublyCircularLinkedList() { head = new Node<>(null); head.prev = head; head.next = head; } // 在链表末尾添加元素 public void add(T data) { Node<T> node = new Node<>(data); node.prev = head.prev; node.next = head; head.prev.next = node; head.prev = node; } // 在指定位置插入元素 public void insert(int index, T data) { Node<T> node = new Node<>(data); Node<T> p = head.next; int i = 0; while (p != head && i < index) { p = p.next; i++; } if (p == head || i > index) { throw new IndexOutOfBoundsException(); } node.prev = p.prev; node.next = p; p.prev.next = node; p.prev = node; } // 删除指定位置的元素 public void remove(int index) { Node<T> p = head.next; int i = 0; while (p != head && i < index) { p = p.next; i++; } if (p == head || i > index) { throw new IndexOutOfBoundsException(); } p.prev.next = p.next; p.next.prev = p.prev; p.prev = null; p.next = null; } // 获取指定位置的元素 public T get(int index) { Node<T> p = head.next; int i = 0; while (p != head && i < index) { p = p.next; i++; } if (p == head || i > index) { throw new IndexOutOfBoundsException(); } return p.data; } // 获取链表长度 public int size() { Node<T> p = head.next; int size = 0; while (p != head) { size++; p = p.next; } return size; } } ``` 该代码实现了带头双向循环链表的数据结构，支持在链表末尾添加元素、在指定位置插入元素、删除指定位置的元素、获取指定位置的元素、获取链表长度等操作。在算法实现中，通过一个Node类来表示链表中的节点，包含数据域、前驱指针和后继指针。同时，链表的头节点也是一个Node对象，通过头节点来连接链表的首尾，形成双向循环链表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值