C++中二叉搜索树的模拟实现(二叉搜索树是map,set的底层原理)

news2025/1/16 1:05:42

搜索二叉树

定义

搜索二叉树:左子树小于根,右子树大于根.搜索二叉树的中序序列是升序的.所以对于二叉树而言,它的左子树和右子数都是二叉搜索树

下图就是二叉搜索树
在这里插入图片描述

二叉搜索树的性质:

  • 二叉搜索树的中序遍历出的数据是有序的,并且二叉树搜索树在查找某个数的时候,一般情况下的时间复杂度是O(log2(N))级别的.
  • 二叉搜索树中是没有值相同的节点的,否则无法构成二叉搜索树.

节点的定义

二叉树和别的树的区别就是各个节点的排列有了区别,节点中存储的内容还是不会变的,仍然是左右指针,和一个值.

template<class K>
struct BinarySearchTreeNode
{
	typedef BinarySearchTreeNode<K> Node;
	Node* _left;
	Node* _right;
	K _key;
	BinarySearchTreeNode(const K& key)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key){}
};

节点的构造方法

	BinarySearchTreeNode(const K& key)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key){}

二叉搜索树的创建

二叉搜索树的创建首先只需要一个根节点即可,后续插入节点或者删除节点时,保持住连接关系就好.

template<class T>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node;
	private:
	Node* _root = nullptr;
	public:
	// 各种函数
};

注意:后边的这些方法都是写在类的public中的.

向树中插入节点

例如:插入节点A的时候,要判断A中的key值和树中根节点开始,依次比较key值,我们定义一个cur指针,用于为新来的节点找到合适的插入位置,假如A节点的key值<cur节点的key值,那么就cur就向左树开始遍历.假如A的key值和cur的key值相同,直接返回.假如A的key值大于cur的key值,cur就向右数遍历.最终cur的位置就是能插入数据的地方,但是cur的值最后是为空的,那么我们如何将cur处的值替换为这个A节点呢?换句话说,如何让cur的父节点指向这个A节点呢?答案是:我们在cur向下一个节点行进之前,先保存当前节点的指针,也就是保存好cur的父节点的值.

但是A节点最终是链接在父节点的左边还是在父节点的右边呢??这个只能通过保存的父节点中保存的值进行判断.若A节点的值小于父节点,那么就链接在父节点的左边,否则链接在父节点的右边.
在这里插入图片描述

代码实现:

bool insert(const K& key)
{
	// 插入节点之前,检查是不是空树
	if(_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* cur = _root;
	Node* parent = _root;
	while(cur)
	{
        if(key<cur->_key)
        {
        	parent = cur;
            cur = cur->_left;
        }
        else if(key>cur->_key)
        {
        	parent = cur;
        	cur = cur->_right;
        }
        else
        {
        	// 值不能相同直接返回
        	return false;
        }
    }
        if(parent->_key<key)
        {
        	parent->_left = new Node(key);
        }
        else
        {
        	parent->_right = new Node(key);
        }
        return true;
}

查找元素

查找元素就比较简单了,要查找的值小于cur的当前值,那么就向左树查找,若大于当前值,就向右数查找.

代码实现:

bool find(const K& key)
{
	Node* cur = _root;
	while(cur)
	{
		if(key<cur->_key)
        {
			cur = cur->_left;		
        }
        else if(key>cur->_key)
        {
        	cur = cur->_right;
        }
        else
        {
        	return true;
        }
	}
	return false;
}

删除元素

二叉搜素树中,删除节点是最比较复杂的.分为了3种情况

  1. 要被删除的目标节点的左树是空:每次cur指针在找目标节点时,每次cur迭代之前,都需要记录cur的当前位置,也就是用parent指针来记录.

    • 当删除的节点是parent的右边时:就需要parent的右指针指向目标节点的右子树.
    • 当删除的节点是parent的左边时:就需要parent的左指针指向目标节点的右子树.
      在这里插入图片描述

  2. 要被删除的节点的右树是空:每次cur指针在找目标节点时,每次cur迭代之前,都需要记录cur的当前位置,也就是用parent指针来记录.

    • 当删除的节点是parent的右边时:就需要parent的右指针指向目标节点的左子树.
    • 当删除的节点是parent的左边时:就需要parent的左指针指向目标节点的左子树.
      在这里插入图片描述

  3. 要被删除的节点的左右都不是空的时候:
    此时就需要用替换法了,
    例如:我们要删除下图中的值为8的节点.删除节点但是不能破环二叉搜索树的结构,所以就需要找到一个值在3和10的节点来替换这里的值为8的节点.那么这值如何找呢?由于二叉搜索树的结构可知,左树的值小于根的值,右树的值总是大于根的值.所以我们可以在左树中找到最大的值或者是在右树中找到最小的值(这两个值的任意一个值都是符合要求的,即大于3小于10的)来替换要被删除节点的位置的值,如下图,就可以将7复制到8这个位置,紧接着删除原本的7所在的节点,就删除成功了.

    注意:删除原本值为7的节点时,一定属于第一种和第二种情况之一,因为:左树的最大值的右指针一定为空,右数的最小值的左树一定为空.
    在这里插入图片描述

代码实现:

bool erase(const K& key)
{
	Node* cur = _root;
	Node* parent = _root;
	while(cur)
	{
		if(key<cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if(key>cur->_key)
		{
			parent  = cur;
			cur = cur ->_right;
		}
		else
		{
		// 删除的节点的左树为空
			if(cur->_left == nullptr)
			{
                if(cur == _root)
                {
                    _root = _root->_right;
                }
                else
                {
                    	if(parent->_right == cur)
                        {
                            parent ->_right = cur->_right;
                        }
                        else
                        {
                            parent->_left = cur->_right;
                        }
                }
			
                delete cur;
                return true;
			}
            
			// 删除的节点的右树为空
			else if(cur->_right == nullptr)
			{
                if(cur == _root )
                {
                    _root = _root ->_left;
                }
                else
                {
                    		if(parent->_right == cur)
                            {
                                parent->_right = cur->_left;
                            }
                            else
                            {
                                parent->_left = cur->_left;
                            }
                }
                delete cur;
                return true;
			}
			 // 左右都不为空,替换法
			else
			{
				// 以右边的最小值为例子
				Node* rightMinParent = cur;
				Node* rightMin = cur->_right;
				while(rightMin->_left){
					rightMin = rightMin ->_left;
				}
				cur->_key = rightMin->_key;
				if(rightMinParent->_left == rightMin){
					rightMinParent->_left = rightMin->_right;
				}else
				{
					rightMinParent->_right = rightMin->_right;
				}
				delete rightMin;
				return true;
			}
		}
	}
	return false;
}

二叉树的中序遍历

由于类的成员函数不能递归调用,所以创建一个私有函数_Inorder,接着在public中定义Inorder方法,调用这个_Inorder犯法即可.

void Inorder()
{
    _Inorder(_root);
}
void _Inorder(Node* root)
{
	if(root==nullptr) return;
	_Inorder(root->_left);
	cout<<root->_key<<endl;
	_Inorder(root->_right);
}

二叉搜索树的递归找数字

bool _Find(Node* root,const K& key)
{
	if(root == nullptr) return false;
	else if(root->_key == key) return true;
	else if (root->_key < key)
    {
        _Find(root->_right, key);
    }
    else
    {
        _Find(root->_left, key);
    }
}

二叉搜索树删除元素的另一种方法

这里的root定义成引用即可,root必定是节点的左指针或者右指针的引用.这里直接改变引用的值即可.就不用找父节点了.更方便一点.

		bool _Erase(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return _Erase(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _Erase(root->_left, key);
			}
			else
			{
				Node* del = root;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					// 替换法
					Node* rightMin = root->_right;
					while (rightMin->_left)
					{
						rightMin = rightMin->_left;
					}
					swap(rightMin->_key, root->_key);
					// 将当前root位置和rightMin位置的值进行交换,接着在root的右边的树中删除key

					return _Erase(root->_right, key);
				}
				delete del;
				return true;
			}
		}

二叉搜索树插入数据的第二种方式

// 注意这里的&是不可少的,不然要使用二级指针进行操作了.
		bool _Insert(Node*& root, Node* parent, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
			}
			if (root->_key > key)
			{
				return _Insert(root->_left, parent, key);
			}
			else if (root->_key < key)
			{
				return _Insert(root->_right, parent, key);
			}
			else if (root->_key == key)
			{
				return false;
			}
		}

二叉搜索树的构造方法

拷贝构造

先拷贝根,再拷贝左右子树

Node* Copy(Node* root)
{
	if(root == nullptr)return nullptr;
	Node* newRoot = new Node(root->_key);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);
	return newRoot;
}
// 在构造函数中:
BinarySearchTree(BinarySearchTree<K>& t){
    this->_root = Copy(t._root);
}

赋值拷贝

注意:要使用如下这种方法,参数必须是类实体,不能是类引用,返回值必须是类引用.

