【高阶数据结构】 B树 -- 详解

news2024/11/18 0:41:12

一、常见的搜索结构

适合做内查找：

以上结构适合用于数据量相对不是很大，能够一次性存放在内存中，进行数据查找的场景。如果数据量很大，比如有 100G 数据，无法一次放进内存中，那就只能放在磁盘上了。

如果放在磁盘上，有需要搜索某些数据，那么如果处理呢？

那么我们可以考虑将存放关键字及其映射的数据的地址放到一个内存中的搜索树的节点中，那么要访问数据时，先取这个地址去磁盘访问数据。

适合做外查找：B树系列

1、使用平衡二叉树搜索树的缺陷

平衡二叉树搜索树的高度是 logN，这个查找次数在内存中是很快的。但是当数据都在磁盘中时，访问磁盘速度很慢，在数据量很大时，logN 次的磁盘访问是一个难以接受的结果。

2、使用哈希表的缺陷

哈希表的效率很高是 O(1)，但是一些极端场景下某个位置冲突很多，导致访问次数剧增，也是难以接受的。
那如何加速对数据的访问呢？
  1. 提高 IO 的速度（SSD 相比传统机械硬盘快了不少，但是还是没有得到本质性的提升）。
  2. 降低树的高度 —— 多叉树平衡树。

在平衡搜索树的基础上找优化空间：

  1. 压缩高度，二叉变多叉。
  2. 一个节点里面有多个关键字及映射的值。 

二、B树 的概念

1970 年，R.Bayer 和 E.mccreight 提出了一种适合外查找的树，它是一种平衡的多叉树，称为 B树（后面有一个 B 的改进版本 B+树，有些地方的 B树写的是 B-树）

注意 ：不要误读成 “B减树”。

一棵 m 阶（m>2）的 B树，是一棵平衡的 M 路平衡搜索树，可以是空树或者满足以下性质：

  1. 根节点至少有两个孩子。
  2. 每个分支节点都包含 k-1 个关键字和 k 个孩子，其中 ceil(m/2) ≤ k ≤ m（ceil 是向上取整函数）。
  3. 每个叶子节点都包含 k-1 个关键字，其中 ceil(m/2) ≤ k ≤ m。
  4. 所有的叶子节点都在同一层。
  5. 每个节点中的关键字从小到大排列，节点当中 k-1 个元素正好是 k 个孩子包含的元素的值域划分。
  6.  每个结点的结构为 (n, A0, K1, A1, K2, A2, …, Kn, An )。其中，Ki (1≤i≤n) 为关键字，且 Ki<Ki+1 (1≤i≤n-1)。Ai (0≤i≤n) 为指向子树根结点的指针，且 Ai 所指子树所有结点中的关键字均小于 Ki+1。n 为结点中关键字的个数，满足 ceil(m/2)-1≤n≤m-1。

三、B-树 的插入分析

为了简单起见，假设 M=3，即三叉树。每个节点中存储两个数据，两个数据可以将区间分割成三个部分，因此节点应该有三个孩子，为了后续实现简单期间，节点的结构如下：

注意：孩子永远比数据多一个。

用序列 {53, 139, 75, 49, 145, 36, 101} 构建 B树的过程如下：

天然平衡，向右和向上生长，根节点分裂，增加一层。

新插入的节点一定是在叶子节点插入，叶子节点没有孩子，不影响关键字和孩子的关系。

叶子节点满了，分裂出一个兄弟，提取中位数，向父亲插入一个值和一个孩子。

插入过程总结：

  1. 如果树为空，直接插入新节点中，该节点为树的根节点。
  2. 树非空，找待插入元素在树中的插入位置（注意：找到的插入节点位置一定在叶子节点中）。
  3. 检测是否找到插入位置（假设树中的 key 唯一，即该元素已经存在时则不插入）。
  4. 按照插入排序的思想将该元素插入到找到的节点中。
  5. 检测该节点是否满足 B-树的性质：即该节点中的元素个数是否等于 M，如果小于则满足。
  6. 如果插入后节点不满足 B树的性质，需要对该节点进行分裂：申请新节点，找到该节点的中间位置，将该节点中间位置右侧的元素以及其孩子搬移到新节点中，将中间位置元素以及新节点往该节点的双亲节点中插入，即继续 4。
  7. 如果向上已经分裂到根节点的位置，插入结束。

四、B-树 的插入实现

1、B-树 的节点设计 

