带头双向循环链表：一种高效的数据结构

news2025/1/19 8:13:53
  • 💓 博客主页：江池俊的博客
  • ⏩ 收录专栏：数据结构探索
  • 👉专栏推荐：✅cpolar ✅C语言进阶之路
  • 💻代码仓库：江池俊的代码仓库
  • 🔥编译环境：Visual Studio 2022
  • 🎉欢迎大家点赞👍评论📝收藏⭐

在这里插入图片描述

文章目录

    • 一、带头循环双向链表的概念及结构
    • 二、使用带头双向循环链表的优势及注意事项
    • 三、带头双向链表的创建
      • ✨3.1 准备工作✨
      • ✨3.2 创建返回链表的头结点✨
      • ✨3.3 双向链表销毁✨
      • ✨3.4 双向链表打印✨
      • ✨3.5 双向链表尾插✨
      • ✨3.6 双向链表尾删✨
      • ✨3.7 双向链表头插✨
      • ✨3.8 双向链表头删✨
      • ✨3.9 双向链表查找✨
      • ✨3.10 双向链表在pos的前面进行插入✨
      • ✨3.11 双向链表删除pos位置的节点✨
    • 四、源代码
      • 🌅4.1 List.h 文件
      • 🌅4.2 List.c 文件
      • 🌅4.3 Test.c 文件
      • 🌅4.4 测试结果

双向循环链表是一种复杂的数据结构，它结合了双向链表和循环链表的优点。与单向链表相比，双向链表可以双向遍历，而循环链表则可以在尾部链接到头部，形成一个闭环。这种数据结构在某些应用场景下非常有用，比如事件处理、图形界面、内存管理等。

一、带头循环双向链表的概念及结构

双向循环链表是一种特殊类型的链表，它由一系列节点组成，每个节点包含一个数据域和两个指针域。其中一个指针指向下一个节点，另一个指针指向前一个节点。在双向循环链表中，首节点的前一个节点是尾节点，尾节点的下一个节点是首节点，形成一个闭环。

在这里插入图片描述

二、使用带头双向循环链表的优势及注意事项

【优势】：

  1. 高效遍历：由于带头双向循环链表可以双向遍历，因此可以在O(1)时间内访问任何节点。
  2. 内存高效：与双向链表相比，带头双向循环链表不需要额外的内存来存储头部节点。
  3. 插入和删除操作高效：在带头双向循环链表中插入和删除节点时，只需调整指针即可，无需移动大量数据。

【注意事项】：

  1. 初始化：在创建带头双向循环链表时，需要正确初始化所有节点的指针。
  2. 异常处理：在进行插入、删除等操作时，需要处理指针异常情况，如空指针或无效指针。
  3. 内存管理：在使用带头双向循环链表时，需要正确管理内存，避免内存泄漏或野指针。

三、带头双向链表的创建

✨3.1 准备工作✨

将代码分成三个文件可以提高代码的可读性、可维护性和可重用性。具体来说，三个文件可以分别关注以下方面：

  1. 配置文件：用于存储应用程序的配置信息，如数据库连接信息、应用程序名称、应用程序版本等。该文件可以在应用程序的整个生命周期内进行维护和管理，并且可以轻松地与其他开发人员共享。
  2. 模块文件：用于存储应用程序的各个模块，如用户管理、订单管理、产品管理等。每个模块都可以单独维护和测试，并且可以在不同的应用程序中重复使用。这有助于降低代码冗余和提高代码的可重用性。
  3. 入口文件：用于定义应用程序的入口，如路由、请求处理等。该文件可以控制应用程序的整个流程，并且可以轻松地与其他开发人员共享。

通过将代码分成三个文件，可以更好地组织代码结构，使其更加清晰和易于维护。同时，这也使得代码更易于测试和调试，并且可以更好地支持代码重构和优化。

在这里插入图片描述

#pragma once

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

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data; //节点存储的数据元素
	struct ListNode* next; //指向前驱节点
	struct ListNode* prev; //指向后继节点
}ListNode; //双链表结构

//几大接口
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

✨3.2 创建返回链表的头结点✨

动态申请一个节点作为双向链表的头节点。并将头节点的 prev 指向自己，next也指向自己，表明这是一个双向链表，且链表为空。

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		perror("ListCreate --> malloc");
		return;
	}
	head->data = -1;
	head->prev = head;
	head->next = head;
	return head;
}

✨3.3 双向链表销毁✨

从链表的第二个节点开始，逐个释放链表中的节点，直到回到头节点并释放头节点的内存空间。这样做可以确保链表中的所有节点都被正确释放，防止内存泄漏。

// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next; 
	}
	free(pHead);
	printf("双链表销毁成功！\n");
}

✨3.4 双向链表打印✨

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	printf("哨兵位 <--> ");
	while (cur != pHead)
	{
		printf("%d <--> ", cur->data);
		cur = cur->next;
	}
	printf("哨兵位\n");
}

✨3.5 双向链表尾插✨

在进行插入节点之前，无论是头插还是尾插都需要申请一个新的节点，于是可以把此步骤成一个函数，减少代码的冗余。

//申请一个节点
ListNode* CreateLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("CreateLTNode --> malloc");
		return;
	}

	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL;

	return newnode;
}
  1. 首先，创建一个新的节点newnode，并将数据x存储在其中。
  2. 将newnode的prev指针指向当前链表的第一个节点pHead的前一个节点，即pHead->prev。
  3. 将newnode的next指针指向当前链表的第一个节点pHead。
  4. 将当前链表的第一个节点pHead的前一个节点的next指针指向新节点newnode。
  5. 将当前链表的第一个节点pHead的prev指针指向新节点newnode。

通过以上步骤，新节点被插入到双向链表的尾部，并且链表中的其他节点仍然保持其原始顺序和链接关系。这样做可以确保新节点被正确地添加到链表中，并且不会破坏链表的结构。

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = CreateLTNode(x);

	//pHead           pHead->prev  newnode
	newnode->prev = pHead->prev; 
	newnode->next = pHead;
	pHead->prev->next = newnode;
	pHead->prev = newnode;
}

✨3.6 双向链表尾删✨

  1. 首先，获取链表的最后一个节点tail，它应该是头节点pHead的前一个节点（即pHead->prev）。
  2. 接着，获取最后一个节点的前一个节点tailPrev。
  3. 将头节点pHead的prev指针指向最后一个节点的前一个节点tailPrev，从而将最后一个节点从链表中间删除。
  4. 将最后一个节点的前一个节点的next指针指向头节点pHead，从而将头节点和最后一个节点连接起来。
  5. 最后，释放最后一个节点的内存空间。
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->next!=pHead);//链表不能为空

	ListNode* tail = pHead->prev;
	ListNode* tailPrev = tail->prev;
	// pHead     tailPrev tail
	pHead->prev = tailPrev;
	tailPrev->next = pHead;

	free(tail);
}

✨3.7 双向链表头插✨

  1. 首先，创建一个新的节点newnode，并将数据x存储在其中。
  2. 将新节点的prev指针指向当前链表的第一个节点pHead。
  3. 将新节点的next指针指向当前链表的第一个节点的下一个节点，即pHead->next。
  4. 将当前链表的第一个节点的next指针指向新节点newnode。
  5. 将当前链表的第一个节点的下一个节点的prev指针指向新节点newnode。

通过以上步骤，新节点被插入到双向链表的头部，并且链表中的其他节点仍然保持其原始顺序和链接关系。这样做可以确保新节点被正确地添加到链表中，并且不会破坏链表的结构。

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = CreateLTNode(x);

	ListNode* rear = pHead->next;
	pHead->next = newnode;
	newnode->prev = pHead;
	newnode->next = rear;
	rear->prev = newnode;
}

✨3.8 双向链表头删✨

  1. 首先，获取链表的第一个节点cur，它应该是头节点pHead的下一个节点（即pHead->next）。
  2. 将头节点的next指针指向第一个节点的下一个节点，从而将第一个节点从链表中间删除。
  3. 将第一个节点的下一个节点的prev指针指向头节点pHead，从而将头节点和第一个节点连接起来。
  4. 最后，释放第一个节点的内存空间。
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->next != pHead);

	ListNode* cur = pHead->next;
	pHead->next = cur->next;
	cur->next->prev = pHead;

	free(cur);
}

✨3.9 双向链表查找✨

  1. 首先，从链表的第二个节点开始（即pHead->next），遍历链表的每个节点。
  2. 对于每个节点，检查其存储的数据是否与要查找的数据x相等。
  3. 如果找到了匹配的节点，则返回该节点。
  4. 如果遍历完整个链表都没有找到匹配的节点，则返回空指针（NULL）。
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//如果没找到，返回空
}

✨3.10 双向链表在pos的前面进行插入✨

  1. 首先，创建一个新的节点newnode，并将数据x存储在其中。
  2. 获取要插入位置的前一个节点_prev。
  3. 将前一个节点的next指针指向新节点newnode。
  4. 将新节点的prev指针指向前一个节点_prev。
  5. 将新节点的next指针指向当前节点pos。
  6. 将当前节点的prev指针指向新节点newnode。

