[数据结构进阶 C++] 二叉搜索树(BinarySearchTree)的模拟实现

在这里插入图片描述

文章目录

  • 1、二叉搜索树
    • 1.1 二叉搜索数的概念
    • 1.2 二叉搜索树的操作
      • 1.2.1 二叉搜索树的查找
      • 1.2.2 二叉搜索树的插入
      • 1.2.3 二叉搜索树的删除
  • 2、二叉搜索树的应用
    • 2.1 K模型
    • 2.2 KV模型
  • 3、二叉搜索树的性能分析
  • 4、K模型与KV模型完整代码
    • 4.1 二叉搜索树的模拟实现（K模型）
    • 4.2 KV模型的模拟实现

1、二叉搜索树

1.1 二叉搜索数的概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树
    我们先给出两个示例：
    在这里插入图片描述
    此二叉树就不是搜索二叉树，根据性质来看，每颗子树也是二叉搜索树，红圈圈起来的地方显然是违背了这个性质。
    在这里插入图片描述
    此搜索二叉树按性质来看是完全满足的，因此此二叉树就是二叉搜索树。

1.2 二叉搜索树的操作

二叉搜索树的操作包含，增删查，下面我们就来分别模拟实现这些接口。

1.2.1 二叉搜索树的查找

思路：
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。
查找比较好理解，这里就不画图了，直接开始写代码。
1.查找的非递归方法：

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

2.查找的递归方法：

bool FindR(const K& key)
{
    return _FindR(_root, key);
}

bool _FindR(Node* root, const K& key)
{
    if (nullptr == root)
        return false;

    if (key > root->_key)
        return _FindR(root->_right, key);
    else if (key < root->_key)
        return _FindR(root->_left, key);
    else
        return true;
}

在递归查找中，我们用户在使用的时候只需要填入要查找的数字，但是我们的查找接口需要两个参数，开始节点与查找数值，因此我们在 FindR 下再封装一层 _FindR 就可以实现了。

1.2.2 二叉搜索树的插入

二叉搜索树的插入思路：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
我们先来以图例演示一遍过程：
对下面这棵树插入一个值为11的节点
在这里插入图片描述

这里是成功插入的情况，具体过程是上面的图例，我们在梳理一遍：
1、首先，我们用两个结点指针 parent和cur ，cur不断寻找正确插入位置，parent不断记下来cur的父节点指针；
2、当 cur 找到正确位置之后，先 new 一个节点对象给 cur，此时 new 出来的对象只是给了 cur 这个指针变量，并没有链接起来；
3、判断要插入的位置是 parent 的左孩子还是右孩子，再将其链接到正确位置插入就算完成了。
失败情况：
因为是二叉搜索树，节点左子树的值全小于节点的值，右子树的值全大于节点的值，不存在相等的情况，因此当找到一个节点的值与要插入的值相等时，就是插入失败，此时返回false。
根据上面的图示以及过程的梳理我们来写非递归版本的代码：

bool Insert(const K& key)
{
    if (nullptr == _root)
    {
        _root = new Node(key);
        return true;
    }

    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (key > cur->_key)
        {
            parnet = cur;
            cur = cur->_right;
        }
        else if (key < cur->_key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }

    cur = new Node(key);
    if (key > parent->_key)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = cur;
    }
    return true;
}

insert接口我们只提供非递归版本的。

1.2.3 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题–替换法删除
1、删除节点没有左孩子
在这里插入图片描述

// 1、左为空
if (cur->_left == nullptr)
{
    if (cur == _root)
    {
        _root = cur->_right;
    }
    
    if (parent->_left == cur)
    {
        parent->_left = cur->_right;
    }
    else
    {
        parent->_right = cur->_right;
    }
}

2、删除节点没有右孩子
在这里插入图片描述

// 2、右为空
else if (cur->_right == nullptr)
{
    if (cur == _root)
    {
        _root = cur->_left;
    }		

    if (parent->_left == cur)
    {
        parent->_left = cur->_left
    }
    else
    {
        parent->_right = cur->_left;
    }
}

3、删除节点左右孩子都存在
在这里插入图片描述

