红黑树封装map和set（模拟实现）

news2024/12/23 11:07:36

troop主页
临近五一放假，祝大家节日快乐，我们的学习还在路上！！
在前面一章我们已经实现出了红黑树的基本框架，现在我们要有这个底层结构去封装map和set。

一 红黑树的迭代器

但在这之前我们要先把红黑树的迭代器实现出来，因为map和set也是有迭代器的。
迭代器常用的有这么几个"-> * ++ == !="这个几个中++的实现是重点，其他的较为简单。

1.2 operator++

在这里插入图片描述

要理解++首先我们要知道++后下一个节点是谁。当然红黑树走的是中序遍历，
举两个例子，假如it现在是在13的位置上，那么++it下一个点是谁？
在这里插入图片描述

中序：左子树+根+右子树。所以当it在13的位置时说明他的左子树已经全部遍历完成了，现在就要到右子树的最左节点也就是15.
那如果it现在在15的位置时，++it呢？可以看见，15的右子树为空，那就要寻找他的父亲节点也就是17.
分析完毕，我们来总结一下。

  1. 当it指向的当前节点的右子树不为空，那就去寻找此节点右子树的最左节点。
  2. 当it指向的当前节点的右子树为空，说明这个节点的中序遍历已经结束了，要向上返回了，下一个节点就是孩子=父亲的左，这个节点。
    这里还有一些细节问题。当我们在向上返回的时候，如果cur走到了根节点，那么parent这个节点就会出现越界访问的问题，所以在写条件的时候要加上这一点。
Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}

1.3 迭代器完整代码

template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T> Self;
	Node* _node;

	T* operator->()
	{
		return &_node->_data;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	bool operator == (const Self & s)
	{
		return _node == s._node;
	}
};

二 封装

这一部分刚开始看可能会有些晕，因为我们要在三个文件中来回的更改代码。

2.1改造红黑树

因为关联式容器中存储的是<key,value>的键对值，因此我们不能单纯的写K和V。
这里的value对于map和set来说是完全不一样的。

对于set来说value就是K
对于map来说value就是pair<K,V>

那么对于模板来说set就是<K,K>
对于map就是<K,pair<K,V>>

//template<class K, class V>
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	//pair<K, V> _kv;
	T _data;
	Colour _col;

	RBTreeNode(const T data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

这里改造前的代码我搞成了注释，方便大家观察。下面有K，V的也都改成了T。

现在我们把map和set写出来，再梳理一遍
在这里插入图片描述
但此时又产生了一个新的问题，我们的比较大小怎么办？我们预期的比较大小是只有first比较也就是K比较，而seco是不参与比较的。我们先来看一看库里面的pair有没有比较。
在这里插入图片描述
库里面的pair还有second的比较这是不符合我们的预期的，那么我们要怎么做呢？
我们可以自己写一个仿函数来进行比较。写一个仿函数
1.如果是set就取出key

		struct setKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

2.如果是map取出pair里面的key

		struct mapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};

我们在红黑树的类型中加入这个仿函数，并且在每个需要用到key的位置上加入这个仿函数。

三 代码全

1 RBTree

#pragma once
#include<vector>
#include<iostream>
using namespace std;
enum Colour
{
	RED,
	BLACK
};

//template<class K, class V>
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	//pair<K, V> _kv;
	T _data;
	Colour _col;

	RBTreeNode(const T data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};
