【数据结构】五、树：7.哈夫曼树、哈夫曼编码

news2024/11/15 22:23:52

3.哈夫曼树和哈夫曼编码

文章目录

    • 3.哈夫曼树和哈夫曼编码
      • 3.1带权路径长度
      • 3.2哈夫曼树的定义和原理
      • 3.3哈夫曼树的构造
        • 代码实现
      • 3.4特点
      • 3.5哈夫曼编码
        • 压缩比
        • 代码实现
      • 3.6哈夫曼树-C++

3.1带权路径长度
1
1
4
1
2
5
1
10
3

结点的权：有某种现实含义的数值（如：表示结点的重要性等）。

结点的带权路径长度：从树的根到该结的路径长度（经过的边数）与该结点上权值的乘积。
结点的带权路径长度 = 权 × 边数 结点的带权路径长度=权×边数 结点的带权路径长度=权×边数

比如第四层第四个结点度为3，它的带权路径长度：边数 * 权 = 3*3 = 9

树的带权路径长度（WPL, weighted path length）：树中的所有的叶子节点的带权路径长度的和。
W P L ( 树的带权路径长度 ) = ∑ i = 1 n w i l i WPL(树的带权路径长度)=\sum_{i=1}^n w_il_i WPL(树的带权路径长度)=i=1∑n​wi​li​

  • w i w_i wi​是第i个叶结点所带的权值；
  • l i l_i li​是第i个叶结点到根结点的路径长度。

在这里插入图片描述

3.2哈夫曼树的定义和原理

哈夫曼树（Huffman Tree）：在含有n个带权叶子节点的二叉树中，其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也称最优二叉树。

例如，在上图求WPL的四棵树中，都是4个同样权值的叶子节点，中间两棵树的WPL最小，那么它们两个就是哈夫曼树。

3.3哈夫曼树的构造

步骤：

  1. 先把有权值的叶子结点按照从大到小（从小到大也可以）的顺序排列成一个有序序列。
  2. 取最后两个最小权值的结点作为一个新节点的两个子结点，注意相对较小的是左孩子（可以不是）。
  3. 用第2步构造的新结点替掉它的两个子节点，插入有序序列中，保持从大到小排列。
  4. 重复步骤2到步骤3，直到根节点出现。

看图就清晰了，如下图所示：

在这里插入图片描述

代码实现
typedef double DataType; //结点权值的数据类型

typedef struct HTNode //单个结点的信息
{
	DataType weight; //权值
	int parent; //父节点
	int lc, rc; //左右孩子
}*HuffmanTree;

代码实现时，我们用一个数组（静态三叉链表）存储构建出来的哈夫曼树中各个结点的基本信息（权值、父结点、左孩子以及右孩子）。该数组的基本布局如下：

在这里插入图片描述

我们以“用数字7、5、4、2构建一棵哈夫曼树”为例，代码的基本实现步骤如下：

  • 第一阶段

所构建的哈夫曼树的总结点个数为2 × 4 − 1 = 7，但是这里我们开辟的数组可以存储8个结点的信息，因为数组中下标为0的位置我们不存储结点信息，具体原因后面给出。

我们先将用于构建哈夫曼树的数字7、5、4、2依次赋值给数组中下标为1-4的权值位置，其余信息均初始化为0。

在这里插入图片描述

  • 第二阶段

从数组中下标为1-4的元素中，选取权值最小，并且父结点为0（代表其还没有父结点）的两个结点，生成它们的父结点：

1、下标为5的结点的权值等于被选取的两个结点的权值之和。
 2、两个被选取的结点的父结点就是下标为5的结点。
 3、下标为5的结点左孩子是被选取的两个结点中权值较小的结点，另外一个是其右孩子。

在这里插入图片描述

再从数组中下标为1-5的元素中，选取权值最小，并且父结点为0的两个结点，生成它们的父结点。

在这里插入图片描述

继续从数组中下标为1-6的元素中，选取权值最小，并且父结点为0的两个结点，生成它们的父结点。

在这里插入图片描述

此时，除了下标为0的元素以外，数组中所有元素均已有了自己的结点信息，哈夫曼树已经构建完毕。

为什么数组中下标为0的元素不存储结点信息？