// M叉树：即一个节点最多有M个孩子，M-1个数据域
template<class K, size_t M>
struct BTreeNode
{
	//K _keys[M - 1];
	//BTreeNode<K, M>* _subs[M];

	// 为了方便插入以后再分裂，多给一个空间
	K _keys[M]; // 存放元素
	BTreeNode<K, M>* _subs[M+1]; // 存放孩子节点，注意：孩子比数据多一个
	BTreeNode<K, M>* _parent;
	size_t _n; // 记录实际存储多个关键字 

	BTreeNode()
	{
		for (size_t i = 0; i < M; ++i)
		{
			_keys[i] = K();
			_subs[i] = nullptr;
		}
		_subs[M] = nullptr;
		_parent = nullptr;
		_n = 0;
	}
};

2、插入 key 的过程

按照插入排序的思想插入 key。

void InsertKey(Node* node, const K& key, Node* child)
{
	// 按照插入排序思想插入key
	int end = node->_n - 1;
	while (end >= 0)
	{
		if (key < node->_keys[end])
		{
			// 将key和他的右孩子往右搬移一个位置
			node->_keys[end + 1] = node->_keys[end];
			node->_subs[end + 2] = node->_subs[end + 1];
 			end--;
		}
		else
			break;
	}
	// 插入key以及新分裂出的节点
	node->_keys[end + 1] = key;
	node->_subs[end + 2] = child;

	// 更新节点的双亲
	if (child)
		child->_parent = node;
	node->_n++;
}

注意：在插入 key 的同时，可能还要插入新分裂出来的节点。

3、B-树 的插入实现 

bool Insert(const K& key)
{
	// 如果树为空，直接插入
	if (_root == nullptr)
	{
		_root = new Node;
		_root->_keys[0] = key;
		_root->_n++;
		return true;
	}

	// key已经存在，不插入
	pair<Node*, int> ret = Find(key);
	if (ret.second >= 0)
	{
		return false;
	}

	// 如果没有找到，find顺便带回了要插入的那个叶子节点
	// 循环每次往cur插入newkey和child
	Node* parent = ret.first;
	K newKey = key;
	Node* child = nullptr;
	while (1)
	{
		// 将key插入到parent所指向的节点中
		InsertKey(parent, newKey, child);
		// 满了就要分裂；没有满，插入就结束
		if (parent->_n < M)
		{
			return true;
		}
		else
		{
			size_t mid = M / 2;
			// 分裂一半[mid+1, M-1]给兄弟
			Node* brother = new Node;
			// 将中间位置右侧的元素以及孩子搬移到新节点中
			size_t j = 0;
			size_t i = mid + 1;
			for (; i <= M - 1; i++)
			{
				// 分裂拷贝key和key的左孩子
				brother->_keys[j] = parent->_keys[i];
				brother->_subs[j] = parent->_subs[i];
				// 跟新孩子节点的双亲
				if (parent->_subs[i])
				{
					parent->_subs[i]->_parent = brother;
				}
				j++;

				// 拷走重置一下方便观察
				parent->_keys[i] = K();
				parent->_subs[i] = nullptr;
			}

			// 注意：还有最后一个右孩子拷给(孩子比关键字多搬移一个)
			brother->_subs[j] = parent->_subs[i];
		    if (parent->_subs[i])
			{
				parent->_subs[i]->_parent = brother;
			}
			parent->_subs[i] = nullptr;

			brother->_n = j;
			// 更新parent节点的剩余数据个数
			parent->_n -= (brother->_n + 1);

			K midKey = parent->_keys[mid];
			parent->_keys[mid] = K();

			// 如果刚刚分裂是根节点，需要重新申请一个新的根节点，
			// 将中间位置数据以及分裂出的新节点，插入到新的根节点中，插入结束
			if (parent->_parent == nullptr)
			{
				_root = new Node;
				_root->_keys[0] = midKey;
				_root->_subs[0] = parent;
				_root->_subs[1] = brother;
				_root->_n = 1;
				parent->_parent = _root;
				brother->_parent = _root;
				break;
			}
			else // 如果分裂的节点不是根节点，将中间位置数据以及新分裂出的节点继续向parent的双亲中进行插入
			{
				// 转换成往parent->parent去插入parent->[mid]和brother
				newKey = midKey;
				child = brother;
				parent = parent->_parent;
			}
		}
	}
	return true;
}

4、B-树 的简单验证