BinarySearchTree<K>& operator=(const BinarySearchTree<K> t)
{
	swap(t._root,this->_root);
	return *this;
}

默认构造

BinarySearchTree() = default;

析构函数

先写一个destroy函数

~BinarySearchTree()
{
	Destroy(_root);
}
void Destroy(Node* root)
{
	if(root== nullptr)return ;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

源码

#include<iostream>
using namespace std;
namespace key 
{

	template<class K>
	struct BinarySearchTreeNode {
		typedef BinarySearchTreeNode<K> Node;
		Node* _left;
		Node* _right;
		K _key;
		BinarySearchTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BinarySearchTree {
		typedef BinarySearchTreeNode<K> Node;
	public:
		bool Erase(const K& key) // 删除指定的节点.
		{
			Node* cur = _root;
			Node* parent = _root;
			while (cur)
			{
				if (cur->_key == key)
				{
					if (cur->_right == nullptr)
					{
						if (cur == _root) {
							_root = _root->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
						return true;
					}
					else if (cur->_left == nullptr)
					{
						if (cur == _root) {
							_root = _root->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
						return true;
					}

					// 左右都不为空的时候使用替换法
					else
					{
						Node* rightMinParent = cur; // 这里要用cur进行初始化
						// 右边的最小值
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}
						cur->_key = rightMin->_key;
						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;
						delete rightMin;
						return true;
					}
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					parent = cur;
					cur = cur->_right;
				}
			}
			return false;
		}
		void Inorder()
		{
			_Inorder(_root);
		}
		bool Insert(const K& k)
		{
			if (_root == nullptr)
			{
				_root = new Node(k);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (cur->_key == k)
				{
					return false;
				}
				else if (cur->_key > k)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					parent = cur;
					cur = cur->_right;
				}
			}
			//保存父节点
			if (k < parent->_key)
			{
				parent->_left = new Node(k);
			}
			else
			{
				parent->_right = new Node(k);
			}
			return true;
		}
		bool Find(const K& k)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key == k)
				{
					return true;
				}
				else if (cur->_key > k)
				{
					cur = cur->_left;
				}
				else
				{
					cur = cur->_right;
				}
			}
			return false;
		}

		bool FindR(const K& key) //递归找数字
		{
			return _Find(_root, key);
		}
		bool InsertR(const K& key)
		{
			return _Insert(_root, _root, key);
		}
		bool EraseR(const K& key)
		{
			return _Erase(_root, key);
		}

		~BinarySearchTree()
		{
			Destroy(_root);
		}
		// 自动生成默认的构造
		BinarySearchTree() = default;
		// 拷贝构造
		BinarySearchTree(const BinarySearchTree<K>& t)
		{
			this->_root = Copy(t._root);
		}
		// 赋值拷贝
		BinarySearchTree<K>& operator=(const BinarySearchTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}

	private:
		Node* Copy(const Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}
		bool _Erase(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return _Erase(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _Erase(root->_left, key);
			}
			else
			{
				Node* del = root;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					// 替换法
					Node* rightMin = root->_right;
					while (rightMin->_left)
					{
						rightMin = rightMin->_left;
					}
					swap(rightMin->_key, root->_key);
					// 将当前root位置和rightMin位置的值进行交换,接着在root的右边的树中删除key

					return _Erase(root->_right, key);
				}
				delete del;
				return true;
			}
		}
		// 注意这里的&是不可少的,不然要使用二级指针进行操作了.
		bool _Insert(Node*& root, Node* parent, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
			}
			if (root->_key > key)
			{
				return _Insert(root->_left, parent, key);
			}
			else if (root->_key < key)
			{
				return _Insert(root->_right, parent, key);
			}
			else if (root->_key == key)
			{
				return false;
			}
		}
		Node* _root = nullptr;
		void _Inorder(Node* root)
		{
			if (root == nullptr)
				return;
			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);
		}
		bool _Find(Node* root, const K& key)        
		{
			if (root == nullptr)return false;        
			else if (root->_key == key)return true;        
			else if (root->_key < key)        
			{
				_Find(root->_right, key);        
			}
			else        
			{
				_Find(root->_left, key);        
			}
		}
	};
}

结束

本篇文章就到这里就结束啦,若有不足,请在评论区指正,下期再见,

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

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

相关文章

Outlook会议邀请邮件在答复后就不见了

Outlook会议邀请邮件在答复后就不见了

