【C++ —— 用一棵红黑树同时封装出map和set】

C++ —— 用一棵红黑树同时封装出map和set

  • 总览
    • RBTree
    • MyMap
    • MySet
  • 红黑树源代码
  • 红黑树模板参数的控制
  • 模板参数中仿函数的增加
  • 迭代器模拟
    • 1. 迭代器的定义和结构
    • 2. 迭代器的操作符重载
  • set模拟
  • map模拟
  • 代码
    • 红黑树的代码
    • set的代码
    • map的代码

总览

RBTree

enum Colour
{RED,BLACK
};// RBTree节点
template<class T>
struct RBTreeNode
{RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;Colour _col;T _data;RBTreeNode(const T& data): _left(nullptr), _right(nullptr), _parent(nullptr), _col(RED), _data(data){}
};// RBTree迭代器
template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{typedef RBTreeNode<T> Node;typedef __RBTreeIterator<T, Ref, Ptr> Self;Node* _node;__RBTreeIterator(Node* node) : _node(node) {}Ref operator*();Ptr operator->();bool operator!=(const Self& s);Self& operator++();
};// RBTree实现
template<class K, class T, class KeyOfT>
class RBTree
{typedef RBTreeNode<T> Node;public:typedef __RBTreeIterator<T, T&, T*> Iterator;typedef __RBTreeIterator<T, const T&, const T*> ConstIterator;RBTree() = default;RBTree(const RBTree<K, T, KeyOfT>& t);~RBTree();RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t);Iterator Begin();Iterator End();ConstIterator Begin() const;ConstIterator End() const;Iterator Find(const K& key);std::pair<Iterator, bool> Insert(const T& data);void RotateR(Node* parent);void RotateL(Node* parent);void InOrder();bool IsBalance() const;private:Node* Copy(Node* root);void Destroy(Node* root);bool Check(Node* root, int blackNum, const int refNum) const;void _InOrder(Node* root) const;Node* _root = nullptr;
};

MyMap

namespace qq
{template<class K, class V>class map{struct MapKeyOfT{const K& operator()(const std::pair<K, V>& kv);};public:typedef typename RBTree<K, std::pair<const K, V>, MapKeyOfT>::Iterator iterator;typedef typename RBTree<K, const std::pair<K, V>, MapKeyOfT>::ConstIterator const_iterator;const_iterator begin() const;const_iterator end() const;iterator begin();iterator end();iterator find(const K& key);std::pair<iterator, bool> insert(const std::pair<K, V>& kv);V& operator[](const K& key);private:RBTree<K, std::pair<const K, V>, MapKeyOfT> _t;};
}

MySet

namespace qq
{template<class K>class set{struct SetKeyOfT{const K& operator()(const K& key);};public:typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator const_iterator;const_iterator begin() const;const_iterator end() const;iterator begin();iterator end();iterator find(const K& key);std::pair<iterator, bool> insert(const K& key);private:RBTree<K, const K, SetKeyOfT> _t;};
}

红黑树源代码