通过以上步骤，新节点被插入到指定位置的前面，并且链表中的其他节点仍然保持其原始顺序和链接关系。这样做可以确保新节点被正确地添加到链表中，并且不会破坏链表的结构。

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = CreateLTNode(x);
	ListNode* _prev = pos->prev;

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

✨3.11 双向链表删除pos位置的节点✨

  1. 首先，确保要删除的节点pos不是空指针。
  2. 获取要删除节点的前一个节点_prev和后一个节点rear。
  3. 将前一个节点的next指针指向后一个节点，从而将要删除的节点从链表中间删除。
  4. 将后一个节点的prev指针指向前一个节点，从而将前一个节点和后一个节点连接起来。
  5. 释放要删除的节点的内存空间。
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* _prev = pos->prev;
	ListNode* rear = pos->next;

	_prev->next = rear;
	rear->prev = _prev;

	free(pos);
}

四、源代码

🌅4.1 List.h 文件

#pragma once

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

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data; //节点存储的数据元素
	struct ListNode* next; //指向前驱节点
	struct ListNode* prev; //指向后继节点
}ListNode; //双链表结构

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

🌅4.2 List.c 文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "List.h"

//申请一个节点
ListNode* CreateLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("CreateLTNode --> malloc");
		return;
	}

	newnode->data = x;
	newnode->prev = NULL;
	newnode->next = NULL;

	return newnode;
}
// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		perror("ListCreate --> malloc");
		return;
	}
	head->data = -1;
	head->prev = head;
	head->next = head;
	return head;
}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next; 
	}
	free(pHead);
	printf("双链表销毁成功！\n");
}
// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	printf("哨兵位 <--> ");
	while (cur != pHead)
	{
		printf("%d <--> ", cur->data);
		cur = cur->next;
	}
	printf("哨兵位\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = CreateLTNode(x);

	//pHead           pHead->prev  newnode
	newnode->prev = pHead->prev; 
	newnode->next = pHead;
	pHead->prev->next = newnode;
	pHead->prev = newnode;
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->next!=pHead);//链表不能为空

	ListNode* tail = pHead->prev;
	ListNode* tailPrev = tail->prev;
	// pHead     tailPrev tail
	pHead->prev = tailPrev;
	tailPrev->next = pHead;

	free(tail);
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = CreateLTNode(x);

	ListNode* rear = pHead->next;
	pHead->next = newnode;
	newnode->prev = pHead;
	newnode->next = rear;
	rear->prev = newnode;
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->next != pHead);

	ListNode* cur = pHead->next;
	pHead->next = cur->next;
	cur->next->prev = pHead;

	free(cur);
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//如果没找到，返回空
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = CreateLTNode(x);
	ListNode* _prev = pos->prev;

	// _prev newnode pos
	_prev->next = newnode;
	newnode->prev = _prev;
	newnode->next = pos;
	pos->prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* _prev = pos->prev;
	ListNode* rear = pos->next;

	_prev->next = rear;
	rear->prev = _prev;

	free(pos);
}

🌅4.3 Test.c 文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "List.h"


void Test1()
{
	ListNode* plist = ListCreate();
	//尾插1、2、3
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPrint(plist);
	//头插5、4
	ListPushFront(plist, 5);
	ListPushFront(plist, 4);
	ListPrint(plist);
	//查找元素3，找到返回节点地址，没找到返回空
	ListNode* pos = ListFind(plist, 3);
	if (pos)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	//在3前面插入30
	ListInsert(pos, 30);
	ListPrint(plist); 
	//删除3
	if (pos)
	{
		ListErase(pos);
		pos = NULL;
	}
	ListPrint(plist);
	//尾删两次
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);
	//头删两次
	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);
	//销毁链表
	ListDestory(plist);
	plist = NULL;
}


int main()
{
	Test1();
	return 0;
}

🌅4.4 测试结果

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1280526.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Unity DOTS《群体战斗弹幕游戏》核心技术分析之3D角色动画

Unity DOTS《群体战斗弹幕游戏》核心技术分析之3D角色动画

最近DOTS发布了正式的版本, 我们来分享现在流行基于群体战斗的弹幕类游戏&#xff0c;实现的核心原理。今天给大家介绍大规模战斗群体3D角色的动画如何来实现。 DOTS 对角色动画支持的局限性 截止到Unity DOTS发布的版本1.0.16,目前还是无法很好的支持3D角色动画。在DOTS 的b…
阅读更多...
【Python】tensorflow学习的个人纪录（2）