// 3、左右都不为空
else
{
    Node* parent = cur;
    Node* subLeft = cur->_right;
    while (subLeft->_left)
    {
        parent = subLeft;
        subLeft = subLeft->_left;
    }

    swap(cur->_key, subLeft->_key);
    
    if (subLeft == parent->_left)
        parent->_left = subLeft->_right;
    else
        parent->_right = subLeft->_right;

    delete(subLeft);
}

整个删除接口合在一起的代码：

bool Erase(const K& key)
{
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (key > cur->_key)
        {
            parnet = cur;
            cur = cur->_right
        }
        else if (key < cur->_key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            // 1、左为空
            if (cur->_left == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_right;
                }

                if (parent->_left == cur)
                {
                    parent->_left = cur->_right;
                }
                else
                {
                    parent->_right = cur->_right;
                }
                delete(cur);
            }
            // 2、右为空
            else if (cur->_right == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_left;
                }		

                if (parent->_left == cur)
                {
                    parent->_left = cur->_left
                }
                else
                {
                    parent->_right = cur->_left;
                }
                delete(cur);
            }
            // 3、左右都不为空
            else
            {
                Node* parent = cur;
                Node* subLeft = cur->_right;
                while (subLeft->_left)
                {
                    parent = subLeft;
                    subLeft = subLeft->_left;
                }

                swap(cur->_key, subLeft->_key);
                
                if (subLeft == parent->_left)
                    parent->_left = subLeft->_right;
                else
                    parent->_right = subLeft->_right;

                delete(subLeft);
            }
        }
    }	
}

递归版本：
递归版本与非递归版本类似， 非递归版本中使用while循环来找key位置，递归就是不断调用自身来找key位置，当找到后，依然分三种情况来分析：左为空、右为空、左右都不为空。
递归版本中用引用来接受传来的root，因此不用考虑链接问题，也就不存在判断删除位置是父节点的左还是右，直接修改root即可。
1、左为空/左右都为空：先记下要删除的节点，再修改root，最后释放删除的节点。 Node* del = root; root = root->_right; delete(del);
2、右为空：先记下要删除的节点，再修改root，最后释放删除的节点。Node* del = root; root = root->_left; delete(del);
3、左右都不为空：先找到右子树的最左节点（最小值），交换 root->_key与subLeft->_key， 右子树的最左节点一定是叶子节点，因此删除subLeft直接再去调用函数自身即可，即再来一次左右都为空（左为空）的删除。

bool EraseR(const K& key)
{
    return _EraseR(_root, key);
}
bool _EraseR(Node*& root, const K& key)
{
    if (root == nullptr)
        return false;

    if (root->_key < key)
    {
        _EraseR(root->_right, key);
    }
    else if (root->_key > key)
    {
        _EraseR(root->_left, key);
    }
    else
    {
        if (root->_left == nullptr)
        {
            Node* del = root;
            root = root->_right;
            delete(del);// 必须释放，不释放会导致内存泄漏
            return true;
        }
        else if (root->_right == nullptr)
        {
            Node* del = root;
            root = root->_left;
            delete(del);
            return true;
        }
        else
        {
            Node* subLeft = root->_right;
            while (subLeft->_left)
            {
                subLeft = subLeft->_left;
            }

            swap(root->_key, subLeft->_key);

            return _EraseR(root->_right, key);
        }
    }
}

2、二叉搜索树的应用

2.1 K模型

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

  • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2.2 KV模型

KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。 该种方式在现实生活中非常常见：
● 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
● 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

3、二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log_2 N
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N
最差情况是退化为单支树，性能就变得很差了，因为后续我们将改进搜索二叉树的插入与删除，来实现平衡二叉搜索树，即AVL树与红黑树（RB树）。

4、K模型与KV模型完整代码

