【数据结构与算法篇】一文详解数据结构之二叉树

树的介绍及二叉树的C++实现

  • 一 . 树的概念
  • 二 . 相关术语
  • 三 . 树的表示
  • 四 . 什么是二叉树
    • 1> 二叉树的特性
    • 2> 特殊的二叉树
    • 3> 二叉树的性质
  • 五 . 二叉树的存储结构
    • 1> 二叉树的顺序存储
    • 2> 二叉树的链式存储
  • 六 . 堆
    • 1> 什么是堆
    • 2> 用堆存储数据
    • 3> 堆的Cpp代码实现
      • 1) 堆的初始化
      • 2) 堆的销毁
      • 3) 堆的遍历
      • 4) 向上(或向下)调整建大堆(或小堆)
        • 小堆中向上调整
        • 小堆中向下调整
        • 大堆中向上调整
        • 大堆中向下调整
      • 5) 堆的插入
      • 6) 堆删除
      • 7) 返回堆顶元素
      • 8) 返回堆中元素个数
      • 9) 判断堆是否为空
    • 4> 堆排序
      • 1） 排升序
      • 2) 排降序
    • 5> TOP - K问题
  • 七 . 二叉树的链式存储结构
    • 1> 链式二叉树的代码实现
      • 1) 链式二叉树的四种遍历方式
        • 前序遍历
        • 中序遍历
        • 后序遍历
        • 层序遍历
      • 2) 返回二叉树中节点的个数
        • 返回二叉树中节点的总个数
        • 返回二叉树中叶子节点的个数
        • 返回二叉树中第k层节点的总个数
      • 3) 二叉树中的查找
      • 4) 返回二叉树的高度
      • 5) 判断是否为完全二叉树
      • 6) 二叉树的销毁

一 . 树的概念

    树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一
个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，
也就是说它是根朝上，而叶朝下的。
  • 根结点: 树中的从上开始的第一个节点， 是树中的特殊节点
    • 根节点没有前驱结点
    • 有至少一个或者n个后继节点
  • 其余结点： 除根节点之外的节点 。 它们被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i
    <= m)又是一棵结构与树类似的子树。
  • 每棵子树的根结点
    • 有且只有一个前驱(所有子树的根节点)
    • 可以有0个或多个后继
  • 因此，树是递归定义的
    • 递归 : 复杂问题拆解成多个类似的小问题进行求解。
  • 注意：树形结构中，子树之间不能有交集，否则就不是树形结构

二 . 相关术语

在这里插入图片描述

  • 节点的度 :
    • 一个节点含有的子树的个数称为该节点的度
    • 如上图：A节点的度为6
  • 叶节点(又叫终端节点):
    • 度为0的节点称为叶节点
    • 如上图：B、C、H、I…等节点为叶节点
  • 子树 :
    • 根节点之下的节点所形成的树。树由多个子树构成
  • 分支节点(又叫非终端节点):
    • 度不为0的节点
    • 如上图：D、E、F、G…等节点为分支节点
  • 父节点(又叫双亲节点)：
    • 若一个节点含有子节点，则这个节点称为其子节点的父节点
    • 如上图：A是B的父节点
  • 子节点(又叫孩子节点)：
    • 一个节点含有的子树的根节点称为该节点的子节点
    • 如上图：B是A的孩子节点
  • 兄弟节点：
    • 具有相同父节点的节点互称为兄弟节点
    • 如上图：B、C是兄弟节点
  • 树的度：
    • 一棵树中，最大的节点的度称为树的度
    • 如上图：A节点的度为6，是最大的度 因此树的度为 6
  • 节点的层次：
    • 从根开始定义起，根为第1层，根的子节点为第2层，以此类推
  • 树的高度(也称深度)：
    • 树中节点的最大层次
    • 如上图：树的高度为4
  • 堂兄弟节点：
    • 双亲在同一层的节点互为堂兄弟
    • 如上图：H、I互为兄弟节点
  • 节点的祖先：
    • 从根到该节点所经分支上的所有节点
    • 如上图：A是所有节点的祖先
  • 子孙：
    • 以某节点为根的子树中任一节点都称为该节点的子孙
    • 如上图：所有节点都是A的子孙
  • 森林：
    • 由m 加粗样式(m>0) 棵互不相交的树的集合称为森林