【Python】tensorflow学习的个人纪录（2）

actor.learn(s, a, td_error)def learn(self, s, a, td):s s[np.newaxis, :]feed_dict {self.s: s, self.a: a, self.td_error: td}_, exp_v self.sess.run([self.train_op, self.exp_v], feed_dict)return exp_v输入变量的数值&#xff1a; 步进&#xff1a; []---->[…
阅读更多...
算法设计与实现--动态规划篇

算法设计与实现--动态规划篇

什么是动态规划算法 动态规划算法是一种求解复杂问题的方法&#xff0c;通过将原问题分解为相对简单的子问题来求解。其基本思想是将待求解的问题分解为若干个子问题&#xff08;阶段&#xff09;&#xff0c;按顺序求解子阶段&#xff0c;前一子问题的解&#xff0c;为后一子…
阅读更多...
割裂式“多渠道”不是真正的全渠道！浅析全渠道零售和DTC在理念上的不谋而合｜徐礼昭

割裂式“多渠道”不是真正的全渠道！浅析全渠道零售和DTC在理念上的不谋而合｜徐礼昭

图文&#xff1a;徐礼昭 全渠道零售概念解析 全渠道零售概念由来已久&#xff0c;单纯从业务经营角度&#xff0c;一个品牌在线上线下多个渠道铺货卖货&#xff0c;只能说是多渠道零售&#xff0c;而不是全渠道零售。商派市场负责人徐礼昭认为&#xff0c;品牌企业应该从消费者…
阅读更多...
前后端分离部署https

前后端分离部署https

引用&#xff1a;https://blog.csdn.net/weixin_35676679/article/details/127841598 前后端部署&#xff0c;&#xff0c;一般用的是nginx和java&#xff0c;&#xff0c;&#xff0c; 下载SSL证书&#xff1a; java配置https 将证书配置到springboot中 server:port: 544…
阅读更多...
为什么要构建指标中台？数据指标的问题

为什么要构建指标中台？数据指标的问题

1、综合内部实践和外部交流&#xff0c;指标使用问题主要集中在以下六大方面&#xff1a; 指标口径不一致&#xff1a;常规数据质量问题统计中&#xff0c;约有 31% 涉及指标口径问题&#xff1b; 指标入口不统一&#xff1a;缺少一个企业级的统一消费入口&#xff0c;不知道从…
阅读更多...
Ubuntu22.04无需命令行将软件更新源切换到国内

Ubuntu22.04无需命令行将软件更新源切换到国内

1、右上角打开设置 2、在设置中拉到最下面点击About&#xff0c;然后点击Software Updates 3、点击下拉框 4、选择other 5、找到China&#xff0c;选择一个网址&#xff0c;然后点击Choose Server 6、输入密码并回车 7、点击Close 8、点击Reload 9、等待完成即可 10、等结束之后…
阅读更多...
【数电笔记】16-卡诺图绘制（逻辑函数的卡诺图化简）

【数电笔记】16-卡诺图绘制（逻辑函数的卡诺图化简）

目录 说明&#xff1a; 最小项卡诺图的组成 1. 相邻最小项 2. 卡诺图的组成 2.1 二变量卡诺图 2.2 三表变量卡诺图 2.3 四变量卡诺图 3. 卡诺图中的相邻项&#xff08;几何相邻&#xff09; 说明&#xff1a; 笔记配套视频来源&#xff1a;B站&#xff1b;本系列笔记并…
阅读更多...
【STM32】STM32学习笔记-软件安装(03)

【STM32】STM32学习笔记-软件安装(03)

00. 目录 文章目录 00. 目录01. MDK安装02. Keil5注册03. 支持包安装04. ST-LINK驱动安装05. USB转串口驱动06. 附录 01. MDK安装 MDK 源自德国的 KEIL 公司&#xff0c;是 RealView MDK 的简称。在全球 MDK 被超过 10 万的嵌入式开发工程师使用。目前最新版本为&#xff1a; …
阅读更多...
Python生产者消费者模型

Python生产者消费者模型

额滴名片儿 &#x1f388; 博主&#xff1a;一只程序猿子 &#x1f388; 博客主页&#xff1a;一只程序猿子 博客主页 &#x1f388; 个人介绍&#xff1a;爱好(bushi)编程&#xff01; &#x1f388; 创作不易&#xff1a;如喜欢麻烦您点个&#x1f44d;或者点个⭐&#xff01…
阅读更多...
Python面向对象⑤：多态【侯小啾python领航班系列（二十三）】