对 B树 进行中序遍历，如果能得到一个有序的序列，说明插入正确。 
void _InOrder(Node* cur)
{
	if (cur == nullptr)
		return;
	// 左 根  左 根  ...  右
	size_t i = 0;
	for ( ; i < cur->_n; ++i)
	{
		_InOrder(cur->_subs[i]); // 左子树
		cout << cur->_keys[i] << " "; // 根
	}
	_InOrder(cur->_subs[i]); // 最后的那个右子树
}

5、B-树 的性能分析

对于一棵节点为 N 度为 M 的 B-树，查找和插入需要$log{M-1}N$~$log{M/2}N$次比较，这个很好证明：对于度为 M 的 B-树，每一个节点的子节点个数为 M/2 ~(M-1) 之间，因此树的高度应该在要 log(M-1)N 和 log(M/2)N 之间，在定位到该节点后，再采用二分查找的方式可以很快的定位
到该元素。
B-树 的效率是很高的，对于 N = 62*1000000000 个节点，如果度 M 为 1024，则 log(M/2)N <=
4，即在 620 亿个元素中，如果这棵树的度为 1024，则需要小于 4 次即可定位到该节点，然后利用 二分查找可以快速定位到该元素，大大减少了读取磁盘的次数。

五、B+树 & B*树

1、B+树

B+树 是 B树 的变形，是在 B树 基础上优化的多路平衡搜索树，B+树 的规则跟 B树 基本类似，但是又在 B树 的基础上做了以下几点改进优化：

  1. 分支节点的子树指针与关键字个数相同。
  2. 分支节点的子树指针 p[i] 指向关键字值大小在 [k[i]，k[i+1]) 区间之间。
  3. 所有叶子节点增加一个链接指针链接在一起。
  4. 所有关键字及其映射数据都在叶子节点出现。

分支节点跟叶子节点有重复的值，分支节点村的是叶子节点的索引。

父亲中存的是孩子节点中的最小值做索引。

分支节点可以只存储 key，那么分支节点比较小，分支节点映射的磁盘数据块就可以尽快加载到 Cache。

叶子节点存 key/value。

（1）B+树 的特性

  1. 所有关键字都出现在叶子节点的链表中，且链表中的节点都是有序的。
  2. 不可能在分支节点中命中。
  3. 分支节点相当于是叶子节点的索引，叶子节点才是存储数据的数据层。

B+树 的插入过程跟 B树 基本是类似的，细节区别在于：第一次插入两层节点，一层做分支，一层做根。

后面一样往叶子节点去插入，插入满了以后，分裂一半给兄弟，转换成往父亲插入一个 key 和一个孩子，孩子就是兄弟，key 是兄弟的第一个最小值得 key。

（2）总结

  1. 简化 B树 孩子比关键字多一个的规则，变成相等。
  2. 所有值都在叶子上，方便遍历查找所有值。

2、B*树

B*树 是 B+树 的变形，在 B+树 的非根和非叶子节点再增加指向兄弟节点的指针。

（1）B+树的分裂

当一个结点满时，分配一个新的结点，并将原结点中 1/2 的数据复制到新结点，最后在父结点中增加加新结点的指针。B+树 的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针。

（2）B*树的分裂

当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）。如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制 1/3 的数据到新结点，最后在父结点增加新结点的指针。

所以，B*树 分配新结点的概率比 B+树 要低，空间使用率更高。

3、总结

  • B树：有序数组 + 平衡多叉树。
  • B+树：有序数组链表 + 平衡多叉树。
  • B*树：一棵更丰满的，空间利用率更高的 B+树。

六、B-树 的应用

1、索引

B-树 最常见的应用就是用来做索引。索引通俗的说就是为了方便用户快速找到所寻之物，比如：书籍目录可以让读者快速找到相关信息，hao123 网页导航网站，为了让用户能够快速的找到有价值的分类网站，本质上就是互联网页面中的索引结构。

MySQL 官方对索引的定义为：索引（index）是帮助 MySQL 高效获取数据的数据结构，简单来说：索引就是数据结构。

当数据量很大时，为了能够方便管理数据，提高数据查询的效率，一般都会选择将数据保存到数据库。因此数据库不仅仅是帮助用户管理数据，而且数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用数据，这样就可以在这些数据结构上实现高级查找算法，该数据结构就是索引。

B+树 做主键索引相比 B树 的优势：

  1. B+树 所有的值都在其叶子节点上，遍历方便，方便区间查找。
  2. 对于没有建立索引的字段，全表扫描的遍历很方便。
  3. 分支节点只存储 key，一个分支节点的空间占用更小，可以尽可能加载到缓存中。

