【C++】搜索二叉树底层实现

news2024/11/26 0:43:18

目录

一，概念

二，实现分析

1.  插入

（1.）非递归版本 

 （2.）递归版本

 2. 打印搜索二叉树

3.查找函数

（1.）非递归版本

（2.）递归版本

4. 删除函数（重难点） 

易错点分析，包你学会

（1.）删除目标，没有左右孩子

（2.）删除目标，只有一个孩子

（3.）删除目标，有两个孩子

代码

（1.）非递归版本 

（2.）递归版本

5. 析构函数

6.拷贝构造 

 三，应用

 四，搜索二叉树的缺陷及优化

五，代码汇总

结语

一，概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

为啥又被称作二叉排序树呢？ 当该树被层序遍历时，就是升序。

二，实现分析

实验例子：

int a[] = {8, 3, 1, 10, 6, 4, 5, 7, 14, 13}; 

1.  插入

（1.）非递归版本 

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。

 比较简单这里就直接放代码：

template <class K>
class BinarySeaTree_node
{
	typedef BinarySeaTree_node<K> BST_node;
public:
	BinarySeaTree_node(const K& val)
		: _val(val)
		,_left(nullptr)
		,_right(nullptr)
	{}

	K _val;
	BST_node* _left;
	BST_node* _right;
};


template <class T>
class BSTree
{
	typedef BinarySeaTree_node<T> BST_node;
private:
	BST_node* root = nullptr;

public:
	bool Insert(const T& val)
	{
		BST_node* key = new BST_node(val);
		BST_node* cur = root;
		BST_node* parent = nullptr;
		while (cur)
		{
			if (key->_val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key->_val > cur->_val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return 0;
			}
		}

		// 查询好位置后，建立链接
		if (!root)
		{
			root = key;
			return 0;
		}

		if (key->_val > parent->_val)
		{
			parent->_right = key;
		}
		else
		{
			parent->_left = key;
		}
		return 1;
	}
};

 （2.）递归版本

这里面整了个活，大家注意了!!!

bool Re_Insert(const T& val){  return Re_Insert_table(root, val);}

	bool Re_Insert_table(BST_node*& node, const T& val)
	{
		if (node == nullptr)
		{
			node = new BST_node(val);
			return 1;
		}

		if (val < node->_left)
		{
			return Re_Insert_table(node->_left, val);
		}
		else if (val > node->_right)
		{ 
			return Re_Insert_table(node->_right, val);
		}
		else
		{
			return 0;
		}
	}

这里方便大家理解，我给大家花一个递归展开图。

 2. 打印搜索二叉树

 

插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

这里也是仅做代码分享： 

void Print_table() { Re_Print(root); }

	void Re_Print(const BST_node* node)
	{
		if (node == nullptr)
			return;
		Re_Print(node->_left);
		cout << node->_val << " ";
		Re_Print(node->_right);
	}

3.查找函数

思路：其实也没啥思路，比父结点小，就找左边，否则找右边。 

（1.）非递归版本

