DS:二叉树的顺序结构及堆的实现

                                       创作不易,兄弟们给个三连!!

一、二叉树的顺序存储

      顺序结构指的是利用数组来存储,一般只适用于表示完全二叉树,原因如上图,存储不完全二叉树会造成空间上的浪费,有的人又会问,为什么图中空的位置不能存储呢??原因是我们需要根据数组的下标关系才能访问到对应的节点!!有以下两个下标关系公式:

1、父亲找孩子:leftchild=parent*2+1,rightchild=parent*2+2

2、孩子找父亲:parent=(child-1)/2   要注意,这边无论用左孩子算还是右孩子算都是可以的,因为一般俩说,(child-1)/2 由于int类型向下取整的特点,所以得到的结果都是一样的!!

      所以我们想要上面这种方式去访问节点,并且还不希望有大量的空间浪费,现实中只有堆才会使用数组存储,二叉树的顺序存储中在物理上是一个数组,再逻辑上是一颗二叉树!!

二、堆的概念及结构

    现实中我们把堆(类似完全二叉树)使用顺序结构来存储,要注意这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分区。

   如果有一个关键码的集合k,我们将他的全部元素按照完全二叉树的存储逻辑放在一个一维数组中,则成为堆,根节点最大的堆叫做大堆,根节点最小的堆叫做小堆。 

堆的性质:

1、堆中某个节点的值总是不大于或不小于其父节点的值

2、堆总是一颗完全二叉树

注意:并不一定有序 

三、堆的实现

假设我们实现小堆

3.1 相关结构体的创建

跟顺序表的形式是一样的,但是换了个名字

typedef int HPDataType;
typedef struct Heap
{
	HPDataType * a;
	int size;
	int capacity;
}Heap;

3.2 堆的初始化

void HeapInit(Heap* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}

3.3 堆的插入

堆的插入很简单,但是我们要保证堆插入后还能维持堆的形状

所以我们在插入后,还要进行向上调整,也就是孩子要根据下标关系找到自己的父亲去比较,小就交换

void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	//首先要判断是否需要扩容
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* temp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc fail");
			exit(1);
		}
	    //扩容成功
		php->a = temp;
		php->capacity = newcapacity;
	}
     //扩容后,我们插入这个元素并size++
	php->a[php->size++] = x;
	//但是插入之后可能会破坏堆的结构,所以我们需要这个元素和他的父辈进行逐个比较, 
	AdjustUp(php->a,php->size-1);//封装一个向上调整函数,传入数组和新加元素的下标
}

3.4 向上调整算法

void AdjustUp(HPDataType* a, int child)
{
	assert(a);
    //通过孩子找父亲  parent=(child-1)/2
	int parent = (child - 1) / 2;
	//孩子和父亲开始比较,如果孩子小,就交换,如果孩子大,退出循环
	while (child>0)//如果孩子变成了根节点,就没有必要再找了,因为已经没有父母了
		//如果用parent>=0来判断,那么由于(0-1)/2是-1/2,取整后还是0,就会一直死循环,所以必须用孩子来当循环条件
	{
		if (a[child] < a[parent])//孩子小,交换
		{
			Swap(&a[child], &a[parent]);
			//但是交换过后,可能还需要继续往上比,所以我们要让原来的父亲变成孩子,然后再找新的父亲进行比较
			child = parent;
			parent = (child - 1) / 2;
		}
		else//孩子大,退出
			break;
	}
}

注:这里的向上调整算法和后面向下调整算法我们都不用跟堆有关的接口,原因就是这个算法的运用范围很广,可以用在堆排序以及top-k问题中!!

3.5 交换函数

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

3.6 堆的删除

         一般来说,如果直接删除堆的最后一个元素,其实是没什么意义的,一行代码就可以搞定,没必要封装什么函数,所以这里的堆的删除指的是删除根部的元素!!

        

