【C++修炼之路：二叉搜索树】

news2024/11/15 14:00:22

目录：

  • 二叉搜索树的概念
  • 构建一颗二叉树
    • 二叉树的查找
      • 二插树的插入
  • 二叉树的删除
      • 删除右子树的最小节点
    • 写一个中序来走这个二叉搜索树
        • 递归版删除（recursion）
          • 递归版插入（recursion）
            • 递归版查找（recursion）
  • BSTree.h的代码
    • test.cpp的代码
      • 二叉树的应用
        • 二叉树的性能分析

二叉搜索树的概念

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

在这里插入图片描述

构建一颗二叉树

在这里插入图片描述

二叉树的查找


	bool Find(const K& key)//查找
	{
		Node* cur = _root;
		while (cur)//如果比cur大走右边
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)//如果比cur小走左边
			{
				cur = cur->_left;
			}
			else//如果相等就找到了
			{
				return true;
			}
		}

		return false;//如果走到空找不到
	}

二插树的插入

	bool Insert(const K& key)
	{
		if (_root == nullptr)//如果是一颗空树
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = nullptr;//定义一个父亲节点的指针
		Node* cur = _root;//定义一个cur指针找这个节点插入的位置
		while (cur)
		{
			if (cur->_key < key)//如果key值大就往右边走
			{
				parent = cur;//cur往下走的时候先给给我们parent
				cur = cur->_right;
			}
			else if (cur->_key > key)//如果key值小就往左边走
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;//如果相等就不插入
			}
		}

		cur = new Node(key);
		//cur是一个局部变量，需要和父亲节点链接起来
		//如果我的key大就链接到右边
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		//如果我的key小就链接在左边
		else
		{
			parent->_left = cur;
		}

		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 (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						//如果我是父亲的左，那就让父亲的左指向我的右
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						//如果我是父亲的右，那就让父亲的右指向我的右
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;//释放cur
				}
				else if (cur->_right == nullptr)//右为空
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						//如果我是父亲的左，那就让父亲的左指向我的左
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						//如果我是父亲的右，那就让父亲的右指向我的左
						else
						{
							parent->_right = cur->_left;
						}

					}
					delete cur;//释放cur
				}
				else
				{
					//右子树的最小节点
					Node* parent = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)//不等于空继续
					{
						parent = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;//赋值
					if (minRight == parent->_left)
					{
						parent->_left = minRight->_right;//父亲的左指向它的右
					}
					else
					{
						parent->_right = minRight->_right;
					}

					delete minRight;//删除
				}

				return true;
			}
		}

		return false;//找不到
	}

删除右子树的最小节点

依次删除7、14、3、8，3和14属于直接删除的场景，那么删除3和8两个节点麻烦一点，就需要替换法进行删除的场景，代码和图示如下：
在这里插入图片描述

	
		else{
					//右子树的最小节点
					Node* parent = cur;//记录父亲
					//最开始父亲有可能就是最左节点，所以父亲不能为空，为空就不会进入循环了
					Node* minRight = cur->_right;//在右树里面找最左节点
					while (minRight->_left)//不等于空继续
					{
						parent = minRight;//最左节点给父亲
						minRight = minRight->_left;//往下走
					}

					cur->_key = minRight->_key;//赋值
					//判断最左节点在父亲的左边还是右边
					//因为parent有能在左边也有可能在右边
					if (minRight == parent->_left)
					{
						parent->_left = minRight->_right;//父亲的左指向它的右
					}
					else
					{
						parent->_right = minRight->_right;//父亲的右指向它的右
					}

					delete minRight;//替换删除
				}

				return true;
			}

写一个中序来走这个二叉搜索树

套一层：由于根是私有的调不动需要写一个子函数，让子函数去递归,因此我们需要套一层，也可以自己写一个getroot

	void InOrder()
	{
		_InOrder(_root);//调子函数递归
		cout << endl;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)//空树
			return;

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

递归版删除（recursion）

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		//相等就删除
		else
		{
			Node* del = root;//定义一个指针删掉原来的root
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				//调用递归
				swap(root->_key, minRight->_key);
				return _EraseR(root->_right, key);

			}
			delete del;//释放
			return true;

		}

	}
递归版插入（recursion）
	//用引用链接父亲
	bool _InsertR(Node*& root, const K& key)
	{
		//插入
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key);

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

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

		if (root->_key < key)
			return _FindR(root->_right, key);
		else if (root->key > key)
			return _FindR(root->_left, key);
		else
			return true;
	}
递归版查找（recursion）
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;

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