时常会有同事找到我说&#xff0c;Outlook答复会议邀请邮件后收件箱就找不到会议邀请的邮件了。 这其实是Outlook的的一个机制&#xff0c;会把应答后的会议邀请邮件从收件箱自动删除&#xff0c;到已删除的邮件那里就能找到。如果不想要自动删除&#xff0c;改一个设置即可。…
阅读更多...
kafka 高吞吐设计分析

kafka 高吞吐设计分析

说明 本文基于 kafka 2.7 编写。author blog.jellyfishmix.com / JellyfishMIX - githubLICENSE GPL-2.0 概括 支撑 kafka 高吞吐的设计主要有以下几个方面: 网络 nio 主从 reactor 设计模式 顺序写。 零拷贝。 producer producer 开启压缩后是批量压缩&#xff0c;bro…
阅读更多...
k8s部署微服务例子

k8s部署微服务例子

一、部署服务 需要部署minio、nacos、mysql、consul、elasticsearch、视频解析服务、nfs、skywalking-oap及ui。 二、三个微服务程序 minio服务解析视频-》上传到minio进行存储&#xff0c;构造领域对象信息保存到hive&#xff08;hive on spark&#xff09;异步处理-》元数据…
阅读更多...
c#程序报错引用无效解决办法之一：检查引用的文件路径

c#程序报错引用无效解决办法之一：检查引用的文件路径

直接右键然后打开本地 打开这个.csproj文件&#xff0c;直接对着路径看看里面的路径对不对。 一般是很多人一起开发&#xff0c;然后这个文件路径被推送上来的问题
阅读更多...
前端三剑客 —— CSS （第四节）

前端三剑客 —— CSS （第四节）

目录 内容回顾&#xff1a; 1.常见样式 2.特殊样式 特殊样式 过滤效果 动画效果 动画案例&#xff1a; 渐变效果 其他效果&#xff1a; 多列效果 字体图标&#xff08;icon&#xff09; 内容回顾&#xff1a; 1.常见样式 text-shadow x轴 y轴 阴影的模糊程度 阴影的…
阅读更多...
kubectl explain资源文档命令

kubectl explain资源文档命令

学习并使用了一段时间的kubernetes&#xff0c;发现对k8s还是了解甚少&#xff0c;于是利用上下班通勤的时间又去B站看一些大佬的视频&#xff0c;又来重学巩固一遍知识&#xff0c;并做些记录。 之前在学习使用过程中未成了解过explain这个命令&#xff0c;因为自己部署的版本…
阅读更多...
一站式知识库服务平台真的有那么好用吗？看完你就懂了

一站式知识库服务平台真的有那么好用吗？看完你就懂了

在快速发展的信息化社会&#xff0c;我们经常会听到“知识就是力量”的这句话&#xff0c;而一个一站式的知识库服务平台就是这样一把“开启力量之门”的钥匙。那么&#xff0c;这把钥匙真的有那么好用吗&#xff1f;让我们一起探讨一下。 首先&#xff0c;“一站式”可能已经解…
阅读更多...
vite.config.js

vite.config.js

Vue3vite vite和webpack区别&#xff1f; 1.vite服务器启动速度比webpack快&#xff0c;由于vite启动的时候不需要打包&#xff0c;也就无需分析模块依赖、编译&#xff0c;所以启动速度非常快。当浏览器请求需要的模块时&#xff0c;再对模块进行编译&#xff0c;这种按需动态…
阅读更多...
软件杯 深度学习中文汉字识别

软件杯 深度学习中文汉字识别

文章目录 0 前言1 数据集合2 网络构建3 模型训练4 模型性能评估5 文字预测6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习中文汉字识别 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐&#xf…
阅读更多...
【T5中的激活函数】GLU Variants Improve Transformer

【T5中的激活函数】GLU Variants Improve Transformer

【mT5中的激活函数】GLU Variants Improve Transformer 论文信息 阅读评价 Abstract Introduction Gated Linear Units (GLU) and Variants Experiments on Text-to-Text Transfer Transformer (T5) Conclusion 论文信息 名称内容论文标题GLU Variants Improve Transfo…
阅读更多...
AI绘画：实例-利用Stable Diffusion ComfyUI实现多图连接：区域化提示词与条件设置

AI绘画：实例-利用Stable Diffusion ComfyUI实现多图连接：区域化提示词与条件设置

在Stable Diffusion ComfyUI中&#xff0c;有一种高级技巧可以让用户通过细致的区域化提示词来控制图像的不同部分&#xff0c;从而实现多图连接的效果。这种方法允许艺术家在同一画布上展现多个场景&#xff0c;创造出富有层次和故事性的图像。以下是实现这一效果的详细步骤。…
阅读更多...
【与C++的邂逅之旅】--- 内联函数 auto关键字 基于范围的for循环 nullptr