因为在数组中叶子结点的左右孩子是0，根结点的父结点是0，我们若是用数组中下标为0元素存储结点信息，那么我们将不能区分左右孩子为0的结点是叶子结点还是说该结点的左右孩子是下标为0的结点，同时也不知道哈夫曼树的根结点到底是谁。

// 在下标为1到i-1的范围(n个数)找到权值最小的两个值的下标, 其中s1的权值小于s2的权值, 返回s1和s2的下标
// HT是哈夫曼树的根结点，n是叶子结点的个数
void Select(HuffmanTree& HT, int n, int& s1, int& s2)
{
	int min;
	//找第一个最小值
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0){
			min = i;
			break;
		}
	}
	for (int i= min+1; i <= n; i++){
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight)
			min = i;
	}
	s1 = min; //第一个最小值给s1

	//找第二个最小值
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0 && i != s1){
			min = i;
			break;
		}
	}
	for (int i= min+1; i <= n; i++){
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight && i != s1)
			min = i;
	}
	s2 = min; //第二个最小值给s2
}


// 构建哈夫曼树
// HT是哈夫曼树的根结点，w是n个叶子结点的权值数组，n是叶子结点(初始节点)的个数
void CreateHuff(HuffmanTree& HT, DataType* w, int n)
{
	// step1.分配足够空间
	int number = 2*n - 1; //哈夫曼树总结点数

	HT = (HuffmanTree)calloc(number + 1, sizeof(HTNode)); //开m+1个HTNode，因为下标为0的HTNode不存储数据
	if (!HT){
		printf("分配内存失败\n");
		exit(0);
	}

	// step2.构建叶子结点
	for (int i=1; i <= n; i++){
		HT[i].weight = w[i - 1]; //赋权值给n个叶子结点
	}

	// step3.构建哈夫曼树(分支节点)，所以从新位置开始
	for (int i= n+1; i <= number; i++){
		//选择权值最小的s1和s2，生成它们的父结点
		int s1, s2;
		Select(HT, i-1, s1, s2); //在下标为1到i-1的范围找到权值最小的两个值的下标，其中s1的权值小于s2的权值
		HT[i].weight = HT[s1].weight + HT[s2].weight; //i的权重是s1和s2的权重之和
		HT[s1].parent = i; //s1的父亲是i
		HT[s2].parent = i; //s2的父亲是i
		HT[i].lc = s1; //左孩子是s1
		HT[i].rc = s2; //右孩子是s2
	}
}


//打印哈夫曼树中各结点之间的关系
void PrintHuff(HuffmanTree HT, int n)
{
	printf("下标   权值     父结点   左孩子   右孩子\n");
	printf("0                                  \n");
	for (int i=1; i <= n; i++)
	{
		printf("%-4d   %-6.2lf   %-6d   %-6d   %-6d\n", i, HT[i].weight, HT[i].parent, HT[i].lc, HT[i].rc);
	}
		printf("\n");
}

注：为了避免使用二级指针，函数传参使用了C++中的引用传参。

3.4特点

  1. 每个初始结点最终都成为叶结点，且权值越小的结点到根结点的路径长度越大。

  2. 哈夫曼树的结点总数为 2n - 1。

    因为共有n个叶子结点，也就是两两合成n-1次，就多了n-1个分支节点，n-1+n = 2n-1。

  3. 哈夫曼树中不存在度为1的结点。

    解释度为1：就是只有一个孩子结点。

  4. 哈夫曼树并不唯一，但WPL必然相同且最优。

  5. 把二叉树上的所有分支都进行编号，将所有左分支都标记为0，所有右分支都标记为1。

  6. 对于树上的任何一个结点，都可以根据从根结点到该结点的路径唯一确定一个编号。

【不足】当权值大小相差不大的时候，哈夫曼压缩效果不理想。

3.5哈夫曼编码

赫夫曼当前研究这种最优树的目的是为了解决当年远距离通信（主要是电报）的数据传输的最优化问题。

哈夫曼编码是一种被广泛应用而且非常有效的数据压缩编码。

比如我们有一段文字内容为“ BADCADFEED”要网络传输给别人，显然用二进制的数字(0和1)来表示是很自然的想法。我们现在这段文字只有六个字母ABCDEF，那么我们可以用相应的二进制数据表示，如下表所示：

字母ABCDEF
二进制字符000001010011100101

这样按照固定长度编码编码后就是“001000011010000011101100100011”，对方接收时可以按照3位一分来译码。如果一篇文章很长，这样的二进制串长度也将非常的可怕。

