双链表——“数据结构与算法”

news2025/1/11 6:07:59

各位CSDN的uu们你们好呀，今天，小雅兰又回来了，到了好久没有更新的数据结构与算法专栏，最近确实发现自己有很多不足，需要学习的内容也有很多，所以之后更新文章可能不会像之前那种一天一篇或者一天两篇啦，话不多说，下面，让我们进入双链表的世界吧

 之前小雅兰写过单链表的文章：https://xiaoyalan.blog.csdn.net/article/details/130353520?spm=1001.2014.3001.5502

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

 

 这八种结构分别为：单向带头循环链表、单向带头非循环链表、单向不带头循环链表、单向不带头非循环链表、双向带头循环链表、双向带头非循环链表、双向不带头循环链表、双向不带头非循环链表

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

单向不带头非循环链表和双向带头循环链表

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结 构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  • 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都 是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带 来很多优势，实现反而简单了，后面我们代码实现了就知道了。  

下面，我们开始用代码和图来实现一下双向带头循环链表！！！

在后续函数中，有很多函数都需要这样一个功能：创建一个新节点

那么，我们把此功能单独封装成一个函数：

//创建一个新节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = ((LTNode*)malloc(sizeof(LTNode)));
	if (newnode == NULL)
	{
		printf("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

双链表的初始化：

//双链表的初始化
LTNode* LTInit()
{
	//哨兵位的头节点
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

 尾插：

 

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	//malloc一个新节点
	LTNode* newnode = BuyLTNode(x);
	//让tail的下一个结点指向newnode，链接起来
	tail->next = newnode;
	//newnode的前一个结点指向tail
	newnode->prev = tail;
	//newnode的下一个结点指向头，形成循环
	newnode->next = phead;
	//phead的上一个结点指向newnode
	phead->prev = newnode;
}

头插：

 

//头插
//插在哨兵位的头节点的后面
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

当然，这样的代码可读性是非常高的，可是，有些人就不喜欢定义那么多指针，然后就还有另外一种写法：

//头插
//插在哨兵位的头节点的后面
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

 但是这样的代码，可读性就显得不是那么的高，所以尽量不要使用这种写法

不是说你写代码多定义了几个指针就说你写的代码没有那些没有定义什么指针的代码差，关键得看可读性！！！

双链表的打印：

//双链表的打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("guard<--->");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<--->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

 下面，让我们来验证一下头插和尾插的功能：

void TestDoubleList1()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	LTPushFront(plist, 6);
	LTPushFront(plist, 7);
	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPushFront(plist, 10);
	LTPrint(plist);
}
int main()
{
	TestDoubleList1();
	return 0;
}

 尾删：

 首先要判断此链表是否为空：

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

头删：

 

 

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* first = phead->next;
	LTNode* second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);

}

头删也有另外一种写法，和上面阐述的一样，也是可以不用定义这么多指针，但是代码的可读性差一些

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* next = phead->next;
	phead->next = next->next;
	next->next->prev = phead;
	free(next);
}

下面，让我们来验证一下头删和尾删的功能：

void TestDoubleList2()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	LTPushFront(plist, 6);
	LTPushFront(plist, 7);
	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPushFront(plist, 10);
	LTPrint(plist);
	LTPopBack(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);
}
int main()
{
	TestDoubleList2();
	return 0;
}

在双链表里面查找：

//在双链表里面查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
}

在pos位置之前插入值： 

 

//在pos位置之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

一般查找和在pos位置之前插入值是搭配使用的！！！

下面，让我们来测试一下此功能：

void TestDoubleList3()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	LTPushFront(plist, 6);
	LTPushFront(plist, 7);
	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPushFront(plist, 10);
	LTPrint(plist);
	LTPopBack(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTNode* pos = LTFind(plist, 3);
	if (pos != NULL)
	{
		LTInsert(pos, 30);
	}
	LTPrint(plist);

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

 在pos位置之前插入值这个功能，可以很好地解决之前头插和尾插的功能，头插和尾插可以直接复用此代码：

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	LTInsert(phead->next, x);
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead, x);
}

删除pos位置的值： 

 

//删除pos位置的值
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

验证一下该删除功能：