4.1 二叉搜索树的模拟实现（K模型）

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

	template <class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

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

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除分情况讨论：
					// 1. 左为空（左右都为空）；2. 右为空；3.左右都不为空
					if (cur->_left == nullptr)// 左为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_right;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete(cur);
					}
					else if (cur->_right == nullptr)// 右为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_left;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete(cur);
					}
					else// 左右都不为空
					{
						// 替换法，找左子树最大 / 右子树最小来替换cur
						Node* parent = cur;
						Node* subLeft = cur->_right;
						while (subLeft->_left)
						{
							parent = subLeft;
							subLeft = subLeft->_left;
						}

						swap(cur->_key, subLeft->_key);

						if (subLeft == parent->_left)
							parent->_left = subLeft->_right;
						else// 处理删除根节点的情况
							parent->_right = subLeft->_right;

						delete(subLeft);
					}
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		//递归
		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

		// C++11
		BSTree() = default; // 强制编译器生成默认构造

		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}

		// 赋值重载，现代写法
		BSTree<K>& operator=(BSTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}

		~BSTree()
		{
			Destroy(_root);
		}

	private:
		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;
		}

		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}

		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}

			if (root->_key < key)
			{
				_InsertR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_InsertR(root->_left, key);
			}
			else
			{
				return false;
			}
		}

		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}

			if (root->_key < key)
			{
				_FindR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_FindR(root->_left, key);
			}
			else
			{
				return true;
			}
		}

		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key < key)
			{
				_EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_EraseR(root->_left, key);
			}
			else
			{
				if (root->_left == nullptr)
				{
					Node* del = root;
					root = root->_right;
					delete(del);// 必须释放，不释放会导致内存泄漏
					return true;
				}
				else if (root->_right == nullptr)
				{
					Node* del = root;
					root = root->_left;
					delete(del);
					return true;
				}
				else
				{
					Node* subLeft = root->_right;
					while (subLeft->_left)
					{
						subLeft = subLeft->_left;
					}

					swap(root->_key, subLeft->_key);

					return _EraseR(root->_right, key);
				}
			}
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
};

4.2 KV模型的模拟实现

namespace kv
{
	template <class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _val;

		BSTreeNode(const K& key, const V& val)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _val(val)
		{}
	};

	template <class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		bool Insert(const K& key, const V& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, val);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key, val);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

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

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除分情况讨论：
					// 1. 左为空（左右都为空）；2. 右为空；3.左右都不为空
					if (cur->_left == nullptr)// 左为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_right;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete(cur);
					}
					else if (cur->_right == nullptr)// 右为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_left;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete(cur);
					}
					else// 左右都不为空
					{
						// 替换法，找左子树最大 / 右子树最小来替换cur
						Node* parent = cur;
						Node* subLeft = cur->_right;
						while (subLeft->_left)
						{
							parent = subLeft;
							subLeft = subLeft->_left;
						}

						swap(cur->_key, subLeft->_key);

						if (subLeft == parent->_left)
							parent->_left = subLeft->_right;
						else// 处理删除根节点的情况
							parent->_right = subLeft->_right;

						delete(subLeft);
					}
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << " : " << root->_val << endl;
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
};

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

设计模式（三）-结构型模式（6）-享元模式

设计模式（三）-结构型模式（6）-享元模式

一、为何需要享元模式&#xff08;Flyweight&#xff09;? 假如在网页中渲染这样的一个画面&#xff1a;大小不一的星星铺满了整个画布&#xff0c;并且都在不断的进行移动闪烁着。一批星星消失了&#xff0c;另一批又从另一边缘处出现。 要实现这样的渲染效果&#xff0c;在…
阅读更多...
C语言之初识C语言

C语言之初识C语言

文章目录 前言一、什么是C语言二、第一个C语言程序三、数据类型四、变量&#xff0c;常量1、变量1.1 变量的命名1.2 变量的分类1.3 变量的使用1.4 变量的作用域和生命周期2、变量 五、字符串1. 概念2. 求解字符串的长度【strlen】3. 转义字符【含笔试题】 六、注释七、选择语句…
阅读更多...
ESP8266 TCP/串口透传

ESP8266 TCP/串口透传

简介 先在PC上做测试, 使用串口软件对ESP8266 模块进行设置, 使用网络助手软件与串口软件进行自由收发设置 ATRST ## 复位 ATCWMODE_DEF1 ## 设置为Station模式 ATCWJAP_DEF“路由器wifi名称”,“路由器wifi密码” ## 设置ESP连接的路由器名称密码 ATCIPSTART“TCP”,“192.1…
阅读更多...
Alpha突触核蛋白神经退行性疾病

Alpha突触核蛋白神经退行性疾病