事实上，不管是英文、中文或是其他语言，字母或汉字的出现频率是不相同的。

假设六个字母的频率为A 27, B 8, C 15, D 15, E 30, F 5,合起来正好是100%。那就意味着，我们完全可以重新按照赫夫曼树来规划它们。

下图为构造赫夫曼树的过程的权值显示：

42
15
27
58
28
13
5
30
15
8
root
D
A
E
C
F
B

将权值左分支改为0，右分支改为1后的赫夫曼树：

0
0
1
1
0
0
0
1
1
1
root
D
A
E
C
F
B

这哈夫曼树的WPL为：

WPL = 2*( 15 + 27 + 30 ) + 3*15 + 4*( 5 + 8 ) = 241

此时，我们对这六个字母用其从树根到叶子所经过路径的0或1来编码，可以得到如下表所示这样的定义：

字母ABCDEF
二进制字符01100110100111000

固定长度编码：每个字符用相等长度的二进制位表示。

可变长度编码：允许对不同字符用不等长的二进制位表示。

前缀编码：若没有一个编码是另一个编码的前缀，则称这样的编码为前缀编码。

由哈夫曼树得到哈夫曼编码：字符集中的每个字符作为一个叶子结点，各个字符出现的频度作为结点的权值，根据之前介绍的方法构造哈天曼树。

这里使用的就是可变长度编码，并且是前缀编码，这样就不会有歧义。

我们将文字内容为“ BADCADFEED”再次编码，对比可以看到结果串变小了。

原编码二进制串: 000011000011101100100011 (共 30 个字符)
新编码二进制串: 10100101010111100(共 25 个字符)

也就是说，我们的数据被压缩了，节约了大约17%的存储或传输成本。

压缩比

原本ABCDEF这6个字符，最少使用3位二进制数表示，即每个字符用3位。

通过哈夫曼树进行优化之后，按照出现频率（六个字母的频率为A 27, B 8, C 15, D 15, E 30, F 5）计算加权平均长度（字符位数）：

2*0.27 + 4*0.08 + 3*0.15 + 2*0.15 + 2*0.3 + 4*0.05 = 2.41位

【技巧】但是其实 WPL/100 就压缩后的平均位数

未压缩长度3，压缩后长度2.41，那么压缩比为：

3 − 2.41 3 × 100 % = 0.197 × 100 % = 19.7 % \displaystyle \frac {3-2.41}3×100\% = 0.197×100\%= 19.7\% 33−2.41​×100%=0.197×100%=19.7%

代码实现

一个字符串若是想要容纳下“用n个数据生成的哈夫曼编码”中的任意一个编码，那么这个字符串的长度应该为n，因为我们还需要用一个字节的位置用于存放字符串的结束标志\0。

我们就以数字7、5、4、2构建的哈夫曼树为例，哈夫曼编码生成的基本实现步骤如下：

  • 第一阶段

因为数据个数为4，所以我们开辟一个大小为4的辅助空间，并将最后一个位置赋值为\0，用于暂时存放正在生成的哈夫曼编码。

在这里插入图片描述

为了存放这4个数据哈夫曼编码，我们开辟一个字符指针数组，该数组中有5个元素，每个元素的类型为char**，该字符指针数组的基本布局如下：

在这里插入图片描述

【注意】这里为了与 “构建哈夫曼树时所生成的数组” 中的下标相对应，所以该字符指针数组中下标为0的元素也不存储有效数据。

  • 第二阶段

利用已经构建好的哈夫曼树，生成这4个数据的哈夫曼编码。单个数据生成哈夫曼编码的过程如下：

1、判断该数据结点与其父结点之间的关系，若该数据结点是其父结点的左孩子，则将start指针前移，并将0填入start指向的位置，若是右孩子，则在该位置填1。

2、接着用同样的方法判断其父结点与其父结点的父结点之间的关系，直到待判断的结点为哈夫曼树的根结点为止，该结点的哈夫曼编码生成完毕。

3、将字符串中从start的位置开始的数据拷贝到字符指针数组中的相应位置。

这里我们以生成数据5的哈夫曼编码为例：

在这里插入图片描述

**【注意】**在每次生成数据的哈夫曼编码之前，先将start指针指向\0。

