红黑树 都可以这么细？面试官还能怎么说.

最新推荐文章于 2022-05-07 10:23:52 发布
置顶 最新推荐文章于 2022-05-07 10:23:52 发布
阅读量2.2k 收藏 114
点赞数 46
分类专栏： c/c++ 数据结构 文章标签： 数据结构 红黑树 二叉树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52270223/article/details/117135984
版权

女：你一点都不注重细节；
男：你说我不都细节？？ 你看看下面的红黑树讲解，，你说我不够细节？？
随后男发送下面红黑树代码发给女朋友之后；
女：哇，哥哥果然好细；
男：细节拉满，关注又是一个细节；
当然也不能太细，这样也不太好；

在这里插入图片描述

代码+图解

目录：

红黑树的性质：

首先记住它的性质：

在增删节点时需要调整满足性质

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

对颜色进行定义：

//我们用枚举表示表示出两种颜色  
//枚举默认第一个参数 BLACK 为 0 ，第二个参数 RED 为 1；
enum COLOR {
	BLACK,
	RED
};

红黑树的节点表示：

在这里插入图片描述
看图说节点
红黑树的节点参数，

一个指向上面的节点定义为_parent
一个指向左边的节点的节点指针 _left
一个指向右边的 _right
一个pair类型的值
一个颜色的识别

当然这么写参数那得来个构造函数了，“细节”。

template<class K,class V>
struct RBNode {
	//各个节点
	RBNode<K, V>* _parent;
	RBNode<K, V>* _left;
	RBNode<K, V>* _right;
	//key-value
	pair<K, V> _kv;
	//颜色
	COLOR _color;
	RBNode(const pair<K, V>& kv = pair<K, V>())
		:_parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _kv(kv)
		//新申请的节点定义为RED，黑色的加入，会导致其他所有路径的黑色都遭到破坏；
		, _color(RED) {
	}
};

对树的类进行定义：

在这里插入图片描述

红黑树的头节点——header

指向如图上图：具体下面再写

template<class K,class V>
class RBTree {
public:
	//类型定义,用Node表示RBNode<K,V>
	typedef RBNode<K,V> Node;

	RBTree()
		:_header(new Node) {
		//创建空树
		_header->_left = _header->_right = _header;
	}
private:
	Node* _header;
};

红黑树的插入：

当插入c节点时，为了满足性质，需要对节点进行调整，为了保证调整最优；
如果插入节点的父节点（u）和叔叔节点（u）为红色，那么只需要改变叔叔节点（u）和父节点（p）颜色为黑色，祖父节（g）为黑色即可；
当然如果祖父节点（g) 为根节点，再把其变为黑色；
在这里插入图片描述
不是根节点，向上调整；
在这里插入图片描述

结构右旋：

写一个左旋的操作，在树结构变化时可高效的改变保证结构性质；
如果
当出现情况1：
插入节点为c，当它的叔叔节点为黑色，或者叔叔节点不存在，操作相同；

在这里插入图片描述

记录三个节点，只有这三个节点指向变化；
由图：
用parent表示g，
用subL表示p，
用subLR表示p的右子节点即c；
用pparent表示g的父节点；

	//		  parent
	//	subL
	//			subLR	
	void RotateR(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//改变节点指向：
		subL->_right = parent;
		parent->_left = subLR;
		//如果存在父节点存在，如果为nullptr则没有父节点；
		if (subLR)
			subLR->_parent = parent;
		//判断根
		if (parent == _header->_parent) {
			_header->_parent = subL;
			subL->_parent = _header;
		}
		//不是根
		else {
			Node* pparent = parent->_parent;
			subL->_parent = pparent;
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;
		}
		//先要将parent的父节点赋值出去，才能改变paremt的父节点；
		parent->_parent = subL;
	}

结构左旋：

：如图顺序（未画完全，子节点仍然有且满足性质）

在这里插入图片描述

记录三个节点，只有这三个节点指向变化；（操作和右旋思路相同）
由图：
用pparent表示p的父节点；
	//			parent
	//					subR
	//			subRL				
	void RotateL(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_left = parent;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		if (_header->_parent == parent) {
			_header->_parent = subR;
			subR->_parent = _header;
		}
		else {
			Node* pparent = parent->_parent;
			subR->_parent = pparent;
			if (pparent->_left == parent)
				pparent->_left = subR;
			else
				pparent->_right = subR;
		}
		parent->_parent = subR;
	}