void HeapPop(Heap* php)//一般来说,堆中的删除指的是删除根位置的数据
//如果直接删除根然后往前挪动一位,那么亲缘关系就会十分混乱,为了能够尽量在调整中减少对关系的改变
//我们将根部元素与最后一个元素进行交换之后再删除,此时的根是原先的最后一个元素
//然后将该元素进行向下调整(封装一个函数,传入数组、元素个数、)
{
	assert(php);
	assert(!HeapEmpty(php));//为空的话没有删除的必要
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	//开始向下调整
	AdjustDown(php->a, php->size,0);
}

3.7 向下调整算法

void AdjustDown(HPDataType* a, int n,int parent)
{
	assert(a);
	//此时根部为原来的最后一个元素,往下比较
	//即通过父亲去找到自己的孩子,如果孩子比自己小,就得交换位置,如果孩子比自己大,就退出
	//但是因为父亲有一个左孩子parent*2+1,右孩子parent*2+2,我们选择孩子中较小的和自己交换
	int child = parent * 2 + 1;//假设左孩子比右孩子小
	while (child<n)//当child超出个数的时候结束
	{
		if (child+1<n && a[child + 1]<a[child])//如果右孩子比左孩子小,假设错误,修正错误
			//注意,一定不能写反,要注意只有左孩子没有右孩子的情况
			child++;
		if (a[child] < a[parent])//如果孩子小于父亲,交换
		{
			Swap(&a[child], &a[parent]);
			//交换完后,让原来的孩子变成父亲,然后再找新的孩子
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;//如果孩子大于等于父亲,直接退出
	}
}

       在上述算法中,我们应用了先假设再推翻的方法,一开始我们先假设左孩子比较小,然后我们再给个条件判断,如果左孩子大于右孩子,假设不成立,再推翻,这样可以保证我们的child变量一定是较小的孩子!! 

       虽然这里的parent很明显是从a[0]开始,好像不需要专门去传一个parent的参数,但是这也是为了之后的堆排序做准备!

3.8 取堆顶的数据

HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));//为空的话没有取的必要
	return php->a[0];
}

3.9 堆的数据个数

int HeapSize(Heap* php)
{
	assert(php);
	return php->size;
}

3.10 堆的判空

bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

3.11 堆的销毁

void HeapDestory(Heap* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

3.12 堆的打印(测试)

我们要实现堆的打印,利用我们之前封装的函数,每获取一次堆顶元素就删除一次,直到堆删完就可以获取全部的元素了!!

#include"Heap.h"
int main()//该方法实现堆的顺序打印
{
	Heap hp;
	HeapInit(&hp);
	int a[] = { 55,100,70,32,50,60 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
		HeapPush(&hp, a[i]);//不断进堆
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		printf("%d\n", top);
		HeapPop(&hp);
	}
	HeapDestory(&hp);
	return 0;
}

前面只是先创建一个堆,从while循环开始才是实现对堆的打印!!

运行结果 :32 50 55 60 70 100

          我们发现了一个情况:按道理来说堆只有父子节点之间有大小关系,兄弟之间没有的,但是我们最后打印出来的结果却完成了排序!!!下面我们来进行分析

     总之任何一个堆,我们都可以通过不断地pop去实现它的顺序打印!!堆排序后面会介绍!

四、堆实现的全部代码

4.1 Heap.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType * a;
	int size;
	int capacity;
}Heap;

void Swap(HPDataType* p1, HPDataType* p2);//实现父亲和孩子的交换
void AdjustUp(HPDataType* a, int child);//向上调整算法

// 堆的初始化
void HeapInit(Heap* php);
// 堆的插入
void HeapPush(Heap* php, HPDataType x);
// 堆的删除
void HeapPop(Heap* php);
// 取堆顶的数据
HPDataType HeapTop(Heap* php);
// 堆的数据个数
int HeapSize(Heap* php);
// 堆的判空
bool HeapEmpty(Heap* php);
// 堆的销毁
void HeapDestory(Heap* php);

4.2 Heap.c