BSTree.h的代码

#pragma once
//二叉搜索树
template<class K>//类模板参数
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

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

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree()
		:_root(nullptr)
	{}//构造函数

	//树的拷贝构造
	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}
	//树的赋值
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}


	//析构函数
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	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)//如果比cur大走右边
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)//如果比cur小走左边
			{
				cur = cur->_left;
			}
			else//如果相等就找到了
			{
				return true;
			}
		}

		return false;//如果走到空找不到
	}

	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 (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						//如果我是父亲的左，那就让父亲的左指向我的右
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						//如果我是父亲的右，那就让父亲的右指向我的右
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;//释放cur
				}
				else if (cur->_right == nullptr)//右为空
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						//如果我是父亲的左，那就让父亲的左指向我的左
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						//如果我是父亲的右，那就让父亲的右指向我的左
						else
						{
							parent->_right = cur->_left;
						}

					}
					delete cur;//释放cur
				}
				else
				{
					//右子树的最小节点
					Node* parent = cur;//记录父亲
					//最开始父亲有可能就是最左节点，所以父亲不能为空，为空就不会进入循环了
					Node* minRight = cur->_right;//在右树里面找最左节点
					while (minRight->_left)//不等于空继续
					{
						parent = minRight;//最左节点给父亲
						minRight = minRight->_left;//往下走
					}

					cur->_key = minRight->_key;//赋值
					//判断最左节点在父亲的左边还是右边
					//因为parent有能在左边也有可能在右边
					if (minRight == parent->_left)
					{
						parent->_left = minRight->_right;//父亲的左指向它的右
					}
					else
					{
						parent->_right = minRight->_right;//父亲的右指向它的右
					}

					delete minRight;//替换删除
				}

				return true;
			}
		}

		return false;//找不到
	}
	//套一层
	//由于根是私有的调不动需要写一个子函数，让子函数去递归,因此我们需要套一层，也可以自己写一个getroot
	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);
	}


private:

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

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

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		//相等就删除
		else
		{
			Node* del = root;//定义一个指针删掉原来的root
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				//调用递归
				swap(root->_key, minRight->_key);
				return _EraseR(root->_right, key);

			}
			delete del;//释放
			return true;

		}

	}


	//用引用链接父亲
	bool _InsertR(Node*& root, const K& key)
	{
		//插入
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key);

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

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

		if (root->_key < key)
			return _FindR(root->_right, key);
		else if (root->key > key)
			return _FindR(root->_left, key);
		else
			return true;
	}
	//写一个中序来走这个二叉搜索树
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)//空树
			return;

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

private:
	Node* _root = nullptr;
};


void TestBSTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

	BSTree<int> t;
	for (auto e : a)a的第一个元素和最后一个元素就是e的范围
	{
		t.InsertR(e);
	}

	t.InOrder();//前序遍历
	BSTree<int> Copyt(t);
	Copyt.InOrder();
	t.InOrder();

	//t.EraseR(9);
	// t.InOrder();

	t.EraseR(14);
	t.InOrder();

	t.EraseR(3);
	t.InOrder();

	t.EraseR(8);
	t.InOrder();

	for (auto e : a)
	{
		t.Erase(e);
		t.InOrder();//根是私有调不动
	}
}

test.cpp的代码

#include<iostream>
using namespace std;
#include "BSTree.h"

int main()
{
	TestBSTree1();
	system("pause");
	return 0;
}

我们看下运行结果，这棵树就被我们删完了：
在这里插入图片描述

二叉树的应用

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

二叉树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： l o g 2 N log_2 N log2​N

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： N 2 \frac{N}{2} 2N​

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

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

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

相关文章

基于AT89C51单片机的电子密码锁设计与仿真

基于AT89C51单片机的电子密码锁设计与仿真

点击链接获取Keil源码与Project Backups仿真图&#xff1a; https://download.csdn.net/download/qq_64505944/87760996?spm1001.2014.3001.5503 源码获取 主要内容&#xff1a; &#xff08;1&#xff09;本设计为了防止密码被窃取要求在输入密码时在LCD屏幕上显示*号。 &a…
阅读更多...
类和对象中（1）

类和对象中（1）

文章目录 一、类的6个默认成员函数二、构造函数1、概念2、构造函数只初始化自定义类型3、对于不会初始化内置类型的补丁4、构造函数优点 三、析构函数1、概念2、什么时候需要自己写析构函数 &#xff1f;3、构造和析构顺序差异 四、拷贝构造函数1、概念2、拷贝构造下传值会无限…
阅读更多...
MySQL环境搭建——“MySQL数据库”