Alpha突触核蛋白科研背景 ● Alpha突触核蛋白约 15kDa, 140个氨基酸 ● StressMarq在E. coli中过表达人源基因然后将蛋白从细胞质基质中纯化出来 ● 未折叠的alpha突触核蛋白单体在12% SDS-PAGE上为~15 kDa的条带 StressMarq/欣博盛生物的Alpha突触核蛋白有以下两类&#xf…
阅读更多...
[uni-app] mescroll与 page 本身的滚动冲突处理, 动态禁用下拉刷新

[uni-app] mescroll与 page 本身的滚动冲突处理, 动态禁用下拉刷新

参考贴: uniapp动态禁用mescroll-body组件的下拉刷新,或者动态禁用mescroll-body组件的上拉加载 记录问题场景 如图: 搜索和 第二个标签栏, 都是随页面滚动的, 当页面滚动一定距离, 会触发标签栏的吸顶 即如上图, 问题描述 当列表页面数据部满屏时, 且页面已经由于滚动而吸顶…
阅读更多...
许可式邮件营销与垃圾邮件的区别：合规与效果的关键区分

许可式邮件营销与垃圾邮件的区别：合规与效果的关键区分

接触过邮件营销的人一定不陌生“垃圾邮件”和“许可式邮件营销”这两个名词。在各大电商节到来之际&#xff0c;小编帮助大家弄清楚什么是垃圾邮件&#xff1f;什么是许可式邮件营销&#xff1f;为什么会变成垃圾邮件&#xff1f;怎么做许可式邮件营销&#xff1f;让大家在促销…
阅读更多...
极智嘉(Geek+)货到人方案优势显著，助力拆零场景效率提升

极智嘉(Geek+)货到人方案优势显著，助力拆零场景效率提升

众所周知&#xff0c;零售行业所面临的物流挑战比其他行业更为严峻。这是由于零售行业复杂的行业业态、繁多的商品种类、“唯快主义”的配送需求&#xff0c;以及零售行业的终端客户多为个体消费者&#xff0c;购买习惯以单件、多品为主&#xff0c;购买习惯具有周期性和爆发性…
阅读更多...
minio 分布式对象存储

minio 分布式对象存储

分布式文件系统应用 1.1、Minlo 介绍 Minlo 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口&#xff0c;非常适合于存储大容量非结构化的数据&#xff0c;例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等&#xff0c;而一个对象…
阅读更多...
LVM将多个磁盘组成一个逻辑卷实战

LVM将多个磁盘组成一个逻辑卷实战

LVM&#xff08;Logical Volume Manager&#xff09;是一种逻辑卷管理器&#xff0c;是Linux系统中的一个重要的存储管理技术。它的主要作用是将若干个硬盘分区或者物理硬盘合并成一个逻辑卷组&#xff08;Volume Group&#xff0c;简称VG&#xff09;&#xff0c;然后再将逻辑…
阅读更多...
使用Flask逐步搭建Web应用程序

使用Flask逐步搭建Web应用程序

大家好&#xff0c;Flask是一个使用Python编写的轻量级Web应用框架。它被设计成简单、易于学习和使用的&#xff0c;同时具备足够的灵活性和扩展性&#xff0c;以满足各种规模的Web应用开发需求。本文我们将介绍一个使用Flask逐步搭建Web应用程序的简单入门示例。 1.安装Flask…
阅读更多...
开发模型和测试模型

开发模型和测试模型

1. 开发模型 1.1 瀑布模型 瀑布模型是其他模型的基础框架 start—>需求分析---->计划----->设计----->编码----->测试----->End&#xff08;其实就是软件开发的生命周期&#xff09; 特点&#xff1a;线性的开发流程 缺陷&#xff1a;测试被后置。①风险往…
阅读更多...
企业“数据入表”之政策及业务模式解读

企业“数据入表”之政策及业务模式解读

2023年8月21日&#xff0c;财政部重磅发布了《企业数据资源相关会计处理暂行规定》&#xff08;以下简称“暂行规定”&#xff09;&#xff0c;该规定将于2024年1月1日正式施行。 “暂行规定”发布后&#xff0c;引起全社会的广泛关注&#xff0c;关注的焦点集中在数据入表概念…
阅读更多...
指标体系构建-01-什么是数据指标

