手撕红黑树 | 变色+旋转你真的明白了吗？【超用心超详细图文解释 | 一篇学会Red_Black_Tree】

news2024/9/22 17:25:00

说在前面

我们也很久没有更新数据结构系列了，半年前博主重新深入学习了红黑树这个数据结构，一直想更新呈现给大家，最近也一直没有时间，今天红黑树它来了！

博主为了这篇博客，做了很多准备，试了很多画图软件，就是为了让大家看得明白！希望大家不要吝啬一键三连啊！！

前言

那么这里博主先安利一下一些干货满满的专栏啦！

手撕数据结构https://blog.csdn.net/yu_cblog/category_11490888.html?spm=1001.2014.3001.5482这里包含了博主很多的数据结构学习上的总结，每一篇都是超级用心编写的，有兴趣的伙伴们都支持一下吧！
算法专栏https://blog.csdn.net/yu_cblog/category_11464817.html这里是STL源码剖析专栏，这个专栏将会持续更新STL各种容器的模拟实现。

STL源码剖析https://blog.csdn.net/yu_cblog/category_11983210.html?spm=1001.2014.3001.5482

什么是红黑树？

在学习红黑树之前，我们必须先了解和熟悉AVL树：

万字手撕AVL树 | 上百行的旋转你真的会了吗？【超用心超详细图文解释 | 一篇学会AVL】https://blog.csdn.net/Yu_Cblog/article/details/127698306?spm=1001.2014.3001.5501红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。

因此，红黑树不是直接通过检验【没有一条路径会比其他路径长出2倍】而维护平衡的，而是通过对根到叶子路径上节点的着色的限制！它不是像AVL一样直接控制平衡，而是间接控制平衡。

红黑树的性质

  • 每个结点不是红色就是黑色
  • 根节点是黑色的
  • 如果一个节点是红色的，则它的两个孩子结点是黑色的
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
  • 每个叶子结点都是黑色的(此处的叶子结点指的是空结点（NIL节点）)

红黑树节点结构

同样，红黑树也是使用三叉链进行构造

enum Colour {
	RED,BLACK
};
template<class K,class V>
struct __Red_Black_TreeNode {
	__Red_Black_TreeNode<K, V>* _left;
	__Red_Black_TreeNode<K, V>* _right;
	__Red_Black_TreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Colour _col;
	__Red_Black_TreeNode(const pair<K, V>& kv)
		:_left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv) {}
};

红黑树的插入（重点）

首先插入节点，前面的部分和搜索树和AVL一样，找位置插入即可：

	bool insert(const pair<K, V>& kv) {
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first < kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
				parent = cur;
				cur = cur->_left;
			}
			else return false;
		}
		cur = new Node(kv);
		cur->_col = RED;//一开始尽量先变红
		if (parent->_kv.first < kv.first) {
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

        //判断是否需要调整颜色或旋转
		while (...) {
			//...
		}
        //根据规则，最后的根节点一定是黑色的
		_root->_col = BLACK;//最后无论根是红是黑 -- 都处理成黑
		return true;
	}

在插入这部分，我们要牢牢记住红黑树的两个规则，这是我们插入节点最根本的根据！

  • 规则三:如果一个节点是红色的，那它的孩子是黑色的
  • 规则四:对于每一个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点

插入的新节点默认是红色

现在我们要插入一个新的节点

我们可以分为两种情况：

  • 插入节点的父亲是黑色的
  • 插入节点的父亲是红色的 

如果插入节点的父亲是黑色的，我们插入黑色节点就会违反规则4，插入红节点并不违反规则，所以我们应该插入的节点应该设置成红色。

如果插入节点的父亲是红色的，我们插入黑色节点就会违反规则4，插入红节点违反规则3。此时我们应该插入什么颜色的节点呢？

答案是我们应该插入红色节点，再做后续的变色工作。

原因：如果插入黑色节点，我们违反规则4，相当于整棵树违法了规则。而我们违反规则3，我们可以通过局部的调整颜色或者旋转解决问题，因此我们选择先把新节点设置成红色，再做变色（+旋转）的处理。

因此，在红黑树中插入一个新节点，无论什么情况，先设置成红色！

变色和旋转

当我们插入一个红节点之后，我们就要检查这颗红黑树是否符合规则了。

