[数据结构]—带头双向循环链表——超详解

💓作者简介🎉:在校大二迷茫大学生

💖个人主页🎉:小李很执着

💗系列专栏🎉:数据结构

每日分享✨:旅行是为了迷路,迷路是为了遇上美好❣️❣️❣️

目录

💓1.总体布局

 💓2.详细解读

❣️1.创建双向链表节点

❣️2.初始化双向循环链表

❣️3.打印双向循环链表

❣️4.循环双向链表尾插

❣️5.双向循环链表中删除尾节点

❣️6.双向链表的头插操作

❣️7.双向链表的头部删除操作

❣️8.循环链表中查找指定值节点

❣️9.该函双向链表中指定节点pos的前面插入一个新的节点

❣️10.双向链表中删除某个节

❣️11.销毁一个循环双向链表

💓3.部分代码进阶

❣️1.根据2—9:void LTInsert(LTNode* pos, LTDataType x)

❣️2.根据2—10void LTErase(LTNode* pos)

💓4.整体代码

❣️1.List.h

❣️2.List.c

❣️3.Test.c


💓1.总体布局

1.创建双向链表节点

LTNode* CreateLTNode(LTDataType x);

2.初始化双向循环链表

LTNode* LTInit();

3.打印双向循环链表
void LTPrint(LTNode* phead);

4.循环双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);

5.双向循环链表中删除尾节点
void LTPopBack(LTNode* phead);

6.双向链表的头插操作

void LTPushFront(LTNode* phead, LTDataType x);

7.双向链表的头部删除操作
void LTPopFront(LTNode* phead);

8.循环链表中查找指定值节点

LTNode* LTFind(LTNode* phead, LTDataType x);

9.该函双向链表中指定节点pos的前面插入一个新的节点
void LTInsert(LTNode* pos, LTDataType x);

10.双向链表中删除某个节
void LTErase(LTNode* pos);

11.销毁一个循环双向链表

void LTDestroy(LTNode * phead); 

 💓2.详细解读

❣️1.创建双向链表节点

函数输入参数为节点的值x,函数返回一个指向节点的指针。

函数内部实现:

  1. 使用malloc函数为新节点分配内存空间,分配的大小为一个LTNode结构体的大小。

  2. 判断内存分配是否成功,如果分配失败,则输出错误信息并退出程序。

  3. 对新节点进行初始化,将节点的值设置为x,next指针和prev指针设置为NULL。

  4. 返回指向新节点的指针。

LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

❣️2.初始化双向循环链表

链表中的每个节点都是LTNode类型的结构体,其中包含一个指向前一个节点的指针prev和一个指向后一个节点的指针next。该函数首先创建一个值为-1的头节点,并将头节点的前一个节点和后一个节点都指向头节点本身,以形成一个空的双向循环链表。最后返回头节点的指针。