#include"Heap.h"
//当前实现小堆
void HeapInit(Heap* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

void AdjustUp(HPDataType* a, int child)
{
	assert(a);
    //通过孩子找父亲  parent=(child-1)/2
	int parent = (child - 1) / 2;
	//孩子和父亲开始比较,如果孩子小,就交换,如果孩子大,退出循环
	while (child>0)//如果孩子变成了根节点,就没有必要再找了,因为已经没有父母了
		//如果用parent>=0来判断,那么由于(0-1)/2是-1/2,取整后还是0,就会一直死循环,所以必须用孩子来当循环条件
	{
		if (a[child] < a[parent])//孩子小,交换
		{
			Swap(&a[child], &a[parent]);
			//但是交换过后,可能还需要继续往上比,所以我们要让原来的父亲变成孩子,然后再找新的父亲进行比较
			child = parent;
			parent = (child - 1) / 2;
		}
		else//孩子大,退出
			break;
	}
}

void AdjustDown(HPDataType* a, int n,int parent)
{
	assert(a);
	//此时根部为原来的最后一个元素,往下比较
	//即通过父亲去找到自己的孩子,如果孩子比自己小,就得交换位置,如果孩子比自己大,就退出
	//但是因为父亲有一个左孩子parent*2+1,右孩子parent*2+2,我们选择孩子中较小的和自己交换
	int child = parent * 2 + 1;//假设左孩子比右孩子小
	while (child<n)//当child超出个数的时候结束
	{
		if (child+1<n && a[child + 1]<a[child])//如果右孩子比左孩子小,假设错误,修正错误
			//注意,一定不能写反,要注意只有左孩子没有右孩子的情况
			child++;
		if (a[child] < a[parent])//如果孩子小于父亲,交换
		{
			Swap(&a[child], &a[parent]);
			//交换完后,让原来的孩子变成父亲,然后再找新的孩子
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;//如果孩子大于等于父亲,直接退出
	}
}


void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	//首先要判断是否需要扩容
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* temp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc fail");
			exit(1);
		}
	    //扩容成功
		php->a = temp;
		php->capacity = newcapacity;
	}
     //扩容后,我们插入这个元素并size++
	php->a[php->size++] = x;
	//但是插入之后可能会破坏堆的结构,所以我们需要这个元素和他的父辈进行逐个比较, 
	AdjustUp(php->a,php->size-1);//封装一个向上调整函数,传入数组和新加元素的下标
}

void HeapPop(Heap* php)//一般来说,堆中的删除指的是删除根位置的数据
//如果直接删除根然后往前挪动一位,那么亲缘关系就会十分混乱,为了能够尽量在调整中减少对关系的改变
//我们将根部元素与最后一个元素进行交换之后再删除,此时的根是原先的最后一个元素
//然后将该元素进行向下调整(封装一个函数,传入数组、元素个数、)
{
	assert(php);
	assert(!HeapEmpty(php));//为空的话没有删除的必要
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	//开始向下调整
	AdjustDown(php->a, php->size,0);
}


HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php));//为空的话没有取的必要
	return php->a[0];
}

int HeapSize(Heap* php)
{
	assert(php);
	return php->size;
}

bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