三 . 树的表示

  • 树有很多种表示方式, 例如：
    • 双亲表示法
    • 孩子表示法
    • 孩子双亲表示法
    • 孩子兄弟表示法等
  • 孩子兄弟表示法是最常用的一种表示法， 介绍如下:
  • 树中的任意一个节点的组成
    • 值域 : 存储数据
    • 孩子节点 : 指向其第一个孩子节点
    • 兄弟节点 : 指向它的下一个兄弟节点
typedef int DataType
struct TreeNode
{
	struct TreeNode* firstChild1;   // 指向其第一个孩子节点
	struct TreeNode* nextBrother;  // 指向其下一个兄弟节点
	DataType _data;              // 节点中的数据域
}

左孩子右兄弟表示法 : 指向左边第一个孩子节点(子节点)， 指向右边第一个兄弟节点

高度为h的完全二叉树 : 前h-1层为满的， 第h层不一定满， 但是第h层一定是从左到右连续的

四 . 什么是二叉树

一棵二叉树是节点的有限集合

  • 节点可以为空， 此时为空树
  • 可以只有一个节点， 该节点被称为根节点
  • 也可以由根与子树构成(左子树和右子树， 子树可为空)

在这里插入图片描述

1> 二叉树的特性

  • 二叉树的度最大为2
  • 每个父节点所拥有子节点的个数为 1或2
  • 不存在子节点的节点是二叉树中的叶节点
  • 二叉树的子树有左右之分， 不可以颠倒。 因此二叉树也被称为有序树

对于任意的二叉树都是由以下情况复合而成的
在这里插入图片描述

2> 特殊的二叉树

  • 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
    • 在这里插入图片描述
  • 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对
    应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树
    • 在这里插入图片描述

3> 二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i-1个结点.
  2. **若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h - 1)
  3. 对任何一棵二叉树, 如果其叶结点个数为 n0 , 度为2的分支结点个数为 n1, 则有 n0＝ n1 ＋1
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log(n+1) (ps： log以2为底，n+1为对数)
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有
    • 若i>0，i位置节点的双亲序号：(i-1)/2
    • 若i=0，i为根节点编号，无双亲节点
    • 若2i+1<n，左孩子序号：2i+1; 2i+1>=n代表无左孩子
    • 若2i+2<n，右孩子序号：2i+2; 2i+2>=n代表无右孩子

五 . 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1> 二叉树的顺序存储

  • 顺序结构存储就是使用数组来存储
  • 一般使用数组只适合表示完全二叉树，因为非完全二叉树会有空间的浪费
  • 在现实中使用中 只有数据结构 - 堆(完全二叉树)才会使用数组来存储
  • 二叉树的顺序存储在物理上通过数组来实现，在逻辑上是一颗二叉树的结构
  • 完全二叉树的顺序存储:
    完全二叉树的顺序存储
  • 非完全二叉树的顺序存储:
    在这里插入图片描述

2> 二叉树的链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是:

  • 链表中每个结点由三个域组成，数据域和左右指针域
  • 左右指针分别用来指向该结点的左孩子节点和右孩子节点
  • 链式结构又分为二叉链和三叉链，在本篇文章中讲述的是二叉链
  • 二叉链:
    • 在这里插入图片描述
  • 三叉链:
    • 在这里插入图片描述

六 . 堆

1> 什么是堆

完全二叉树的顺序存储结构被称之为堆
堆分为大堆和小堆:

  • 大堆 : 父节点 >= 子节点 (指的是节点中存储的值)
  • 小堆 : 父节点 <= 子节点 (指的是节点中存储的值)

2> 用堆存储数据

堆是一种数据结构， 可以看作是一种容器， 用来存放数据， 若要将数据存入堆中， 那么要通过以下步骤:

    1. 将数据按照完全二叉树的顺序存储方式存入到一维数组中，
  • 2 . 调整数组中元素的关系， 必须满足 父节点 >=(<=) 子节点
  • 3 . 当数组中的元素满足在二叉树中 父节点 >= 子节点时， 这是相当于将数据存入大堆中
  • 4 . 如果满足 父节点 <= 子节点， 这是相当于将数据存入小堆中。
  • 堆示例图:
    • 在这里插入图片描述

3> 堆的Cpp代码实现

1) 堆的初始化