Python面向对象⑤：多态【侯小啾python领航班系列（二十三）】

Python面向对象⑤：多态【侯小啾python领航班系列（二十三）】 大家好，我是博主侯小啾， 🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹꧔ꦿ🌹…
阅读更多...
Pytest测试攻略：探寻pytest.main()隐藏的利器

Pytest测试攻略：探寻pytest.main()隐藏的利器

更多资料获取 &#x1f4da; 个人网站&#xff1a;ipengtao.com 在Pytest测试框架中&#xff0c;pytest.main()是一个重要的功能&#xff0c;用于启动测试执行。它允许以不同方式运行测试&#xff0c;传递参数和配置选项。本文将深入探讨pytest.main()的核心功能&#xff0c;提…
阅读更多...
大数据技术学习笔记（七）—— Zookeeper

大数据技术学习笔记（七）—— Zookeeper

目录 1 Zookeeper 概述1.1 Zookeeper 定义1.2 Zookeeper 工作机制1.3 Zookeeper 特点1.4 数据结构1.5 应用场景 2 Zookeeper 安装3 客户端命令行操作4 Zookeeper 的 Java 客户端操作4.1 IDEA 环境搭建4.2 初始化 ZooKeeper 客户端4.3 创建子节点4.4 获取子节点4.5 判断Znode是否…
阅读更多...
根据豆瓣对《流浪地球》的短评数据进行文本分析和挖掘

根据豆瓣对《流浪地球》的短评数据进行文本分析和挖掘

1背景 2019年2月5日电影《流浪地球》正式在中国内地上映。该电影在举行首映的时候&#xff0c;口德好得出奇&#xff0c;所有去看片的业界大咖都发出了画样赞叹&#xff0c;文化学者能锦说:“中国科幻电影元年开启了。"导演徐峰则说&#xff0c;“里程碑式的电影&#xf…
阅读更多...
Debian12配置ssh服务器

Debian12配置ssh服务器

Debian12配置ssh服务器 安装ssh-server sudo apt install openssh-server启动ssh sudo systemctl start ssh启用ssh sudo systemctl enable ssh查看ssh状态 sudo systemctl status ssh可以看到有enabled和running字样 说明ssh启用成功 连接到服务器 # username是你的用…
阅读更多...
洛谷 P5715 三位数排序 C++代码

洛谷 P5715 三位数排序 C++代码

目录 前言 思路点拨 AC代码1 AC代码2 AC代码3 结尾 前言 今天我们来做洛谷上的一道题目。 网址&#xff1a;【深基3.例8】三位数排序 - 洛谷 思路点拨 ​ 这题思路很简单&#xff0c;就是普通的排序题目。 但是我们要学习小题大做这个道理&#xff0c;于是我将介绍三…
阅读更多...
第十五届蓝桥杯模拟赛（第二期）

第十五届蓝桥杯模拟赛（第二期）

大家好&#xff0c;我是晴天学长&#xff0c;本次分享&#xff0c;制作不易&#xff0c;本次题解只用于学习用途&#xff0c;如果有考试需要的小伙伴请考完试再来看题解进行学习&#xff0c;需要的小伙伴可以点赞关注评论一波哦&#xff01;后续会继续更新第三期的。&#x1f4…
阅读更多...
Nacos 客户端版本从1.x 升级到 2.x 的排坑记

Nacos 客户端版本从1.x 升级到 2.x 的排坑记

问题描述 应用引入 Nacos Config 配置管理功能&#xff0c;应用启动时读取 Nacos 配置中心的配置作为启动参数&#xff0c;其中包括数据源信息 url 。 当 Nacos 正在进行 GC 操作、无法响应客户端请求时&#xff0c;应用端刚启动时发送的登录认证请求 http://IP:PORT/nacos/v…
阅读更多...
本地仓库设置阿里云镜像

本地仓库设置阿里云镜像

一、maven 修改maven配置文件conf/settings&#xff0c;在mirrors节点下添加以下内容 <mirror><id>aliyunmaven</id><mirrorOf>*</mirrorOf><name>阿里云公共仓库</name><url>https://maven.aliyun.com/repository/public&l…
阅读更多...
JVM垃圾回收机制GC

JVM垃圾回收机制GC

一句话介绍GC&#xff1a; 自动释放不再使用的内存 一、判断对象是否能回收 思路一&#xff1a;引用计数 给这个对象里安排一个计数器&#xff0c; 每次有引用指向它&#xff0c; 就把计数器1&#xff0c; 每次引用被销毁&#xff0c;计数器-1&#xff0c;当计数器为0的时候…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023