按照此方式，依次生成7、5、4、2的哈夫曼编码后，字符指针数组的基本布局如下：

在这里插入图片描述

哈夫曼编码生成完毕。

代码如下：

//生成哈夫曼编码
void HuffCoding(HuffmanTree& HT, HuffmanCode& HC, int n)
{
	HC = (HuffmanCode)malloc(sizeof(char*) * (n+1)); //开n+1个空间char**，因为下标为0的空间不用

	char* code = (char*)malloc(sizeof(char) * n); //辅助空间，编码最长为n(最长时，前n-1个用于存储数据，最后1个用于存放'\0')
	code[n - 1] = '\0'; //辅助空间最后一个位置为'\0'

	for (int i = 1; i <= n; i++)
	{
		int start = n - 1; //每次生成数据的哈夫曼编码之前，先将start指针指向'\0'
		int c = i; //正在进行的第i个数据的编码
		int parent_c = HT[c].parent; //找到该数据的父结点

		while (parent_c) //直到父结点为0，即父结点为根结点时，停止
		{
			//如果该结点是其父结点的左孩子，则编码为0，否则为1
			if (HT[parent_c].lc == c)
				code[--start] = '0';
			else
				code[--start] = '1';

			c = parent_c; //继续往上进行编码
			parent_c = HT[c].parent; //c的父结点
		}

		HC[i] = (char*)malloc(sizeof(char) * (n-start)); //开辟用于存储编码的内存空间
		strcpy(HC[i], &code[start]); //将编码拷贝到字符指针数组中的相应位置
	}
	free(code); //释放辅助空间
}

3.6哈夫曼树-C++

/* 二叉树
	哈夫曼树：在含有n个带权叶子节点的二叉树中，
	其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也称最优二叉树。

用一个 静态三叉链表 来存储
C++实现

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>


typedef double DataType; //结点权值的数据类型

typedef struct HTNode //单个结点的信息
{
	DataType weight; //权值
	int parent; //父节点
	int lc, rc; //左右孩子
} *HuffmanTree;
typedef char **HuffmanCode;	//字符指针数组中存储的元素类型

void Select(HuffmanTree& HT, int n, int& min1, int& min2);
void Select2(HuffmanTree& HT, int n, int& s1, int& s2);	//在哈夫曼树中选择两个权值最小的结点
void Select3(HuffmanTree& HT, int n, int& s1, int& s2);
void CreateHuff(HuffmanTree& HT, DataType* w, int n); //构建哈夫曼树
void PrintHuff(HuffmanTree HT, int n); //打印哈夫曼树
void HuffCoding(HuffmanTree& HT, HuffmanCode& HC, int n);	//哈夫曼编码

double GetWpl(HuffmanTree HT, int n, int target);
double GetWPL(HuffmanTree HT, int n);
double GetAverageLength(HuffmanTree HT, HuffmanCode HC, int n);
double GetCompressionRate(HuffmanTree HT, HuffmanCode HC, int n);


int main()
{
	//测试数据
	int n = 1;
	DataType w[] = {27,8,15,15,30,5};
	// 获取长度
	n = sizeof(w)/sizeof(DataType);

	//创建哈夫曼树
	HuffmanTree HT;
	CreateHuff(HT, w, n);

	//打印哈夫曼树
	PrintHuff(HT, n);

	HuffmanCode HC;
	HuffCoding(HT, HC, n);

	//打印哈夫曼编码
	for (int i=1; i <= n; i++){
		printf("%.2lf的哈夫曼编码是：%s\n", HT[i].weight, HC[i]);
	}

	//计算哈夫曼树的带权路径长度
	printf("\n哈夫曼树的带权路径长度WPL是：%.2lf\n", GetWPL(HT,n));

	// GetAverageLength(HC, n);
	printf("压缩率是 %.2lf %%", GetCompressionRate(HT, HC, n)*100);


	return 0;
}






// ------------------------- 哈夫曼树 构建------------------------

// 在下标为1到i-1的范围(n是叶子结点数)找到权值最小的两个值的下标, 其中s1的权值小于s2的权值, 返回s1和s2的下标
void Select2(HuffmanTree& HT, int n, int& s1, int& s2)
{
	int min;
//找第一个最小值
	//初始化，把第一个父结点为0的叶子结点作为最小值
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0){
			min = i;
			break;
		}
	}
	//在剩下的n-1个父结点为0的叶子结点中，找到权值最小的
	for (int i= min+1; i <= n; i++){
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight)
			min = i;
	}
	s1 = min; //第一个最小值给s1

//找第二个最小值
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0 && i != s1){
			min = i;
			break;
		}
	}
	for (int i= min+1; i <= n; i++){
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight && i != s1)
			min = i;
	}
	s2 = min; //第二个最小值给s2
}

/*
设立两个变量，x(min1)，y(min2)
将数组前两个值赋值给x，y；
比对x，y的大小，
更大的值给y，更小的值给x
循环数组，与y对比，当小于y时，与x对比，若小于x，则将x的值给y，x的值为min；
大于x则将min赋值给y；
*/
void Select(HuffmanTree& HT, int n, int& min1, int& min2)
{
	//初始化，把第一个父结点为0的叶子结点作为最小值
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0){
			min1 = i;
			break;
		}
	}
	for (int i=1; i <= n; i++){
		if (HT[i].parent == 0 && i!=min1){
			min2 = i;
			break;
		}
	}
	//min1比min2小
	if (HT[min1].weight > HT[min2].weight){
		int temp = min1;
		min1 = min2;
		min2 = temp;
	}

	for (int i=1; i <= n; i++){
		if(HT[i].parent == 0){
			if (HT[i].weight < HT[min1].weight){
				min2 = min1;
				min1 = i;
			}else if (HT[i].weight < HT[min2].weight && i != min1){
				min2 = i;
			}
		}
	}
}