// 堆的初始化
void HPInit(HP* php)
{
	assert(php);

	php->_arr = new HPDataType[4];
	php->capacity = 4;
	php->size = 0;
}

2) 堆的销毁

// 堆的销毁
void HPDestroy(HP* php)
{
	assert(php);

	if (!php)
	{
		return;
	}
	delete[] php->_arr;
	php->_arr = NULL;
	php->capacity = php->size = 0;
}

3) 堆的遍历

// 堆的遍历
void HPPrint(HP* php)
{
	for (int i = 0; i < php->size; i++)
	{
		cout << php->_arr[i] << " ";
	}
	cout << endl;
}

4) 向上(或向下)调整建大堆(或小堆)

小堆中向上调整
// 堆向上调整 (堆中插入或互换元素向上调整) (小堆)
void AdjustUpS(HPDataType* a, int child)
{
	while (child)
	{
		int parent = (child - 1) / 2;
		if (a[parent] < a[child])
			return;
		else
		{
			HPSwap(a[parent], a[child]);
			child = parent;
		}
	}
}
小堆中向下调整
// 堆向下调整 (堆中插入或互换元素向下调整) (小堆)
void AdjustDownS(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}
		if (a[child] < a[parent])
		{
			HPSwap(a[child], a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
大堆中向上调整
// 堆向上调整 (堆中插入或互换元素向上调整) (大堆)
void AdjustUpB(HPDataType* a, int child)
{
	while (child)
	{
		int parent = (child - 1) / 2;
		if (a[parent] > a[child])
			return;
		else
		{
			HPSwap(a[parent], a[child]);
			child = parent;
		}
	}
}
大堆中向下调整
// 堆向下调整 (堆中插入或互换元素向下调整) (大堆)
void AdjustDownB(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			HPSwap(a[child], a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

5) 堆的插入

// 堆的插入 (小堆 插入元素向上调整)
void HPPush(HP* php, HPDataType val)
{
	assert(php);

	if (php->size == php->capacity)
	{
		HPDataType* newHP = new HPDataType[php->capacity * 2];
		for (int i = 0; i < php->size; i++)
		{
			newHP[i] = php->_arr[i];
		}
		delete[] php->_arr;
		php->_arr = newHP;
	}
	php->_arr[php->size] = val;
	++php->size;

	AdjustUpS(php->_arr, php->size - 1);       // 对新插入堆中的值 val 进行比较排序， 直至符合小堆为止
}

6) 堆删除

// 堆删除 (小堆， 删除 向上调整)
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	HPSwap(php->_arr[0], php->_arr[php->size - 1]);
	--php->size;

	AdjustDownS(php->_arr, php->size, 0);      // 再进行向下调整
}

7) 返回堆顶元素

// 返回堆顶元素
HPDataType HPTop(HP* php)
{
	assert(php);

	assert(php->size > 0);

	return php->_arr[0];
}

8) 返回堆中元素个数

// 返回堆中元素的个数
int HPSize(HP* php)
{
	assert(php);

	return php->size;
}

9) 判断堆是否为空

// 判断堆是否为空
bool HPEmpty(HP* php)
{
	return php->size == 0;
}

4> 堆排序

1） 排升序

排升序 : 将待排序序列排为升序, 步骤如下:

    1. 将待排序序列构造为一个大堆
    1. 利用堆顶元素， 也就是根元素是堆中最大值的特点， 将堆顶元素换至堆末尾
    1. 然后将新的堆顶元素进行向下调整
      注意:此时向下调整时， 原堆顶元素(被换至末尾的堆顶元素)不参与向下调整
    1. 之后再次进行如上步骤
    1. 直至待排序序列完全为升序

2) 排降序

派降序: 将待排序序列排为降序， 步骤如下:

    1. 将待排序序列构造为一个小堆
    1. 利用堆顶元素， 也就是根元素是堆中最小值的特点， 将堆顶元素换至堆末尾
    1. 然后将新的堆顶元素进行向下调整
      注意:此时向下调整时， 原堆顶元素(被换至末尾的堆顶元素)不参与向下调整
    1. 之后再次进行如上步骤
    1. 直至待排序序列完全为降序

5> TOP - K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

  • 比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
  • 对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
    1. 用数据集合中前K个元素来建堆
      • 前k个最大的元素，则建小堆
      • 前k个最小的元素，则建大堆
    2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
    3. 将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