void HeapDestory(Heap* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

4.3 test.c(测试)

#include"Heap.h"
int main()//该方法实现堆的顺序打印
{
	Heap hp;
	HeapInit(&hp);
	int a[] = { 55,100,70,32,50,60 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
		HeapPush(&hp, a[i]);//不断进堆
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		printf("%d\n", top);
		HeapPop(&hp);
	}
	HeapDestory(&hp);
	return 0;
}

五、堆的应用

5.1 堆排序

要对数组排序前,我们要用堆排序,首先要建堆!

大家看看之前堆的打印时的测试代码逻辑的方法

就是我们得到一个数组,就先建堆,然后先把数组push进去,再pop出来,是可以实现有序的

但是现在我们的需求不是打印出来,而是将他排好序后放进数组里,所以们可以这么写:

void HeapSort(int* a, int n)
{
	HP hp;
	HeapInit(&hp);
	// N*logN
	for (int i = 0; i < n; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	// N*logN
	int i = 0;
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		a[i++] = top;
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

 这个方法固然是可以的,但是很麻烦,原因如下:

1、每次都要建立一个新的堆,然后再销毁,比较麻烦,而且空间复杂度比较高 

2、我通过把数组放进变成堆,还要再把堆拷贝到数组中,数据的拷贝是很繁琐的!!

所以我们要思考一种方式避免数据的拷贝,所以就有了向上调整建堆和向下调整建堆的方法了!!

也就是我们在原数组的基础上直接建堆,然后向下调整排序即可,下面会详细介绍

5.1.1 向上调整建堆

 假设数组有n个元素

for (int i = 1; i < n; i++)
{
	AdjustUp(a, i);
}

5.1.2 向下调整建堆

for (int i = (n-1-1)/2; i >= 0; i--)
{
	AdjustDown(a, n, i);
}

5.1.3 堆排序的实现

那我们究竟选择向下建堆好还是向下建堆好呢??我们来分析一下

所以我们发现向上调整建堆的时间复杂度大概是N*logN,而向下调整建堆的时间复杂度是N

其实们在推导的时候也能发现,向上调整建堆是节点多的情况调整得多,节点少的情况调整的少,次数是多*多+少*少 ,而向下调整建堆是节点多的情况调整得少,节点少的情况调整的多,次数是多*少+少*多,显然是向下调整建堆是更有优势的!!

     接下去我们建好堆,就要想着怎么去排序了,我们思考一下,之前我们对堆的打印时,不断pop打印出来有序结果的原因是什么??原因就是pop函数里的向下调整算法!!每一次交换根节点和尾节点,将每个节点进行向下调整,最后就可以得到有序的

 

 因为我们之前实现的向下调整算法是小堆的,所以我们这边来实现一个降序的堆排序算法

void HeapSort(int* a, int n)
{
	//降序  建小堆
	//升序  建大堆
	for (int i = (n-1-1)/2; i >=0;i--)
		AdjustDown(a, n, i);
	//开始排序   先交换向下调整
	int end = n - 1;
	while (end >= 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

 

 如果我们想实现升序,将向下调整算法按照大堆的规则改一下就行 

向下调整算法和向上调整算法的空间复杂度都是(logN) 

堆排序中,建堆的时间复杂度是o(N),排序的时间复杂度是(N*logN)所以堆排序的总时间复杂度是N*logN

5.2 TOP-K问题

Top-k问题:即求数据中前k个最大的元素或者是最小的元素,一般情况下的数据量都比较大!

比如:专业前10名、世界五百强、富豪榜前十

堆排序能够帮助我们在大量数据中筛选出最好的几个。

5.2.1 思路

        比如说我们要从1000个学生的成绩中找到前10个分数最高的,方法就是将所有的数据放在一个数组里,直接建大堆,然后pop9次就可以找到了(pop中的向下调整算法可以使得每次pop出去的都是最大值,然后pop9次的原因是因为第10次就可以直接去获取堆顶元素即可)

但是有些情况,上述思路解决不了,分析:

5.2.2 通过数组验证TOP-K

void PrintTopK(int* a, int n, int k)
{
	//建前k个建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
		AdjustDown(a, k, i);
	//将剩余n个数据不断与堆顶元素比较,大就交换,然后向下调整
	for (int i = k; i < n; i++)
	{
		if (a[i] > a[0])
		{
			a[0] = a[i];//直接覆盖就行,不用交换
			AdjustDown(a, k, 0);
		}
	}
	//打印
	for(int i=0;i<k;i++)
	printf("%d ", a[i]);
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand((unsigned int)time(NULL));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;//随机数范围0-999999
	}
// 为了能够方便找到这些数
	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;
}

5.2.3 通过文件验证TOP-K

其实用数组的方法,并不能有效地模拟,我们可以尝试用文件的方式来验证

void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand((unsigned int)time(NULL));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);//将随机数写进文件
	}
	fclose(fin);
}

void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}

	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc fail");
		return;
	}

	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);//从文件读取数据
	}

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

	int val = 0;
	while (!feof(fout))//feof是文件结束的标识,如果返回1,则说明文件结束
	{
		fscanf(fout, "%d", &val);//fscaf的光标闪动到原先的位置,所以会从k的位置开始读
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}
int main()//该方法实现堆的顺序打印
{
	CreateNDate();
	PrintTopK(5);
	return 0;
}