头节点指向的左右节点：

如图：header头节点指向最左最右的节点；
#

找红黑树的最左节点：

	//最左节点
	Node* leftMost() {
		Node* cur = _header->_parent;
		while (cur && cur->_left) {
			cur = cur->_left;
		}
		return cur;
	}

找红黑树的最右节点：

//最右节点
	Node* rightMost() {
		Node* cur = _header->_parent;
		while (cur && cur->_right) {
			cur = cur->_right;
		}
		return cur;
	}

红黑树的插入情况分析：

  • 情况1：插入节点的父节点颜色为黑色；

处理1：直接插入;

  • 情况2：插入节点的父节点为红色，叔叔节点存在且为红色；

处理2：插入后叔叔节点和父节点颜色变黑，祖父节点颜色变红，向上遍历查看情况；

  • 情况3：父节点为红色，叔叔节点存在为黑色或不存在，插入节点为父节点的左子树，父节点为祖父节点的左子树；

处理3：进行结构右旋操作（RotateR）；

  • 情况4：和情况3的结构调整相反父节点为红色，叔叔节点存在为黑色或不存在，插入节点为父节点的右子树，父节点为祖父节点的右子树；

处理4：进行结构左旋操作（RotateL）；

  • 情况5：和情况6结构调整相反父节点为红色，叔叔节点存在为黑色或不存在，插入节点为父节点的左子树，父节点为祖父节点的右子树；

处理5：先以父节点为根，先右旋操作（RotateR），再以祖父节点为根，左旋操作（RotateL）；

  • 情况6：父节点为红色，叔叔节点存在为黑色或不存在，插入节点为父节点的右子树，父节点为祖父节点的左子树；

处理6：先以父节点为根，左旋操作（RotateL），再以祖父节点为根，右旋操作（RotateR）；

上图:（个情况）

  • 情况1：在这里插入图片描述

  • 情况2：在这里插入图片描述

  • 情况3：在这里插入图片描述

  • 情况4：
    和情况3相反，自己画去；

  • 情况5：
    情况6相反，自己画去；

  • 情况6在这里插入图片描述

上代码：

	//插入
	bool insert(const pair<K,V>& kv) {
		//1.搜索树颜色
		//空树：_header->parent:nullptr
		if (_header->_parent == nullptr) {
			//创建根节点
			Node* root = new Node(kv);

			_header->_parent = root;
			root->_parent = _header;
			_header->_left = _header->_right = root;
			//根节点是黑色
			root->_color = BLACK;
			return true;
		}
		
		//从根节点开始搜索
		//正常插入
		Node* cur = _header->_parent;
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			//和key值进行比较
			//kv： pair<K,V>, key:pair.first
			if (cur->_kv.first == kv.first) {
				//key值存在，不允许插入
				return false;
			}
			
			else if (cur->_kv.first > kv.first) {
			//向小的找,左子树去找
				cur = cur->_left;
			}
			else {
			//向大的找,右子树去找
				cur = cur->_right;
			}
		}//找到了
		
		//创建待插入节点
		cur = new Node(kv);
		if (parent->_kv.first > cur->_kv.first)
			parent->_left = cur;//比较大小，插在左右那个位置；
		else
			parent->_right = cur;
		cur->_parent = parent;

		//2.调整结构或者修改颜色
	//判断是否至少有三层；
		while (cur != _header->_parent && cur->_parent->_color == RED) {
			parent = cur->_parent;
			Node* gfather = parent->_parent;
			//可能出现情况6，情况3
			if (gfather->_left == parent) {
				Node* uncle = gfather->_right;
				//情况2：uncle存在，并且都是红色
				if (uncle && uncle->_color == RED) {
					parent->_color = uncle->_color = BLACK;
					gfather->_color = RED;
					//继续向上更新
					cur = gfather;
				}
				//
				else {
					cout << "Rotate" << endl;
					//双旋结构
					//情况6：
					if (cur == parent->_right) {
						RotateL(parent);
						swap(cur, parent);
					}
//经过第一次左旋后，情况6 与情况3 只有cur节点和父节点的指向不一样，
//经过swap两者后，接下来操作相同都为右旋；
					RotateR(gfather);
					parent->_color = BLACK;
					gfather->_color = RED;
					break;
				}
			}
			else {
				//gfather->_right=parent的情况；
				//情况4，情况5,；
				//处理与情况3，情况6相反；
				Node* uncle = gfather->_right;
				//uncle存在，且都是红色，最简
				if (uncle && uncle->_color == RED) {
					parent->_color = uncle->_color = BLACK;
					gfather->_color = RED;
					cur = gfather;
				}
				//情况3：uncle不存在，或者uncle存在为黑色
				//双旋结构
				else {
					//		gfather
					//	uncle    	parent  
					//			 cur
					//
					if (cur == parent->_left) {
						RotateR(parent);
						swap(cur, parent);
					}
					RotateL(gfather);
					parent->_color = BLACK;
					gfather->_color = RED;
					break;
				}
			}
		}
		//根节点的颜色改成黑的；
		_header->_parent->_color = BLACK;
		//更新header左右指向
		_header->_left = leftMost();
		_header->_right = rightMost();
	}