七 . 二叉树的链式存储结构

1> 链式二叉树的代码实现

1) 链式二叉树的四种遍历方式

前序遍历
// 链式二叉树的前序遍历
void PreOrder(BTNode* root)
{
	if (!root)
	{
		cout << " ";
		return;
	}
	cout << root->data << " ";
	PreOrder(root->left);
	PreOrder(root->right);
}
中序遍历
// 链式二叉树的中序遍历
void InOrder(BTNode* root)
{
	if (!root)
	{
		//cout << " ";
		return;
	}
	PreOrder(root->left);

	cout << root->data << " ";

	PreOrder(root->right);
}
后序遍历
// 链式二叉树的后序遍历
void EpilOgue(BTNode* root)
{
	if (!root)
	{
		//cout << " ";
		return;
	}
	PreOrder(root->left);
	PreOrder(root->right);

	cout << root->data << " ";
}
层序遍历

链式二叉树的层序遍历需要依靠队列这一种数据结构

// 链式二叉树的层序遍历
void Sequence(BTNode* root)
{
	queue<BTNode*> que;
	if (root)
	{
		que.push(root);
	}
	while (!que.empty())
	{
		BTNode* front = que.front();
		cout << front->data << " ";
		que.pop();

		if(front->left)
		    que.push(front->left);
		if(front->right)
		    que.push(front->right);
	}
	cout << endl;
}

2) 返回二叉树中节点的个数

返回二叉树中节点的总个数
// 返回链式二叉树中节点的总个数 (后序递归遍历)
int TreeSize(BTNode* root)
{
	// return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
	if (!root)
	{
		return 0;
	}
	return TreeSize(root->left) + TreeSize(root->right) + 1;
}
返回二叉树中叶子节点的个数
// 返回链式二叉树中叶子节点的个数
int TreeLeafSize(BTNode* root)
{
	if (!root)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}
返回二叉树中第k层节点的总个数
// 返回链式二叉树第k层所有节点的个数 (非完全二叉树)
int TreeKLevel(BTNode* root, int k)
{
	assert(k > 0);

	if (!root)
		return 0;

	if (k == 1)
		return 1;

	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
}

3) 二叉树中的查找

//  链式二叉树中查找值为val的节点 并返回其地址
BTNode* TreeFind(BTNode* root, BTDataType val)
{
	if (!root)
		return NULL;

	if (root->data == val)
		return root;

	BTNode* ret = TreeFind(root->left, val);
	if (ret)
		return ret;

	ret = TreeFind(root->right, val);
	if (ret)
		return ret;

	return NULL;
}

4) 返回二叉树的高度

// 返回二叉树的高度(或者说 最大深度)
int TreeHight(BTNode* root)
{
	if (!root)
		return 0;

	int left = TreeHight(root->left);
	int right = TreeHight(root->right);

	return left >= right ? left + 1 : right + 1;
}

5) 判断是否为完全二叉树

// 判断是否为完全二叉树
int TreeComplete(BTNode* root)
{
	queue<BTNode*> q1;
	if (root)
		q1.push(root);

	while (!q1.empty())
	{
		BTNode* front = q1.front();
		if (!front)
			break;
		q1.push(front->left);
		q1.push(front->right);

		q1.pop();
	}

	while (!q1.empty())
	{
		if (q1.front())
			return false;
		q1.pop();
	}

	return true;
}

6) 二叉树的销毁

// 链式二叉树的销毁
void TreeDestory(BTNode** root)
{
	if (!(*root))
		return;

	TreeDestory(&((*root)->left));
	TreeDestory(&((*root)->right));

	delete *root;
	*root = NULL;
}

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

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

相关文章

HarmonyOS4.0开发应用——【ArkUI组件使用】

HarmonyOS4.0开发应用——【ArkUI组件使用】