void Select3(HuffmanTree& HT, int n, int& s1, int& s2)
{
	double min1=255, min2=255; //初始化，把第一个父结点为0的叶子结点作为最小值
	s1=s1=0;
	for (int i=1; i <= n; i++){
		if(HT[i].parent == 0){
			if (HT[i].weight < min1){
				min2 = min1, s2 = s1;
				min1 = HT[i].weight, s1 = i;
			}else if (HT[i].weight < min2){
				min2 = HT[i].weight, s2 = i;
			}
		}
	}
}


// 构建哈夫曼树
// HT是哈夫曼树的根结点，w是n个叶子结点的权值数组，n是叶子结点(初始节点)的个数
void CreateHuff(HuffmanTree& HT, DataType* w, int n)
{
	// step1.分配足够空间
	int number = 2*n - 1; //哈夫曼树总结点数

	HT = (HuffmanTree)calloc(number + 1, sizeof(HTNode)); //开m+1个HTNode，因为下标为0的HTNode不存储数据
	if (!HT){
		printf("分配内存失败\n");
		exit(0);
	}

	// step2.构建叶子结点
	for (int i=1; i <= n; i++){
		HT[i].weight = w[i - 1]; //赋权值给n个叶子结点
	}

	// step3.构建哈夫曼树(分支节点)，所以从新位置开始
	for (int i= n+1; i <= number; i++){
		//选择权值最小的s1和s2，生成它们的父结点
		int s1, s2;
		Select(HT, i-1, s1, s2); //在下标为1到i-1的范围找到权值最小的两个值的下标，其中s1的权值小于s2的权值
		HT[i].weight = HT[s1].weight + HT[s2].weight; //i的权重是s1和s2的权重之和
		HT[s1].parent = i; //s1的父亲是i
		HT[s2].parent = i; //s2的父亲是i
		HT[i].lc = s1; //左孩子是s1
		HT[i].rc = s2; //右孩子是s2
	}
}


//打印哈夫曼树中各结点之间的关系
void PrintHuff(HuffmanTree HT, int n)
{
	int m = 2*n-1;
	printf("哈夫曼树为:>\n");
	printf("下标   权值     父结点   左孩子   右孩子\n");
	printf("0                                  \n");
	for (int i=1; i <= m; i++){
		printf("%-4d   %-6.2lf   %-6d   %-6d   %-6d\n", i, HT[i].weight, HT[i].parent, HT[i].lc, HT[i].rc);
	}
		printf("\n");
}


// ------------------------- 哈夫曼 编码------------------------