enum Colour
{RED,BLACK
};template<class K, class V>
struct RBTreeNode
{RBTreeNode<K, V>* _left;RBTreeNode<K, V>* _right;RBTreeNode<K, V>* _parent;pair<K, V> _kv;Colour _col;RBTreeNode(const pair<K, V>& kv):_left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _col(RED){}
};template<class K, class V>
class RBTree
{typedef RBTreeNode<K, V> Node;
public:bool Insert(const pair<K, V>& kv){if (_root == nullptr){_root = new Node(kv);_root->_col = BLACK;return true;}Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first < kv.first){parent = cur;cur = cur->_right;}else if (cur->_kv.first > kv.first){parent = cur;cur = cur->_left;}else{return false;}}cur = new Node(kv);cur->_col = RED; // 新增节点给红色if (parent->_kv.first < kv.first){parent->_right = cur;}else{parent->_left = cur;}cur->_parent = parent;// parent的颜色是黑色也结束while (parent && parent->_col == RED){// 关键看叔叔Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;// 叔叔存在且为红，-》变色即可if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 继续往上处理cur = grandfather;parent = cur->_parent;}else // 叔叔不存在，或者存在且为黑{if (cur == parent->_left){//     g  //   p   u// c RotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else{//      g  //   p     u//      c RotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}else{Node* uncle = grandfather->_left;// 叔叔存在且为红，-》变色即可if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;// 继续往上处理cur = grandfather;parent = cur->_parent;}else // 叔叔不存在，或者存在且为黑{// 情况二：叔叔不存在或者存在且为黑// 旋转+变色//      g//   u     p//            cif (cur == parent->_right){RotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else{//		g//   u     p//      cRotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}}_root->_col = BLACK;return true;}void RotateR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR)subLR->_parent = parent;subL->_right = parent;Node* ppNode = parent->_parent;parent->_parent = subL;if (parent == _root){_root = subL;_root->_parent = nullptr;}else{if (ppNode->_left == parent){ppNode->_left = subL;}else{ppNode->_right = subL;}subL->_parent = ppNode;}}void RotateL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;parent->_right = subRL;if (subRL)subRL->_parent = parent;subR->_left = parent;Node* ppNode = parent->_parent;parent->_parent = subR;if (parent == _root){_root = subR;_root->_parent = nullptr;}else{if (ppNode->_right == parent){ppNode->_right = subR;}else{ppNode->_left = subR;}subR->_parent = ppNode;}}void InOrder(){_InOrder(_root);cout << endl;}bool IsBalance(){if (_root->_col == RED){return false;}int refNum = 0;Node* cur = _root;while (cur){if (cur->_col == BLACK){++refNum;}cur = cur->_left;}return Check(_root, 0, refNum);}private:bool Check(Node* root, int blackNum, const int refNum){if (root == nullptr){//cout << blackNum << endl;if (refNum != blackNum){cout << "存在黑色节点的数量不相等的路径" << endl;return false;}return true;}if (root->_col == RED && root->_parent->_col == RED){cout << root->_kv.first << "存在连续的红色节点" << endl;return false;}if (root->_col == BLACK){blackNum++;}return Check(root->_left, blackNum, refNum)&& Check(root->_right, blackNum, refNum);}void _InOrder(Node* root){if (root == nullptr){return;}_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);}private:Node* _root = nullptr;//size_t _size = 0;
};

红黑树模板参数的控制

因为set是K模型的容器，而map是KV模型的容器，我们上面实现的红黑树是KV模型的红黑树，那怎么去使用KV的红黑树来同时实现set和map呢？
这里我们就需要更改红黑树的模板参数了，讲红黑树的第二个模板参数更改为T。

template<class K, class T>
class RBTree

当我们模拟实现set时，只需控制T传入Key，如果模拟实现map时，则需要给T传入K 和 V。
如下图：
在这里插入图片描述

为什么要保留第一个模板参数是K？

我们可以通过第二个模板参数T来决定传入的是K还是KV，那为什么还要保留第一个K？

例如，在 Find函数中，你需要传入一个键值来查找相应的元素。由于键的类型可能与存储的值类型不同，单独保存键的类型允许你灵活地处理不同的键类型。
示例:如果你的树存储的是 std::pair<int, std::string>，但你想用 int 作为键来查找元素，那么你需要K作为键的类型。K 允许 RBTree 区分存储的实际数据类型和用作索引的键类型。

模板参数中仿函数的增加

因为我们现在不知道红黑树代码模板的第二个参数传入的是K还是pair，所以在后续的操作(比如比大小等)时会出现问题，所以这里我们使用一个仿函数来达到取值的目的。

如果是set，那么这里的仿函数则直接返回第二个模板参数的k即可。
如果是map，那么这里的仿函数则根据map的取值规则，返回pair<k,v>的k即可。

仿函数是重载运算符()，通过对象调用函数来是使用。具体的仿函数可以参考这篇博客priority_queue的模拟实现

class set
{struct SetKeyOfT{const K& operator()(const K& key){return key;}};
}class map
{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};
}

迭代器模拟

 在红黑树中，迭代器是访问和遍历树节点的关键工具。下面将介绍红黑树迭代器的实现，包括如何通过迭代器遍历节点、解引用节点，以及判断两个迭代器是否相等。我们将详细讲解每个操作的实现细节，来更好理解如何高效地操作红黑树中的元素。

1. 迭代器的定义和结构