如果插入节点的父亲是黑色，是不违反红黑树规则的，我们不需要做处理。

下面我们重点讨论：插入节点的父亲为红色的情况。

红黑树处理情况分类所要关注的节点：父亲、祖父和叔叔（叔叔为父亲的兄弟节点）

我们把握好父亲祖父和叔叔，就能处理红黑树的所有状况。其中，叔叔的颜色最为关键！

下面是红黑树调整的三种情况：

约定cur为当前节点，p为父亲节点，g为祖父节点，u为叔叔节点。

情况一：cur为红，p为红，g为黑，u存在且为红

处理如下：

tips：我们可以发现，这个情况是不需要看左右的，cur在p的左或右，处理的方式其实都是一样的。

情况二: cur为红，p为红，g为黑，u不存在/u为黑（且cur,p,g在同一直线上）

在情况一中，我们把父亲变黑的时候，可以把叔叔一起拉下水，让叔叔也变黑，这样我们就能保证路径上的黑色节点个数保持一致。

但是现在，叔叔不存在或叔叔已经是黑色的了，此时只能旋转了。

 

说明: u的情况有两种

  1. 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点则cur和p一定有一个节点的颜色是黑色，就不满足性质4: 每条路径黑色节点个数相同
  2. 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

p为g的左孩子，cur为p的左孩子，则进行右单旋转;

相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转

p、g变色--p变黑，g变红 

因为cur,p,g在同一直线上，所以情况二只需要单旋！下面这种情况就需要双旋了！

情况三: cur为红，p为红，g为黑，u不存在/u为黑（且cur,p,g不在同一直线上）

p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
则转换成了情况2 

红黑树的删除等

讲到这里有伙伴可能会问,为什么讲红黑树,不讲删除那些接口呢?

因为,校招,公司面试,以后工作中都基本不会考察到AVL树和红黑树的删除接口，我们只需要掌握插入接口就行了。

AVL树,红黑树我们都是做了解性学习,我们并不需要去手撕它的全部代码,这样时间成本很大,意义不大.我们学习红黑树,我们需要深入的去理解它的结构,学习一个插入接口,我们已经可以很好的做到这一点了。

检查红黑树是否合法

思路：找到最左向下路径的黑色节点数作为基准值，检查每条路径黑色节点数目是否与基准值相等。

    bool prev_check(Node* root, int blackNum,int bench_mark) {
		if (root == nullptr) {
			if (blackNum != bench_mark)return false;
			return true;
		}
		if (root->_col == BLACK) {
			blackNum++;
		}
		if (root->_col == RED && root->_parent->_col == RED) {
			//存在连续的红节点，return false
			return false;
		}
		return prev_check(root->_left, blackNum, bench_mark) &&
			prev_check(root->_right, blackNum, bench_mark);
	}
	bool is_balance() {
		if (_root == nullptr)return true;
		if (_root->_col == RED)return false;
		//黑色节点数量基准值
		int bench_mark = 0;
		Node* cur = _root;
		while (cur) {
			if (cur->_col == BLACK)++bench_mark;
			cur = cur->_left;
		}
		return prev_check(this->_root, 0, bench_mark);
	}

RBTree.h

#pragma once
//#include<map>
#include<iostream>
#include<assert.h>
using namespace std;


enum Colour {
	RED,BLACK
};
template<class K,class V>
struct __Red_Black_TreeNode {
	__Red_Black_TreeNode<K, V>* _left;
	__Red_Black_TreeNode<K, V>* _right;
	__Red_Black_TreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Colour _col;
	__Red_Black_TreeNode(const pair<K, V>& kv)
		:_left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv) {}
};