template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T> Self;
	Node* _node;

	T* operator->()
	{
		return &_node->_data;
	}
	T& operator*()
	{
		return _node->_data;
	}
	Self& operator++()
	{
		if (_node->_right && _node)//右子树不为空
		{
			Node* subLeft = _node->_left;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//右子树为空
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (cur == parent->_right && parent)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	bool operator == (const Self & s)
	{
		return _node == s._node;
	}
};
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
	
public:
	typedef RBTreeIterator<T> iterator;
	iterator begin()
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}
		return iterator(subLeft);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	
	bool Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}
		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (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 false;
			}
		}

		cur = new Node(data); // 红色的
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_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
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}


	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;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}

	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;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

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

		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (refBlackNum != blackNum)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}

			//cout << blackNum << endl;
			return true;
		}

		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (cur->_col == BLACK)
			++blackNum;

		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

	size_t Size()
	{
		return _Size(_root);
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

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

		return NULL;
	}

	//int _Height(Node* root)
	//{
	//	if (root == nullptr)
	//		return 0;

	//	int leftHeight = _Height(root->_left);
	//	int rightHeight = _Height(root->_right);

	//	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	//}

	//int Height()
	//{
	//	return _Height(_root);
	//}

	//int GetRotateSize()
	//{
	//	return rotateSize;
	//}

private:
	Node* _root;
	//int rotateSize = 0;
};

//void TestRBTree1()
//{
//	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
//	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14,16, 3, 7, 11, 9, 26, 18, 14, 15 };
//	RBTree<int, int> t;
//	for (auto e : a)
//	{
//		t.Insert(make_pair(e, e));
//
//		// 1、先看是插入谁导致出现的问题
//		// 2、打条件断点，画出插入前的树
//		// 3、单步跟踪，对比图一一分析细节原因
//		//cout << e << "->" << t.IsBalance() << endl;
//	}
//
//	t.InOrder();
//	cout << t.IsBalance() << endl;
//}

2 map

#pragma once
#include"RBTree.h"
namespace yjt
{
	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<K, V>, mapKeyOfT>::iterator iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		bool insert(const pair<K,V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<K, V>, mapKeyOfT> _t;
	};
	void test_map1()
	{
		map<int,int> m;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}

		map<int,int>::iterator it = m.begin();
		while (it != m.end())
		{
			//if(*it % 2 == 0)
			//	*it += 100;

			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}
}

3 set

#pragma once
#include"RBTree.h"
namespace yjt
{
	template<class K>
	class set
	{
		struct setKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K,K, setKeyOfT>::iterator iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		bool insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, setKeyOfT> _t;
	};
	void test_set1()
	{
		set<int> s;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			s.insert(e);
		}

		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//if(*it % 2 == 0)
			//	*it += 100;

			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
}

四 总结

这个就需要多写代码去理解，因为代码都普遍比价大一些。

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

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

相关文章

SRS WebRTC Whip 和 Whep 部署体验问题

SRS WebRTC Whip 和 Whep 部署体验问题

whip 報錯 404 webrtc推流 小窗口一闪而过&#xff0c;然后查看f12回复404的报错信息 chrome版本&#xff1a; 正在检查更新 版本 123.0.6312.123&#xff08;正式版本&#xff09; &#xff08;64 位&#xff09; centos 7.9 源码安装部署&#xff0c; 代码分支5.0 完全按…
阅读更多...
linux /openEuler/annocanda/SecretNote

linux /openEuler/annocanda/SecretNote

国产操作系统欧拉&#xff08;EulerOS&#xff09;是华为公司自主研发并推广的开源操作系统。它基于Linux内核&#xff0c;旨在为各种设备提供统一的操作系统平台&#xff0c;从而为用户提供更加流畅、安全、可靠和智能的使用体验。 linux 中安装annocanda : Anaconda3-2024.0…
阅读更多...
逆向修改app就可以游戏充值到账？

逆向修改app就可以游戏充值到账？

hello ，大家好， 现在市场仍然流行着非常多的传奇类游戏私服或者其他类型的游戏私服，随着私服越来越多（很多并不合法），越来越多的人加入了破解，逆向修改，或者代充的队伍并从中获利。这里我给大家分享一下这些做代充的常规的做法，以及大家作为游戏服务器如何避坑做强校验…
阅读更多...
《LINUX运维从入门到精通 》：运维入门者的自学用书

《LINUX运维从入门到精通 》：运维入门者的自学用书