template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{typedef RBTreeNode<T> Node;typedef __RBTreeIterator<T, Ref, Ptr> Self;Node* _node;__RBTreeIterator(Node* node): _node(node){}// 各种操作符重载
};

  • 模板参数：

    • T：表示树节点存储的数据类型。
    • Ref：引用类型，用于 operator* 的返回类型。
    • Ptr：指针类型，用于 operator-> 的返回类型。
      成员变量：

  • _node：当前迭代器指向的节点。

2. 迭代器的操作符重载

解引用操作符 operator 和箭头操作符 operator->*

Ref operator*()
{return _node->_data;
}Ptr operator->()
{return &_node->_data;
}
  • operator* 返回当前节点的引用，允许直接访问节点数据。
  • operator-> 返回当前节点数据的指针，允许通过指针访问节点数据成员。

不等于操作符 operator!=

bool operator!=(const Self& s)
{return _node != s._node;
}
  • 用于比较两个迭代器是否指向不同的节点。

前置递增操作符 operator++
前置递增操作符 operator++ 在红黑树迭代器中用于移动到下一个节点。其目的是实现节点的遍历，确保能够按顺序访问树中的元素。红黑树的迭代器在实现这个操作符时需要处理两种主要情况：

  • 如果节点有右子树： 如果当前节点 _node 有右子节点，则下一个节点是其右子树中的最左子节点。
  • 如果节点没有右子树： 如果当前节点没有右子节点，向上追溯父节点，直到当前节点是其父节点的左子节点，那个父节点即为后继节点。

图示讲解
假设我们有如下二叉搜索树：

示例 1：节点有右子树
假设当前节点是 6。

  1. 节点 6 有右子树。
  2. 找右子树的最左节点，即节点 7。
  3. 因此，节点 6 的后继节点是 7。

示例 2：节点没有右子树
假设当前节点是 5。

  1. 节点 5 没有右子树。
  2. 向上追溯父节点：
  • 当前节点 5 是其父节点 3 的右子节点。
  • 继续向上追溯，节点 3 是其父节点 6 的左子节点。
  • 因此，节点 6 是节点 5 的后继节点。
    在这里插入图片描述

代码：

Self& operator++()
{if (_node->_right){Node* leftMin = _node->_right;while (leftMin->_left){leftMin = leftMin->_left;}_node = leftMin;}else{Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_right){cur = parent;parent = parent->_parent;}_node = parent;}return *this;
}

set模拟

我们使用红黑树来封装set，在红黑树的基础上，我们只需要对其进行简单的封装即可完成set的简单模拟。

template<class K>class set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator const_iterator;const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}iterator begin(){return _t.Begin();}iterator end(){return _t.End();}iterator find(const K& key){return _t.Find(key);}pair<iterator, bool> insert(const K& key){return _t.Insert(key);}private:RBTree<K, const K, SetKeyOfT> _t;};

map模拟

map的实现也与set的实现类似，但注意仿函数的实现即可。

template<class K, class V>class map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;typedef typename RBTree<K, const K, MapKeyOfT>::ConstIterator const_iterator;const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}iterator begin(){return _t.Begin();}iterator end(){return _t.End();}iterator find(const K& key){return _t.Find(key);}pair<iterator, bool> insert(const pair<K, V>& kv){return _t.Insert(kv);}V& operator[](const K& key){pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));return ret.first->second;}private:RBTree<K, pair<const K, V>, MapKeyOfT> _t;};

代码

红黑树的代码