template<class K, class V>
struct RBTree {
	typedef __Red_Black_TreeNode<K, V>Node;
private:
	Node* _root = nullptr;
private:
	//左单旋
	void rotate_left(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;//记录一下原先parent的parent
		subR->_left = parent;
		parent->_parent = subR;
		if (_root == parent) {
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
			//如果ppNode==nullpt，是不会进来这里的
			if (ppNode->_left == parent) {
				ppNode->_left = subR;
			}
			else {
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	//右单旋
	void rotate_right(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (_root == parent) {
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			if (ppNode->_left == parent) {
				ppNode->_left = subL;
			}
			else {
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}
	void _inorder(Node* root) {
		if (root == nullptr)return;
		_inorder(root->_left);
		cout << root->_kv.first << endl;
		_inorder(root->_right);
	}
	bool prev_check(Node* root, int blackNum,int bench_mark) {
		if (root == nullptr) {
			if (blackNum != bench_mark)return false;
			return true;
		}
		if (root->_col == BLACK) {
			blackNum++;
		}
		if (root->_col == RED && root->_parent->_col == RED) {
			//存在连续的红节点，return false
			return false;
		}
		return prev_check(root->_left, blackNum, bench_mark) &&
			prev_check(root->_right, blackNum, bench_mark);
	}
public:
	bool is_balance() {
		if (_root == nullptr)return true;
		if (_root->_col == RED)return false;
		//黑色节点数量基准值
		int bench_mark = 0;
		Node* cur = _root;
		while (cur) {
			if (cur->_col == BLACK)++bench_mark;
			cur = cur->_left;
		}
		return prev_check(this->_root, 0, bench_mark);
	}
public:
	void inorder() {
		this->_inorder(this->_root);
		cout << "\n";
	}
	//前面插入的过程和搜索树一样的
	bool insert(const pair<K, V>& kv) {
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first < kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
				parent = cur;
				cur = cur->_left;
			}
			else return false;
		}
		cur = new Node(kv);
		cur->_col = RED;//一开始尽量先变红
		if (parent->_kv.first < kv.first) {
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED) {
			Node* grandparent = parent->_parent;
			assert(grandparent && grandparent->_col == BLACK);
			//关键看叔叔
			//判断一下左右
			if (parent == grandparent->_left) {
				Node* uncle = grandparent -> _right;
				//情况1（不看方向）
				if (uncle && uncle->_col == RED) {
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					//继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				//情况2+3
				//uncle不存在/存在且为黑
				else {
					//情况2
					//   g
					//  p  u
					// c
					//右单旋+变色
					if (cur == parent->_left) {
						rotate_right(grandparent);
						parent->_col = BLACK;//父亲变黑
						grandparent->_col = RED;//祖父变红
					}
					//情况3
					//   g
					//  p  u
					//   c
					//左右双旋+变色
					else {
						rotate_left(parent);
						rotate_right(grandparent);
						//看着图写就行了
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else {
				Node* uncle = grandparent->_left;
				//情况1（不看方向）
				if (uncle && uncle->_col == RED) {
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					//继续向上处理
					cur = grandparent;
					parent = cur->_parent;
				}
				else {
					//情况2
					//   g
					//  u  p
					//      c 
					//左单旋+变色
					if (cur == parent->_right) {
						rotate_left(grandparent);
						parent->_col = BLACK;//父亲变黑
						grandparent->_col = RED;//祖父变红
					}
					//情况3
					//   g
					//  u  p
					//    c
					//右左双旋+变色
					else {
						rotate_right(parent);
						rotate_left(grandparent);
						//看着图写就行了
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;//最后无论根是红是黑 -- 都处理成黑
		return true;
	}
};


void test1() {
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	RBTree<int, int>t1;
	for (auto e : a) {
		t1.insert(make_pair(e, e));
	}
	t1.inorder();
	cout << "is_balance():" << t1.is_balance() << endl;
}
void test2() {
	size_t N = 10000;
	srand((unsigned)time(nullptr));
	RBTree<int, int>t1;
	for (size_t i = 0; i < N; ++i) {
		int x = rand();
		t1.insert(make_pair(x, i));
	}
	cout << "is_balance():" << t1.is_balance() << endl;
}

总结

看到这里,大家应该对红黑树的实现,重点是它的旋转有了比较深入的了解了。这篇博客博主花了很多心思在画图上，也投入了很多时间到画图上。下期给大家带来map/set的封装。希望大家可以多多支持，一键三连，点赞关注收藏评论后在离开哦!

( 转载时请注明作者和出处。未经许可，请勿用于商业用途 )
更多文章请访问我的主页

@背包https://blog.csdn.net/Yu_Cblog?type=blog

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

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

相关文章

怎么修复老照片?给你推荐这几个修复方法

怎么修复老照片?给你推荐这几个修复方法

相信大家的家里都有老照片吧&#xff0c;那在你们翻看这些老照片的时候&#xff0c;有没有发现有些老照片变得有些破旧、泛黄、模糊等情况呢&#xff1f;看到这些情况&#xff0c;大家是不是会很心疼呢&#xff1f;因为这些老照片都充满了各种各样的回忆&#xff0c;根本拍不出…
阅读更多...
Docker查看容器的初始启动命令参数的常见几种方式

Docker查看容器的初始启动命令参数的常见几种方式

1.在使用docker容器的过程中&#xff0c;经常需要查看容器启动的命令来看当时启动容器时候所用的参数&#xff0c;如果时间不是很久或者通过history命令就可以很容易的想起或查看到命令&#xff0c;一旦时间过了很久或history被清空那么就无法获取命令&#xff0c;如下所示dock…
阅读更多...
cengbox2靶机(hydra爆破、公私钥免密登录)

cengbox2靶机(hydra爆破、公私钥免密登录)

环境准备 靶机链接&#xff1a;百度网盘 请输入提取码 提取码&#xff1a;zdpr 虚拟机网络链接模式&#xff1a;桥接模式 攻击机系统&#xff1a;kali linux 2021.1 信息收集 1.arp-scan -l探测目标靶机ip 2.nmap -p- -A -T4 192.168.1.107 探测目标靶机开放端口和服务 …
阅读更多...
Docker基本使用

Docker基本使用

1、centos7安装docker engine 参考文档&#xff1a;https://docs.docker.com/engine/install/centos/ &#xff08;1&#xff09;卸载之前的docker sudo yum remove docker \docker-client \docker-client-latest \docker-common \docker-latest \docker-latest-logrotate \…
阅读更多...
Spring——AOP

Spring——AOP

Spring中的可插拔组件技术 Spring AOP Spring AOP——Aspect Oriented Programming 面向切面编程AOP 的做法是将通用的、与业务无关的功能抽象封装为切面层切面可配置在目标方法执行前后&#xff0c;做到即插即用 不修改源码对程序功能进行拓展 AoP的关键概念 Spring AoP 与A…
阅读更多...
栈与队列3：有效的括号

栈与队列3：有效的括号

主要是我自己刷题的一些记录过程。如果有错可以指出哦&#xff0c;大家一起进步。 转载代码随想录 原文链接&#xff1a; 代码随想录 leetcode链接&#xff1a;20. 有效的括号 题目&#xff1a; 给定一个只包括 ‘(’&#xff0c;‘)’&#xff0c;‘{’&#xff0c;‘}’&am…
阅读更多...
怎样才能批量查询网站的谷歌PR权重？把手教你批量查询网站谷歌PR权重值

怎样才能批量查询网站的谷歌PR权重？把手教你批量查询网站谷歌PR权重值

谷歌PR是Google排名运算法则&#xff08;排名公式&#xff09;的一部分&#xff0c;用来标识网页的等级/重要性。在计算网站排名时&#xff0c;PageRank会将网站的外部链接数考虑进去。一个网站的外部链接数越多其PR值就越高&#xff1b;外部链接站点的级别越高&#xff0c;网站…
阅读更多...
docker安装nginx代理nacos2.1.2版本集群

docker安装nginx代理nacos2.1.2版本集群

目录 安装docker最新版本 创建一个docker network&#xff0c;使之固定docker局域ip docker安装mysql主从 配置挂载的my.cnf配置文件 进入mysql主数据库容器命令 登录主数据库创建用于从数据连接主数据的账号密码 输入show master status;查看master数据库状态 在从数据库…
阅读更多...
基于训练和推理场景下的MindStudio高精度对比

基于训练和推理场景下的MindStudio高精度对比

摘要&#xff1a;MindStudio提供精度比对功能&#xff0c;支持Vector比对能力。本文分享自华为云社区《【MindStudio训练营第一季】MindStudio 高精度对比随笔》&#xff0c;作者&#xff1a;Tianyi_Li。 训练场景下&#xff0c;迁移原始网络 (如TensorFlow、PyTorch) &#x…
阅读更多...
[附源码]Python计算机毕业设计SSM家纺商品展示平台（程序+LW)

[附源码]Python计算机毕业设计SSM家纺商品展示平台（程序+LW)

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
连锁门店进销存软件的用途

连锁门店进销存软件的用途

门店式经营对于很多经营有道的老板来说是第一步&#xff0c;在规模扩张中&#xff0c;生意越做越大。这时要想拓宽销路&#xff0c;让收益更上一层楼&#xff0c;连锁、分店确实是一种行之有效的方法。 多门店管理经营存在的长久性难点是决策性工作量激增&#xff0c;管理方面…
阅读更多...
[附源码]计算机毕业设计勤工俭学管理小程序Springboot程序

[附源码]计算机毕业设计勤工俭学管理小程序Springboot程序

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
Multimodal Token Fusion for Vision Transformers

Multimodal Token Fusion for Vision Transformers

水平太浅&#xff0c;理解不到位。谨慎观看。 多模态token融合&#xff0c;我是语义分割&#xff0c;只看RGB和Depth模态。 1&#xff1a;作者为了解决transformer多输入的问题&#xff0c;对基于transformer视觉任务进行剪枝&#xff0c;为了有效的融合多模态&#xff0c;toke…
阅读更多...
Docker(一) ----初始Docker

Docker(一) ----初始Docker

文章目录前言一、什么是 Docker1.1 Docker 的定义1.2 Docker对于上述问题的解决二、Docker 与虚拟机三、Docker 架构3.1 镜像和容器3.2 Docker 和 Docker Hub3.3 Docker 架构四、安装Docker4.1 卸载 (可选)4.2 安装Docker4.3 启动 Docker4.4 配置镜像加速总结前言 本文章主要是…
阅读更多...
艾美捷肝细胞培养基试剂盒说明书

艾美捷肝细胞培养基试剂盒说明书

肝细胞培养基是专门为正常人类肝细胞体外培养设计的最适于其生长的培养基&#xff0c;是经灭菌的液体培养基&#xff0c;包含必需和非必需氨基酸、维生素、有机和无机化合物、激素、生长因子、微量矿物质和低浓度胎牛血清(5%)。 艾美捷肝细胞培养基试剂盒为我们的大鼠肝细胞设计…
阅读更多...
WIN10商业版64位22H2正式版19045.2251MSDN11月原版镜像

WIN10商业版64位22H2正式版19045.2251MSDN11月原版镜像

微软表示 Windows 10 是迄今为止最好的 Windows 操作系统。无论你是普通办公用户、游戏玩家还是开发者&#xff0c;Win10 都能带给你目前最先进的功能特性以及使用体验。 其实微软对 Windows 10 版本的命名一直没有什么统一标准&#xff0c;最新的「22H2」是以开发代号命名的。…
阅读更多...
【JavaWeb开发-Servlet】day02-使用eclipse实现Servlet开发

【JavaWeb开发-Servlet】day02-使用eclipse实现Servlet开发

目录 1、安装IDE-eclipse编译器 2、配置IDE开发环境 &#xff08;1&#xff09;使用eclipse关联Tomcat服务器 &#xff08;2&#xff09;使用Servlet访问Hello World页面 &#xff08;3&#xff09;Java中常用的方法调用方式 &#xff08;4&#xff09;Java中常用的反射机…
阅读更多...
web3.0学习入门7：深入学习Web3.0

web3.0学习入门7：深入学习Web3.0

Web3.0背景 2个大事件&#xff1a; 1、2021年10月28日&#xff0c;月活破30亿的Facebook正式官宣改名为Meta&#xff0c;元宇宙和Web3等概念正式从币圈破圈&#xff1b; 2、2021年12月8日&#xff0c;美国众议院加密金融听证会有议员喊出“确保Web3.0革命发生在美国”&#…
阅读更多...
数字图像处理实验（二）|图像变换（附实验代码和截图）

数字图像处理实验（二）|图像变换（附实验代码和截图）

文章目录一、实验目的二、主要仪器设备三、实验原理&#xff08;一&#xff09;变换原理1.离散傅里叶变换2.离散余弦变换3.频谱平移&#xff08;二&#xff09;频谱分析原理四、实验步骤和内容1. 为下面三段程序写出注释并上机运行&#xff0c;将实际运行结果如实记录到实验报告…
阅读更多...
《数据结构》队列

《数据结构》队列

学习目录队列队列的概念队列的使用(Queue)队列的模拟实现循环队列双端队列&#xff08;Deque&#xff09;面试题队列 队列的概念 队列是一种先进先出&#xff0c;后进后出的特点&#xff0c;是只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023