void TestDoubleList4()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	LTPushFront(plist, 6);
	LTPushFront(plist, 7);
	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPushFront(plist, 10);
	LTPrint(plist);
	LTPopBack(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTNode* pos = LTFind(plist, 3);
	if (pos != NULL)
	{
		LTInsert(pos, 30);
	}
	LTPrint(plist);
	pos = LTFind(plist, 1);
	if (pos != NULL)
	{
		LTErase(pos);
	}
	LTPrint(plist);
}
int main()
{
	TestDoubleList4();
	return 0;
}

 

这个功能也很神奇，删除pos位置的值，之前我们写的头删和尾删一样可以复用此代码的功能

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->prev);
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTErase(phead->next);
}

 双链表的销毁：

//双链表的销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

如果不销毁双链表，就会有内存泄漏的问题！！！

源代码如下：

List.h的内容：

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	LTDataType data;
}LTNode;
//双链表的初始化
LTNode* LTInit();
//双链表的打印
void LTPrint(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);
//在双链表里面查找
LTNode* LTFind(LTNode* phead, LTDataType x);
//在pos位置之前插入
void LTInsert(LTNode* pos, LTDataType x);
//删除pos位置的值
void LTErase(LTNode* pos);
//双链表的销毁
void LTDestroy(LTNode* phead);

List.c的内容：

#include"List.h"
//创建一个新节点
LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = ((LTNode*)malloc(sizeof(LTNode)));
	if (newnode == NULL)
	{
		printf("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}
//双链表的初始化
LTNode* LTInit()
{
	//哨兵位的头节点
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
//双链表的打印
void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("guard<--->");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<--->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	//malloc一个新节点
	LTNode* newnode = BuyLTNode(x);
	//让tail的下一个结点指向newnode，链接起来
	tail->next = newnode;
	//newnode的前一个结点指向tail
	newnode->prev = tail;
	//newnode的下一个结点指向头，形成循环
	newnode->next = phead;
	//phead的上一个结点指向newnode
	phead->prev = newnode;
}
//头插
//插在哨兵位的头节点的后面
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	LTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}
头插
插在哨兵位的头节点的后面
//void LTPushFront(LTNode* phead, LTDataType x)
//{
//	assert(phead);
//	LTNode* newnode = BuyLTNode(x);
//	newnode->next = phead->next;
//	phead->next->prev = newnode;
//	phead->next = newnode;
//	newnode->prev = phead;
//}
头插
//void LTPushFront(LTNode* phead, LTDataType x)
//{
//	LTInsert(phead->next, x);
//}
尾插
//void LTPushBack(LTNode* phead, LTDataType x)
//{
//	assert(phead);
//	LTInsert(phead, x);
//}
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
}
头删
//void LTPopFront(LTNode* phead)
//{
//	assert(phead);
//	assert(!LTEmpty(phead));
//	LTNode* next = phead->next;
//	phead->next = next->next;
//	next->next->prev = phead;
//	free(next);
//}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* first = phead->next;
	LTNode* second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);
}
尾删
//void LTPopBack(LTNode* phead)
//{
//	assert(phead);
//	assert(!LTEmpty(phead));
//	LTErase(phead->prev);
//}
头删
//void LTPopFront(LTNode* phead)
//{
//	assert(phead);
//	assert(!LTEmpty(phead));
//	LTErase(phead->next);
//}
//在双链表里面查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
}
//在pos位置之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}
//删除pos位置的值
void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}
//双链表的销毁
void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

好啦，小雅兰今天的学习内容就到这里啦，还要继续加油噢！！！

 

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

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

相关文章

浅谈 Node.js

浅谈 Node.js

Node.js 是什么&#xff1f; Node.js 是一个开源、跨平台的 JavaScript 运行时环境。 官网&#xff1a;https://nodejs.org/zh-cn 更多精彩内容&#xff0c;请微信搜索“前端爱好者“&#xff0c; 戳我 查看 。 Node.js ≠ JavaScript Node.js中&#xff0c;没有BOM和DOM。…
阅读更多...
【LLM】LangChain基础使用（构建LLM应用）

【LLM】LangChain基础使用（构建LLM应用）