ArkUI组件使用 这里会详细演示以下组件使用: ImageTextTextInputButtonSliderColumn&&RowList自定义组件以及相关函数使用 Image 可以是网络图片、可以是本地图片、也可以是像素图 Image("https://ts1.cn.mm.bing.net/th?idOIP-C.cYA-_PINA-ND9OeBaolDTwHaHa&…
阅读更多...
Linux 环境变量

Linux 环境变量

文章目录 环境变量概念查看环境变量设置环境变量代码获取环境变量补充说明 环境变量概念 定义 &#xff1a;环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数。 个人理解&#xff1a;Linux下一切皆文件&#xff0c;在Linux中所用的指…
阅读更多...
正则表达式（4）：连续次数的匹配

正则表达式（4）：连续次数的匹配

正则表达式&#xff08;4&#xff09;&#xff1a;连续次数的匹配 小结 本博文转载自 在本博客中&#xff0c;”正则表达式”为一系列文章&#xff0c;如果你想要从头学习怎样在Linux中使用正则&#xff0c;可以参考此系列文章&#xff0c;直达链接如下&#xff1a; 在Linux中…
阅读更多...
uniapp使用vue-i18n国际化多国语言

uniapp使用vue-i18n国际化多国语言

前言&#xff1a;uniapp是自带有i18n这个插件的&#xff0c;如果没有npm安装即可 此插件需要自己去给每一个需要国际化的字符去手动配置key&#xff0c;所以如果是已经完成的项目可能工作量就稍微有点大了 第一步&#xff1a; 语言命名是有规范的不能乱取名&#xff0c;具体可…
阅读更多...
TCP首部格式_基本知识

TCP首部格式_基本知识

TCP首部格式 表格索引: 源端口目的端口 序号 确认号 数据偏移保留 ACK等 窗口检验和紧急指针 TCP报文段首部格式图 源端口与目的端口: 各占16位 序号:占32比特&#xff0c;取值范围0~232-1。当序号增加到最后一个时&#xff0c;下一个序号又回到0。用来指出本TCP报文段数据载…
阅读更多...
Linux下如何运行.sh文件

Linux下如何运行.sh文件

运行环境为ubuntu20.04 如在/home/zoe/map运行.sh文件&#xff1a; 进入到/home/zoe文件夹下&#xff1a; cd /home/zoe/map 第一种运行方式&#xff1a; sh play.sh 结果&#xff1a; 第二种方式&#xff1a; 使用chmod修改文件的执行权限&#xff0c;然后运行 chmod x …
阅读更多...
图书馆智能密集书架怎么用的

图书馆智能密集书架怎么用的

图书馆智能密集书架是一种高密度存储书籍的设备&#xff0c;通过机器控制和操作&#xff0c;实现了对书籍的高效存储和检索。使用专久智能智能密集书架的方法如下&#xff1a; 1.先进行授权认证&#xff0c;确认身份和权限&#xff0c;进行操作前要确保权限正确&#xff0c;以免…
阅读更多...
HTTP请求

HTTP请求

前言 HTTP是应用层的一个协议。实际我们访问一个网页&#xff0c;都会像该网页的服务器发送HTTP请求&#xff0c;服务器解析HTTP请求&#xff0c;返回HTTP响应。如此就是我们获取资源或者上传资源的原理 HTTP请求报头格式 图片来自网络 HTTP请求报头总体有四部分&#xff1a;…
阅读更多...
Gmsh ＜二＞：Mesh generation

Gmsh ＜二＞：Mesh generation

上一节主要涉及Gmsh的使用入门和几何模型构建简介中&#xff0c;我们讲了Gmsh构建几何的一些基本知识&#xff0c;下面主要侧重于Gmsh在网格生成方面的操作。 网格生成的不同算法 在Gmsh中&#xff0c;当几何模型构建完成后&#xff0c;我们可以使用函数gmsh.model.mesh.gene…
阅读更多...
unity 2d入门飞翔小鸟按钮点击功能且场景切换（二）

unity 2d入门飞翔小鸟按钮点击功能且场景切换（二）

1、素材包获取 链接: https://pan.baidu.com/s/1KgCtQ_7wt2mlbGbIaMVvmw 提取码: xxh8 2、将素材全部拉进去 3、创建新的场景 并且将场景添加到build settings里面 4、脚本 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityE…
阅读更多...
Python的海龟 turtle 库使用详细介绍（画任意多边形，全网最详细）

Python的海龟 turtle 库使用详细介绍（画任意多边形，全网最详细）

学Turtle库&#xff0c;其实就是学数学&#xff0c;而且还能提高对数学和学习的兴趣。Turtle库还能够帮助孩子更好地理解几何学和数学概念&#xff0c;比如角度、比例、几何图形的性质等等&#xff0c;是Python中一个很有趣的库。 前言 Turtle库是Python中一个很有趣的库&…
阅读更多...
装修流程篇

装修流程篇

装修流程 https://www.xiaohongshu.com/explore/627ba70d00000000210357b3 https://www.xiaohongshu.com/explore/63b6bc0c000000002203776f 半包装修流程 https://www.xiaohongshu.com/explore/64e5ea3b0000000003021711 户型图 效果 https://www.xiaohongshu.com/ex…
阅读更多...
5G承载网和大客户承载的演进

5G承载网和大客户承载的演进

文章目录 移动4/5G承载网联通和电信4/5G承载网M-OTN&#xff08;Metro-optimized OTN&#xff09;&#xff0c;城域型光传送网PeOTN&#xff08;packet enhanced optical transport network&#xff09;&#xff0c;分组增强型OTN板卡增强型PeOTN集中交叉型PeOTN VC-OTN&#x…
阅读更多...
CoreDNS实战(六)-编译安装unbound插件

CoreDNS实战(六)-编译安装unbound插件

本文主要介绍coredns的unbound插件进行编译安装的过程及常用的配置方法。 coredns官方的unbound文档&#xff1a;unbound unbound插件的github地址&#xff1a;https://github.com/coredns/unbound 注&#xff1a;unbound插件虽然是coredns中的External Plugins&#xff0c;但…
阅读更多...
如何使用llm 制作多模态

如何使用llm 制作多模态

首先将任何非字符的序列信息使用特殊n个token 编码。 具体编码方法以图像为例子说明&#xff1a; 将固定尺寸图像如256256 的图像分割为1616 的子图像块。 将已知的所有图像数据都分割后进行str将其看做是一个长的字符&#xff0c;而后去重后方式一个词表。 使用特殊1024 个tok…
阅读更多...
GNN Maximum Flow Problem (From Shusen Wang)

GNN Maximum Flow Problem (From Shusen Wang)

Maximum Flow Problem ShusenWang 图数据结构和算法课程笔记 Slides Maximum Flow Problem Description Naive Algorithm Residual Capacity - FlowLeft: Original GraphRight: Residual Graph - Bottleneck capacity 2- Iteration 2:- Find an augmenting path: s -&g…
阅读更多...
IntelRealSense深度相机D455在ROS1运行中的消息内容

IntelRealSense深度相机D455在ROS1运行中的消息内容

IntelRealSense深度相机D455在ROS1运行中的消息内容 通过下面命令所有相关信息通过ros topic的方式发布出去rosnode查看rqt_graph查看rostopic查看通过下面命令直接查看RVIZ中点云信息rosnode查看rqt_graph查看rostopic查看 Physical Port:&#xff1a; /sys/devices/pci0000:0…
阅读更多...
线性回归既是一种数据挖掘与建模算法，也是统计学领域、计量经济学领域的常用学术建模方法，有何不同？

线性回归既是一种数据挖掘与建模算法，也是统计学领域、计量经济学领域的常用学术建模方法，有何不同？

一.线性回归的基本形式 线性回归既是一种数据挖掘与建模算法&#xff0c;也是统计学领域、计量经济学领域的常用学术建模方法。在数据挖掘与建模领域&#xff0c;线性回归算法是一种较为基础的机器学习算法&#xff0c;其基本思想是将响应变量&#xff08;因变量、被解释变量&…
阅读更多...
协议栈的内部结构

协议栈的内部结构

上层会向下层逐层委派工作。 最上面的部分是网络应用程序&#xff0c;它们会将收发数据等工作委派给下层的部分来完成。尽管不同的应用程序收发的数据内容不同&#xff0c;但收发数据的操作是共通的。 应用程序的下面是Socket库&#xff0c;其中包括解析器&#xff0c;解析器…
阅读更多...
Java+Swing+Mysql实现超市管理系统

Java+Swing+Mysql实现超市管理系统

一、系统介绍 1.开发环境 操作系统&#xff1a;Win10 开发工具 &#xff1a;IDEA2018 JDK版本&#xff1a;jdk1.8 数据库&#xff1a;Mysql8.0 2.技术选型 JavaSwingMysql 3.功能模块 4.系统功能 1.系统登录登出 管理员可以登录、退出系统 2.商品信息管理 管理员可以对商品信息…
阅读更多...
最新文章

Copyright @ 2022~2023