友友们上述代码有不理解的,看看博主关于文件操作里的函数介绍:

C语言:文件操作详解-CSDN博客

 不太好找,所以我们可以先注释创造数据的文件,然后再文件中修该出5个最大数,然后再执行一次函数

以上就是通过数组验证top和利用文件验证tok的方法!!

 

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

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

相关文章

数据接收程序

#include<reg51.h> //包含单片机寄存器的头文件 sbit pPSW^0; /***************************************************** 函数功能&#xff1a;接收一个字节数据 ***************************************************/ unsigned char Receive(void) { unsigned…

【教3妹学编程-算法题】子集中元素的最大数量

2哥 : 3妹&#xff0c;今年过年收到压岁钱了没呢。 3妹&#xff1a;切&#xff0c;我都多大了啊&#xff0c;肯定没收了啊 2哥 : 俺也一样&#xff0c;不仅没收到&#xff0c;小侄子小外甥都得给&#xff0c;还倒贴好几千 3妹&#xff1a;哈哈哈哈&#xff0c;2叔叔&#xff0c…

Activation of network connection failed(ubuntu连不上网)

ubuntu连不上网&#xff0c;看了好几个方法找到个有用的记录一下 1. 还原默认设置 2. 更改适配器&#xff1a;加上vmware bridge protocol

新机Word/PowerPoint新建空白文档后闪退问题

首先可以尝试一下常规的修复&#xff1a; 设置-应用-安装的应用-搜索office-点击Micros Office Home and Student...右侧三个点-选择修改-点击是-快速修复-修复 再不行就按上面的选择联机修复&#xff0c;这个会卸载现有Office然后自动帮你重新下载 我做了以上两个都没有解决问…

Rust - 变量与数据的交互方式(move)

变量与数据的交互方式 - 移动 Rust 中的多个变量可以采用一种比较独特的方式和同一个数据进行交互&#xff0c;如下代码所示&#xff0c;将变量x的值赋给y&#xff1a; fn main() {let x 1;let y x; }我们大概可以推论出上述代码的原理&#xff1a;将1这个整数绑定给x变量&…

MATLAB | 情人节画个花瓣venn图?

之前七夕节情人节各种花&#xff0c;相册&#xff0c;爱心啥的都快画够了&#xff0c;今年画个花瓣韦恩图&#xff1f; 花瓣上的数字是仅属于该类的样本数&#xff0c;而中心的数字是属于每一类的样本数 教程部分 0 数据准备 % 给组起名t1 t2 t3...t15 setName compose(t%d,…

(13)Hive调优——动态分区导致的小文件问题

前言 动态分区指的是&#xff1a;分区的字段值是基于查询结果自动推断出来的&#xff0c;核心语法就是insertselect。 具体内容指路文章&#xff1a; https://blog.csdn.net/SHWAITME/article/details/136111924?spm1001.2014.3001.5501文章浏览阅读483次&#xff0c;点赞15次…

Linux rp_filter、arp_filter、arp_ignore、arp_announce参数说明

Linux rp_filter、arp_filter、arp_ignore、arp_announce参数说明。我查看了参考资料&#xff0c;又去查阅了官方文档&#xff0c;凭着我的理解整理了以下文档。各位大神的文档写的很好&#xff0c;但都不喜欢断句啊&#xff0c;读的我这叫一个累。 参考 1.网络编程之网络丢包…

【Pygame手册01/20】最简应用:窗口

目录 一、说明 二、pygame是什么&#xff1f; 2.1 为游戏开发设计 2.2 版本发展史 2.3 特点 三、pygame安装要点 四、入门知识 4.1 初始使用 4.2 要更改 pygame 窗口的外观 4.3 完整窗口程序 4.4 窗口对象接口示例 五、隐形窗口和显性窗口 六、结论 一、说明 为什…

vue_dev_tools工具下载安装打包