note LangChain应用开发框架&#xff0c;支持python和typescript语言&#xff1b;可以帮助生成prompt模板&#xff0c;并通过代理充当其他组件&#xff08;如提示模板、其他大语言模型、外部数据和其他工具&#xff09;的中央接口。LangChain可以直接与 OpenAI 的 text-davinc…
阅读更多...
BGW协议（算数共享）

BGW协议（算数共享）

概述 BGW协议可以用于对域上包含加法、乘法、常数乘法门的算术电路求值&#xff0c;此协议强依赖Shamir秘密分享方案&#xff0c;利用其同态特性对各个秘密份额进行适当的处理&#xff0c;就可以在秘密值上进行安全计算。 加法门 算数加法共享&#xff08;两方&#xff09; …
阅读更多...
c++ 友元介绍

c++ 友元介绍

友元的目的就是让一个函数或类访问另一个函数中的私有成员 友元函数 &#xff08;1&#xff09;普通函数作为友元函数 class 类名{friend 函数返回值类型 友元函数名(形参列表);//这个形参一般是此类的对象.... } 经过以上操作后&#xff0c;友元函数就可以访问此类中的私有…
阅读更多...
Vue最新快速上手教程（狂神）

Vue最新快速上手教程（狂神）

文章目录 前端核心分析1. 第一个Vue程序2. Vue基本语法3. Vue绑定事件4. Vue双向绑定5. 组件讲解6. Axios异步通信7. 计算属性8. 插槽slot9. 自定义事件内容分发10. 第一个vue-cli程序11. webpack学习使用12. vue-router路由13. vueelementUI14. 路由嵌套15. 参数传递及重定向1…
阅读更多...
【JAVA】黑马程序员JAVA教程笔记 基础篇 Day 1

【JAVA】黑马程序员JAVA教程笔记 基础篇 Day 1

常用命令行DOS命令 Path环境变量 用途 1. 可以理解为系统中的一个大管家&#xff0c;记录了很多软件的完整路径。 2. 将常用的软件都交给Path环境变量&#xff0c;便于用命令行打开。 设置步骤 复制要使用的软件的存储地址右键点击 此电脑&#xff0c;打开属性点击 高级系统…
阅读更多...
【2023最新】几乎涵盖你需要的Android性能优化的所有操作

【2023最新】几乎涵盖你需要的Android性能优化的所有操作

前言 现如今&#xff0c;Android开发在市面上的需求不再像以前一样一人难求&#xff0c;僧多认识的情况直接导致整个行业对Android开发岗位的要求越来越高&#xff0c;Android 开发越来越规范&#xff0c;间接导致项目对质量要求的提升。启动优化、内存优化、App 崩溃监控等性…
阅读更多...
【网络安全CTF】BUUCTF(Basic篇)

【网络安全CTF】BUUCTF(Basic篇)

Linux Labs 解题思路&#xff1a;已给用户名密码&#xff0c;直接用ssh工具连接即可获取flag 查找flag在跟下 提交完成。 BUU LFI COURSE 1 访问链接&#xff1a;为php代码审计题&#xff0c;看题目要求构造GET请求读取文件 http://9a7d4988-99f9-4c29-88d8-600e19887723.n…
阅读更多...
三极管知识大全

三极管知识大全

一、三极管的使用 一般可以当做开关管来使用&#xff0c;也可以利用三极管的放大特性&#xff0c;来搭建恒流源&#xff0c;恒压源等等&#xff0c; 三极管当做开关管来使用的话&#xff0c;三极管输出的是高、低、高、低的方波信号 BUCK电源的开关频率在65KHz&#xff0c;也…
阅读更多...
【刷题笔记】另类加法+走方格的方案数

【刷题笔记】另类加法+走方格的方案数

一、另类加法 题目&#xff1a; 牛客网链接&#xff1a;另类加法_牛客题霸_牛客网 描述 给定两个int A和B。编写一个函数返回AB的值&#xff0c;但不得使用或其他算数运算符。 测试样例&#xff1a;1&#xff0c;3 返回&#xff1a;4 解析&#xff1a; 因为无法使用算数运算符…
阅读更多...
网易云音乐开发--完善video模块

网易云音乐开发--完善video模块