作者简介&#xff1a;一名云计算网络运维人员、每天分享网络与运维的技术与干货。 公众号&#xff1a;网络豆云计算学堂 座右铭&#xff1a;低头赶路&#xff0c;敬事如仪 个人主页&#xff1a; 网络豆的主页​​​​​ 写在前面 《Linux运维从入门到精通》从初学者角度…
阅读更多...
NCF29A1 高端阻抗匹配

NCF29A1 高端阻抗匹配

一、前言 Class E 高端 L-Front 匹配集成了额外的滤波器&#xff0c;提供了足够的谐波衰减&#xff0c;使 NCF29A1 与天线在比基频更高的频率下具有相当大的增益。向 PA 提供的阻抗和输出电容与表 1 ZPAOUT 所示相同。 二、原理图 图 1 高端 L-Front 匹配原理图 1&#xff…
阅读更多...
【数据结构】AVL树（万字超详细 附动图）

【数据结构】AVL树（万字超详细 附动图）

一、前言 二、AVL树的性质 三、AVL树节点的定义 四、AVL树的插入 五、AVL树的平衡调整 六、AVL树的验证 6.1 验证有序 6.2 验证平衡 七、AVL树的删除 八、AVL树的性能和代码 一、前言 还没有学习过二叉搜索树的同学可以移步 【数据结构】二叉搜索树-CSDN博客https:/…
阅读更多...
Acrobat Pro DC 2021：强大的PDF编辑软件

Acrobat Pro DC 2021：强大的PDF编辑软件

Acrobat Pro DC 2021是Adobe公司推出的一款全面而强大的PDF编辑软件&#xff0c;凭借其卓越的性能和丰富的功能&#xff0c;成为了PDF编辑领域的领军者。 Acrobat Pro DC 2021中文激活版下载 这款软件具备全面的PDF编辑功能&#xff0c;包括文本编辑、图片处理、页面组织等&…
阅读更多...
Vue3引入高德地图js API 2.0

Vue3引入高德地图js API 2.0

文章目录 前言一、地图加载1.本文准备环境2.引入库3.加载地图4.加载地图控件 二、POI搜索1.什么是poi搜索2.如何使用 三、绘制点标记与信息窗体1.场景描述2.案例3.信息窗体-链接路由跳转4.进阶-通过Marker自动触发标记点&#xff08;非鼠标手动点击&#xff09; 四、jsApi地图事…
阅读更多...
指挥中心实战指挥平台-通信指挥类装备多链路聚合设备解决方案实例

指挥中心实战指挥平台-通信指挥类装备多链路聚合设备解决方案实例

一、建设目标及要求 坚持“一切为了实战、一切围绕实战、一切服务实战”的总要求&#xff0c;紧紧围绕大数据应用和自动化、智能化、智慧化这一主题主线&#xff0c;建设升级改造支队指挥中心&#xff0c;集成语音、视频、即时消息、短信、对讲、会议等多媒体通信能力&#xf…
阅读更多...
AJAX——图片上传

AJAX——图片上传

图片上传流程 1.获取图片文件对象 2.使用FormData携带图片文件 3.提交表单数据到服务器&#xff0c;使用图片url网址 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible"…
阅读更多...
埋点，自己写插件，自己写的按钮埋点，掘金同款投递简历

埋点，自己写插件，自己写的按钮埋点，掘金同款投递简历

20分钟掌握 Vite 插件开发 - 掘金 vite的生命周期啥的 1.浏览器的控制台输出有样式的字 // const randomLetterPlugin ()>{ // const letters [wwwwwww,000000000000,888888888888]; // //随机获取一个字符并打印 // const printRandomLetter ()>{ // …
阅读更多...
LCD彩屏显示方案选型攻略：从接口到GUI开发工具的全面评估

LCD彩屏显示方案选型攻略：从接口到GUI开发工具的全面评估