中序遍历进行打印：

//对中序遍历进行封装：
	void inorder() {
		_inorder(_header->_parent);
		cout << endl;
	}
	//使用递归从叶子节点开始；
	//1.打印最左节点，
	//2.打印此节点
	//3.打印右节点
	void _inorder(Node* root) {
		if (root) {
			_inorder(root->_left);
			cout << root->_kv.first << "--->" << root->_kv.second << endl;
			_inorder(root->_right);
		}
	}

判断是否满足红黑树的性质：

	//红黑树：
	//1.根：黑色
	//2.每条路径黑色个数相同
	//3.红色不能连续
	bool isBalance() {
		if (_header->_parent == nullptr)
			return true;//只有头节点也是满足红黑树
		Node* root = _header->_parent;
		//1.判断根节点的颜色
		if (root->_color == RED)
			return false;
		//统计一条路劲的黑色节点个数
		int bCount = 0;
		Node* cur = root;
		while (cur) {
			if (cur->_color == BLACK)
				++bCount;
			cur = cur->_left;
		}
		//遍历每一条路径
		int curBCount = 0;
		return _isBalance(root, bCount, curBCount);
	}
	bool _isBalance(Node* root, int& bCount, int curBCount) {
		//当root为空，一条路径遍历结束
		if(root == nullptr){
		//判断黑色节点个数是否相同
		if (bCount != curBCount)
			return false;
		else
			return true;
		}
		//判断是否为黑节点
		if (root->_color == BLACK)
			++curBCount;
		//判断红色节点是否有连续
		if (root->_parent && root->_color == RED
			&& root->_parent->_color == RED) {
			cout << "data: " << root->_kv.first << "--->" << root->_kv.second << endl;
			return false;
		}
		return _isBalance(root->_left, bCount, curBCount) 
			&& _isBalance(root->_right,bCount, curBCount);
	}

完整代码如下：可直接调试

#include<iostream>
#include<iostream>
#include<utility>
using namespace std;

//设置颜色属性
enum COLOR {
	BLACK,
	RED
};
template<class K,class V>
struct RBNode {
	//typedef bool color;
	//各个节点
	RBNode<K, V>* _parent;
	RBNode<K, V>* _left;
	RBNode<K, V>* _right;
	//key-value
	pair<K, V> _kv;
	//颜色
	COLOR _color;
	RBNode(const pair<K, V>& kv = pair<K, V>())
		:_parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _kv(kv)
		, _color(RED) {
	}
};
template<class K,class V>
class RBTree {
public:
	//类型定义
	typedef RBNode<K,V> Node;