LTNode* LTInit()
{
	LTNode* phead = CreateLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

❣️3.打印双向循环链表

其参数为双向循环链表的头结点指针,函数内部会从头结点开始遍历链表,并依次打印每个节点的值,直到遍历到头结点为止。最终输出的内容是形如“哨兵位<=>x<=>y<=>z<=>哨兵位”的字符串,其中x、y、z分别表示链表中的元素值。

void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("哨兵位<=>");

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

❣️4.循环双向链表尾插

将一个元素x插入到链表的最后一个节点的后面。

函数接收两个参数,一个是指向链表头结点的指针phead,另一个是要插入到链表尾部的元素x。

首先使用assert函数检查参数phead是否为NULL,如果是则直接终止程序。

接着定义两个指针tail和newnode,tail指向链表的最后一个节点,newnode是要插入到链表尾部的新节点。

然后将新节点插入到链表尾部。具体步骤如下:

  1. 让tail节点的next指针指向newnode节点,即tail->next = newnode。

  2. 让newnode节点的prev指针指向tail节点,即newnode->prev = tail。

  3. 让newnode节点的next指针指向链表头节点phead,即newnode->next = phead。

  4. 让phead节点的prev指针指向newnode节点,即phead->prev = newnode。

这样就完成了在链表尾部插入新节点的操作。

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = CreateLTNode(x);
	// phead               tail  newnode
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

❣️5.双向循环链表中删除尾节点

具体分析如下:

  1. 首先使用assert函数来判断phead是否为空,如果为空则程序立即终止。

  2. 由于是双向循环链表,在删除尾节点之前需要判断链表中是否存在节点。使用assert函数来判断phead的next指针是否指向phead本身,如果是则链表为空,程序立即终止。

  3. 设置指针tail指向链表的尾节点,并使用tailPrev指针来记录尾节点的前一个节点。

  4. 释放tail指向的节点,即删除尾节点。

  5. 将tailPrev节点的next指针指向phead节点,即将链表尾节点删除后,将尾节点的前一个节点的next指针指向头节点。

  6. 将phead节点的prev指针指向tailPrev节点,即将链表尾节点删除后,将头节点的prev指针指向链表的倒数第二个节点,以保证链表仍然是双向循环的。

注意,该函数的前提条件是链表中至少存在一个节点,否则会因为assert函数判断失败而终止程序。在使用该函数时需要注意链表的状态。

void LTPopBack(LTNode* phead)
{
	assert(phead);
	// 空
	assert(phead->next != phead);
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;

}

❣️6.双向链表的头插操作

将一个新节点插入到链表的第一个位置。

输入参数:

  • phead:头结点指针,其中包含链表的头指针和尾指针;
  • x:要插入的节点的值。

函数流程:

  1. 创建新节点,其数据域为x;
  2. 获取原链表中第一个节点的指针first;
  3. 将新节点插入到头结点之后的位置,使得新节点为原链表的第一个节点,first成为新节点的后继节点;
  4. 将原第一个节点的prev指针指向新节点,完成头插操作。

注意事项:

  • 函数中使用了assert宏,用于判断头结点是否存在;
  • 操作需要改变多个节点的指针,需要仔细考虑顺序和细节。
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = CreateLTNode(x);
	LTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;

}

❣️7.双向链表的头部删除操作

1. 首先使用assert函数判断传入的链表头结点指针phead是否为空,如果为空则终止程序运行。

2. 再通过assert函数判断链表是否为空,即头结点的下一个结点是否还是头结点自身,如果是则说明链表为空,同样终止程序运行。

3. 取出链表头结点的下一个结点first,以及第二个结点second。

4. 将头结点的下一个结点指向第二个结点,同时将第二个结点的前一个结点指向头结点,完成删除操作。

5. 最后使用free函数释放被删除的结点first的内存空间,并将first指针置为空。

void LTPopFront(LTNode* phead)
{
	assert(phead);
	// 空
	assert(phead->next != phead);
	LTNode* first = phead->next;
	LTNode* second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);
	first = NULL;
	
}

❣️8.循环链表中查找指定值节点

参数说明:

  • phead:指向循环链表头节点的指针。
  • x:需要查找的值。

函数实现步骤:

  1. 首先,断言链表头节点不为空。
  2. 定义一个指针 cur,指向链表的第一个节点。
  3. 遍历链表,如果找到了值为 x 的节点,直接返回该节点指针。
  4. 如果遍历完整个链表都没有找到值为 x 的节点,就返回 NULL 指针,表示没有找到。

需要注意的是,该函数是针对循环链表的查找实现,因此需要判断 cur 指针是否回到了头节点 phead,如果回到了头节点,则表示遍历完整个链表,需要退出循环。

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

❣️9.该函双向链表中指定节点pos的前面插入一个新的节点

节点的值为x。函数实现需要注意以下几点:

  1. 首先需要判断pos节点是否存在,若不存在则直接返回。

  2. 创建一个新节点newnode,并将其值赋为x。

  3. 获取pos节点的前一个节点posPrev,posPrev节点和newnode节点之间需要插入新的节点。

  4. 将posPrev节点的next指针指向newnode节点,将newnode节点的prev指针指向posPrev节点,将newnode节点的next指针指向pos节点,将pos节点的prev指针指向newnode节点。

  5. 确保插入操作顺利完成后,函数返回。

// 在pos前面的插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* newnode = CreateLTNode(x);
	// posprev newnode pos
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