在现代人类社会&#xff0c;彩色显示技术是科技王国里最为绚丽夺目的技术奇葩&#xff0c;LCD彩屏通过显示实时信息并提供交互式的体验&#xff0c;将信息时代打扮得多姿多彩。无论是智能家电还是医疗健康设备领域&#xff0c;精美直观的LCD彩屏显示&#xff0c;往往能够为用户…
阅读更多...
学习JFinal

学习JFinal

1.五个配置类 configConstants&#xff08;配置&#xff09;&#xff1a; configRoute&#xff08;路由&#xff09;&#xff1a; 2.Controller层&#xff08;控制器&#xff09; 访问流程&#xff1a; Action&#xff1a; getPara&#xff1a; 参数说明&#xff1a;第一个参…
阅读更多...
monkey测试详解

monkey测试详解

一、monkey测试的定义 Monkey 测试是通过向系统发送伪随机的用户事件流（如按键输入、触摸屏输入、手势输入等），实现对应用程序客户端的稳定性测试；通俗来说，Monkey 测试即“猴子测试”，是指像猴子一样，不知道程序的任何用户交互方面的知识，就对界面进行无目的、乱点乱按…
阅读更多...
MATLAB基于图像特征的火灾检测

MATLAB基于图像特征的火灾检测

实验目标 基于图像特征的火灾检测 实验环境 Windows电脑、MATLAB R2020a 实验内容 1.读取图像&#xff0c;彩色图像的灰度化处理&#xff0c;进行边缘检测&#xff0c;实现对火焰的检测。 2.对两幅RGB图像进行火焰特征提取实验 3.对比分析边缘检测算法处理结果和基于图像…
阅读更多...
离散型制造行业智能工厂解决方案,助力国家新智产业升级

离散型制造行业智能工厂解决方案,助力国家新智产业升级

离散型制造行业智能工厂标准解决方案 离散型制造行业的智能工厂解决方案是推动国家智能制造产业升级的关键。 1. 集中优势资源&#xff1a;实施攻关计划&#xff0c;瞄准关键核心技术和重点产业进行定向突破&#xff0c;特别是在集成电路(IC)、AI、生物医药等领域。2. 国家创…
阅读更多...
华为外派伊拉克，一天补助6000元

华为外派伊拉克，一天补助6000元

大家好&#xff0c;我是YUAN哥&#xff01; 最近有朋友询问关于华为外派伊拉克的补助情况&#xff0c;听说一天能拿到6000元&#xff0c;这听起来相当诱人&#xff0c;但真实性有待考证。 据我所知&#xff0c;华为对艰苦地区的外派员工确实有补助&#xff0c;但最高一天是100美…
阅读更多...
关于pdf.js中文本坐标尺寸的使用

关于pdf.js中文本坐标尺寸的使用

一个电子教材项目中有这样一个需求&#xff1a; 用户向网站上传一个PDF书籍后&#xff0c;网站可以对PDF书籍进行解析&#xff0c;并支持用户对PDF书籍的每一页做一些操作&#xff0c;比如&#xff1a;为英语课本的单词和句子添加音频热区。因为热区数量很多&#xff0c;所以&a…
阅读更多...
C语言进阶课程学习记录- 函数与宏分析

C语言进阶课程学习记录- 函数与宏分析

C语言进阶课程学习记录- 函数与宏分析 实验-宏和函数实验-宏的副作用实验-宏的妙用小结 本文学习自狄泰软件学院 唐佐林老师的 C语言进阶课程&#xff0c;图片全部来源于课程PPT&#xff0c;仅用于个人学习记录 实验-宏和函数 #include <stdio.h>#define RESET(p, len) …
阅读更多...
详解Mixtral-8x7B背后的MoE！

详解Mixtral-8x7B背后的MoE！

高端的模型往往只需最朴素的发布方式。 这个来自欧洲的大模型团队在12月8日以一条磁力链接的方式发布了Mixtral-8x7B，这是一种具有开放权重的**「高质量稀疏专家混合模型」**(SMoE)。 该模型在大多数基准测试中都优于Llama2-70B，相比之下推理速度快了6倍，同时在大多数标准基…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023