B树 的优势：不需要遍历到叶子节点就能找到值，而 B+树 一定要遍历到叶子节点。但是 B+树 的高度足够低，所以二者差别并不大。

2、MySQL 索引简介

mysql 是目前非常流行的开源关系型数据库，不仅是免费的，可靠性高，速度也比较快，而且拥有灵活的插件式存储引擎，如下：

MySQL 中索引属于存储引擎级别的概念，不同存储引擎对索引的实现方式是不同的。

注意 ：索引是基于表的，而不是基于数据库的。

（1）MyISAM

MyISAM 引擎是 MySQL 5.5.8 版本之前默认的存储引擎，不支持事务，支持全文检索，使用 B+Tree 作为索引结构，叶节点的 data 域存放的是数据记录的地址（方便索引树和主键树映射同样的数据），其结构如下：

建表的主键就是 B+树 的 key，B+树 的 value 事存储一行数据的磁盘地址。

分支节点也需要存到磁盘中，因为数据量大的话，内存是存不下的。分支节点中应该是一个磁盘地址，但是分支节点理论应该尽量被缓存到 Cache。

上图是以 Col1 为主键，MyISAM 的示意图，可以看出 MyISAM 的索引文件仅仅保存数据记录的地址。在 MyISAM 中，主索引和辅助索引（Secondary key）在结构上没有任何区别，只是主索引要求 key 是唯一的，而辅助索引的 key 可以重复。如果想在 Col2 上建立一个辅助索引，则此索引的结构如下图所示：

同样也是一棵 B+Tree，data 域保存数据记录的地址。因此，MyISAM 中索引检索的算法为首先按照 B+Tree 搜索算法搜索索引，如果指定的 Key 存在，则取出其 data 域的值，然后以 data 域的值为地址，读取相应数据记录。MyISAM 的索引方式也叫做 “非聚集索引” 的。

（2）InnoDB

InnoDB 存储引擎支持事务，其设计目标主要面向在线事务处理的应用，从 MySQL 5.5.8 版本开始，InnoDB 存储引擎是默认的存储引擎。InnoDB 支持 B+树 索引、全文索引、哈希索引。但 InnoDB 使用 B+Tree 作为索引结构时，具体实现方式却与 MyISAM 截然不同。

第一个区别是 InnoDB 的数据文件本身就是索引文件。MyISAM 索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。而 InnoDB 索引，表数据文件本身就是按 B+Tree 组织的一个索引结构，这棵树的叶节点 data 域保存了完整的数据记录。这个索引的 key 是数据表的主键，因此  InnoDB 表数据文件本身就是主索引。

上图是 InnoDB 主索引（同时也是数据文件）的示意图，可以看到叶节点包含了完整的数据记录，这种索引叫做聚集索引。因为 InnoDB 的数据文件本身要按主键聚集，所以 InnoDB 要求表必须有主键（MyISAM 可以没有），如果没有显式指定，则 MySQL 系统会自动选择一个可以唯一标识数据记录的列作为主键，如果不存在这种列，则 MySQL 自动为 InnoDB 表生成一个隐含字段作为主键，这个字段长度为 6 个字节，类型为长整型。

InnoDB 建立索引时，索引树的叶子节点和主键树的叶子节点中的数据不一样，没有办法进行直接映射。

第二个区别是 InnoDB 的辅助索引 data 域存储相应记录主键的值而不是地址，所有辅助索引都引用主键作为 data 域。

聚集索引这种实现方式使得按主键的搜索十分高效，但是辅助索引搜索需要检索两遍索引：首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录。

参考资料：【高阶数据结构】MySQL 索引背后的数据结构及算法原理-CSDN博客

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

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

相关文章

【C++】数据结构：哈希桶

【C++】数据结构：哈希桶

哈希桶&#xff08;Hash Bucket&#xff09;是哈希表&#xff08;Hash Table&#xff09;实现中的一种数据结构&#xff0c;用于解决哈希冲突问题。哈希表是一种非常高效的数据结构&#xff0c;它通过一个特定的函数&#xff08;哈希函数&#xff09;将输入数据&#xff08;通常…
阅读更多...
aws eks中cwagent收集性能日志的理解

aws eks中cwagent收集性能日志的理解

参考资料 CloudWatch代理配置参考Prometheus的CloudWatch代理配置 本文旨在明确以下几个问题 eks的container insight addon包括哪些组件&#xff1f;分别起什么作用&#xff1f;eks的cwagent的指标获取具体包括那些部分&#xff1f;数据源是什么&#xff1f;eks的cwagent如…
阅读更多...
【NumPy】全面解析NumPy的where函数：高效条件操作指南