❣️10.双向链表中删除某个节

输入参数是要删除的节点指针pos。

首先通过断言语句assert(pos)来检查输入参数是否为空。

然后通过pos指针找到它的前驱节点posPrev和后继节点posNext,将它们之间的连接断开,即将posPrev的next指针指向posNext,将posNext的prev指针指向posPrev。

最后通过free函数释放pos指向的内存空间,完成删除操作。

// 删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* posNext = pos->next;
	LTNode* posPrev = pos->prev;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	
}

❣️11.销毁一个循环双向链表

参数phead是链表的头指针,其指向一个LTNode类型的结构体,该结构体中有两个指针,分别指向链表的头节点和尾节点。

首先,函数中使用了断言assert(phead),判断参数phead是否为空指针,如果是,程序会终止运行,有助于在调用函数时发现错误。

然后,定义一个指针cur指向链表第一个节点,然后使用while循环遍历除了头节点之外的所有节点,直到遍历完所有节点为止。

在循环中,使用一个指针next指向当前节点的下一个节点,然后释放当前节点的内存空间,最后将cur指向下一个节点。

循环结束后,释放链表头节点的内存空间,销毁整个链表。

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

💓3.部分代码进阶

❣️1.根据2—9:void LTInsert(LTNode* pos, LTDataType x)

 1.循环双向链表尾插操作

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead, x);
}

2. 双向链表的头插操作

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}

❣️2.根据2—10void LTErase(LTNode* pos)

1.双向循环链表中删除尾节点

void LTPopBack(LTNode* phead)
{
	assert(phead);
	LTErase(phead->prev);
}

2. 双向链表的头部删除操作

void LTPopFront(LTNode* phead)
{
	assert(phead);
	// 空
	assert(phead->next != phead);
	LTErase(phead->next);
}

💓4.整体代码

❣️1.List.h

#pragma once

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

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType val;
}LTNode;

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

void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);

LTNode* LTFind(LTNode* phead, LTDataType x);


void LTInsert(LTNode* pos, LTDataType x);

void LTErase(LTNode* pos);

void LTDestroy(LTNode * phead); 

❣️2.List.c

#include"List.h"



LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = CreateLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("哨兵位<=>");

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

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* tail = phead->prev;
	//LTNode* newnode = CreateLTNode(x);

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

	LTInsert(phead, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);

	// 空
	assert(phead->next != phead);

	/*LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

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

	LTErase(phead->prev);
}

//void LTPushFront(LTNode* phead, LTDataType x)
//{
//	assert(phead);
//	LTNode* newnode = CreateLTNode(x);
//
//	newnode->next = phead->next;
//	phead->next->prev = newnode;
//
//	phead->next = newnode;
//	newnode->prev = phead;
//
//}

void LTPushFront(LTNode* phead, LTDataType x)
{
	/*assert(phead);
	LTNode* newnode = CreateLTNode(x);
	LTNode* first = phead->next;

	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;*/

	LTInsert(phead->next, x);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	// 空
	assert(phead->next != phead);

	/*LTNode* first = phead->next;
	LTNode* second = first->next;

	phead->next = second;
	second->prev = phead;
	free(first);
	first = NULL;*/
	LTErase(phead->next);
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

// 在pos前面的插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* newnode = CreateLTNode(x);

	// posprev newnode pos
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

// 删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* posNext = pos->next;
	LTNode* posPrev = pos->prev;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	//pos = NULL;
}

void LTDestroy(LTNode* phead)
{
	assert(phead);

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

	free(phead);
	//phead = NULL;
}

❣️3.Test.c

#include "List.h"

void TestList1()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 5);
	LTPushBack(plist, 4);

	LTPrint(plist);

	LTPushFront(plist, 10);
	LTPrint(plist);
}

void TestList2()
{
	LTNode* plist = LTInit();
	LTPushFront(plist, 10);
	LTPushFront(plist, 20);
	LTPushFront(plist, 30);
	LTPushFront(plist, 40);

	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	//LTPopFront(plist);
	//LTPrint(plist);
}