解决多个视频同时播放问题 老样子&#xff0c;npm start开启服务器 说一下问题 现在打开多个视频会让他&#xff0c;同时播放&#xff0c;相当的吵闹。我们只需要一次只有一个视频播放 看文档&#xff0c;我们的思路是点击这个视频&#xff0c;关闭上次视频 我们传入这个id …
阅读更多...
shell脚本语言

shell脚本语言

# 编写一个名为myfirstshell.sh的脚本&#xff0c;它包括以下内容。 #!/bin/bash# 1、包含一段注释&#xff0c;列出您的姓名、脚本的名称和编写这个脚本的目的 # 杨轩 # myfirstshell.sh # 脚本命令的练习# 2、和当前用户说“hello 用户名” echo "hello xuan"# 3、…
阅读更多...
Vue生命周期函数执行顺序（使用注意事项）

Vue生命周期函数执行顺序（使用注意事项）

文章目录 beforeCreatecreatedbeforeMountmountedbeforeUpdateupdatedbeforeDestroydestroyed Vue.js 是一个基于 MVVM 模式的前端框架&#xff0c;它的核心是一个响应式的数据绑定系统。在 Vue.js 中&#xff0c;组件是一个可复用的 Vue 实例&#xff0c;它拥有自己的生命周期…
阅读更多...
第二章 进程管理

第二章 进程管理

2.1 进程的引入 2.1.1程序的顺序执行 1.程序的顺序执行 程序是人们要计算机完成特定功能的一些指令序列&#xff0c;是一个按严格次序、顺序执行的操作序列&#xff0c;是一个静态的概念。 如&#xff1a;有一个程序&#xff0c;要求先输入数据&#xff0c;再做相应的计算…
阅读更多...
platform_get_resource=NULL内核源码分析

platform_get_resource=NULL内核源码分析

platform_get_resourceNULL内核源码分析 文章目录 platform_get_resourceNULL内核源码分析1.第一步&#xff0c;我们看一下什么情况下platform_get_resource函才会返回NULL,也就是没有获取到资源。2.第二步&#xff0c;因为myled这个设节点会转成了platform_device&#xff0c;…
阅读更多...
suricata中DPDK收发包线程模型和配置说明

suricata中DPDK收发包线程模型和配置说明

《基于DPDK收包的suricata的安装和运行》中已经讲过基于DPDK收发包的suricata的安装过程&#xff0c;今天我们来看一下&#xff0c;suricata中DPDK的收发包线程模型以及相关的配置。 1、收发包线程模型&#xff1a; 通过分析代码&#xff0c;suricata中DPDK收发包线程模型如下…
阅读更多...
C高级 day03

C高级 day03

1.编写一个名为myfirstshell.sh的脚本&#xff0c;它包括以下内容。 1、包含一段注释&#xff0c;列出您的姓名、脚本的名称和编写这个脚本的目的 2、和当前用户说“hello 用户名” 3、显示您的机器名 hostname 4、显示上一级目录中的所有文件的列表 5、显示变量PATH和HOM…
阅读更多...
采药 DP 裸01背包 java

采药 DP 裸01背包 java

&#x1f351; 采药 import java.util.*;class Main{static int N 1010;static int[] f new int[N];public static void main(String[] aaa){Scanner sc new Scanner(System.in);int m sc.nextInt();int n sc.nextInt();for(int i 0; i < n; i){int v sc.nextInt()…
阅读更多...
s2021ss62找规律

s2021ss62找规律

代码&#xff1a; #include<bits/stdc.h> using namespace std; int n,m,ans; int main() {cin>>n>>m;for(int i1;i<n-1;i)ansi;cout<<ansm;return 0; }
阅读更多...
一文了解支付卡行业数据安全标准（PCI DSS 4.0）新要求

一文了解支付卡行业数据安全标准（PCI DSS 4.0）新要求

在接下来不到一年的时间里&#xff0c;将有越来越多的企业要遵守支付卡行业数据安全标准 (PCI DSS) 4.0 版的多项新要求。 关于 PCI DSS PCI DSS 包含 12 项保护支付卡数据的要求&#xff0c;在过去十年中都没有更新。但经过三年的商讨&#xff0c;现在已经进行了重大改革。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023