【NumPy】全面解析NumPy的where函数：高效条件操作指南

&#x1f9d1; 博主简介&#xff1a;阿里巴巴嵌入式技术专家&#xff0c;深耕嵌入式人工智能领域&#xff0c;具备多年的嵌入式硬件产品研发管理经验。 &#x1f4d2; 博客介绍&#xff1a;分享嵌入式开发领域的相关知识、经验、思考和感悟&#xff0c;欢迎关注。提供嵌入式方向…
阅读更多...
5-26作业

5-26作业

网络聊天室 服务器&#xff1a; 1 #include <myhead.h>2 int main(int argc, const char *argv[])3 {4 if(argc!3)5 {6 printf("请输入IP和端口号\n");7 return -1;8 }9 int sfd socket(AF_INET, SOCK_DGRAM, 0);10 if(…
阅读更多...
汇编：循环结构

汇编：循环结构

16位汇编语言中的循环结构主要通过条件跳转指令&#xff08;如LOOP、JMP, JE, JNE, JG, JL, 等&#xff09;来实现&#xff0c;常见的循环类型包括for循环和while循环&#xff1b; Loop指令 LOOP指令的操作非常简单&#xff1a;它将CX寄存器的值减1&#xff0c;如果结果不为零…
阅读更多...
代码随想录算法训练营day21|530.二叉搜索树的最小绝对值差、501.二叉搜索树中的众数、236.二叉树的最近公共祖先

代码随想录算法训练营day21|530.二叉搜索树的最小绝对值差、501.二叉搜索树中的众数、236.二叉树的最近公共祖先

二叉搜索树的最小绝对值差 递归法 首先需考虑这是一个二叉搜索树&#xff0c;在中序遍历后的结果为从小到大的一个序列&#xff0c;寻找二叉搜索树的最小绝对值差&#xff0c;只需比较一个节点与之后的差值即可。在遍历的过程中&#xff0c;我们需要一个节点保存前节点…
阅读更多...
[Android]将私钥（.pk8）和公钥证书（.pem/.crt）合并成一个PKCS#12格式的密钥库文件

[Android]将私钥（.pk8）和公钥证书（.pem/.crt）合并成一个PKCS#12格式的密钥库文件

如下&#xff0c;我们有一个platform.pk8和platform.x509.pem。为了打包&#xff0c;需要将私钥&#xff08;.pk8&#xff09;和公钥证书&#xff08;可能是.pem或.crt文件&#xff09;合并成一个PKCS#12 格式的密钥库文件 1.准备你的私钥和证书文件 确保你有以下两个文件&…
阅读更多...
【论文阅读】xLSTM: Extended Long Short-Term Memory

【论文阅读】xLSTM: Extended Long Short-Term Memory

xLSTM: Extended Long Short-Term Memory 引用&#xff1a; Beck M, Pppel K, Spanring M, et al. xLSTM: Extended Long Short-Term Memory[J]. arXiv preprint arXiv:2405.04517, 2024. 论文链接&#xff1a; [2405.04517] xLSTM: Extended Long Short-Term Memory (arxiv.…
阅读更多...
Nocobase快速上手 -第一个collection

Nocobase快速上手 -第一个collection

本文记录Nocobase中如何创建collection&#xff0c;以及如何将collection展示到页面中&#xff0c;并且配置CRUD相应的操作. Collection 在NocoBase中&#xff0c;collection&#xff08;集合&#xff09;是用来组织和存储各种数据的容器&#xff0c;如订单、产品、用户、评论…
阅读更多...
VMware中的虚拟机设置开启VT虚拟化

VMware中的虚拟机设置开启VT虚拟化

虚拟机系统关机打开虚拟机设置-----点击处理器----勾选虚拟化引擎---确定即可
阅读更多...
【UML】-01-UML基本元素的介绍

【UML】-01-UML基本元素的介绍

1、UML的词汇表 &#xff08;1&#xff09;事物&#xff1b; &#xff08;2&#xff09;关系&#xff1b; &#xff08;3&#xff09;图。 事物是对模型中首要成分的抽象&#xff1b;关系把事物结合在一起&#xff1b;图聚集了相关的事物。 注&#xff1a;事物也称为元素 2…
阅读更多...
Springboot项目——网页版本五子棋

Springboot项目——网页版本五子棋