//生成哈夫曼编码
void HuffCoding(HuffmanTree& HT, HuffmanCode& HC, int n)
{
	HC = (HuffmanCode)malloc(sizeof(char*) * (n+1)); //开n+1个空间char**，因为下标为0的空间不用

	char* code = (char*)malloc(sizeof(char) * n); //辅助空间，编码最长为n(最长时，前n-1个用于存储数据，最后1个用于存放'\0')
	code[n - 1] = '\0'; //辅助空间最后一个位置为'\0'

	for (int i = 1; i <= n; i++)
	{
		int start = n - 1; //每次生成数据的哈夫曼编码之前，先将start指针指向'\0'
		int c = i; //正在进行的第i个数据的编码
		int parent_c = HT[c].parent; //找到该数据的父结点

		while (parent_c) //直到父结点为0，即父结点为根结点时，停止
		{
			//如果该结点是其父结点的左孩子，则编码为0，否则为1
			if (HT[parent_c].lc == c)
				code[--start] = '0';
			else
				code[--start] = '1';

			c = parent_c; //继续往上进行编码
			parent_c = HT[c].parent; //c的父结点
		}

		HC[i] = (char*)malloc(sizeof(char) * (n-start)); //开辟用于存储编码的内存空间
		strcpy(HC[i], &code[start]); //将编码拷贝到字符指针数组中的相应位置
	}
	free(code); //释放辅助空间
}


// --------------------------- Get -----------------------------
// 结点的带权路径长度
// 获得n个叶子情况下结点target的带权路径长度
// 结点的带权路径长度=权×边数
double GetWpl(HuffmanTree HT, int n, int target){
	if(target <= 0 || target > n){
		return -1;
	}
	int sum = 0;	//边数
	int parent_target = HT[target].parent;
	while(parent_target){
		sum++;
		parent_target = HT[parent_target].parent;
	}
	return sum * HT[target].weight;
}

// 树的带权路径长度WPL
double GetWPL(HuffmanTree HT, int n){
	double wpl = 0;
	for (int i=1; i <= n; i++){
		wpl += GetWpl(HT, n, i);
	}
	return wpl;
}

// 计算哈夫曼编码的平均长度(字符位数)
double GetAverageLength(HuffmanTree HT, HuffmanCode HC, int n){
	double Number_of_AVEdigits = 0;	//压缩后的平均长度(字符位数)

	//遍历哈夫曼编码
	for (int i=1; i <= n; i++){
		// printf("%s哈夫曼编码长度：%d\n", HC[i], strlen(HC[i]));
		Number_of_AVEdigits += strlen(HC[i]) * HT[i].weight / 100;
	}
	return Number_of_AVEdigits;
}

// 计算压缩率
// 压缩率 = 加权平均字符位数 / 未压缩字符位数
double GetCompressionRate(HuffmanTree HT, HuffmanCode HC, int n){
	double Number_of_digits = 0;	//未压缩字符位数
	for(int i=1; i <= n; i++){
		if(pow(2, i) >= n){
			Number_of_digits = i;
			break;
		}
	}
	GetAverageLength(HT, HC, n);
	return (Number_of_digits - GetAverageLength(HT, HC, n) ) / Number_of_digits;
}



// 计算哈夫曼编码的熵
//pase

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

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

相关文章

【第18章】Spring Cloud之Gateway配置

【第18章】Spring Cloud之Gateway配置

文章目录 前言一、示例二、Route Metadata Configuration1. 路由元数据配置2. 获取元数据配置 三、Http timeouts configuration(请求超时配置)1. Global timeouts(全局)2. Per-route timeouts(路由) 四、CORS Configuration(跨域配置)1. Global CORS Configuration(全局)2. Ro…
阅读更多...
【HarmonyOS NEXT星河版开发学习】小型测试案例07-弹性布局小练习

【HarmonyOS NEXT星河版开发学习】小型测试案例07-弹性布局小练习

个人主页→VON 收录专栏→鸿蒙开发小型案例总结​​​​​ 基础语法部分会发布于github 和 gitee上面&#xff08;暂未发布&#xff09; 前言 在鸿蒙&#xff08;HarmonyOS&#xff09;开发中&#xff0c;Flex布局是一种非常有用的布局方式&#xff0c;它允许开发者创建灵活且响…
阅读更多...
FPGA知识基础之--存储器知识点总结以及基于ip核的简单双端口RAM的实现和仿真（附RTL代码和Testbench代码）

FPGA知识基础之--存储器知识点总结以及基于ip核的简单双端口RAM的实现和仿真（附RTL代码和Testbench代码）