【与C++的邂逅之旅】--- 内联函数 auto关键字 基于范围的for循环 nullptr

关注小庄 顿顿解馋૮(˶ᵔ ᵕ ᵔ˶)ა 博主专栏&#xff1a; &#x1f4a1; 与C的邂逅之旅 &#x1f4a1; 数据结构之旅 上篇我们了解了函数重载和引用&#xff0c;我们继续学习有关C的一些小语法— 内联函数&#xff0c;auto关键字&#xff0c;基于范围的for循环以及 nullptr&…
阅读更多...
element-ui empty 组件源码分享

element-ui empty 组件源码分享

今日简单分享 empty 组件的源码实现&#xff0c;主要从以下三个方面&#xff1a; 1、empty 组件页面结构 2、empty 组件属性 3、empty 组件 slot 一、empty 组件页面结构 二、empty 组件属性 2.1 image 属性&#xff0c;图片地址&#xff0c;类型 string&#xff0c;无默认…
阅读更多...
Docker 安装 | 部署MySQL 8.x 初始设置

Docker 安装 | 部署MySQL 8.x 初始设置

1、准备工作 如果不想看前面的废话请直接右边目录跳到 运行容器 处 默认你已经有 docker 环境。 Windows 推荐 Docker Desktop &#xff08;下载地址&#xff09;并基于 WSL2 运行 Docker 环境 mac 推荐 Orbstack &#xff08;下载地址&#xff09;&#xff08;这个很节省资源&…
阅读更多...
C++之函数提高（HM）

C++之函数提高（HM）

目录 1.函数默认参数&#xff08;缺省参数&#xff09; 2.占位参数 3.函数重载 4.类和对象--封装 &#xff08;1&#xff09;圆类&#xff1a; &#xff08;2&#xff09;访问权限 &#xff08;3&#xff09;struct&&class &#xff08;4&#xff09;立方体类的…
阅读更多...
适用于车载设备无钥匙进入系统汽车用晶振FA-238A

适用于车载设备无钥匙进入系统汽车用晶振FA-238A

汽车用晶振FA-238A是一款适用于车载设备无钥匙进入系统的耐高温晶振。汽车用晶振FA-238A是爱普生推出一的款MHz表贴式晶体单元&#xff0c;具有很好的预率性能&#xff0c;符合AEC-0200标准&#xff0c;其封装尺寸仅为3.2x2.5x0.7mm&#xff0c;工作温度范围在-40℃~125℃之间&…
阅读更多...
Linux云计算之网络基础9——园区网络架构项目

Linux云计算之网络基础9——园区网络架构项目

要求构建大型园区网络架构&#xff0c;方案如下&#xff1a; 园区A 园区c 公司B 要求&#xff1a; 1、A公司园区网络 一台汇聚层三层交换机&#xff0c;两台接入层二层交换机。 出口有一台路由器。 2、A园区有五台服务器。 分别为两台 WEB 服务器&#xff0c;…
阅读更多...
Spring Boot Mockito (三)

Spring Boot Mockito (三)

Spring Boot Mockito (三) 这篇文章主要是讲解Spring boot 与 Mockito 集成测试。 前期项目配置及依赖可以查看 Spring Boot Mockito (二) - DataJpaTest Spring Boot Mockito (一) - WebMvcTest Tag("Integration") SpringBootTest // TestMethodOrder(MethodOr…
阅读更多...
分布式系统架构中的相关概念

分布式系统架构中的相关概念

1.1、衡量网站的性能指标 响应时间&#xff1a;指执行一个请求从开始到最后收到响应数据所花费的总体时间。并发数&#xff1a;指系统同时能处理的请求数量。 并发连接数&#xff1a;指的是客户端向服务器发起请求&#xff0c;并建立了TCP连接。每秒钟服务器连接的总TCP数量请…
阅读更多...
MySQL 主从复制架构搭建及其原理

MySQL 主从复制架构搭建及其原理

前言 系统的性能瓶颈一般出现在数据库上&#xff0c;以 mysql 为例&#xff0c;如果存在高并发的写请求&#xff0c;势必会有锁表&#xff0c;锁数据行的情况发生&#xff0c;这时候如果有读请求刚好访问到被锁的数据&#xff0c;那么读请求会阻塞&#xff0c;直到写请求处理完…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023