Day18：初识B、B+树＆RB树

已于 2022-08-18 10:13:28 修改
阅读量285 收藏
点赞数 1
文章标签： b树 数据结构
于 2022-08-18 10:13:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjjaibc/article/details/126399611
版权

一、B树和B+树

1.B树：


    23树的基础上  引入  M值
    23树就是M值为3的B树

Day13：数据结构之2-3树__https://blog.csdn.net/zjjaibc/article/details/126194415?spm=1001.2014.3001.5501

2.B+树：


    B树加上两个特性：
        1. 数据只存在叶子节点上
        2. 叶子节点之间用指针连接


        通常用于数据库和操作系统的文件系统中。B+树的特点是能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。B+树元素自底向上插入，这与二叉树恰好相反。

        数据库  DB  DBA   关系型数据库  B+树
            MySql  

        硬盘：
            物理结构       (内存四区：代码区  栈区  堆区  静态区
            数据存储结构      B+树  

 查询的时候,

        相当于根据索引大致确定了查找的区间,所有的真实数据均放在叶子结点上,

        且相互连接构成了一个链表,.

二、红黑树： 

红黑二叉树：
    不怎么降低AVL的查找效率，大幅优化增删效率

红黑二叉树 相对AVL树：
    稍稍降低查找效率（不是绝对平衡） 增删效率加快很多（三次旋转搞定）

红黑二叉树规则：
    1. 树中节点 非红即黑
    2. 根和叶子都是黑节点(空节点算叶子),枝干非红即黑
    3. 红色节点的孩子必定是黑色,插入的结点一开始必为红色,两个红色结点不能相连
    4. 从一个节点到这个节点的任意一个子孙节点路径上包含相同个数的黑色节点。

红黑二叉树插入步骤：    

1. 新节点统一着色为红色
    情况一：新节点为根节点
        着色为黑
    情况二：新节点的父节点颜色为黑
        啥都不干
    情况三：新节点的父节点颜色为红色
        3.1 被插入节点父节点颜色为红色，并且叔叔节点颜色为黑色，并且被插入节点是其父节点的左孩子
            3.1.1 父节点设置为黑色
            3.1.2 爷爷节点设置为红色
            3.1.3 以其父节点为轴右旋
        3.2 被插入节点父节点颜色为红色，并且叔叔节点颜色为黑色，并且被插入节点是其父节点的右孩子
            3.2.1 以其父节点为轴 ，左旋
            3.2.2 新节点设置为黑色
        3.3 被插入节点父节点颜色为红色，并且叔叔节点颜色为红色
            3.3.1 父节点设置为黑色
            3.3.2 叔叔节点设置为黑色
            3.3.3 爷爷节点设置为红色
            3.3.4 把爷爷节点当成新节点插入

(1) 情景1：红黑树为空树

  • 将插入节点作为根节点，然后将根节点设置为黑色

(2) 情景2：插入点的key已存在

  • 替换原节点的value值

(3) 情景3：插入节点的父节点是黑节点

  • 直接插入，不会影响自平衡

(4) 情景4：插入节点的父节点是红节点

根据性质2：父节点为红色一定不是根节点；根据性质4：爷节点肯定是黑色。

         情景4.1：叔叔节点存在，且为红色

         

  • 将父节点P和叔节点U改为黑色

  • 爷节点PP改为红色。

  • 进行后续处理: 

      情景4.2：叔节点不存在或为黑节点，且插入节点的父节点是爷节点的左孩子  

                注意：叔叔节点应该非红即空，否则破坏性质

                 情景4.2.1：插入节点是父节点的左孩子（LL双红情况）

  • 将父节点P设为黑色，将爷节点PP设为红色

  • 对爷节点PP进行右旋

                情景4.2.1：插入节点是父节点的右孩子（LR双红情况）

  • 对父节点P进行左旋

  • 将P设为当前节点，得到LL双红情况

  • 将I设为黑色，将爷节点PP设为红色

  • 对爷节点PP进行右旋

        情景4.3：叔叔节点不存在或为黑节点，且插入节点的父节点是爷节点的右孩子

                对应情景4.2，只是方向相反

红黑树代码实现

#include <stdio.h>
#include <stdlib.h>			
//辅助宏
#define RED		0
#define BLACK	1
//获取节点的颜色
#define COLOR(x)  ((x)->color)
//获取当前节点的父节点
#define PARENTNODE(x) ((x)->parentNode)
//设置当前节点的父节点
#define SET_PARENT(x,p) ((x)->parentNode=(p))
//设置当前节点的颜色
#define SET_COLOR(x,c) ((x)->color=(c))
//设置当前节点颜色为黑色
#define SET_BLACK(x) ((x)->color=BLACK)
//设置当前节点颜色为红色
#define SET_RED(x) ((x)->color=RED)
//判断当前节点颜色是否为黑色
#define IS_BLACK(x) ((x)->color==BLACK)
//判断当前节点颜色是否为红色
#define IS_RED(x) ((x)->color==RED)
//红黑树的结构体
struct RBTreeNode 
{
	unsigned int color;			//颜色
	int key;				//关键字
	struct RBTreeNode* LChild;
	struct RBTreeNode* RChild;
	struct RBTreeNode* parentNode;
}
typedef  struct RBTreeNode	NODE;
typedef  struct RBTreeNode* LPNODE;

struct RBTree 
{
	LPNODE 	root;
	int 	treeSize;
}
typedef struct RBTree	RBTREE;
typedef struct RBTree*	LPRBTREE;

LPNODE createNode(int key) 
{
	LPNODE newNode = (LPNODE)malloc(sizeof(NODE));
	newNode->key = key;
	newNode->LChild = NULL;
	newNode->RChild = NULL;
	newNode->parentNode = NULL;
	newNode->color = BLACK;
	return newNode;
}
//创建树
LPRBTREE createRBTree() 
{
	LPRBTREE tree = (LPRBTREE)malloc(sizeof(RBTREE));
	tree->root = NULL;
	return tree;
}
//左旋
void L_Rotation(LPRBTREE tree,LPNODE x) 
{
	//1.拿到x的右边 y怎么表示？
	LPNODE y = x->RChild;
	//2.y的左边成为x的右边
	x->RChild = y->LChild;
	//3.判断下y的左边是不是空的
	//父节点的处理
	if (y->LChild != NULL) {
		y->LChild->parentNode = x;
	}
	//y替换了x ,所以x的父节点就是y的父节点
	y->parentNode = x->parentNode;
	//如果x是根不，循环后，红黑树的根改变
	if (x->parentNode == NULL) {
		tree->root = y;
	}
	else {
		//不是根部判断x是在原来父节点左边还是右边
		if(x->parentNode->LChild==x){
			x->parentNode->LChild = y;
		}
		else {
			x->parentNode->RChild = y;
		}
	}
	//处理一下x的位置
	y->LChild = x;
	x->parentNode = y;
}
//右旋
void R_Rotation(LPRBTREE tree, LPNODE y) 
{
	//拿到x节点
	LPNODE x = y->LChild;
	y->LChild = x->RChild;
	if (x->RChild != NULL) 
	{
		x->RChild->parentNode = y;
	}
	//处理x和y的父节点
	x->parentNode = y->parentNode;
	if (y->parentNode == NULL) 
	{
		tree->root = x;
	}
	else 
	{
		if (y == y->parentNode->LChild) 
		{
			y->parentNode->LChild = x;
		}
		else 
		{
			y->parentNode->RChild = x;
		}
	}
	//
	x->RChild = y;
	y->parentNode = x;
}
//1.插入
//1.1 当作BST(有序二叉树)做一个插入
//1.2 调整成为红黑树
void insertAdjustTree(LPRBTREE tree, LPNODE node) 
{
	LPNODE parent, gparent;
	while ((parent = PARENTNODE(node)) && IS_RED(parent)) 
	{
		gparent = PARENTNODE(parent);
		//三种情况分析
		if (parent == gparent->LChild) 
		{//父节点是祖父节点的左孩子
			//No.1 U=RED;//对应笔记中的情况三 . 3
			{
				LPNODE uncle = gparent->RChild;
				if (uncle && IS_RED(uncle)) 
				{
					SET_BLACK(uncle);		 //uncle->color=BLACK;
					SET_BLACK(parent);		 //parent->color=BLACK;
					SET_RED(gparent);	     //gpranet->color=RED;
					node = gparent;			
					continue;
				}
			}
			//No.2 u=BLACK S=R //对应笔记中 情况三.1
			if (parent->RChild == node) 
			{
				LPNODE temp;
				L_Rotation(tree, parent);
				temp = parent;
				parent = node;
				node = temp;
			}
			//No.3 U=BLACK S=L    //对应笔记中 情况三.2
			SET_BLACK(parent);
			SET_RED(gparent);
			R_Rotation(tree, gparent);
		}
		else 
		{//父节点是祖父节点的右孩子
			//No.1   //对应笔记中的情况三 . 3
			{
				LPNODE uncle = gparent->LChild;
				if (uncle && IS_RED(uncle)) 
				{
					SET_BLACK(uncle);		 //uncle->color=BLACK;
					SET_BLACK(parent);		 //parent->color=BLACK;
					SET_RED(gparent);	     //gpranet->color=RED;
					node = gparent;
					continue;
				}
			}
			//No.2  
			if (parent->LChild == node) //对应笔记中 情况三.1
			{
				LPNODE temp;
				R_Rotation(tree, parent);
				temp = parent;
				parent = node;
				node = temp;
			}
			SET_BLACK(parent);//对应笔记中 情况三.2
			SET_RED(gparent);
			L_Rotation(tree, gparent);
		}
	}
	SET_BLACK(tree->root);// 对应笔记中 情况一：新节点是根节点
}
//1.1 当作BST做一个插入
void insertNode(LPRBTREE tree, LPNODE node) 
{
	//当作BST做一个插入
	LPNODE y = NULL;
	LPNODE x = tree->root;
	while (x != NULL) 
	{
		y = x;		//记录父节点
		if (node->key < x->key) 
		{
			x = x->LChild;
		}
		else 
		{
			x = x->RChild;
		}
	}
	//新节点应该插在y节点的下面
	SET_PARENT(node, y);
	if (y != NULL) 
	{
		if (node->key < y->key) 
		{
			y->LChild = node;
		}
		else 
		{
			y->RChild = node;
		}
	}
	else	//树是空的，第一次插入节点就要成为根节点
	{
		tree->root = node;
	}
	SET_COLOR(node, RED);		//插入节点着色红色
	//2.按照红黑树的规则情况去调整二叉树成为红黑树
	insertAdjustTree(tree, node);
}
void printCurNode(LPNODE curNode) 
{
	printf("%d:%s\n", curNode->key, curNode->color ? "BLACK" : "RED");
}
void preOrder(LPNODE root) 
{
	if (root != NULL) 
	{
		printCurNode(root);	//printf("%d:%s\n", curNode->key, curNode->color ? "BLACK" : "RED");
		preOrder(root->LChild);
		preOrder(root->RChild);
	}
}
//2.红黑树的删除
//2.1 当做BST 去做删除
//2.2 调整
void deleteAdjustTree(LPRBTREE tree, LPNODE node, LPNODE parent) 
{
	LPNODE other;
	while (!node || IS_BLACK(node) && node != tree->root) 
	{
		if (parent->LChild == node) //node是其父节点的左孩子
		{
			other = parent->RChild;
			if (IS_RED(other))//node的兄弟为红色节点
			{
				//No.1 xB=RED
				SET_BLACK(other);
				SET_RED(parent);
				L_Rotation(tree, parent);
				other = parent->RChild;
			}
			if ((!other->LChild) || IS_BLACK(other->LChild) &&
				(!other->RChild) || IS_BLACK(other->RChild)) 
			{
				//No.2  xB=BLACK
				SET_RED(other);
				node = parent;
				parent = PARENTNODE(node);
			}
			else 
			{
				if (!other->RChild || IS_BLACK(other->RChild)) 
				{
					//No.3 xB=BLACK xB->LChild=RED, xB->RChild=BLACK;
					SET_BLACK(other->LChild);
					SET_RED(other);
					R_Rotation(tree, other);
					other = parent->RChild;
				}
				//No.4 xB=BLACK xB=RChild=RED
				SET_COLOR(other, COLOR(parent));
				SET_BLACK(parent);
				SET_BLACK(other->RChild);
				L_Rotation(tree, parent);
				node = tree->root;
				break;
			}
		}
		else //node是其父节点的右孩子
		{
			other = parent->LChild;
			if (IS_RED(other))
			{
				//No.1 xB=RED
				SET_BLACK(other);
				SET_RED(parent);
				L_Rotation(tree, parent);
				other = parent->LChild;
			}
			if ((!other->LChild) || IS_BLACK(other->LChild) &&
				(!other->RChild) || IS_BLACK(other->RChild))
			{
				//No.2  xB=BLACK
				SET_RED(other);
				node = parent;
				parent = PARENTNODE(node);
			}
			else
			{
				if (!other->LChild || IS_BLACK(other->LChild))
				{
					//No.3 xB=BLACK xB->RChild=RED, xB->LChild=BLACK;
					SET_BLACK(other->RChild);
					SET_RED(other);
					L_Rotation(tree, other);
					other = parent->LChild;
				}
				//No.4 xB=BLACK xB=LChild=RED
				SET_COLOR(other, COLOR(parent));
				SET_BLACK(parent);
				SET_BLACK(other->LChild);
				R_Rotation(tree, parent);
				node = tree->root;
				break;
			}
		}
	}
	if (node) 
	{
		SET_BLACK(node);
	}
}
//2.1 当做BST 去做删除
void deleteNode(LPRBTREE tree, LPNODE node) 
{
	LPNODE child, parent;
	int color;					//删除节点兄弟的颜色
	//左右子树都存在
	if ((node->LChild) != NULL && (node->RChild) != NULL)
	{
		LPNODE replace = node;
		replace = replace->RChild;		//调整树：从右子树中拿最左边
		while (replace->LChild != NULL)
		{
			replace = replace->LChild;
		}
		//讨论删除节点是不是根节点
		if (PARENTNODE(node))
		{
			if (PARENTNODE(node)->LChild == node)
			{
				PARENTNODE(node)->LChild = replace;
			}
			else
			{
				PARENTNODE(node)->RChild = replace;
			}
		}
		else 
		{
			tree->root = replace;
		}
		child = replace->RChild;
		parent = PARENTNODE(replace);
		color = COLOR(replace);
		if (parent == node) 
		{
			parent = replace;
		}
		else 
		{
			if (child) 
			{
				SET_PARENT(child, parent);
			}
			parent->LChild = child;
			replace->RChild = node->RChild;
			SET_PARENT(node->RChild, replace);
		}
		//调整替换节点父节点
		replace->parentNode = node->parentNode;
		replace->color = node->color;
		replace->LChild = node->LChild;
		//调整删除节点父节点
		node->LChild->parentNode = replace;
		if (color == BLACK) 
		{
			//调整树：
			deleteAdjustTree(tree, child, parent);
		}
		free(node);
		return;
	}
	if (node->LChild != NULL) 
	{
		child = node->LChild;
	}
	else 
	{
		child = node->RChild;
	}
	parent = node->parentNode;
	color = node->color;
	if (parent) 
	{
		if (parent->LChild == node) 
		{
			parent->LChild = child;
		}
		else 
		{
			parent->RChild = child;
		}
	}
	else
	{
		tree->root = child;
	}
	if (color == BLACK) 
	{
		//调整二叉树
		deleteAdjustTree(tree, child, parent);
	}
	free(node);
}
LPNODE search(LPNODE x, int key)
{
	if (x == NULL || x->key == key)
		return x;
	if (key < x->key) 
	{
		return search(x->LChild, key);
	}
	else 
	{
		return search(x->RChild, key);
	}
}
void deleteTreeNode(LPRBTREE tree, int key) 
{
	LPNODE result = search(tree->root, key);
	if (result != NULL)
		deleteNode(tree, result);
}

int main()
{
	int array[] = {10,40,30,60,90,70,20,50,80};
	int arrayNum = 9;
	LPRBTREE tree = createRBTree();
	for (int i = 0; i < arrayNum; i++) 
	{
		insertNode(tree, createNode(array[i]));
	}
	preOrder(tree->root);
	printf("\n");
	printf("删除:\n");
	deleteTreeNode(tree, 10);
	preOrder(tree->root);
	printf("\n");
	printf("删除:\n");
	deleteTreeNode(tree, 80);
	preOrder(tree->root);
	printf("\n");

	while(1);//防止闪屏
	return 0;
}

_Ocean__
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[网络安全自学篇] 八十二.WHUCTF之隐写和逆向类解题思路WP（文字解密、图片解密、佛语解码、冰蝎流量分析、逆向分析）
杨秀璋的专栏
06-04 1万+
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。前文分享了Easy_unserialize解题思路，详细分享文件上传漏洞、冰蝎蚁剑用法、反序列化phar等。这篇文章将详细讲解WHUCTF隐写和逆向题目，包括文字解密、图片解密、佛语解码、冰蝎流量分析、逆向分析。第一次参加CTF，还是学到了很多东西。人生路上，要珍惜好每一天与家人陪伴的日子。感谢武汉大学，感谢这些大佬和师傅们（尤其出题和解题的老师们）~
Python day13--网络编程
qq_36983538的博客
01-19 2141
Python网络编程
【数据结构与算法】B/B+ 树 、RB树
mick_seu的博客
05-04 3142
B / B+ / B*树采用 多叉树 结构降低树深度，主要用在磁盘文件系统与数据库。 参考自： 1）http://taop.marchtea.com/03.02.html 2）https://segmentfault.com/a/1190000004690721 3）http://blog.codinglabs.org/articles/theory-of-mysql-index.html
数据结构--RBTree/BTree/B+Tree
m0_37695902的博客
06-07 135
本文链接：https://blog.csdn.net/qawsedrf123lala/article/details/107594807 树，二叉树，二叉搜索...
B-Tree 和 B+Tree傻傻分不清楚
qq_40798377的博客
02-01 210
B-Tree B-Tree又叫做B树，和平衡二叉树不同的地方在于B树是多叉树(平衡多路查找树)，Oracle和MongoDB的索引技术就是基于B树的数据结构，B树也可以看作是对2-3查找树的一种扩展。 一个m阶的B-Tree有以下性质 每个节点最多有m个子节点； 每个非叶子节点（根节点除外）至少含有m/2个子节点； 如果根节点不是叶子节点，那么根节点至少有两个子节点； 每个节点上，所有的关键字都是有序的，从左到右，依次从小到大排序； 每个关键字的左子树的均值小于当前关键字，右子树的均值大于当前关键字； 每
STL笔记---B树，B+树，RB树
mmdev
10-06 460
一。红黑树(RB-Tree) 红黑树是每个节点都有’颜色’特征的平衡二叉查找树。 除了一般平衡二叉树做具备的条件，它还具有如下特征： 1） 节点的颜色是红色或者黑色； 2） 根节点的颜色是黑色的； 3） 如果一个节点时带红色属性的，那么它的子节点必须是黑色的； 4） 所有叶子节点是黑色的（叶子节点为NULL节点）； 5） 从任一节点开始到其叶子(NULL)节点的所有简单路径中，包含相...
AVL树、B-树、RB树、B+树、B*树比较
c_living的博客
07-24 1644
一：AVL树        也就是平衡二叉树，该二叉树为了优化查找的性能，会让每个结点的左右子树的高度差维持在1以内，也就是小于等于1。因为我们在二叉查找树上查找数据的时候，是类似二分法的，那么我们每次折半的区间长度就会决定了我们查找的效率，从概率的角度讲，在未知的情况下肯定是一半一半获得的效率最高。所以在二叉查找树中，决定查找效率就是树的高度，为什么呢？        其实我们可以这样想，因...
☆B树与B+树
我能在河边钓一整天的鱼
07-14 342
前言 关于索引的基本概念可参考这篇博客https://blog.csdn.net/Delicious_Life/article/details/105466368 我们知道MySQL的索引结构使用了B+树，想必读者很想知道为什么百度B+树会搜出来个B树，B树和B+树到底有什么异同？要清楚这些内容，首先我们要了解平衡二叉树 平衡二叉树 我们知道程序运行时需要从本地磁盘加载到内存中。每次从磁盘加载到内存都可以看做是一次I/O操作，而这种I/O操作是很耗费时间和...
总结整理：从B树、B+树、B*树谈到R 树
狂奔的蜗牛
12-10 2890
最近学习高级数据库技术，涉及到很多的数据结构如B+树，R树，因此想系统的整理一下从B树、B+树、B*树谈到R 树，网上查阅了一些资料进行了整理。 下面有关内容部分转自：http://blog.csdn.net/v_JULY_v/article/details/6530142   其中，我认为第一篇文章说到的B+树的定义是有问题的，B+树的有n棵子树的结点中含有n个关键字，应该是含有n-1个关键
day15文件操作总结和作业
tw19980305的博客
03-07 221
day15文件操作总结和作业 一、文件操作基础 数据持久化 1）背景：程序中数据默认保存在运行内存中，保存在运行内存中的数据在程序运行结束后就会被销毁 ​ 如果程序中的数据在程序结束后不销毁必须将数据通过文件的形式保存到磁盘中 2）数据持久化又叫数据本地化，就是将程序中的数据存储到文件中的过程 3）常见的数据持久化工具：数据库（.db、.sqlite）、json文件、plist文件、csv文件、ecxcel文件、txt文件等 文件操作 - 操作的是文件内容 操作基本流程：打开文件 -&gt
《利用Python进行数据分析》notebook
solonebaeya的博客
02-25 481
Chapter1.准备工作 包括环境搭建，编译器安装，重要python库的初识等入门内容。 Chapter2.Python语言基础、IPython及Jupyter notebook 2.1 Python解释器 交互式Python解释器可以通过在命令行输入python命令（python 1.py）启动。But数据分析和科学计算的人会使用IPython和Jupyter notebook。...
Python从入门到自闭(基础篇)
日魔
08-10 3131
Python从入门到自闭 作者:日魔 Python的创始人吉多.范罗苏姆(Guido va Rossum)(外号:龟叔) 一. ***Python***的历史： 1. 1989年圣诞节的时候为了打发时间决定开发一款新的脚本解释程序。 199年第一个python编译器诞生，他是用C语言实现的并能调用C语言的库文件。 1994年Python_1.0诞生，添加了lambda,map,filter ...
【数据结构】B树、B+树与B*树详解
白夜行
07-21 3668
B树1.B树的定义 B树（B-tree）是对2-3树数据结构的扩展，又称为多路平衡查找树，它的一个节点可以拥有多于2个子节点的二叉查找树。与自平衡二叉查找树不同， B树是一种自平衡树数据结构，可以保持数据排序，它能够存储数据、对其进行排序并允许以O(log n)的时间复杂度运行进行查找、顺序读取、插入和删除的数据结构 B树针对读写大数据块的系统进行了优化。B树的算法减少定位记录时所经历的中间过程，从
从零开始学数据结构系列之第五章《B树的删除》
铁匠匠匠的博客
09-06 951
可以观看以下两个UP的视频来先看看1）如果当前需要删除的key位于非叶子结点上，则用后继key（这里的后继key均指后继记录的意思）覆盖要删除的key，然后在后继key所在的子支中删除该后继key。此时后继key一定位于叶子结点上，这个过程和二叉搜索树删除结点的方式类似。删除这个记录后执行第2步2）该结点key个数大于等于Math.ceil(m/2)-1，结束删除操作，否则执行第3步。
B+树优势
最新发布
qq_53199639的博客
09-06 442
红黑树：每个节点只存储两个节点，而IO一次会读取至少一页的数据（16K数据），而每个节点只存储一个数据，浪费IO操作，存储的节点少，树层数高，IO次数也多。1. 非叶子节点不存储数据，不需要在遍历树节点时进行IO操作，降低IO次数，IO友好。B树：每一层可以有多个节点，非叶子节点也存储数据，且叶子节点之间不互联。B+树：非叶子节点不存储数据，且叶子节点之前双向链表互联。2. 都是在叶子节点获取数据，查询效率更稳定。3. 叶子节点之间互联，便于扫库和范围查询。平衡二叉树：要大量的操作来维持树的平衡。
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 970
详解了推有关的两个面试题：堆排序，TopK问题
栈—数据结构
weixin_63722559的博客
09-06 982
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
MATLAB 中双引号 ““ 和单引号 ‘‘ 的区别详解
2202_75569688的博客
09-03 616
在 MATLAB 中，双引号""和单引号''都可以用来表示字符串，但它们的作用和底层类型是不同的。理解它们之间的区别，对于正确使用字符串处理功能非常重要。本文将深入探讨 MATLAB 中""和''的区别，以及在实际编程中的应用场景。
int+numDoctors+=+(day+>=+1+&&+day+<=+5)+?+1+:+2;解释
12-29
numDoctors += (day >= 1 && day ) ? 1 : 2; ``` 这段代码的目的是根据给定的`day`值来决定增加`numDoctors`的数量。具体的逻辑如下： - 如果`day`的值在1到5之间（包括1和5），则将`numDoctors`增加1。 - 如果`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_Ocean__

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值