数据结构初阶--二叉树的顺序结构之堆

目录

一.堆的概念及结构

1.1.堆的概念

1.2.堆的存储结构

二.堆的功能实现

2.1.堆的定义

2.2.堆的初始化

2.3.堆的销毁

2.4.堆的打印

2.5.堆的插入

向上调整算法

堆的插入

2.6.堆的删除

向下调整算法

堆的删除

2.7.堆的取堆顶元素

2.8.堆的判空

2.9.堆的求堆的大小

三.堆的创建

3.1.向上调整建堆

时间复杂度

3.2.向下调整建堆

时间复杂度

四.堆的应用

4.1.堆排序

步骤一:建堆

步骤二:排序

4.2.TOP-K问题


一.堆的概念及结构

1.1.堆的概念

若n个关键字序列L[1...n]满足下面某一条性质,则称为堆(Heap)

  1. 若满足:L(i)>=L(2i)且L(i)>=L(2i+1)(1<=i<=n/2)--大根堆(大顶堆)
  2. 若满足:L(i)<=L(2i)且L(i)<=L(2i+1)(1<=i<=n/2)--小根堆(小顶堆)

大根堆在逻辑视角上可以看成所有子树根>=左,右的完全二叉树。相应的小根堆也可以看成根<=左,右的完全二叉树。

堆的性质:

  1. 堆中某个结点的值总是不大于或不小于其父结点的值;
  2. 堆总是一棵完全二叉树。

1.2.堆的存储结构

普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储。

二.堆的功能实现

2.1.堆的定义

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;//开辟一个动态数组a
	int size;//当前元素个数
	int capacity;//数组的最大容量
}HP;

定义一个struct来保存堆的信息,主要包含数组首元素的地址a,数组中当前元素个数size以及数组的最大容量capacity。堆的定义同顺序表的定义类似。

2.2.堆的初始化

void HeapInit(HP* php)
{
	//判空
	assert(php);

	//将数组首元素的地址位置空
	php->a = NULL;

	php->size = php->capacity = 0;
}

在初始化堆之前,首先需要对传入的参数php进行断言判断其是否为空,然后将数组首元素的地址置为空NULL,最后再将size和capacity都初始化为0。

调试分析:

2.3.堆的销毁

void HeapDestory(HP* php)
{
	//判空
	assert(php);

	//释放
	free(php->a);
	php->a = NULL;

	php->size = php->capacity = 0;
}

在销毁堆之前,首先需要对传入的参数php进行断言判断其是否为空,然后调用free函数释放数组首元素的地址,并将数组首元素的地址置为空NULL,最后再将size和capacity都置为0。

调试分析:

2.4.堆的打印

void HeapPrint(HP* php)
{
	//判空
	assert(php);

	//打印
	for (int i = 0; i < php->size; ++i)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

首先判断传入的参数php是否为空,然后进行for循环依次打印数组中的各个元素。

2.5.堆的插入

当在堆中插入新元素时,对于小根堆,新元素放到表尾,与父结点对比,若新元素比父结点更小,则将二者互换。新元素就这样一路向上调整,直到无法继续上升为止。

向上调整算法

当在堆的末尾插入一个新元素,而新插入的元素可能会破坏堆的性质,这时就要进行调整。以小堆为例,当新元素大于其对应的父结点,则满足堆的性质,无需调整;当新元素小于其对应的父结点,则不满足堆的性质,要进行调整。

调整规则:

若新插入的元素child小于其对应的父结点parent,则调用Swap函数,将二者进行交换,此时child来到父结点parent的位置,其对应的新的父结点的下标为(child-1)/2,然后将child继续与parent进行比较,依次往上执行,直到child大于其对应的父结点parent,则跳出循环。

循环判断条件为:child>0,这是考虑到最坏的情况,也就是当child一直小于其对应的父结点时,child经过最后一次交换来到根结点的位置时,此时堆的调整已经结束。

实现:

//交换数据
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整(小堆)
void AdjustUp(HPDataType* a, int child)
{
	//查找父结点下标
	int parent = (child - 1) / 2;

	//最坏情况是一路调整到根
	while (child > 0)
	{
		if (a[child] < a[parent])//大堆:a[child]>a[parent]
		{
			//将父子结点进行交换
			Swap(&a[child], &a[parent]);

			//把父结点的下标赋值给孩子
			child = parent;

			//再去查找父结点的下标
			parent = (child - 1) / 2;
		}
		else
		{
			//若已构成堆,则直接跳出循环
			break;
		}
	}
}

堆的插入

void HeapPush(HP* php, HPDataType x)
{
	//判空
	assert(php);

	//检查容量是否为空或已满
	if (php->size == php->capacity)
	{
		//扩容
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;//为空就开辟四个元素空间,不为空,就扩容至二倍
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);

		//判空
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		//将新开辟的内存空间的首地址tmp赋值给a
		php->a = tmp;
		//更新capacity
		php->capacity = newCapacity;
	}

	//插入
	//先将元素插入到堆的末尾,即最后一个孩子后面
	//插入之后如果堆的性质遭到了破坏,则将新插入结点顺着其双亲往上调整到合适的位置
	php->a[php->size] = x;//注意:size指向数组最后一个元素的下一个位置
	php->size++;

	//向上调整
	AdjustUp(php->a, php->size - 1);
}