	RBTree()
		:_header(new Node) {
		//创建空树
		_header->_left = _header->_right = _header;
	}
	//插入
	bool insert(const pair<K,V>& kv) {
		//1.搜索树颜色
		//空树：_header->parent:nullptr
		if (_header->_parent == nullptr) {
			//创建根节点
			Node* root = new Node(kv);

			_header->_parent = root;
			root->_parent = _header;
			_header->_left = _header->_right = root;

			//根节点是黑色
			root->_color = BLACK;
			return true;
		}
		//从根节点开始搜索
		//正常插入
		Node* cur = _header->_parent;
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			//和key值进行比较
			//kv： pair<K,V>, key:pair.first
			if (cur->_kv.first == kv.first) {
				//key值不允许重复
				return false;
			}
			else if (cur->_kv.first > kv.first) {
				cur = cur->_left;
			}
			else {
				cur = cur->_right;
			}
		}
		//创建待插入节点
		cur = new Node(kv);
		if (parent->_kv.first > cur->_kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;
		cur->_parent = parent;

		//2.修改颜色或者调整结构
		while (cur != _header->_parent && cur->_parent->_color == RED) {
			parent = cur->_parent;
			Node* gfather = parent->_parent;

			if (gfather->_left == parent) {
				Node* uncle = gfather->_right;
				//1.uncle存在，并且都是红色
				if (uncle && uncle->_color == RED) {
					parent->_color = uncle->_color = BLACK;
					gfather->_color = RED;
					//继续更新
					cur = gfather;
				}
				
				else {
					cout << "Rotate" << endl;
					//双旋结构
					if (cur == parent->_right) {
						RotateL(parent);
						swap(cur, parent);
					}
					RotateR(gfather);
					parent->_color = BLACK;
					gfather->_color = RED;
					break;
				}
			}
			else {
				//gfather->_right=parent;
				Node* uncle = gfather->_right;
				//uncle存在，且都是红色，最简
				if (uncle && uncle->_color == RED) {
					parent->_color = uncle->_color = BLACK;
					gfather->_color = RED;
					cur = gfather;
				}
				//uncle不存在，或者uncle存在为黑色
				//双旋结构
				else {
					//		gfather
					//	uncle    	parent  
					//			 cur
					//
					if (cur == parent->_left) {
						RotateR(parent);
						swap(cur, parent);
					}
					RotateL(gfather);
					parent->_color = BLACK;
					gfather->_color = RED;
					break;
				}
			}
		}
		//根节点的颜色改成黑的；
		_header->_parent->_color = BLACK;
		//更新header左右指向
		_header->_left = leftMost();
		_header->_right = rightMost();
	}
	//			parent
	//					subR
	//			subRL				
	void RotateL(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_left = parent;
parent->_right = subRL;
if (subRL) {
	subRL->_parent = parent;
}
if (_header->_parent == parent) {
	_header->_parent = subR;
	subR->_parent = _header;
}
else {
	Node* pparent = parent->_parent;
	subR->_parent = pparent;
	if (pparent->_left == parent)
		pparent->_left = subR;
	else
		pparent->_right = subR;

}
parent->_parent = subR;
	}
	//		  parent
	//		subL
	//			subLR	
	void RotateR(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		subL->_right = parent;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		//判断根
		if (parent == _header->_parent) {
			_header->_parent = subL;
			subL->_parent = _header;
		}
		//不是根
		else {
			Node* pparent = parent->_parent;
			subL->_parent = pparent;
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;
		}
		parent->_parent = subL;


	}
	//最左节点
	Node* leftMost() {
		Node* cur = _header->_parent;
		while (cur && cur->_left) {
			cur = cur->_left;
		}
		return cur;
	}
	//最右节点
	Node* rightMost() {
		Node* cur = _header->_parent;
		while (cur && cur->_right) {
			cur = cur->_right;
		}
		return cur;
	}
	void inorder() {
		_inorder(_header->_parent);
		cout << endl;
	}
	void _inorder(Node* root) {
		if (root) {
			_inorder(root->_left);
			cout << root->_kv.first << "--->" << root->_kv.second << endl;
			_inorder(root->_right);
		}
	}

	//红黑树：
	//1.根：黑色
	//2.每条路径黑色个数相同
	//3.红色不能连续
	bool isBalance() {
		if (_header->_parent == nullptr)
			return true;
		Node* root = _header->_parent;

		if (root->_color == RED)
			return false;
		//统计一条路劲的黑色节点个数
		int bCount = 0;
		Node* cur = root;
		while (cur) {
			if (cur->_color == BLACK)
				++bCount;
			cur = cur->_left;
		}
		//遍历每一条路径
		int curBCount = 0;
		return _isBalance(root, bCount, curBCount);
	}
	bool _isBalance(Node* root, int& bCount, int curBCount) {
		//当root为空，一条路径遍历结束
		if(root == nullptr){
		//判断黑色节点个数是否相同
		if (bCount != curBCount)
			return false;
		else
			return true;
		}
		//判断是否为黑节点
		if (root->_color == BLACK)
			++curBCount;
		//判断红色节点是否有连续
		if (root->_parent && root->_color == RED
			&& root->_parent->_color == RED) {
			cout << "data: " << root->_kv.first << "--->" << root->_kv.second << endl;
			return false;
		}
		return _isBalance(root->_left, bCount, curBCount) 
			&& _isBalance(root->_right,bCount, curBCount);
	}
private:
	Node* _header;
};
void test() 	{
	RBTree<int, int> rbt;
	int n;
	cin >> n;
	for (int i = n; i > 0; --i) {
		rbt.insert(make_pair(i, i));
	}
	rbt.inorder();
	cout << rbt.isBalance();
}
int main() {
	test();
	return 0;
}