BST_node* Find(const T& val)
	{
		//直接跟寻找位置一样
		BST_node* parent = nullptr;
		BST_node* cur = root; // 以返回cur的方式返回

		while (cur)   // 非递归版本
		{
			if (val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (val > cur->_val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return cur;
	}

（2.）递归版本

BST_node* Re_Find(const T& val){   return Re_Find_table(root, val); }
	
	BST_node* Re_Find_table(BST_node* node, const T& val)
	{
		if (node == nullptr)
			return nullptr;

		if (val < node->_val)
		{
			return Re_Find_table(node->_left, val);
		}
		else if (val > node->_val)
		{
			return Re_Find_table(node->_right, val);
		}
		else
		{
			return node;
		}
	}

4. 删除函数（重难点） 

我们简单寻找了一下思路，如下：

但这些思路只是大概方向，其中藏着许多的坑点，诺接下来我来带大家，对这些易错点进行分析。

首先是查询到目标：

这个比较简单，这里不做解释。 

       //首先寻找到目标,并且记录到parent
		BST_node* parent = nullptr;
		BST_node* cur = root;
		while (cur)
		{
			if (val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (val > cur->_val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}
		if (!cur)
		{
			return 0;
		}

易错点分析，包你学会

（1.）删除目标，没有左右孩子

 

（2.）删除目标，只有一个孩子

一般的思路： 

 但，这是有漏洞的！

诺：

（3.）删除目标，有两个孩子

 好啦，前菜上完了来看看，本次的大菜。

代码

（1.）非递归版本 

bool Erase(const T& val)
	{
		//首先寻找到指定值,并且记录到parent
		BST_node* parent = nullptr;
		BST_node* cur = root;
		while (cur)
		{
			if (val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (val > cur->_val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}
		if (!cur)
		{
			return 0;
		}

		// 查询成功,开始删除
		if (!cur->_left && !cur->_right) // cur没有左右孩子
		{   // 当要删除目标是根
			if (cur == root)
			{
				root = nullptr;
				delete cur;
			}
			// 判断cur是左右孩子
			else if (cur->_val < parent->_val)
			{
				parent->_left = nullptr;
				delete cur;
			}
			else
			{
				parent->_right = nullptr;
				delete cur;
			}
			return 1;
		}
		else if (!cur->_left || !cur->_right)  // 只有一个孩子
		{
			if (!parent)  // 判断是否是目标是根
			{
				root = cur->_left != nullptr ? cur->_left : cur->_right;
				delete cur;
			}
			// 判断cur为啥孩子
			else if (cur->_val < parent->_val) // 左侧
			{
				parent->_left = cur->_left != nullptr ? cur->_left : cur->_right;
				delete cur;
			}
			else                          // 右侧
			{
				parent->_right = cur->_left != nullptr ? cur->_left : cur->_right;
				delete cur;
			}
		}
		else   // 有2个孩子
		{  // 使用左侧最大的孩子来领养
			// 寻找左侧最大
			BST_node* maxnode = cur->_left;
			BST_node* max_parent = cur;
			while (maxnode->_right)
			{
				max_parent = maxnode;
				maxnode = maxnode->_right;
			}
			
			// 现在又进入一种特殊情况,1.max_parent就没进入循环，2.进入了循环
			if (max_parent == cur)
			{
				max_parent->_left = maxnode->_left;
			}
			else
			{
				max_parent->_right = maxnode->_left;
			}
			// 值转移
			cur->_val = maxnode->_val;
			delete maxnode;
		}
		return 1;
	}

（2.）递归版本

bool Re_Erease( const T& val)
	{
		return Re_Erease_table(root, val);
	}

	bool Re_Erease_table(BST_node*& node, const T& val)
	{
		// 首先我们先找到值
		if (node == nullptr)
		{
			return 0; // 如果访问到了空，则说明删除失败，原因是：不存在
		}

		if (val < node->_val)
		{
			return Re_Erease_table(node->_left, val);
		}
		else if (val > node->_val)
		{
			return Re_Erease_table(node->_right, val);
		}
		else
		{
			// 开始删除目标数据。方法如下；
			// 1. 就按照非递归的思路，不用改多少代码 
			// 2. 使用递归方法，优势就是代码简洁
			// 这里使用方法2
			BST_node* del = node;  // 保存每次访问的对象，如果是目标，就备份好了
			if (node->_left == nullptr)
			{
				node = node->_right;
			}
			else if (node->_right == nullptr)
			{
				node = node->_left;
			}
			else
			{
				//处理左右都有孩子的目标
				// 左侧查找最大值，右侧查找最小值
				BST_node* max_node = node->_left;
				while (max_node->_right)
				{
					max_node = max_node->_right;
				}
				// 完成循环后，max_node最多有左孩子，然后数据交换，我们以目标左侧树为起点
				// 再次递归删除替换数据。
				swap(max_node->_val, node->_val);
				return Re_Erease_table(node->_left, val); //已经完成删除，就直接退出，以免触发删除delete
			}			
			//处理前两种情况
			delete del;
		}
	}

5. 析构函数

思路：

~BSTree()
	{  
		Distroy_Re(root);
		root = nullptr;   
	}
void Distroy_Re(BST_node*& node) // 我们采用递归删除
	{
		if (node == nullptr)
			return ;
		// 先处理左右孩子
		Distroy_Re(node->_left);
		Distroy_Re(node->_right);
		delete node;
		node = nullptr;
	}

6.拷贝构造 

    // 我们实现了拷贝构造，默认构造函数则不会生成 
	// 解决方案：1.实现构造函数 2.使用default关键字，强制生成默认构造
	BSTree()                 
	{
	}
	 // BSTree() = default

     BSTree(const BSTree& Tree) // 拷贝构造
	{
		root = copy(Tree.root);
	}

	BST_node* copy(BST_node* root)
	{
		if (root == nullptr)
			return nullptr;

		BST_node* new_node = new BST_node(root->_val);
		new_node->_left = copy(root->_left);
		new_node->_right = copy(root->_right);
		return new_node;
	}

 三，应用

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
     比如： 给一个单词word，判断该单词是否拼写正确，具体方式如下：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
     比如 英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如 统计单词次数，统计成功后，给定单词就可快速找到其出现的次数， 单词与其出现次数就是<word, count>就构成一种键值对（这个比较简单，修改一下即可）

 四，搜索二叉树的缺陷及优化

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最坏情况：N

平均情况：O(logN)

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。

五，代码汇总

namespace key
{
template <class K>
class BinarySeaTree_node
{
	typedef BinarySeaTree_node<K> BST_node;
public:
	BinarySeaTree_node(const K& val)
		: _val(val)
		,_left(nullptr)
		,_right(nullptr)
	{}

	K _val;
	BST_node* _left;
	BST_node* _right;
};

template <class T>
class BSTree
{
public:
	typedef BinarySeaTree_node<T> BST_node;

	// 我们实现了拷贝构造，默认构造函数则不会生成 
	// 解决方案：1.实现构造函数 2.使用default关键字，强制生成默认构造
	BSTree()
	{
	}

	// BSTree() = default
   BSTree(const BSTree& Tree) // 拷贝构造
   {
	   root = copy(Tree.root);
   }

   BSTree<T>& operator=(BSTree<T> t)
   {
	   swap(root, t.root);
	   return *this;
   }

   BST_node* copy(BST_node* root)
   {
	   if (root == nullptr)
		   return nullptr;

	   BST_node* new_node = new BST_node(root->_val);
	   new_node->_left = copy(root->_left);
	   new_node->_right = copy(root->_right);
	   return new_node;
   }

   bool Re_Insert(const T& val) { return Re_Insert_table(root, val); }
   void Re_Print() { Re_Print_table(root); }
   bool Re_Erease(const T& val) { return Re_Erease_table(root, val); }
   BST_node* Re_Find(const T& val) { return Re_Find_table(root, val); }

   bool Insert(const T& val)
   {
	   BST_node* key = new BST_node(val);
	   BST_node* cur = root;
	   BST_node* parent = nullptr;
	   while (cur)
	   {
		   if (key->_val < cur->_val)
		   {
			   parent = cur;
			   cur = cur->_left;
		   }
		   else if (key->_val > cur->_val)
		   {
			   parent = cur;
			   cur = cur->_right;
		   }
		   else
		   {
			   return 0;
		   }
	   }

	   // 查询好位置后，建立链接
	   if (!root)
	   {
		   root = key;
		   return 0;
	   }

	   if (key->_val > parent->_val)
	   {
		   parent->_right = key;
	   }
	   else
	   {
		   parent->_left = key;
	   }
	   return 1;
   }

   BST_node* Find(const T& val)
   {
	   //直接跟寻找位置一样
	   BST_node* parent = nullptr;
	   BST_node* cur = root; // 以返回cur的方式返回

	   while (cur)   // 非递归版本
	   {
		   if (val < cur->_val)
		   {
			   parent = cur;
			   cur = cur->_left;
		   }
		   else if (val > cur->_val)
		   {
			   parent = cur;
			   cur = cur->_right;
		   }
		   else
		   {
			   return cur;
		   }
	   }
	   return cur;
   }

   bool Erase(const T& val)
   {
	   //首先寻找到指定值,并且记录到parent
	   BST_node* parent = nullptr;
	   BST_node* cur = root;
	   while (cur)
	   {
		   if (val < cur->_val)
		   {
			   parent = cur;
			   cur = cur->_left;
		   }
		   else if (val > cur->_val)
		   {
			   parent = cur;
			   cur = cur->_right;
		   }
		   else
		   {
			   break;
		   }
	   }
	   if (!cur)
	   {
		   return 0;
	   }

	   // 查询成功,开始删除
	   if (!cur->_left && !cur->_right) // cur没有左右孩子
	   {   // 当要删除目标是根
		   if (cur == root)
		   {
			   root = nullptr;
			   delete cur;
		   }
		   // 判断cur是左右孩子
		   else if (cur->_val < parent->_val)
		   {
			   parent->_left = nullptr;
			   delete cur;
		   }
		   else
		   {
			   parent->_right = nullptr;
			   delete cur;
		   }
		   return 1;
	   }
	   else if (!cur->_left || !cur->_right)  // 只有一个孩子
	   {
		   if (!parent)  // 判断是否是目标是根
		   {
			   root = cur->_left != nullptr ? cur->_left : cur->_right;
			   delete cur;
		   }
		   // 判断cur为啥孩子
		   else if (cur->_val < parent->_val) // 左侧
		   {
			   parent->_left = cur->_left != nullptr ? cur->_left : cur->_right;
			   delete cur;
		   }
		   else                          // 右侧
		   {
			   parent->_right = cur->_left != nullptr ? cur->_left : cur->_right;
			   delete cur;
		   }
	   }
	   else   // 有2个孩子
	   {  // 使用左侧最大的孩子来领养
		   // 寻找左侧最大
		   BST_node* maxnode = cur->_left;
		   BST_node* max_parent = cur;
		   while (maxnode->_right)
		   {
			   max_parent = maxnode;
			   maxnode = maxnode->_right;
		   }

		   // 现在又进入一种特殊情况,1.max_parent就没进入循环，2.进入了循环
		   if (max_parent == cur)
		   {
			   max_parent->_left = maxnode->_left;
		   }
		   else
		   {
			   max_parent->_right = maxnode->_left;
		   }
		   // 值转移
		   cur->_val = maxnode->_val;
		   delete maxnode;
	   }
	   return 1;
   }

   ~BSTree()
   {
	   Distroy_Re(root);
	   root = nullptr;
   }

protected:
	bool Re_Insert_table(BST_node*& node, const T& val)
	{
		if (node == nullptr)
		{
			node = new BST_node(val);
			return 1;
		}

		if (val < node->_val)
		{
			return Re_Insert_table(node->_left, val);
		}
		else if (val > node->_val)
		{
			return Re_Insert_table(node->_right, val);
		}
		else
		{
			return 0;
		}
	}

	void Re_Print_table(const BST_node* node)
	{
		if (node == nullptr)
			return;
		Re_Print_table(node->_left);
		cout << node->_val << " ";
		Re_Print_table(node->_right);
	}

	BST_node* Re_Find_table(BST_node* node, const T& val)
	{
		if (node == nullptr)
			return nullptr;

		if (val < node->_val)
		{
			return Re_Find_table(node->_left, val);
		}
		else if (val > node->_val)
		{
			return Re_Find_table(node->_right, val);
		}
		else
		{
			return node;
		}
	}

	bool Re_Erease_table(BST_node*& node, const T& val)
	{
		// 首先我们先找到值
		if (node == nullptr)
		{
			return 0; // 如果访问到了空，则说明删除失败，原因是：不存在
		}

		if (val < node->_val)
		{
			return Re_Erease_table(node->_left, val);
		}
		else if (val > node->_val)
		{
			return Re_Erease_table(node->_right, val);
		}
		else
		{
			// 开始删除目标数据。方法如下；
			// 1. 就按照非递归的思路，不用改多少代码 
			// 2. 使用递归方法，优势就是代码简洁

			// 这里使用方法2
			BST_node* del = node;  // 保存每次访问的对象，如果是目标，就备份好了
			if (node->_left == nullptr)
			{
				node = node->_right;
			}
			else if (node->_right == nullptr)
			{
				node = node->_left;
			}
			else
			{
				//处理左右都有孩子的目标
				// 左侧查找最大值，右侧查找最小值
				BST_node* max_node = node->_left;
				while (max_node->_right)
				{
					max_node = max_node->_right;
				}
				// 完成循环后，max_node最多有左孩子，然后数据交换，我们以目标左侧树为起点
				// 再次递归删除替换数据。
				swap(max_node->_val, node->_val);
				return Re_Erease_table(node->_left, val); //已经完成删除，就直接退出，以免触发删除delete
			}
			// 查找到删除数据
			delete del;
		}
	}

	void Distroy_Re(BST_node*& node) // 我们采用递归删除
	{
		if (node == nullptr)
			return;
		// 先处理左右孩子
		Distroy_Re(node->_left);
		Distroy_Re(node->_right);
		delete node;
		node = nullptr;
	}
private:
	BST_node* root = nullptr;
 };
}

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力

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

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

相关文章

【Linux-Day13-生产者消费者模型】

【Linux-Day13-生产者消费者模型】

生产者消费者模型 生产者消费者问题概述 生产者/消费者问题&#xff0c;也被称作有限缓冲问题。可以描述为&#xff1a;两个或者更多的线程共享同一个缓冲 区&#xff0c;其中一个或多个线程作为“生产者”会不断地向缓冲区中添加数据&#xff0c;另一个或者多个线程作为“消…
阅读更多...
基于CNN-LSTM的时序预测MATLAB实战

基于CNN-LSTM的时序预测MATLAB实战

一、算法原理 1.1 CNN原理 卷积神经网络具有局部连接、权值共享和空间相关等特性。卷积神经网络结构包含卷积层、激活层和池化层。 &#xff08;a&#xff09;二维卷积层将滑动卷积滤波器应用于输入。该层通过沿输入垂直和水平方向 移动滤波器对输入进行卷积&#xff0c;并计…
阅读更多...
阿里云无影电脑：免费体验无影云电脑3个月

阿里云无影电脑：免费体验无影云电脑3个月

阿里云无影云电脑免费领取流程&#xff0c;免费无影云电脑配置为4核8G&#xff0c;可以免费使用3个月&#xff0c;阿里云百科分享阿里云无影云电脑&#xff08;云桌面&#xff09;免费申请入口、申请流程及免费使用限制条件说明&#xff1a; 目录 阿里云无影云电脑免费申请入…
阅读更多...
汉威科技亮相上海传感器展并发表主题演讲，智能传感器大有可为

汉威科技亮相上海传感器展并发表主题演讲，智能传感器大有可为

9月15日&#xff0c;第8届中国&#xff08;上海&#xff09;国际传感器技术与应用展览会圆满落幕&#xff0c;该展会吸引了逾400家传感领域国内外的企业、100余家专业传感应用单位、500余位传感大咖共同参与&#xff0c;展会观众达30000人。作为全球三大传感器展之一的盛会&…
阅读更多...
2023年最热门的编程语言：前进的趋势和机会

2023年最热门的编程语言：前进的趋势和机会

2023年最热门的编程语言&#xff1a;前进的趋势和机会 2023年最热门的编程语言&#xff1a;前进的趋势和机会摘要引言1. 编程语言的热门趋势1.1 新兴编程语言的崛起1.2 编程语言的可持续性发展1.3 跨平台编程语言的兴起1.4 人工智能和机器学习编程语言的需求 2. 编程语言职业机…
阅读更多...
Informatica使用操作流程--存储过程调用、序列生成器 使用案例5

Informatica使用操作流程--存储过程调用、序列生成器 使用案例5

映射 [创建]连接工作流 --创建工作流W_EMP_DEPT_COUNT,连接任务S_EMP_DEPT_COUNT,ctrls保存 --右击工作流-->通过任务启动工作流 存储数据的地方查验数据
阅读更多...
00后卷王的软件测试面试秘籍（含文档）

00后卷王的软件测试面试秘籍（含文档）

前言 前段时间去面试了一个公司&#xff0c;成功拿到了offer&#xff0c;薪资也从12k涨到了20k&#xff0c;对于工作都还没两年的我来说&#xff0c;还是比较满意的&#xff0c;毕竟一些工作3、4年的可能还没我高。 我可能就是大家说的卷王&#xff0c;感觉自己年轻&#xff…
阅读更多...
MybatisMybatisPlus 操作 jsonb 格式数据

MybatisMybatisPlus 操作 jsonb 格式数据

最近有用到postgresql&#xff0c;里面的一个特色数据类型便是jsonb&#xff0c;和json差不多&#xff0c;但是查询比较快&#xff0c;关于概念&#xff0c;这里就提一句&#xff0c;不赘述。 我们先来看下用mybatisplus&#xff0c;首先是查询数据。 依赖&#xff1a; <d…
阅读更多...
基于springboot车辆充电桩管理系统springboot000

基于springboot车辆充电桩管理系统springboot000

大家好✌&#xff01;我是CZ淡陌。一名专注以理论为基础实战为主的技术博主&#xff0c;将再这里为大家分享优质的实战项目&#xff0c;本人在Java毕业设计领域有多年的经验&#xff0c;陆续会更新更多优质的Java实战项目&#xff0c;希望你能有所收获&#xff0c;少走一些弯路…
阅读更多...
【百问百答】可靠性基础知识第八期

【百问百答】可靠性基础知识第八期

1、什么是加速度频谱密度值(ASD) ? 表示随机信号的各个频率分量所包的加速度方均值在频域上是如何分布的。通常用ASD表示。 2、什么是功率频谱密度值(PSD) ? 表示随机信号的各个频率分量所包的功率在频域上是怎样分布的。通常用PSD表示&#xff0c;单位&#xff1a;g2/Hz。 0…
阅读更多...
如何快速从 ETL 到 ELT？火山引擎 ByteHouse 做了这三件事

如何快速从 ETL 到 ELT？火山引擎 ByteHouse 做了这三件事

更多技术交流、求职机会&#xff0c;欢迎关注字节跳动数据平台微信公众号&#xff0c;回复【1】进入官方交流群 前言 当涉及到企业分析场景时&#xff0c;所使用的数据通常源自多样的业务数据&#xff0c;这些数据系统大多采用以行为主的存储结构&#xff0c;比如支付交易记录…
阅读更多...
02Spring框架的特点以及jar包下载

02Spring框架的特点以及jar包下载

Spring框架 Spring简介 Spring是由Rod Johnson创建的一个实现了IoC思想的开源框架, Spring最初的出现是为了解决EJB臃肿的设计以及难以测试等问题 Spring是为了解决企业应用开发的复杂性而创建的,从简单性、可测试性和松耦合的角度而言任何Java应用都可以从Spring中受益 Sp…
阅读更多...
2023-驾驶舱数据指标体系建设

2023-驾驶舱数据指标体系建设

一、什么是领导驾驶舱&#xff1f; 领导驾驶舱&#xff0c;它以驾驶舱的形式&#xff0c;通过各种图表形象的展示企业运行的关键指标&#xff08;KPI&#xff09;&#xff0c;直观的监测企业运营情况&#xff0c;并可以对异常关键指标预警和挖掘分析。以根据管理和业务的需要&a…
阅读更多...
期权合约到期日强平了还要扣手续费嘛？

期权合约到期日强平了还要扣手续费嘛？

国内目前的50ETF期权交易是会收取平仓的手续费的&#xff0c;期权手续费是双向收费&#xff0c;开仓收取一次、平仓收取一次。国内不同券商和期权分仓平台的手续费标准不同&#xff0c;下文介绍期权合约到期日强平了还要扣手续费嘛&#xff1f;本文来自&#xff1a;期权酱 一、…
阅读更多...
EFLAGS寄存器与JCC指令

EFLAGS寄存器与JCC指令

EFLAGS寄存器 EFLAGS寄存器有32位&#xff0c;EFLAGS 寄存器的标志位可以通过各种指令进行操作和判断&#xff0c;例如条件分支指令、算术指令和控制指令等。程序可以根据标志位的值来进行条件判断和控制流程&#xff0c;从而实现不同的逻辑和功能。 EFLAGS 寄存器的各个位和…
阅读更多...
js写一个判断字符串是否能够转为JSON 的函数

js写一个判断字符串是否能够转为JSON 的函数

其实非常简单 这里我们需要涉及到 捕获异常 因为如果你直接在if里面转 我已经试过了 直接就报错了 一点面子不给 我们写一个这样的函数 function isJsonString(str) {try {JSON.parse(str);return true;} catch (e) {return false;} }编写如下代码 console.log(isJsonString(…
阅读更多...
Flutter的路由router-页面跳转

Flutter的路由router-页面跳转

文章目录 概念介绍基本路由&#xff08;Basic Routing&#xff09;跳转到某个页面弹出页面 命名路由&#xff08;Named Routing&#xff09;第三方路由管理库&#xff08;Third-Party Routing Libraries&#xff09; Android原生的路由Intent-based Routing&#xff08;基于Int…
阅读更多...
分析数组，结构体在反汇编中存储

分析数组，结构体在反汇编中存储

本文会在IDA中分析数组&#xff0c;结构体在内存中的存储 目录 IDA分析数组存储 IDA分析结构体存储 传递参数的方式 IDA分析数组存储 测试代码如下&#xff1a; /************************************************************************/ /*Author : 玄都大…
阅读更多...
《优化接口设计的思路》系列：第三篇—留下用户调用接口的痕迹

《优化接口设计的思路》系列：第三篇—留下用户调用接口的痕迹

系列文章导航 《优化接口设计的思路》系列&#xff1a;第一篇—接口参数的一些弯弯绕绕 《优化接口设计的思路》系列&#xff1a;第二篇—接口用户上下文的设计与实现 《优化接口设计的思路》系列&#xff1a;第三篇—留下用户调用接口的痕迹 前言 大家好&#xff01;我是sum…
阅读更多...
【TCP】延时应答 与 捎带应答

【TCP】延时应答 与 捎带应答

延时应答 与 捎带应答 一. 延迟应答&#xff08;效率机制&#xff09;二. 捎带应答&#xff08;效率机制&#xff09; 一. 延迟应答&#xff08;效率机制&#xff09; 延时应答&#xff1a;相当于 流量控制 的延伸。 流量控制是 踩下了刹车&#xff0c;是发送方发的不要太快&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023