目录 前言一、存储器的分类二、实验任务三 、简单&#xff08;伪&#xff09;双端口四、程序设计4.1 模块4.2 时序分析4.3 RTL代码ram_wr 写模块2.ram_rd 写模块3.top模块 五、仿真 前言 笔者在最近的存储器学习时&#xff0c;遇到了一些问题&#xff0c;为此笔者用本篇博客来…
阅读更多...
ICM-20948芯片详解（9）

ICM-20948芯片详解（9）

接前一篇文章&#xff1a;ICM-20948芯片详解&#xff08;8&#xff09; 六、寄存器详解 2. USER BANK 0寄存器详述 &#xff08;6&#xff09;INT_PIN_CFG 参考代码&#xff1a; #define ICM20948_INT_PIN_CFG 0x0F &#xff08;7&#xff09;INT_ENABLE 参考代码&#x…
阅读更多...
我有10台120kw的直流充电桩，赢利了多少钱？我列出所有成本和多少利润,这里要算上政府补贴。【慧哥开源充电桩平台 HZCOS-chargeOS-cloud】

我有10台120kw的直流充电桩，赢利了多少钱？我列出所有成本和多少利润,这里要算上政府补贴。【慧哥开源充电桩平台 HZCOS-chargeOS-cloud】

特别申明&#xff1a;仅仅代表个人观点&#xff0c;错的地方虚心请教学习&#xff0c;各位手下留情 拥有的10台120kW直流充电桩的盈利情况&#xff0c;并考虑到政府补贴&#xff0c;具体数字需要根据实际情况调整。 成本计算 初始投资成本 充电桩成本&#xff1a;每台120kW直…
阅读更多...
利用Llama 3 API实现盈利：细节解析

利用Llama 3 API实现盈利：细节解析

随着人工智能技术的快速发展，基于大模型的服务成为了众多初创企业关注的焦点。Llama 3 API作为一种强大的语言模型接口，为小型公司提供了利用先进AI技术的机会。本文将探讨这些小公司如何通过Llama 3 API实现盈利，并分析其中的关键因素。 一、Llama 3 API性能概览 批处理输…
阅读更多...
网络药理学：分子对接之一：macos上MOE和Autodock和PyMol和gromacs的下载、PDB数据库使用、gromacs能量最小化

网络药理学：分子对接之一：macos上MOE和Autodock和PyMol和gromacs的下载、PDB数据库使用、gromacs能量最小化

MOE下载 别想了&#xff0c;要钱的。而且不算是主流软件&#xff0c;过。 Autodock和Autodock tools下载 下载地址&#xff1a;https://autodock.scripps.edu/download-autodock4/ 如果你的电脑满足以下配置&#xff0c;那么推荐下载autodock GPU 操作系统&#xff1a;mac…
阅读更多...
重磅！观测云荣获SOC 2 Type II鉴证报告

重磅！观测云荣获SOC 2 Type II鉴证报告

近日&#xff0c;观测云在数据安全和内控管理领域再获殊荣&#xff0c;成功获得全球四大会计师事务所之一的安永会计师事务所签发的SOC 2 Type II 鉴证报告。这一荣誉不仅是对观测云在相关领域卓越表现的认可&#xff0c;更是对其对客户承诺坚定性和执行力的有力证明。 观测云 …
阅读更多...
软件设计之JavaScript(1)

软件设计之JavaScript(1)

软件设计之JavaScript(1) 【狂神说Java】JavaScript最新教程通俗易懂 学习内容&#xff1a; 软件开发技能点参照&#xff1a;软件开发&#xff0c;小白变大佬&#xff0c;这套学习路线让你少走弯路是认真的&#xff0c;欢迎讨论 软件开发技能点顺序参照&#xff1a;Java学习…
阅读更多...
“前缀和”专题篇一

“前缀和”专题篇一

目录 【模版】前缀和 【模版】二维前缀和 寻找数组的中心下标 除自身以外数组的乘积 【模版】前缀和 题目 思路 这道题如果使用暴力解法&#xff0c;即针对每次查询&#xff0c;先算出前r个数的总和&#xff0c;然后再算出前l-1个数的总和&#xff0c;然后相减就得出本次查…
阅读更多...
2.类和对象（上）

2.类和对象（上）