指标体系构建-01-什么是数据指标

参考 四千字全面解析数据产品经理必知概念&#xff1a;标签、维度、指标 什么是数据指标 指标是指于其中打算达到的指数&#xff0c;规格&#xff0c;标准等,是用数据对事物进行描述的工具。通常指标对应是否有价值取决于这个指标的实际意义。同时关注指标对应的数值&#x…
阅读更多...
Leetcode 134 加油站

Leetcode 134 加油站

题意理解&#xff1a; 给定n个站点&#xff0c;两个数组gas表达每个站点可加的油量&#xff0c;cost表达到下一站点所需耗费的油量。 gas [1,2,3,4,5], cost [3,4,5,1,2] 要求从下表为i的站点开始&#xff0c;刚好能支撑汽车在每个站点转一圈后回到出发位置。 解题思路&#…
阅读更多...
天锐绿盾加密系统是做什么用的？——防止公司内部核心文件数据 \ 资料外泄

天锐绿盾加密系统是做什么用的？——防止公司内部核心文件数据 \ 资料外泄

天锐绿盾加密系统是一款专业的数据加密软件&#xff0c;主要用于保护企业数据的安全性和完整性。该系统采用先进的加密技术&#xff0c;对数据进行加密处理&#xff0c;确保数据在传输和存储过程中的安全性。 PC访问地址&#xff1a;www.drhchina.com 天锐绿盾加密系统的主要…
阅读更多...
RocketMQ系统性学习-RocketMQ高级特性之消息存储在Broker的文件布局

RocketMQ系统性学习-RocketMQ高级特性之消息存储在Broker的文件布局

&#x1f308;&#x1f308;&#x1f308;&#x1f308;&#x1f308;&#x1f308;&#x1f308;&#x1f308; 【11来了】文章导读地址&#xff1a;点击查看文章导读&#xff01; &#x1f341;&#x1f341;&#x1f341;&#x1f341;&#x1f341;&#x1f341;&#x1f3…
阅读更多...
【C语言】自定义类型：结构体深入解析（二）结构体内存对齐宏offsetof计算偏移量结构体传参

【C语言】自定义类型：结构体深入解析（二）结构体内存对齐宏offsetof计算偏移量结构体传参

文章目录 &#x1f4dd;前言&#x1f320; 结构体内存对齐&#x1f309;内存对齐包含结构体的计算&#x1f320;宏offsetof计算偏移量&#x1f309;为什么存在内存对⻬?&#x1f320; 结构体传参&#x1f6a9;总结 &#x1f4dd;前言 本小节&#xff0c;我们学习结构的内存对…
阅读更多...
Redis设计与实现之RDB

Redis设计与实现之RDB

目录 一、RDB 1、保存 2、 SAVE 、BGSAVE 、AOF 写入和 BGREWRITEAOF SAVE BGSAVE 3、载入 4、RDB 文件结构 REDIS DB-DATA SELECT-DB KEY-VALUE-PAIRS EOF CHECK-SUM 二、 小结 一、RDB 在运行情况下&#xff0c;Redis 以数据结构的形式将数据维持在内存中&…
阅读更多...
头歌—衍生密码体制

头歌—衍生密码体制

# 第1关&#xff1a;Rabin密码体制 题目描述 任务描述 Rabin密码体制是RSA密码体制的一种。 本关任务&#xff1a;使用Rabin密码体制对给定的明文进行加密。 相关知识 为了完成本关任务&#xff0c;你需要掌握&#xff1a;Rabin密码体制。 Rabin密码体制 在本关中&#x…
阅读更多...
幻彩LED灯带芯片：SM16703SP单点单控 断点续传

幻彩LED灯带芯片：SM16703SP单点单控 断点续传

幻彩LED灯带芯片SM16703SP3是一款单点单控断点续传的芯片&#xff0c;它采用了先进的技术&#xff0c;可以实现灯光的变化和控制。这款芯片不仅仅可以提供各种丰富多彩的灯光效果&#xff0c;还有断点续传功能&#xff0c; LED断点续传灯条采用了双信号线交叉传输的方案&#x…
阅读更多...
最新文章

Copyright @ 2022~2023