MySQL环境搭建——“MySQL数据库”

各位CSDN的uu们你们好呀&#xff0c;小雅兰又来啦&#xff0c;好久没有更文啦&#xff0c;今天继续&#xff01;&#xff01;&#xff01;今天小雅兰的内容是MySQL环境搭建&#xff0c;下面&#xff0c;让我们进入MySQL数据库的世界吧 MySQL的卸载 MySQL的下载、安装、配置 M…
阅读更多...
ubuntu18.04下pass-through直通realteck PCI设备到qemu-kvm虚拟机实践

ubuntu18.04下pass-through直通realteck PCI设备到qemu-kvm虚拟机实践

设备直通是一种虚拟化资源分配方式&#xff0c;通过将物理设备直通给虚拟机环境&#xff0c;达到虚拟机可以直接访问物理设备的目的&#xff0c;直通功能对设备的要求不高&#xff0c;不需要设备支持PF/VF&#xff0c;18年后的普通家用PC的PCI设备都支持设备直通模式&#xff0…
阅读更多...
【Java】Java对象的比较

【Java】Java对象的比较

Java对象的比较 PriorityQueue中插入对象元素的比较基本数据类型的比较对象的比较重写基类的equals方法基于Comparble接口类的比较基于比较器进行比较 PriorityQueue中插入对象 优先级队列在插入元素时有个要求&#xff1a;插入的元素不能是null或者元素之间必须要能够进行比较…
阅读更多...
Redis持久化之AOF日志高频问题

Redis持久化之AOF日志高频问题

1、如何采用AOF日志避免宕机丢失数据&#xff1f; Redis 的持久化主要有两大机制&#xff0c;即 AOF&#xff08;Append Only File&#xff09;日志和 RDB 快照。 MySQL数据库的写前日志&#xff08;Write Ahead Log, WAL&#xff09;&#xff0c;在实际写数据前&#xff0c;…
阅读更多...
PWLCM分段线性混沌映射

PWLCM分段线性混沌映射

混沌映射是生成混沌序列的一种方法,常见的混沌映射方式有 Logistic映射、Tent映射、Lorenz映射,而PWLCM&#xff08;Piecewise Linear Chaotic Map&#xff0c;分段线性混沌映射&#xff09;作为混沌映射的典型代表&#xff0c;数学形式简单&#xff0c;具有遍历性和随机性。其…
阅读更多...
智能优化算法：基于减法平均的优化算法-附代码

智能优化算法：基于减法平均的优化算法-附代码

智能优化算法&#xff1a;基于减法平均的优化算法 文章目录 智能优化算法&#xff1a;基于减法平均的优化算法1.基于减法平均优化算法1.1 初始化1.2 SABO的数学建模 2.实验结果3.参考文献4.Matlab 摘要&#xff1a;基于减法平均的优化算法&#xff08;Subtraction-Average-Base…
阅读更多...
[数据结构] 二叉搜索树的详解实现

[数据结构] 二叉搜索树的详解实现

文章目录 概念实现架构BSTreeNodea&#xff08;节点&#xff09;BSTree框架 增删查 -- 循环写法insert&#xff08;尾插&#xff09;inOrder&#xff08;遍历&#xff09;Find&#xff08;查找&#xff09;Erase&#xff08;删除&#xff09;默认成员函数构造拷贝构造析构函数赋…
阅读更多...
哈夫曼编码文件压缩和解压

哈夫曼编码文件压缩和解压

哈夫曼编码&文件压缩和解压 文章目录 哈夫曼编码&文件压缩和解压哈夫曼编码基本介绍原理解析代码实现 文件的压缩文件的解压完整代码 哈夫曼编码 基本介绍 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)&#xff0c;又称霍夫曼编码&#xff0c;是一种编码方式, 属于…
阅读更多...
实现c++轻量级别websocket协议客户端

实现c++轻量级别websocket协议客户端

1 websocket 轻量客户端 因以前发过这个代码&#xff0c;但是一直没有整理&#xff0c;这次整理了一下&#xff0c;持续修改&#xff0c;主要是要使用在arm的linux上&#xff0c;发送接收的数据压缩成图片发送出去。 要达到轻量websocket 使用&#xff0c;必须要达到几个方面…
阅读更多...
MySQL：数学函数和字符串函数

MySQL：数学函数和字符串函数