void TestList3()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 5);
	LTPushBack(plist, 4);

	LTPrint(plist);

	LTNode* pos = LTFind(plist, 3);
	if (pos)
	{
		pos->val *= 10;
	}
	LTPrint(plist);

	LTInsert(pos, 30000);
	LTPrint(plist);

	LTInsert(plist, -1);
	LTPrint(plist);

	LTInsert(plist, -2);
	LTPrint(plist);
}

void TestList4()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 5);
	LTPushBack(plist, 4);

	LTPrint(plist);

	LTNode* pos = LTFind(plist, 3);
	if (pos)
	{
		LTErase(pos);
		pos = NULL;
	}
	LTPrint(plist);

	LTDestroy(plist);
	plist = NULL;
}

int main()
{
	TestList4();

	return 0;
}

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Git的基本操作以及原理介绍

文章目录 基本操作创建git仓库配置name和email .git目录的结构git add & git commit.git目录结构的变化 git追踪管理的数据git的版本回退回退的原理回退的三种情况 版本库中文件的删除git分支管理分支的删除合并分支时的冲突分支的合并模式分支策略git stash不要在master分…

数据结构-时间复杂度与空间复杂度详解

文章目录 算法效率时间复杂度概念计算例1例2例3补充例4 空间复杂度例1例2 算法效率 算法效率分析分为两种:第一种是时间效率&#xff0c;第二种是空间效率。时间效率被称为时间复杂度&#xff0c;而空间效率被称作空间复杂度。时间复杂度主要衡量的是一个算法的运行速度&#…

Delicious Retouch5 for mac(PS磨皮插件DR5白金版)

Delicious Retouch5是一款强大的Photoshop插件&#xff0c;专为专业摄影师和摄影爱好者设计&#xff0c;提供一系列高级修图工具&#xff0c;帮助用户更快速、更有效地进行照片修饰和美化。其主要功能包括皮肤美容、人像润色、头发修饰、修复工具等&#xff0c;并配备定制化画笔…

海外邮件接收延迟、接收不到怎么办?U-Mail邮件网关来了

随着经济全球化的发展&#xff0c;很多国内企业开始踏足海外市场&#xff0c;电子邮件就成为了国内企业与海外客户沟通交流的主要渠道。然而海外邮件接收延迟、接收不到等问题成为了困扰企业与海外客户沟通的一大阻碍&#xff0c;导致客户邮件回复不及时&#xff0c;询盘邮件接…

新版本!飞凌嵌入式RK3568系列开发板全面支持Debian 11系统

飞凌嵌入式OK3568-C/OK3568J-C开发板现已全面支持Debian 11系统&#xff0c;新系统的加持能为用户提供主控新选择&#xff0c;并为开发者带来更多开发便利&#xff01; Debian系统作为一种广受欢迎和信赖的开源操作系统&#xff0c;以其稳定性、可靠性和开放性而闻名&#xff0…

2013年5月23日 Go生态洞察:高级Go并发模式分析

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…

OpenELA 正式公开 Enterprise Linux 源代码

导读近日消息&#xff0c;在红帽&#xff08;Red Hat&#xff09;宣布不再对外公开 Red Hat Enterprise Linux&#xff08;RHEL&#xff09;源代码之后&#xff0c;同属 Linux 领域的甲骨文、SUSE 及 CIQ 宣布成立了 Open Enterprise Linux Association&#xff08;OpenELA&…

xstream实现xml和java bean 互相转换

目录 pom引用java bean 类XML 转换工具类测试类执行结果注意问题 Java中实现XML和Bean的转换的方式或插件有以下几种&#xff1a; JAXB&#xff08;Java Architecture for XML Binding&#xff09;&#xff1a;JAXB是Java SE的一部分&#xff0c;可以将Java对象与XML文档相互转…

Linux 图形界面配置RAID

目录 RAID 1 配置 RAID 5配置 , RAID 配置起来要比 LVM 方便&#xff0c;因为它不像 LVM 那样分了物理卷、卷组和逻辑卷三层&#xff0c;而且每层都需要配置。我们在图形安装界面中配置 RAID 1和 RAID 5&#xff0c;先来看看 RAID 1 的配置方法。 RAID 1 配置 配置 RAID 1…