在堆中插入元素之前,首先需要检查当前容量是否为空或者已满。若容量为空,则调用realloc函数开辟四个元素的内存空间,若容量已满,则调用realloc函数将内存空间开辟到原来的二倍,并将新开辟的内存空间的首地址tmp赋值给a,同时更新capacity。接着便可以插入元素,因为size是指向数组最后一个元素的下一个位置,所以先将新元素x插到下标为size的位置,然后再将size+1。最后再调用AdjustUp函数,进行向上调整。

调试分析:

运行结果:

2.6.堆的删除

堆的删除是删除堆顶的元素,将堆顶的元素与最后一个元素交换,然后删除数组最后一个元素,再进行向下调整。

向下调整算法

当对堆进行删除时,删除的往往是堆顶元素,删除之后可能会破坏堆的性质,这时就要进行调整。以小堆为例,在删除之前,首先将堆顶元素与最后一个元素交换,交换完之后再将最后一个元素删除。然后从根结点开始依次向下调整,直到把它调整为一个小堆。

向下调整算法的前提:左右子树必须是一个堆,才能调整。

调整规则:

首先选出根结点的左右孩子中较小的那一个,这里先假设左孩子最小,然后将左孩子与右孩子进行比较,若左孩子小于右孩子,则不变;若左孩子大于右孩子,则将右孩子设为最小。然后将最小的孩子与父结点进行比较,如果比父结点小,则交换,交换完之后,把孩子结点child所在的下标赋值给父结点parent,并让child指向新的父结点的左孩子,然后依次向下比较,直到调整到叶子结点的位置;如果比父结点大,则调整结束。

实现:

//交换数据
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.选出左右孩子中小的那一个
	int child = parent * 2 + 1;//假设左孩子最小

	while (child < size)
	{
		//当右孩子存在且右孩子小于左孩子
		if (child + 1 < size && a[child + 1] < a[child])//大堆:a[child+1]>a[child]
		{
			++child;//则将右孩子置为child
		}

		//2.小的孩子跟父亲比较,如果比父亲小,则交换,然后继续往下调整;如果比父亲大,则调整结束
		if (a[child] < a[parent])//大堆:a[child]>a[parent]
		{
			//交换数据
			Swap(&a[child], &a[parent]);

			//3.继续往下调,最多调整到叶子结点就结束
			//把孩子的下标赋值给父亲
			parent = child;

			//假设左孩子最小
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

堆的删除

void HeapPop(HP* php)
{
	//判空
	assert(php);

	//判断数组是否为空
	assert(php->size > 0);

	//将第一个元素与最后一个元素交换,然后删除
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

在删除之前,首先需要判断数组是否为空,若为空则无法进行删除,若不为空则可以进行删除。然后调用Swap函数将数组的第一个待删除元素与数组的最后一个元素进行交换,并让size-1,删除最后一个元素。最后再调用函数AdjustDown,进行向下调整。

调试分析:

运行结果:

2.7.堆的取堆顶元素

HPDataType HeapTop(HP* php)
{
	//判空
	assert(php);

	//判断数组是否为空
	assert(php->size > 0);

	//根结点即为堆顶元素
	return php->a[0];
}

在取堆顶元素之前,首先要对数组进行判空操作,若数组为空则无法进行读取操作,若数组不为空则直接读取数组的首元素,数组的首元素也就是根结点,即为堆顶元素。

调试分析:

运行结果:

2.8.堆的判空

bool HeapEmpty(HP* php)
{
	//判空
	assert(php);

	//看size的大小是否为0
	return php->size == 0;
}

判断堆是否为空,只需判断size是否等于0,若size为0,则数组为空,即堆为空;若size不为0,则数组不为空,即堆不为空。

调试分析:

2.9.堆的求堆的大小

int HeapSize(HP* php)
{
	//判空
	assert(php);

	//size的大小即为数组的大小,也就是堆的大小
	return php->size;
}

求堆的大小,只需求数组中当前元素个数,也就是求size的大小。

调试分析:

三.堆的创建

3.1.向上调整建堆

向上调整建堆,实际上是模拟堆的插入过程。首先,将数组中的第一个元素看做是堆的根结点,然后将数组中的元素依次插入堆中,每插入一个元素,就调用函数AdjustUp向上调整一次,直到将所有的元素均插入堆中。

实现:

for (int i = 1; i < n; ++i)//从第一个位置插入
{
	AdjustUp(a, i);
}

时间复杂度

因为堆是一棵完全二叉树,而满二叉树又是一种特殊的完全二叉树,为了简化计算,我们不妨假设此处的堆是一棵满二叉树。

由上图得,对于高度为h的满二叉树构成的堆,最多进行向上调整的次数设为T(N),有:

综上,证得向上调整建堆的时间复杂度为O(N*logN)

3.2.向下调整建堆

首先将数组中的元素以完全二叉树的形式排列好,然后从倒数第一个非叶子结点开始,调用函数AdjustDown依次向下调整。每调整一次,则将i的值减1,让其来到倒数第二个非叶子结点的位置,重复上述操作,直到i来到根结点的位置。

实现:

for (int i = (n - 1 - 1) / 2; i >= 0; i--)//n-1为最后一个结点的下标,求最后一个结点的父结点的下标(n-1-1)/2
{
	AdjustDown(a, n, i);
}

注意:

我们可以直接通过向上调整算法来建堆,但是我们不可以直接通过向下调整算法来建堆。因为向下调整算法的前提:左右子树必须是堆,才能调整。

时间复杂度

因为堆是一棵完全二叉树,而满二叉树又是一种特殊的完全二叉树,为了简化计算,我们不妨假设此处的堆是一棵满二叉树。

由上图得,对于高度为h的满二叉树构成的堆,最多进行向上调整的次数设为T(N),有:

综上,证得向上调整建堆的时间复杂度为O(N)。 

四.堆的应用

4.1.堆排序

堆排序也就是利用堆的思想来进行排序,总共分为两个步骤:

  1. 建堆(升序建大堆,降序建小堆);
  2. 利用堆删除思想来进行排序 。

注意:

升序也可以建小堆,只是每次都要通过建堆的方式选出最小的元素。当进行第一次建堆选出最小的元素并放在数组起始位置时,剩余的元素关系就会发生错乱:原本的左孩子结点会变成新的根结点,右孩子结点会变成新的左孩子结点。然后将剩下的元素继续进行建堆,选出剩余元素中最小的元素并放入数组起始位置的下一个位置,重复上述操作,直到整个数组有序。整体时间复杂度为O(N^2),可见效率太低,没有使用到堆的优势。因此,升序要建大堆。

我们以升序建大堆为例:

步骤一:建堆

这里采用时间复杂度较低的向下建堆法来进行大根堆的建立。

实现:

//交换数据
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.选出左右孩子中小的那一个
	int child = parent * 2 + 1;//假设左孩子最小

	while (child < size)
	{
		//当右孩子存在且右孩子小于左孩子
		if (child + 1 < size && a[child + 1] > a[child])//大堆:a[child+1]>a[child]
		{
			++child;//则将右孩子置为child
		}

		//2.小的孩子跟父亲比较,如果比父亲小,则交换,然后继续往下调整;如果比父亲大,则调整结束
		if (a[child] > a[parent])//大堆:a[child]>a[parent]
		{
			//交换数据
			Swap(&a[child], &a[parent]);

			//3.继续往下调,最多调整到叶子结点就结束
			//把孩子的下标赋值给父亲
			parent = child;

			//假设左孩子最小
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//建堆
	//建堆方式二:向下调整
	//向下调整算法的左右子树必须是堆,因此不能使用该方法直接建堆
	//时间复杂度:O(N)
	//首先将数组中的元素以完全二叉树的形式排列好,然后从倒数第一个非叶子结点开始,依次向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//n-1为最后一个结点的下标,求最后一个结点的父结点的下标(n-1-1)/2
	{
		AdjustDown(a, n, i);
	}
}

int main()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	HeapSort(a, sizeof(a) / sizeof(a[0]));

	return 0;
}

调试分析:

建堆前:                                                                      

建堆后:

步骤二:排序

这里用到堆的删除思想。先交换数组的首尾元素,此时尾结点中的元素为堆中的最大值。然后将堆的最后一个元素排除在外,并继续从根结点开始,对堆进行向下调整。重复上述操作,直到堆中仅剩一个元素为止。

实现:

//交换数据
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.选出左右孩子中小的那一个
	int child = parent * 2 + 1;//假设左孩子最小

	while (child < size)
	{
		//当右孩子存在且右孩子小于左孩子
		if (child + 1 < size && a[child + 1] > a[child])//大堆:a[child+1]>a[child]
		{
			++child;//则将右孩子置为child
		}

		//2.小的孩子跟父亲比较,如果比父亲小,则交换,然后继续往下调整;如果比父亲大,则调整结束
		if (a[child] > a[parent])//大堆:a[child]>a[parent]
		{
			//交换数据
			Swap(&a[child], &a[parent]);

			//3.继续往下调,最多调整到叶子结点就结束
			//把孩子的下标赋值给父亲
			parent = child;

			//假设左孩子最小
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//建堆
	//建堆方式二:向下调整
	//向下调整算法的左右子树必须是堆,因此不能使用该方法直接建堆
	//时间复杂度:O(N)
	//首先将数组中的元素以完全二叉树的形式排列好,然后从倒数第一个非叶子结点开始,依次向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//n-1为最后一个结点的下标,求最后一个结点的父结点的下标(n-1-1)/2
	{
		AdjustDown(a, n, i);
	}


	//排序
	//时间复杂度:O(N*logN),其中N为元素个数,logN为向上调整的次数,也即树的高度
	int end = n - 1;
	while (end > 0)
	{
		//将第一个结点与最后一个结点交换
		Swap(&a[0], &a[end]);

		//向下调整选出次大的数
		AdjustDown(a, end, 0);
		--end;
	}
}

int main()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	HeapSort(a, sizeof(a) / sizeof(a[0]));

	return 0;
}

调试分析:

排序前:

排序后:

小结:

建堆和堆的删除都用到了向下调整,因此掌握了向下调整,就可以完成排序。

建堆的时间复杂度为:O(N),排序的时间复杂度为:O(N*logN)。取影响结果较大的一个,也就是O(N*logN)。所以堆排序的时间复杂度为O(N*logN)。

4.2.TOP-K问题

TOP-K问题:即求数据集合中前K个最大的元素或者最小的元素,一般情况下数据量都比较大。
对于TOP-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

法一:

堆排序,采用时间复杂度最低的堆排序,时间复杂度为O(N*logN);

法二:

首先建立N个数的大根堆,然后Top/Pop k次,时间复杂度为O(N+k*logN);

注意:上述两种方法在数据量非常大时,是不太可取的。

法三:

假设N非常大,比如N是100亿,而K比较小,假如k是100,如何求解?

首先,将数据集合中前k个数建立小根堆,时间复杂度:O(k);
然后,将剩下的N-k个元素依次和堆顶元素进行比较,如果比堆顶元素大,就替换堆顶元素,并进行向下调整;
待N-k个元素依次和堆顶元素比较完之后,堆中剩余的k个元素就是所求的最大的前k个元素,时间复杂度:O((N-k)*logk)。

注意:法三较于前两种方法有很高的空间效率。

实现:

//交换数据
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	//1.选出左右孩子中小的那一个
	int child = parent * 2 + 1;//假设左孩子最小

	while (child < size)
	{
		//当右孩子存在且右孩子小于左孩子
		if (child + 1 < size && a[child + 1] < a[child])//大堆:a[child+1]>a[child]
		{
			++child;//则将右孩子置为child
		}

		//2.小的孩子跟父亲比较,如果比父亲小,则交换,然后继续往下调整;如果比父亲大,则调整结束
		if (a[child] < a[parent])//大堆:a[child]>a[parent]
		{
			//交换数据
			Swap(&a[child], &a[parent]);

			//3.继续往下调,最多调整到叶子结点就结束
			//把孩子的下标赋值给父亲
			parent = child;

			//假设左孩子最小
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void PrintTopK(int* a, int n, int k)
{
	//1.建堆:用a中前k个元素建堆
	int* kMinHeap = (int*)malloc(sizeof(int) * k);
	assert(kMinHeap);

	for (int i = 0; i < k; i++)
	{
		//将a中前k的元素放进kMinHeap中
		kMinHeap[i] = a[i];
	}

	//建立小根堆
	for (int i = (k - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(kMinHeap, k, i);
	}


	//2.将剩余的n-k个元素依次与堆顶元素比较,不满则替换
	for (int j = k; j < n; j++)
	{
		//若后面的元素大于堆顶元素,则进行替换,并向下调整
		if (a[j] > kMinHeap[0])
		{
			kMinHeap[0] = a[j];
			AdjustDown(kMinHeap, k, 0);
		}
	}


	//3.打印最大的前k个元素
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kMinHeap[i]);
	}

	printf("\n");

	//销毁
	free(kMinHeap);
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	assert(a);

	srand((size_t)time(0));

	for (int i = 0; i < n; i++)
	{
		//产生一万个不大于100万的随机数
		a[i] = rand() % 1000000;
	}

	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;

	PrintTopK(a, n, 10);
}

int main()
{
	TestTopk();

	return 0;
}

运行结果:

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

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

相关文章

MyBatis-Plus实现分页查询

目录 MyBatis-Plus实现分页查询 代码 定义一个MyBatis-Plus拦截器 在连接数据库的配置文件中添加MyBatis-Plus日志查看MyBatis-Plus的SQL语句 测试 运行结果 MyBatis-Plus实现分页查询 代码 定义一个MyBatis-Plus拦截器 package com.dong.config;import com.baomidou.my…

webpack基础知识二:说说webpack的构建流程?

一、运行流程 webpack 的运行流程是一个串行的过程&#xff0c;它的工作流程就是将各个插件串联起来 在运行过程中会广播事件&#xff0c;插件只需要监听它所关心的事件&#xff0c;就能加入到这条webpack机制中&#xff0c;去改变webpack的运作&#xff0c;使得整个系统扩展…

【学习笔记】Java安全之反序列化

文章目录 反序列化方法的对比PHP的反序列化Java的反序列化Python反序列化 URLDNS链利用链分析触发DNS请求 CommonCollections1利用链利用TransformedMap构造POC利用LazyMap构造POCCommonsCollections6 利用链 最近在学习Phith0n师傅的知识星球的Java安全漫谈系列&#xff0c;随…

分布式限流方案及实现

优质博文&#xff1a;IT-BLOG-CN 一、限流的作用和意义 限流是对高并发访问进行限制&#xff0c;限速的过程。通过限流来限制资源&#xff0c;可以提高系统的稳定性和可靠性&#xff0c;控制系统的负载&#xff0c;削峰填谷&#xff0c;保证服务质量。 服务限流后的常见处理…

电动汽车设计、制造、研发的学科、技术和前沿科技综述

引言&#xff1a;电动汽车作为替代传统燃油汽车的一种先进交通工具&#xff0c;不仅具有环保、低噪音等优势&#xff0c;而且对于能源消耗和气候变化等全球性问题也具有重要意义。本文将综述与电动汽车设计、制造、研发相关的学科、技术和前沿科技&#xff0c;以期对电动汽车领…

MATLAB /Simulink 快速开发STM32(使用st官方工具 STM32-MAT/TARGET),以及开发过程

配置好环境以后就是开发&#xff1a; stm32cube配置芯片&#xff0c;打开matlab添加ioc文件&#xff0c;写处理逻辑&#xff0c;生成代码&#xff0c;下载到板子中去。 配置需要注意事项&#xff1a; STM32CUBEMAX6.5.0 MABLAB2022BkeilV5.2 Matlab生成的代码CTRLB 其中关键的…

海外版金融理财系统源码 国际投资理财系统源码 项目投资理财源码

海外版金融理财系统源码 国际投资理财系统源码 项目投资理财源码

iPhone 8 Plus透明屏应用范围详解

iPhone 8 Plus是苹果公司于2017年推出的一款智能手机&#xff0c;它采用了全新的玻璃机身设计&#xff0c;支持无线充电&#xff0c;并且搭载了更强大的A11仿生芯片。 而透明屏则是一种新型的屏幕技术&#xff0c;可以使手机屏幕呈现出透明的效果。 透明屏是一种将屏幕背后的元…

百度智能云“千帆大模型平台”最新升级:接入Llama 2等33个模型!

今年3月&#xff0c;百度智能云推出“千帆大模型平台”。作为全球首个一站式的企业级大模型平台&#xff0c;千帆不但提供包括文心一言在内的大模型服务及第三方大模型服务&#xff0c;还提供大模型开发和应用的整套工具链&#xff0c;能够帮助企业解决大模型开发和应用过程中的…

在Ruoyi中采用Ajax动态生成Echarts图表实践

前言 在之前博文中&#xff0c;我们讲解了如何使用java在后台进行Echarts的图表生成组件&#xff0c;博文如下&#xff1a; 序号 博客连接1一款基于JAVA开发的Echarts后台生成框架2Ruoyi单体项目与Echarts4.2.1地图集成时的思路及解决办法3解决Ruoyi单体版本集成Echarts多图表时…

RocketMQ生产者和消费者都开启Message Trace后,Consume Message Trace没有消费轨迹

一、依赖 <dependency><groupId>org.apache.rocketmq</groupId><artifactId>rocketmq-spring-boot-starter</artifactId><version>2.0.3</version> </dependency>二、场景 1、生产者和消费者所属同一个程序 2、生产者开启消…

Xcode protobuf2.5添加arm64编译器补丁生成静态库

项目需求&#xff0c;protobuf源码编成静态库使用 但是&#xff0c;github上的protobuf源码没有对应arm64的编译器定义&#xff0c;编译出来的静态库使用时报错。 下面的连接是arm64编译器代码补丁包&#xff0c;把编译器代码放到src/google/protobuf/stubs/atomicops_intern…

二、JVM-深入运行时数据区

深入运行时数据区 计算机体系结构 JVM的设计实际上遵循了遵循冯诺依曼计算机结构 CPU与内存交互图&#xff1a; 硬件一致性协议&#xff1a; MSI、MESI、MOSI、Synapse、Firely、DragonProtocol 摩尔定律 摩尔定律是由英特尔(Intel)创始人之一戈登摩尔(Gordon Moore)提出来…

基于Caffe的静默活体检测识别分析系统

周末的时候看到一个好玩的项目就想着实际拿来使用一下&#xff0c;这个项目主要是做的是开源的跟人脸活体检测相关的内容&#xff0c;这里主要采用的是静默活体检测的方式。 人脸静默活体检测是一种用于验证人脸是真实、活体的技术&#xff0c;而不需要进行任何口头指令或特定…

自监督去噪:Noise2Noise原理及实现(Pytorch)

文章地址&#xff1a;https://arxiv.org/abs/1803.04189 ICML github 代码: https://github.com/NVlabs/noise2noise 本文整理和参考代码: https://github.com/shivamsaboo17/Deep-Restore-PyTorch 文章目录 1. 理论背景2. 实验结果3. 代码实现(1) 网络结构(2) 数据加载(3) 网络…

Elasticsearchr入门

首先在官网下载elasticsearch8.9版本&#xff0c;以及8.9版本的kibana。 解压&#xff0c;点击es8.9bin目录下的elasticsearch.bat文件启动es 如图所示即为成功。 启动之后打开idea&#xff0c;添加依赖 <dependency><groupId>com.fasterxml.jackson.core</g…

后端进阶之路——Spring Security构建强大的身份验证和授权系统(四)

前言 「作者主页」&#xff1a;雪碧有白泡泡 「个人网站」&#xff1a;雪碧的个人网站 「推荐专栏」&#xff1a; ★java一站式服务 ★ ★前端炫酷代码分享 ★ ★ uniapp-从构建到提升★ ★ 从0到英雄&#xff0c;vue成神之路★ ★ 解决算法&#xff0c;一个专栏就够了★ ★ 架…

嵌入式:C高级 Day3

一、整理思维导图 二、判断家目录下&#xff0c;普通文件的个数和目录文件的个数 三、输入一个文件名&#xff0c;判断是否为shell脚本文件&#xff0c;如果是脚本文件&#xff0c;判断是否有可执行权限&#xff0c;如果有可执行权限&#xff0c;运行文件&#xff0c;如果没有可…

中科昊芯28034上手(1)--环境搭建

官网信息还是比较完整&#xff0c;不过需要下载阿里云盘。 1. 官网链接&#xff1a; start28034湖人开发板_北京中科昊芯科技有限公司 官网图片长这样&#xff1a; 实物有些出入&#xff1a; 基本功能差异不大。 2. 资料还是齐备的&#xff0c;不过案例好像都是平头哥的…

Java中的SPI机制与扫描class原理

文章目录 前言ClassLoaderJAVA SPI机制Spring SPI机制示例原理 如何加载jar包里的class 前言 Java的SPI机制与Spring中的SPI机制是如何实现的&#xff1f; ClassLoader 这里涉及到了class Loader的机制&#xff0c;有些复杂&#xff0c;jdk中提供默认3个class Loader&#x…