目录 前言&#xff1a; 数学函数&#xff1a; 求绝对值&#xff1a; 求PI&#xff1a; 求平方根&#xff1a; 求余数&#xff1a; 取整&#xff1a; 随机数&#xff1a; 四舍五入&#xff1a; 只舍不入&#xff1a; 返回参数符号&#xff1a; 幂运算&#xff1a; …
阅读更多...
Illustrator如何编辑图形对象之实例演示？

Illustrator如何编辑图形对象之实例演示？

文章目录 0.引言1.绘制海浪插画2.绘制时尚波浪发型3.绘制一条鲸鱼 0.引言 因科研等多场景需要进行绘图处理&#xff0c;笔者对Illustrator进行了学习&#xff0c;本文通过《Illustrator CC2018基础与实战》及其配套素材结合网上相关资料进行学习笔记总结&#xff0c;本文对图形…
阅读更多...
快速上手Pytorch实现BERT，以及BERT后接CNN/LSTM

快速上手Pytorch实现BERT，以及BERT后接CNN/LSTM

快速上手Pytorch实现BERT&#xff0c;以及BERT后接CNN/LSTM 本项目采用HuggingFace提供的工具实现BERT模型案例&#xff0c;并在BERT后接CNN、LSTM等 HuggingFace官网 一、实现BERT&#xff08;后接线性层&#xff09; 1.引用案例源码&#xff1a; from transformers impo…
阅读更多...
开关电源基础01：电源变换器基础（2）

开关电源基础01：电源变换器基础（2）

说在开头&#xff1a;关于德布罗意的电子波&#xff08;3&#xff09; 1923年&#xff0c;德布罗意在求出他的相波之前&#xff0c;康普顿刚好用光子说解释了康普顿效应&#xff08;记性好的胖友们应该还记得&#xff1a;散射波的波长变长问题&#xff09;&#xff0c;从而带领…
阅读更多...
开关电源基础02：基本开关电源拓扑（2）-BOOST-BUCKBOOST拓扑

开关电源基础02：基本开关电源拓扑（2）-BOOST-BUCKBOOST拓扑

说在开头&#xff1a;关于海森堡的矩阵&#xff08;2&#xff09; 海森堡写完论文就回到了哥廷根大学&#xff0c;他一看见玻恩就把这份论文拿出来请老师把关&#xff0c;还说要趁着假期去趟英国剑桥大学讲课交流。玻恩拿过论文一看&#xff0c;海森堡画的这个表格是啥玩意啊&…
阅读更多...
【操作系统】高性能网络模式：Reactor 和 Proactor

【操作系统】高性能网络模式：Reactor 和 Proactor

【操作系统】高性能网络模式&#xff1a;Reactor 和 Proactor 参考资料&#xff1a; 高性能 RPC 通信的实现- 巧用 reactor 模式 高性能网络模式&#xff1a;Reactor 和 Proactor NIO Reactor模型 Netty「基石」之Reactor模式 高性能IO模型分析-Reactor模式和Proactor模式 【…
阅读更多...
【服务器】无公网IP，异地远程连接威联通NAS

【服务器】无公网IP，异地远程连接威联通NAS

Yan-英杰的主页 悟已往之不谏 知来者之可追 C程序员&#xff0c;2024届电子信息研究生 目录 前言 1. 威联通安装cpolar内网穿透 2. 内网穿透 2.1 创建隧道 2.2 测试公网远程访问 3. 配置固定二级子域名 3.1 保留二级子域名 3.2 配置二级子域名 4. 使用固定二级子…
阅读更多...
Linux诊断原因：生产环境服务器变慢，诊断思路和性能评估

Linux诊断原因：生产环境服务器变慢，诊断思路和性能评估

Linux诊断原因&#xff0c;生产环境服务器变慢&#xff0c;诊断思路和性能评估 1 整机&#xff1a;top&#xff0c;查看整机系统性能 使用top命令的话&#xff0c;重点关注的是 %CPU、%MEM 、load average 三个指标 load average三个指标&#xff1a;分别代表1、5、15时分钟系…
阅读更多...
2022年NOC大赛编程马拉松赛道初赛图形化低年级A卷-正式卷，包含答案

2022年NOC大赛编程马拉松赛道初赛图形化低年级A卷-正式卷，包含答案

目录 选择题： 下载文档打印做题： 2022年NOC大赛编程马拉松赛道【初赛】图形化低年级A卷-正式卷 2022NOC-图形化初赛低年级A卷正式卷 选择题： 1、答案：B 禾木是一个军事迷，他打算利用业余时间制作一款射击游戏。在游戏中，玩家可以通过鼠标控制手枪移动。请问，给手枪…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023