开源项目datavines内存泄漏问题分析

应用程序开启JMX java -Dspring.profiles.activemysql -Dcom.sun.management.jmxremote.port1099 -Dcom.sun.management.jmxremote.sslfalse -Dcom.sun.management.jmxremote.authenticatefalse -Djava.rmi.server.hostname127.0.0.1 -jar dataVines.jar 通过jdk自带工具&…

数据结构第四课 -----线性表之队列

作者前言 &#x1f382; ✨✨✨✨✨✨&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f382; ​&#x1f382; 作者介绍&#xff1a; &#x1f382;&#x1f382; &#x1f382; &#x1f389;&#x1f389;&#x1f389…

使用geek卸载windows软件,干净彻底

我们在电脑上安装软件&#xff0c;以及在使用软件的过程中&#xff0c;会产生一些程序文件、注册表项和临时文件等&#xff0c;用来支持软件的正常使用&#xff0c;都是正常现象。 但是&#xff0c;在卸载软件时&#xff0c;很多软件的卸载程序&#xff0c;并不能完全清除软件…

excel中正态分布函数NORM.DIST和NORMDIST,以及它们之间的区别

NORM.DIST和NORMDIST的区别 NORM.DIST和NORMDIST函数都可以返回正态分布的概率密度、或者正态累积分布。 根据微软官网上的说法&#xff0c;NORMDIST函数已经不建议使用了&#xff0c;它已经被一个或者几个新的函数代替&#xff08;例如NORM.DIST&#xff09;&#xff0c;这些…

RabbitMQ-高级篇-黑马程序员

代码&#xff1a; 链接&#xff1a; https://pan.baidu.com/s/1nQBIgB_SbzoKu_XMWZ3JoA?pwdaeoe 提取码&#xff1a;aeoe 在昨天的练习作业中&#xff0c;我们改造了余额支付功能&#xff0c;在支付成功后利用RabbitMQ通知交易服务&#xff0c;更新业务订单状态为已支付。 但…

Python数据结构:集合(set)详解

1.集合的概念 在Python中&#xff0c;集合&#xff08;Set&#xff09;是一种无序、不重复的数据类型&#xff0c;它的实现基于哈希表&#xff0c;是由唯一元素组成的。集合中不允许有重复的元素&#xff0c;即相同元素只能出现一次。Python中的集合类似于数学中的集合&#xf…

你是想被ChatGPT改变,还是改变软件开发的未来?丨IDCF

人工智能技术的发展&#xff0c;正在深刻地改变着我们的生活和工作方式。在软件工程领域&#xff0c;ChatGPT作为一种新兴的人工智能技术&#xff0c;正在逐渐地被应用到软件开发的各个环节中。那么&#xff0c;ChatGPT对每个人的影响是什么呢&#xff1f; 一、对软件开发人员…

LockBit3.0的字符串解密方法

LockBit 与大多数勒索黑客团体一样以勒索软件即服务 (RaaS) 模式运行,该组织于 2019 年 9 月首次被观察到,此后发展为了今年最主要的勒索软件团伙,甚至超过了Conti、Hive等其他知名团体。据泄露数据站点的数据统计表明,LockBit占2022年第一季度所有与勒索软件相关的泄露事件…

使用Pandas进行数据读写的简易教程

Pandas是一个功能强大且广泛使用的Python库。它提供了一种简单而灵活的方式来读取和写入各种数据格式&#xff0c;包括CSV、Excel、SQL数据库等。本文将介绍如何使用Pandas进行数据的读取和写入操作&#xff0c;帮助你快速上手并高效地处理数据。 一、安装和导入pandas 首先&…

NovelD: A Simple yet Effective Exploration Criterion论文笔记

NovelD:一种简单而有效的探索准则 1、Motivation 针对稀疏奖励环境下的智能体探索问题&#xff0c;许多工作中采用各种内在奖励(Intrinsic Reward)设计来指导困难探索环境中的探索 &#xff0c;例如&#xff1a; ICM&#xff1a;基于前向动力学模型的好奇心驱动探索RND&…