网页五子棋&#xff1a;本项目简单实现了网页版本的五子棋对战功能&#xff0c;同时会根据用户的天梯分数来匹配&#xff0c;可供多位用户同时提供对战功能。大致可分为三个模块&#xff0c;用户模块&#xff0c;匹配模块&#xff0c;对战模块&#xff0c;下面重点介绍以下三个…
阅读更多...
交叉熵损失函数计算过程(tensorflow)

交叉熵损失函数计算过程(tensorflow)

交叉熵损失函数通常用于多类分类损失函数计算。计算公式如下&#xff1a; P为真实值&#xff0c;Q为预测值。 使用tensorflow计算 import tensorflow as tf import keras# 创建一个示例数据集 # 假设有3个样本&#xff0c;每个样本有4个特征&#xff0c;共2个类别 # 目标标签…
阅读更多...
简爱的思维导图怎么做？从这三个角度

简爱的思维导图怎么做？从这三个角度

简爱的思维导图怎么做&#xff1f;《简爱》作为夏洛蒂勃朗特的代表作&#xff0c;不仅是一部经典的爱情小说&#xff0c;也是探索女性独立与自我成长的文学巨著。为了深入理解这部作品&#xff0c;制作思维导图是一种高效的学习和分析工具。以下是三种不同的角度来创建《简爱》…
阅读更多...
excel数据丢失怎么办？表格文件恢复的3个方法

excel数据丢失怎么办？表格文件恢复的3个方法

Excel作为一个常用的表格文件&#xff0c;我们在工作中经常都需要用到它。最令人崩溃的事就是有时候我们辛辛苦苦用Excel完成了工作&#xff0c;但是突然发现Excel数据丢失。这可怎么办呢&#xff1f;如何找回丢失的Excel数据&#xff1f;下面小编就分享几种恢复办法。 方法一&…
阅读更多...
抖音 v27.8.0 内置增强模块，自动播放、无水印下载（可登录，助手增强版）

抖音 v27.8.0 内置增强模块，自动播放、无水印下载（可登录，助手增强版）

介绍 抖音应用作为全球领先的短视频平台&#xff0c;其内置功能允许用户将喜欢的内容保存至本地设备&#xff0c;但默认情况下&#xff0c;这些视频会带有抖音的水印。为了解决这一限制&#xff0c;该版本使用户能够直接保存不带水印的视频到手机中&#xff0c;无需使用任何第…
阅读更多...
TikTok电商带货特训营，跟随时代潮流，跨境掘金（8节课）

TikTok电商带货特训营，跟随时代潮流，跨境掘金（8节课）

课程内容&#xff1a; 1-先导课 2-一、店铺运营认知与思路 3-二、店铺风控注意事项 4-三、美区Tiktok前期工作-1店铺入驻模式 5-三、美区Tiktok前期工作-2指纹浏览器介绍 6-三、美区Tiktok前期工作-4绑定电话号码 7-三、美区Tiktok前期工作-5添加仓库地址 8-三、美区Ti…
阅读更多...
央视网视频下载和花屏问题处理

央视网视频下载和花屏问题处理

央视网(www.cctv.com)视频下载往往是花屏的&#xff0c;如何处理呢&#xff1f; 如果您是IT技术开发者&#xff0c;那么您可以通过下面步骤自己实现。 用chrome浏览器&#xff0c;F2打开开发者工具&#xff0c;找到当前页面的network 然后找一个接口&#xff1a;https://vdn.a…
阅读更多...
JRebel 激活及使用

JRebel 激活及使用

插件下载 JRebel and XRebel - IntelliJ IDEs Plugin | Marketplace 从磁盘安装下载的插件 windows下载激活服务 Releases ilanyu/ReverseProxy GitHub mac没有对应版本&#xff0c;需要Docker搭建本地激活服务 docker pull qierkang/golang-reverseproxy docker run -d -…
阅读更多...
（2024，RWKV-5/6，RNN，矩阵值注意力状态，数据依赖线性插值，LoRA，多语言分词器）Eagle 和 Finch

（2024，RWKV-5/6，RNN，矩阵值注意力状态，数据依赖线性插值，LoRA，多语言分词器）Eagle 和 Finch

Eagle and Finch: RWKV withMatrix-Valued States and Dynamic Recurrence 公众号&#xff1a;EDPJ&#xff08;进 Q 交流群&#xff1a;922230617 或加 VX&#xff1a;CV_EDPJ 进 V 交流群&#xff09; 目录 0. 摘要 3. Eagle/Finch 架构 4. 方法 4.1 Eagle 4.1.1 Eagle…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023