在这里插入图片描述

黑桃_K_
关注
  • 46
    点赞
  • 踩
  • 114
    收藏
    觉得还不错? 一键收藏
  • 50
    评论
专栏目录
c语言k字母的代码,K-进制数 （C语言代码）图解----------------C语言-菜鸟级
weixin_39647977的博客
05-20 1417
解题思路:根据题意，要知道 N位K进制并且不能有连续两个0出现还有首位不能为0的限制条件。本着由简到难的思想 ：假设是让你求 1位 K进制的满足条件的数，那么满足条件的数则有 1，2，3.....K-1一共K-1个数对吧，我们记作res_1=K-1,那么不满足条件的数只有 0 ，一共1个数 ，我们记作res_0=1。假设是让你求 2位 K进制的满足条件的数，那么先考虑首位(也...
K、M、G、T、P、E、B，你知道都是10的多少次方吗？
csdn0125的博客
12-28 5万+
随着计算机硬盘制造技术的飞速发展，硬盘的存贮容量呈快速增长趋势，用来表示存贮空间的计量单位从过去的K升到M，又从M跃升至G甚至T。前几天，我们几个闲谈计算机的配置、存贮空间等问题时，说起“兆”这个单位，不免疑惑，1兆究竟等于10的几次方？通过一番追根朔源地考证，让我大开眼界。 我们目前所用的K、M、G、T等都是英文表示方法，分别是Kilo（103）、Mega（106）、Giga（109）、Ter...
C++ 继承 详解
黑桃K
05-09 9865
文章目录一、什么是继承？1.1、概念1.2、定义1.2.1、继承关系和访问限定符1.2.2、继承基类成员访问方式的变化注意：二、基类和派生类对象赋值转换三、继承中的作用域四、派生类的默认成员函数五、继承与友元六、继承与静态成员七、菱形继承八、继承和组合 一、什么是继承？ 1.1、概念 **继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。 1.2、定义 下面我们看到Person是父类，也称作
五月集训（第七日）哈希表
nannian123的博客
05-07 225
五月集训（第七日）哈希表
cpu字母意思
qq_50642088的博客
07-26 4002
这里写自定义目录标题欢迎使用Markdown编辑器 欢迎使用Markdown编辑器 主要有：M代表标准电压cpu；U代表低电压节能的；H是高电压的；X代表高性能；Q代表至高性能级别；Y代表超低电压的；K代表不锁倍频的处理器。 intel CPU 后缀的意思如下：“K”代表该处理器是不锁倍频桌面级CPU；“S”代表该处理器是功耗降zhi至65W的低功耗版桌dao面级CPU；“T”代表该处理器是功耗降至45W的节能版桌面级CPU；“M”代表该处理器是功耗低于35W的双核移动CPU。 “QM”代表该处理器是功耗为
名企面试官精讲典型编程题.zip
08-18
7. **设计模式**：工厂模式、单例模式、观察者模式、装饰器模式、适配器模式等23种设计模式，是解决常见问题的模板，面试官通常会考察你是否能灵活运用。 8. **JVM**：Java虚拟机的工作原理，如内存管理（堆、栈、...
《Java面试真题全攻略》.rar
06-20
8. 第08话：面试官问起线程池常用参数时，我们说多少个合适.pdf 9. 第09话：线程的生命周期也是面试中很常见的.pdf 10. 第10话：小组Leader级面试题synchronized底层原理.pdf 11. 第11话：帮小伙伴们整理一套最全的...
《剑指Offer-名企面试官精讲典型编程题》第2版 C++实现.zip
01-20
《剑指Offer-名企面试官精讲典型编程题》第二版是一本专注于C++编程面试的书籍，它为有志于进入IT大厂的程序员提供了丰富的知识准备。该书涵盖了C++语言的基础到高级应用，包括但不限于C++面试常见问题、设计模式、...
Java 面试知识点总结.zip
05-08
链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图、排序（冒泡、选择、插入、快速、归并等）、查找（顺序、二分）等是常见的考点。熟练掌握这些数据结构和算法，能有效提升问题解决能力。 3. **集合框架**：...
c++面试算法刷题.zip
01-20
例如，平衡二叉树（AVL、红黑树）的应用、动态规划的实现、图的深度优先搜索与广度优先搜索等。掌握这些数据结构及其操作，有助于解决复杂问题并优化算法效率。 四、操作系统 在C++面试中，面试官可能会询问关于...
网络 基础1
黑桃K
05-11 214
文章目录1、发展背景2、网络中的地址管理2.1 IP地址2.2、MAC地址3、端口4、协议5、 协议分层5.1、OSI七层模型 1、发展背景 计算机技术和通信协议是计算机网络产生与发展的两个最基本的内容; 网络： 局域网：通过交换机和路由器连接在一起，覆盖范围在1KM以内 城域网：覆盖范围在10~20KM 广域网：将远隔千里的计算机都连在一起，覆盖范围在20KM以上 因特网/互联网：具有国际范围的广域网 以太网、令牌环网：比较典型的组网方式 ip地址，端口，通信协议，网 络字节序； 2、网络中的
英文大写字母A~Z，小写字母a~z对应的ASCII码快速查询
热门推荐
野猿新一
03-24 20万+
在做开发的过程中经常会遇到用ASCII码表示的字母，或者字母要用ASCII码来表示。每次都要临时百度查ASCII表。 今天做个记录，以备下次用到。也方便大家查阅。 大写字母ASCII码 Bin(二进制) Oct(八进制) Dec(十进制) Hex(十六进制) 缩写/字符 解释...
k线符号图解大全_K线组合图解大全：新手必知基本K线形态和经典K线组合，知道学会，永远不踏空！...
weixin_39743369的博客
12-27 1406
K线组合可以是单根的也可以是多根的，很少有超过5根或6根的组合。一些典型的K线或K线组合会不断地重复出现，如果你掌握了这些规律，将在很大程度上提高你的胜算。底部组合出现时，告诉你股价很快就会上升，要赶快建仓;顶部组合出现时，告诉你风险已大，要及时获利了结。对于不懂K线语言的投资者，K线就像一本天书，一些初学者学到了一些K线知识，但没有掌握其实质，也容易作出错误的判断。一般认为K线的下影线长表示下档...
英语发音规则---K字母
weixin_33743703的博客
09-26 1740
英语发音规则---K字母 一、总结 一句话总结： 1、K发[k]音？ kind [kaɪnd] n. 种类 bike [baɪk] n. 自行车 skate [skeɪt] vi. 滑冰 make [meɪk] vt. 制造 take [teɪk] vt. 拿，取 week[wiːk] n. 周，星期 2、Kn-发[n]音？...
交换两个变量值的几种方法；
黑桃K
11-27 5363
1.借用一个临时值交换两个变量： #include <stdio.h> int main() { int num1 = 5; int num2 = 8; int temp;//申请一个临时变量 printf("num1和num2的值为%d %d\n", num1, num2); temp = num1; num1 = num2; num2 = temp; printf("num1和num2的值为%d %d\n", num1, num2); return 0; } 2.不用临时
system的用法，多样用法、有趣的system、关机自制
黑桃K
11-10 3793
system的常用用法 //控制系统的控制台的行和列，100是行距离40是列距离，可自行调整: system("mode con cols=100 lines=40"); … … //控制台的背景颜色和字体颜色调节， //eo表示e（大小写都可以）为背景色，0为字体色: // system("color e0"); //例如下图为e0，如果符号输入错误系统会出现上图 … … … //系统会在输入行出现暂停，如果vs在结束之前‘}’输入就会暂停在控制台处。 system(“pause”); … … …
%d %s %c %x %p %u %f %lf %%的使用方法
黑桃K
11-16 1023
%d %nd //表示打印几位有效数字，当结果<n时打印结果靠右边对其 // 以整数形式打印 . %c //以字符形式打印 . %s //以字符串形式打印 . %x //以16进制形式打印 . %p //以指针形式打印 . %u //以无符号整型形式打印 . %f %m.nf //eg： %6.4f表示打印结果有效数字为6位，小数位4位。 //以单精度浮点数形式打印 . %lf //以双精度浮点数形式打印 //%m.nlf 同上 . %...
满红黑树与普通红黑树的区别是什么？
最新发布
07-01
满红黑树（Full Red-Black Tree）是红黑树的一种特殊形态，它是红黑树的一种优化版本，通常用于那些插入操作非常频繁，而删除操作相对较少的情况。在满红黑树中，所有的叶子节点（没有子节点的节点）都被标记为黑色...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 50
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值