#pragma once
#include<vector>enum Colour
{RED,BLACK
};template<class T>
struct RBTreeNode
{RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;Colour _col;T _data;RBTreeNode(const T& data):_left(nullptr), _right(nullptr), _parent(nullptr), _col(RED), _data(data){}
};template<class T,class Ref,class Ptr>
struct __RBTreeIterator
{typedef RBTreeNode<T> Node;typedef __RBTreeIterator<T, Ref, Ptr> Self;Node* _node;__RBTreeIterator(Node* node):_node(node){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}bool operator!=(const Self& s){return _node != s._node;}Self& operator++(){if (_node->_right){//下一个是右数的最左节点Node* leftMin = _node->_right;while (leftMin->_left){leftMin = leftMin->_left;}_node = leftMin;}else{Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_right){cur = parent;parent = parent->_parent;}_node = parent;}return *this;}
};template<class K, class T, class KeyOfT>
class RBTree
{typedef RBTreeNode<T> Node;public:typedef __RBTreeIterator<T, T&, T*> Iterator;typedef __RBTreeIterator<T, const T&, const T*> ConstIterator;RBTree() = default;RBTree(const RBTree<K, T, KeyOfT>&t){_root = Copy(t._root);}// t2 = t1RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t){swap(_root, t._root);return *this;}~RBTree(){Destroy(_root);_root = nullptr;}Iterator Begin(){Node* leftMin = _root;while (leftMin && leftMin->_left){leftMin = leftMin->_left;}return Iterator(leftMin);}Iterator End(){return Iterator(nullptr);}ConstIterator Begin() const{Node* leftMin = _root;while (leftMin && leftMin->_left){leftMin = leftMin->_left;}return ConstIterator(leftMin);}ConstIterator End() const{return ConstIterator(nullptr);}Iterator Find(const K& key){KeyOfT kot;Node* cur = _root;while (cur){if (kot(cur->_data) < key){cur = cur->_right;}else if (kot(cur->_data) > key){cur = cur->_left;}else{return Iterator(cur);}}return End();}pair<Iterator, bool>Insert(const T& data){if (_root == nullptr){_root = new Node(data);_root->_col = BLACK;return make_pair(Iterator(_root), true);}KeyOfT kot;Node* parent = nullptr;Node* cur = _root;//kot对象，用来取T类型data中的keywhile (cur){if (kot(cur->_data) < kot(data)){parent = cur;cur = cur->_right;}else if(kot(cur->_data) > kot(data)){parent = cur;cur = cur->_left;}else{return make_pair(Iterator(cur), false);}}cur = new Node(data);Node* newnode = cur;cur->_col = RED;if (kot(parent->_data) < kot(cur->_data)){parent->_right = cur;}else{parent->_left = cur;}cur->_parent = parent;//parent的颜色是黑色也结束while (parent && parent->_col == RED){//看叔叔Node* grandfather = parent->_parent;if (parent == grandfather->_left){Node* uncle = grandfather->_right;//如果叔叔存在，且为红if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;//继续向上处理cur = grandfather;parent = cur->_parent;}else//如果叔叔不在，或者是黑色{if (cur == parent->_left){//			g//		p		u//	cRotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else{//			g//		p		u//	       cRotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;}}else{Node* uncle = grandfather->_left;//叔叔存在且为红色if (uncle && uncle->_col == RED){uncle->_col = parent->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else//叔叔不存在，或者为黑{if (cur == parent->_right){//			g//		u		p//					cRotateL(grandfather);grandfather->_col = RED;parent->_col = BLACK;}else{//			g//		u		p//			 cRotateR(parent);RotateL(grandfather);grandfather->_col = RED;cur->_col = BLACK;}break;}}}_root->_col = BLACK;return make_pair(Iterator(newnode), true);}void RotateR(Node* parent){Node* SubL = parent->_left;Node* SubLR = SubL->_right;parent->_left = SubLR;if (SubLR)SubLR->_parent = parent;Node* ppNode = parent->_parent;SubL->_right = parent;parent->_parent = SubL;if (parent == _root){_root = SubL;SubL->_parent = nullptr;}else{if (ppNode->_left == parent){ppNode->_left = SubL;}else{ppNode->_right = SubL;}SubL->_parent = ppNode;}}void RotateL(Node* parent){Node* SubR = parent->_right;Node* SubRL = SubR->_left;parent->_right = SubRL;if (SubRL)SubRL->_parent = parent;Node* ppNode = parent->_parent;SubR->_left = parent;parent->_parent = SubR;if (parent == _root){_root = SubR;SubR->_parent = nullptr;}else{if (ppNode->_left == parent){ppNode->_left = SubR;}else{ppNode->_right = SubR;}SubR->_parent = ppNode;}}void InOrder(){_InOrder(_root);cout << endl;}bool IsBalance(){if (_root->_col == RED){return false;}int refNum = 0;Node* cur = _root;while (cur){if (cur->_col == BLACK){refNum++;}cur = cur->_left;}return Check(_root, 0, refNum);}private:Node* Copy(Node* root){if (root == nullptr)return nullptr;Node* newroot = new Node(root->_data);newroot->_col = root->_col;newroot->_left = Copy(root->_left);if (newroot->_left)newroot->_left->_parent = newroot;newroot->_right = Copy(root->_right);if (newroot->_right)newroot->_right->_parent = newroot;return newroot;}void Destroy(Node* root){if (root == nullptr)return;Destroy(root->_left);Destroy(root->_right);delete root;root = nullptr;}bool Check(Node* root, int blackNum, const int refNum){if (root == nullptr){if (blackNum != refNum){cout << "存在黑色节点不相等的路线" << endl;return false;}return true;}if (root->_col == BLACK){blackNum++;}if (root->_col == RED && root->_parent->_col == RED){cout << "存在连续红色节点" << endl;return false;}return Check(root->_left, blackNum, refNum)&& Check(root->_right, blackNum, refNum);}void _InOrder(Node* root){if (root == nullptr){return;}_InOrder(root->_left);// 输出数据if constexpr (std::is_same<T, std::pair<K, typename std::remove_const<K>::type>>::value){cout << root->_data.first << ":" << root->_data.second << endl;}else{cout << root->_data << endl;}_InOrder(root->_right);}Node* _root = nullptr;
};

set的代码

#pragma oncenamespace qq
{template<class K>class set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator const_iterator;const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}iterator begin(){return _t.Begin();}iterator end(){return _t.End();}iterator find(const K& key){return _t.Find(key);}pair<iterator, bool> insert(const K& key){return _t.Insert(key);}private:RBTree<K, const K, SetKeyOfT> _t;};void PrintSet(const set<int>& s){for (auto e : s){cout << e << endl;}}void test_set(){set<int> s;s.insert(4);s.insert(2);s.insert(5);s.insert(15);s.insert(7);s.insert(1);s.insert(5);s.insert(7);PrintSet(s);set<int>::iterator it = s.begin();while (it != s.end()){//*it += 5;cout << *it << " ";++it;}cout << endl;for (auto e : s){cout << e << " ";}cout << endl;set<int> copy = s;for (auto e : copy){cout << e << " ";}cout << endl;//cout << copy._t.IsBalance() << endl;}
}

map的代码

#pragma oncenamespace qq
{template<class K, class V>class map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;typedef typename RBTree<K, const K, MapKeyOfT>::ConstIterator const_iterator;const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}iterator begin(){return _t.Begin();}iterator end(){return _t.End();}iterator find(const K& key){return _t.Find(key);}pair<iterator, bool> insert(const pair<K, V>& kv){return _t.Insert(kv);}V& operator[](const K& key){pair<iterator, bool> ret = _t.Insert(make_pair(key, V()));return ret.first->second;}private:RBTree<K, pair<const K, V>, MapKeyOfT> _t;};void test_map1(){map<string, int> m;m.insert({ "aa",1 });m.insert({ "basd",2 });m.insert({ "asdac",4 });m.insert({ "dsd",3 });map<string, int>::iterator it = m.begin();while (it != m.end()){//it->first += 'x';//it->second += 1;//cout << it.operator->()->first << ":" << it->second << endl;cout << it->first << ":" << it->second << endl;++it;}cout << endl;}void test_map2(){string arr[] = { "asd","qwe","sdf","cvb" };map<string, int> countMap;for (auto& e : arr){countMap[e]++;}for (auto& kv : countMap){cout << kv.first << ":" << kv.second << endl;}cout << endl;}
}

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

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

相关文章

算法板子：Trie树——存储字符串、查找字符串的出现次数

算法板子：Trie树——存储字符串、查找字符串的出现次数

#include <iostream> using namespace std;const int N 1e6 10;// Trie树是一个集合&#xff0c;可以存储字符串 // son二维数组中&#xff0c;每行代表一个节点&#xff0c;该行的每列都是它的儿子&#xff0c;最多26列代表一个节点最多26个儿子(题目中说了都是小写字…
阅读更多...
photoshop学习笔记——选区3

photoshop学习笔记——选区3

从窗口面板可以打开历史记录面板&#xff0c;历史记录面板保存了所有的操作 可以点击历史记录中某一条&#xff0c;回到当时的操作状态&#xff0c;也可以通过编辑中的 还原、重做、切换到最终状态逐步调整或直接跳到最终状态 回退之后&#xff0c;如果有新的操作&#xff0c;历…
阅读更多...
WordPress文章标题定制化前缀插件

WordPress文章标题定制化前缀插件

引言 在当今互联网的海洋中&#xff0c;吸引读者眼球的第一步往往始于文章标题的设计。对于WordPress博主而言&#xff0c;如何让每篇文章的标题更加个性化和吸引人&#xff0c;成为了一项重要的任务。传统的自定义CSS方法虽然可行&#xff0c;但其繁琐的操作和有限的美学效果…
阅读更多...
【高校科研前沿】浙江农林大学童再康教授等人在农林科学顶刊《CATENA》发文：长期覆盖作物可促进多养分循环和地下土壤碳封存

【高校科研前沿】浙江农林大学童再康教授等人在农林科学顶刊《CATENA》发文：长期覆盖作物可促进多养分循环和地下土壤碳封存

文章简介 论文名称&#xff1a;Long-term cover crops boost multi-nutrient cycling and subsurface soil carbon sequestration by alleviating microbial carbon limitation in a subtropical forest&#xff08;长期覆盖作物通过缓解亚热带森林中微生物的碳限制&#xff0c…
阅读更多...
常见的jmeter面试题及答案

常见的jmeter面试题及答案

1、解释什么是JMeter? JMeter是一款Java开源工具&#xff0c; 用于性能负载测试。它旨在分析和衡量Web应用程序和各种服务的性能和负载功能行为。 2、说明JMeter的工作原理? JMeter就像一群将请求发送到目标服务器的用户-样。它收集来自目标服务器的响应以及其他统计数据&…
阅读更多...
每日OJ_牛客_HJ91 走方格的方案数

每日OJ_牛客_HJ91 走方格的方案数

目录 牛客HJ91 走方格的方案数 解析代码 牛客HJ91 走方格的方案数 走方格的方案数_牛客题霸_牛客网 解析代码 本题为求取路径总数的题目&#xff0c;一般可以通过递归求解&#xff0c;对于复杂的问题&#xff0c;可以通过动态规划求解。此题比较简单&#xff0c;也可以通过递…
阅读更多...
Vue2和Vue3实战代码中的小差异（实时更新）

Vue2和Vue3实战代码中的小差异（实时更新）

目录 前言1. 未使用自闭合标签2. 事件名连字符3. 换行符4. 弃用.sync 前言 以下文章实时更新&#xff0c;主打记录差异 1. 未使用自闭合标签 104:7 error Require self-closing on Vue.js custom components (<el-table-column>) vue/html-self-closing✖ 1 problem…
阅读更多...
Logback 快速入门

Logback 快速入门

一、简介 Java 开源日志框架&#xff0c;以继承改善 log4j 为目的而生&#xff0c;是 log4j 创始人 Ceki Glc 的开源产品。 它声称有极佳的性能&#xff0c;占用空间更小&#xff0c;且提供其他日志系统缺失但很有用的特性。 其一大特色是&#xff0c;在 logback-classic 中本…
阅读更多...
大模型算法备案流程最详细说明【流程+附件】

大模型算法备案流程最详细说明【流程+附件】

文章目录 一、语料安全评估 二、黑盒测试 三、模型安全措施评估 四、性能评估 五、性能评估 六、安全性评估 七、可解释性评估 八、法律和合规性评估 九、应急管理措施 十、材料准备 十一、【线下流程】大模型备案线下详细步骤说明 十二、【线上流程】算法备案填报…
阅读更多...
QT vs2019编译报错LNK2019无法解析的外部符号

QT vs2019编译报错LNK2019无法解析的外部符号

严重性 代码 说明 项目 文件 行 禁止显示状态 错误 LNK2019 无法解析的外部符号 "public: __cdecl Dialog_Setting::Dialog_Setting(class QWidget *)" (??0Dialog_SettingQEAAPEAVQWidgetZ)&#xff0c;函数 "public: __cdecl QtWid…
阅读更多...
工业现场实测，焦化厂导烟车与装煤车风机实现无人作业

工业现场实测，焦化厂导烟车与装煤车风机实现无人作业

一、项目背景 作为我国重要的能源行业之一&#xff0c;焦化行业在国民经济中扮演着重要角色&#xff0c;焦化工艺是高温、高压、有毒物质等因素共同作用下进行的&#xff0c;因此存在着安全隐患&#xff0c;并伴有环境污染&#xff0c;改善焦化工艺的安全和环保问题是当前亟待…
阅读更多...
Golang | Leetcode Golang题解之第287题寻找重复数

Golang | Leetcode Golang题解之第287题寻找重复数

题目&#xff1a; 题解&#xff1a; func findDuplicate(nums []int) int {slow, fast : 0, 0for slow, fast nums[slow], nums[nums[fast]]; slow ! fast; slow, fast nums[slow], nums[nums[fast]] { }slow 0for slow ! fast {slow nums[slow]fast nums[fast]}return s…
阅读更多...
分布式搜索引擎ES-DSL搜索详解

分布式搜索引擎ES-DSL搜索详解

1.DSL搜索-入门语法 建立索引&#xff1a; xxx(自定义名称) 自定义mapping: POST /shop/_mapping {"properties": {"id": {"type": "long"},"age": {"type": "integer"},"username": {&quo…
阅读更多...
Springboot 多数据源事务

Springboot 多数据源事务

起因 在一个service方法上使用的事务,其中有方法是调用的多数据源orderDB 但是多数据源没有生效,而是使用的primaryDB 原因 spring 事务实现的方式 以 Transactional 注解为例 (也可以看 TransactionTemplate&#xff0c; 这个流程更简单一点)。 入口&#xff1a;ProxyTransa…
阅读更多...
Java语言程序设计——篇九（1）

Java语言程序设计——篇九（1）

&#x1f33f;&#x1f33f;&#x1f33f;跟随博主脚步&#xff0c;从这里开始→博主主页&#x1f33f;&#x1f33f;&#x1f33f; 内部类 概述内部类—内部类的分类成员内部类实战演练 局部内部类实战演练 匿名内部类实战演练 静态内部类实战演练 概述 内部类或嵌套类&#…
阅读更多...
sheng的学习笔记-AI-公式-指数加权移动平均（EWMA）

sheng的学习笔记-AI-公式-指数加权移动平均（EWMA）

AI目录&#xff1a;sheng的学习笔记-AI目录-CSDN博客 基础知识 指数加权移动平均&#xff08;Exponential Weighted Moving Average&#xff09;&#xff0c;是一种常用的序列处理方式 看例子&#xff0c;首先这是一年365天的温度散点图&#xff0c;以天数为横坐标&#xff0…
阅读更多...
【学一点儿前端】本地或jenkins打包报错：getaddrinfo ENOTFOUND registry.nlark.com.

【学一点儿前端】本地或jenkins打包报错：getaddrinfo ENOTFOUND registry.nlark.com.

问题 今天jenkins打包一个项目&#xff0c;发现报错了 error An unexpected error occurred: "https://registry.nlark.com/xxxxxxxxxx.tgz: getaddrinfo ENOTFOUND registry.nlark.com". 先写解决方案 把yarn.lock文件里面的registry.nlark.com替换为registry.npmmi…
阅读更多...
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第五十八章 中断下文之tasklet

【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第三篇 嵌入式Linux驱动开发篇-第五十八章 中断下文之tasklet

i.MX8MM处理器采用了先进的14LPCFinFET工艺&#xff0c;提供更快的速度和更高的电源效率;四核Cortex-A53&#xff0c;单核Cortex-M4&#xff0c;多达五个内核 &#xff0c;主频高达1.8GHz&#xff0c;2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT…
阅读更多...
全球性“微软蓝屏”事件及其对网络安全和系统稳定性的深远影响

全球性“微软蓝屏”事件及其对网络安全和系统稳定性的深远影响

近日&#xff0c;一次由微软视窗系统软件更新引发的全球性“微软蓝屏”事件&#xff0c;不仅成为科技领域的热点新闻&#xff0c;更是一次对全球IT基础设施韧性与安全性的深刻检验。这次事件源于美国电脑安全技术公司“众击”提供的一个带有“缺陷”的软件更新&#xff0c;它如…
阅读更多...
女人内裤怎么洗才是最干净？内衣裤洗衣机怎么样？哪个牌子更好？

女人内裤怎么洗才是最干净？内衣裤洗衣机怎么样？哪个牌子更好？

最近刚好用到一款比较好用的洗内衣裤洗衣机&#xff01;如果你也和我一样有洗内衣裤烦恼的&#xff0c;或者可以看看&#xff01; 内衣裤作为贴身穿的衣服&#xff0c;我是不会把它和外衣一起清洗的&#xff0c;而家里面的大洗衣机已经担起了清洗外衣的工作&#xff01; 朋友们…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023