vue_dev_tools工具下载安装打包 一、简介二、安装方式2.1.安装图文2.2.打包工具 endl 一、简介 使用 Vue 时&#xff0c;在浏览器上安装 Vue Devtools Vue Devtools 是 Vue 官方发布的调试浏览器插件&#xff0c;可以安装在 Chrome 和 Firefox 等浏览器上&#xff0c;直接内嵌…

C++ STL: list使用及源码剖析

list使用 list常用函数及使用&#xff08;1&#xff09; #include <iostream> #include <list> #include <algorithm>int main() {// 创建liststd::list<int> myList {5, 2, 9, 1, 5, 6};// 打印liststd::cout << "Original list: &quo…

2024年2月份实时获取地图边界数据方法,省市区县街道多级联动【附实时geoJson数据下载】

首先&#xff0c;来看下效果图 在线体验地址&#xff1a;https://geojson.hxkj.vip&#xff0c;并提供实时geoJson数据文件下载 可下载的数据包含省级geojson行政边界数据、市级geojson行政边界数据、区/县级geojson行政边界数据、省市区县街道行政编码四级联动数据&#xff0…

Sentinel 流控-链路模式

链路模式 A B C 三个服务 A 调用 C B 调用 C C 设置流控 ->链路模式 -> 入口资源是 A A、B 服务 package com.learning.springcloud.order.controller;import com.learning.springcloud.order.service.BaseService; import org.springframework.beans.factory.annotatio…

代码随想录算法训练营29期|day51 任务以及具体安排

第九章 动态规划part08 139.单词拆分 class Solution {public boolean wordBreak(String s, List<String> wordDict) {HashSet<String> set new HashSet<>(wordDict);boolean[] valid new boolean[s.length() 1];valid[0] true;for (int i 1; i < s.…

unity的重中之重:组件

检查器&#xff08;Hierarchy&#xff09;面板中的所有东西都是组件。日后多数工作都是和组件打交道&#xff0c;包括调参、自定义脚本组件。 文章目录 12 游戏的灵魂&#xff0c;脚本组件13 玩转脚本组件14 尽职的一生&#xff0c;了解组件的生命周期15 不能插队&#xff01;…

Solidworks:油泵体设计

做一个更复杂的作业&#xff0c;油泵体设计。感觉Solidworks还是用的不熟&#xff0c;分了半天劲才做出来。 先上课本上的插图&#xff1a; 我的作业和课本差不多吧&#xff01; 再来个背面的照片&#xff1a; 课本提供了两种剖面展示的方法&#xff1a; 现在我也轻车熟路…

error An unexpected error occurred: “https://registry.npm.taobao.org

背景&#xff1a; 想使用yarn命令结果报错 问题原因&#xff1a; 原来证书到期了 http://registry.npm.taobao.org/ 把这个放到浏览器搜索的时候自动换成https://registry.npmmirror.com/ 方案&#xff1a; npm cache clean --forcenpm config set registry https://registry…

C++ new 和 malloc 的区别?

相关系列文章 C new 和 malloc 的区别&#xff1f; C内存分配策略​​​​​​​ 目录 1.引言 2.区别 2.1.申请的内存分配区域 2.2.类型安全和自动大小计算 2.3.构造函数和析构函数的调用 2.4.异常处理 2.5.配对简便性 2.6.new 的重载 2.7.关键字和操作符 3.总结 1.引…

考研高数(导数的定义)

总结&#xff1a; 导数的本质就是极限。 函数在某点可导就必连续&#xff0c;连续就有极限且等于该点的函数值。 例题1&#xff1a;&#xff08;归结原则的条件是函数可导&#xff09; 例题2&#xff1a; 例题3&#xff1a;

简单工厂模式-Simple Factory Pattern

原文地址:https://jaune162.blog/design-pattern/simple-factory-pattern/ 简介 简单工厂模式是一种非常常用的设计模式,但是并不属于GoF中的23种设计模式。简单设计模式有很多种实现方式。 本文我们就来讨论简单工厂模式的实现方式,以及如何借助Spring实现一个扩展性很好…