1. 类的定义 1.1 类定义格式 • class为定义类的关键字&#xff0c;Stack为类的名字&#xff0c;{ }中为类的主体&#xff0c;注意类定义结束时后面分号不能省略。类体中内容称为类的成员&#xff1a;类中的变量称为类的属性或成员变量; &#xff08;类和结构体非常像&#…
阅读更多...
12-利用Excel创建IC类元件库

12-利用Excel创建IC类元件库

1.新建excel文件 2.找到模型向导 3.修改属性
阅读更多...
技术速递｜.NET Aspire 8.1 中面向云原生开发人员的新增功能！

技术速递｜.NET Aspire 8.1 中面向云原生开发人员的新增功能！

作者&#xff1a;Mitch Denny 排版&#xff1a;Alan Wang 5 月份&#xff0c;我们向全世界发布了 .NET Aspire 的第一个正式版本。.NET 社区的热烈响应令我们深受鼓舞&#xff0c;在大家首次试用时&#xff0c;我们一直在积极倾听并与开发人员互动。 今天&#xff0c;我们很高…
阅读更多...
EF Core连接PostgreSQL数据库

EF Core连接PostgreSQL数据库

PostgreSQL数据库介绍 PostgreSQL是一个功能强大的开源对象关系型数据库管理系统&#xff08;RDBMS&#xff09;。最初于1986年在加州大学伯克利分校的POSTGRES项目中诞生&#xff0c;PostgreSQL以其稳定性、灵活性和扩展性而著称。它支持丰富的数据类型、复杂的查询、事务完整…
阅读更多...
C语言进阶（3）

C语言进阶（3）

1.数组传参 一维数组传参的时候使用数组名&#xff0c;代表数组首元素的地址&#xff1b;函数接受时形参可以是数组形式&#xff0c;也可能是指针形式&#xff0c;数组形式比较简单数组怎么写&#xff0c;函数接受是就怎么接受,使用指针就要将指针类型写清楚&#xff0c;如下 …
阅读更多...
一文搞懂MES、ERP、SCM、WMS、APS、SCADA、PLM、QMS、CRM、EAM及其关系

一文搞懂MES、ERP、SCM、WMS、APS、SCADA、PLM、QMS、CRM、EAM及其关系

MES、ERP、SCM、WMS、APS、SCADA、PLM、QMS、CRM、EAM各个系统到底是什么意思&#xff1f;今天一文就给大家分享&#xff01; 在企业管理中&#xff0c;各种信息系统扮演着至关重要的角色&#xff0c;它们如同企业的神经系统&#xff0c;确保各个部分高效协同运作。 MES&#…
阅读更多...
微信小程序项目开发【从0到1~入门篇】

微信小程序项目开发【从0到1~入门篇】

创建第一个小程序 1、小程序简介2、第一个小程序&#xff1a;注册小程序开发账号3、第一个小程序&#xff1a;安装开发者工具3.1 了解微信开发者工具3.2下载安装3.3 扫描登录 4、创建小程序项目5、小程序代码的构成5.1json配置文件5.2WXML模板5.3WXSS样式5.4JS 逻辑交互 6、宿主…
阅读更多...
HDMI线连接显示器后色彩灰暗问题解析与解决方案

HDMI线连接显示器后色彩灰暗问题解析与解决方案

随着科技的快速发展&#xff0c;HDMI线已成为连接电脑与显示器的重要工具。然而&#xff0c;当HDMI线连接显示器后&#xff0c;有时会遇到显示器色彩灰暗的问题。本文将针对这一问题进行深入解析&#xff0c;并提供相应的解决方案。 一、HDMI线连接显示器后色彩灰暗的原因 1. …
阅读更多...
C++ SQL ORM

C++ SQL ORM

测试代码 // // Created by www on 2024/8/7. // #include "sqlitepp/database.h" #include "sqlitepp/condition.h"#include <iostream> using namespace sqlitepp; using namespace sqlitepp::literals;enum class test_enum {hello };void test…
阅读更多...
Matplotlib | 绘制折线图

Matplotlib | 绘制折线图

目录 简介安装 Matplotlib开始绘制简单折线图改变线的样式改变节点的样式添加图表文字改变坐标轴标签改变坐标数值范围绘制多条折线实践&#xff1a;绘制温度变化图 简介 折线图&#xff08;Line Chart&#xff09;&#xff0c;是一种以折线来呈现数据随时间变化而变化的图表。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023