【数据结构与算法】堆 / 堆排序 / TopK问题（Heap）

news2024/11/17 4:44:18

文章目录

  • 1.堆
  • 2.C语言实现堆
    • 2.1 堆结构与基本操作
    • 2.2 其它辅助操作
    • 2.3 堆的基本操作
      • 2.3.1 插入
      • 2.3.2 删除
  • 3. 堆排序
  • 4. TopK
  • 5. 所有代码

1.堆

堆总是一棵完全二叉树，而完全二叉树更适合使用**顺序结构（数组）**存储，完全二叉树前h-1层是满的，最后一层不一定是满的，但节点一定连续的。需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
在这里插入图片描述
非完全二叉树不适合用数组来存储，因为存在空间浪费。而极端的二叉搜索树则会造成更多浪费，二叉搜索树即右孩子节点比父节点大，左孩子节点比父节点小的树。
在这里插入图片描述
使用数组存储二叉树，基于父子节点下标间的关系：leftchild = parent * 2 + 1，rightchild = parent * 2 + 2，parent = (child - 1) / 2，如果打破这种存储关系则数组无法表示二叉树，所以数组存储非完全二叉树注定要浪费空间。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。最大堆即任意一个父节点都大于等于孩子节点，最小堆即任意一个父节点都小于等于孩子节点。
在这里插入图片描述

满二叉树实际上也是一棵特殊的完全二叉树，树的每一层都是满节点即是满二叉树。满二叉树有这样一个规律，第一层的节点数为20，第二层节点数为21，假设树的高度为h，则第h层的节点数为2h-1，不难看出是一个等比数列，所以满二叉树的节点数量为2h-1。
在这里插入图片描述
基于这样一个规律，则完全二叉树最多有2h-1个节点，最少有2h-1个节点：[2h-1，2h-1]。知道了节点数量，也就知道了树的高度h：假设N是节点数量，N = 2h-1，则h = log2(N) + 1；N = 2h-1，则h = log2(N+1)。

2.C语言实现堆

2.1 堆结构与基本操作

堆结构看起来与顺序表无异，毕竟都是数组实现。不一样的是逻辑结构，顺序表是线性结构，堆是树形结构。堆的基本操作只有插入和删除，应用场景有堆排序和TopK（前k个最大或最小的数）。

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

// 堆结构
typedef int datatype;
typedef struct Heap {
	datatype* arr;
	int size;
	int capacity;
} Heap;

// 其它辅助操作
void HeapInit(Heap* heap);
void HeapDestroy(Heap* heap);
datatype HeapTop(Heap* heap); // 取堆顶元素
size_t HeapSize(Heap* heap);
bool HeapEmpty(Heap* heap);

// logn
void HeapPush(Heap* heap, datatype val);
void HeapPop(Heap* heap); // 删除堆顶元素
// 插入或删除时，堆向上、向下调整
void Swap(datatype* x, datatype* y);
void AdjustUp(datatype* arr, int child);
void AdjustDown(datatype* arr, int size, int parent);

// 堆排序 nlogn、求TopK nlogk
void HeapSort(datatype* arr, int size);
void PrintTopK(const char* file, int k);

2.2 其它辅助操作

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

void HeapDestroy(Heap* heap) {
	assert(heap);
	free(heap->arr);
	heap->arr = NULL;
	heap->size = heap->capacity = 0;
}

datatype HeapTop(Heap* heap) {
	assert(heap && heap->arr && heap->size > 0);
	return heap->arr[0];
}

size_t HeapSize(Heap* heap) {
	assert(heap);
	return heap->size;
}

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

2.3 堆的基本操作

2.3.1 插入

直接往数组插入数据，然后再向上调整即可。以构建最小堆举例，只要插入的数据比父节点小，就与父节点交换，重复这个操作直到不能再做交换。

void HeapPush(Heap* heap, datatype val) {
	assert(heap);
	if (heap->size == heap->capacity) { // 空间不够时扩容
		heap->capacity = heap->capacity == 0 ? 10 : heap->capacity * 2;
		datatype* tmp = realloc(heap->arr, sizeof(datatype) * heap->capacity);
		if (tmp == NULL) {
			perror("HeapPush malloc failed.");
			exit(-1);
		}
		heap->arr = tmp;
	}
	// 插入
	heap->arr[heap->size++] = val;
	AdjustUp(heap->arr, heap->size - 1);
}
void Swap(datatype* x, datatype* y) {
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
// logn
void AdjustUp(datatype* arr, int child) {
	int parent = (child - 1) / 2;
	while (child > 0 && arr[child] < arr[parent]) {
		Swap(&arr[child], &arr[parent]); // up
		child = parent;
		parent = (child - 1) / 2;
	}
}

如果将while循环的条件arr[child] < arr[parent]改成大于arr[child] > arr[parent]，则是调整构建最大堆。

Heap heap;
HeapInit(&heap);
// 建堆 nlogn
HeapPush(&heap, 67864);
HeapPush(&heap, 7432);
HeapPush(&heap, 854312);
HeapPush(&heap, 909876);
HeapPush(&heap, 8765);
HeapPush(&heap, 2345678);
HeapPush(&heap, 2563);
HeapPush(&heap, 12676);
HeapPush(&heap, 6543);
HeapPush(&heap, 2167);
for (int i = 0; i < heap.size; i++) {
	printf("%d ", heap.arr[i]);
}
HeapDestroy(&heap);

在这里插入图片描述

2.3.2 删除

删除堆元素，只能删除堆顶元素，这是合理的规定，其它诸如任意删除、删除最后一个元素的操作对堆而言都是没有意义的。

如果是直接删除堆顶元素，数组剩下的元素不再构成堆，所以不能这么做。还是以最小堆为例，（1）标准的实现是：将堆顶元素与数组最后一个元素进行交换，即最小的数与较大的数交换，接着删除最后一个元素，然后再向下调整，目的是将堆顶元素往下沉，重新构建最小堆；（2）向下调整的思路：从左右孩子节点中选出最小的，这个孩子节点比父节点小就做交换，重复这个操作。

void HeapPop(Heap* heap) {
	assert(heap && heap->arr && heap->size > 0);
	Swap(&heap->arr[0], &heap->arr[--heap->size]);
	AdjustDown(heap->arr, heap->size, 0);
}
void Swap(datatype* x, datatype* y) {
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
// logn
void AdjustDown(datatype* arr, int size, int parent) {
	int child = parent * 2 + 1; // left or right 
	child = child + 1 < size && arr[child + 1] < arr[child]
										? ++child : chi
	// child<parent调整为小堆，child>parent调整为大堆 
	while (child < size && arr[child] < arr[parent]) {
		Swap(&arr[child], &arr[parent]); // down
		parent = child;
		child = parent * 2 + 1; // left or right
		child = child+1 < size && arr[child+1] < arr[child]
										? ++child : child;
	}
}

如果将arr[child + 1] < arr[child]改成arr[child + 1] > arr[child]，以及while循环的条件arr[child] < arr[parent]改成大于arr[child] > arr[parent]，则是调整构建最大堆。

Heap heap;
HeapInit(&heap);
// 建堆 nlogn
HeapPush(&heap, 67864);
HeapPush(&heap, 7432);
HeapPush(&heap, 854312);
HeapPush(&heap, 909876);
HeapPush(&heap, 8765);
HeapPush(&heap, 2345678);
HeapPush(&heap, 2563);
HeapPush(&heap, 12676);
HeapPush(&heap, 6543);
HeapPush(&heap, 2167);
while (!HeapEmpty(&heap)) {
	printf("%d ", HeapTop(&heap));
	HeapPop(&heap);
}
HeapDestroy(&heap);

在这里插入图片描述
这其实相当于排了个序，时间复杂度为nlogn。不过由于还有插入操作的时间复杂度nlogn，所以整体时间复杂度为2n*2logn。

另外这也能解决TopK问题：

int k = 3; 
while (k--) {
	printf("%d ", HeapTop(&heap));
	HeapPop(&heap);
}

3. 堆排序

前面借助堆基本操作Top和Pop也能做到堆排序，不过却比较麻烦，因为需要实现堆的基本操作。这里所指的堆排序是指，直接将数组构建成堆然后排序，不包含建堆的时间则堆排序的时间复杂度为nlogn。
在这里插入图片描述

// 排升序则构建大堆，排降序则构建小堆
void HeapSort(datatype* arr, int size) {
	// 建堆 O(nlogn) 
	//for (int i = 1; i < size; ++i) {
	//	AdjustUp(arr, i);  
	//}

	// 建堆 O(n) 并非是nlogn
	for (int i = (size - 1 - 1) / 2; i >= 0; --i) {
		AdjustDown(arr, size, i);
	}

	// 排序 O(nlogn)
	for (int end = size - 1; end > 0; --end) {
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
	}
}

利用向下调整建堆的时间复杂度为O(n)的原因是，最后一层不需要向下调整，直接从倒数第二层开始向下调整，这节省了很多时间复杂度，毕竟最后一层的节点占了堆节点总数一半。每一层的节点数量越多，向下调整次数越少；每一层的节点数量越少，向下调整的次数才越多。

而利用向上调整构建堆，从最后一层的节点往上，则会耗费较多时间复杂度，因为最后一层也需要向上调整。

4. TopK

如果数据量太大，比如一千万个数据，以int来算则是四千万字节，差不多相当于40G内存，如果还是按以前那样将所有数据插入堆中求TopK显然是不可能的。

void PrintTopK(const char* file, int k) {
	// 文件
	FILE* fr = fopen(file, "r");
	if (fr == NULL) {
		perror("PrintTopK fopen failed.");
		exit(-1);
	}

	// 大小为k的堆
	datatype* minheap = (datatype*)malloc(sizeof(datatype) * k);
	if (minheap == NULL) {
		perror("PrintTopK malloc failed.");
		exit(-1);
	}
	// 从文件读取前k个建小堆
	for (int i = 0; i < k; i++) {
		fscanf(fr, "%d", &minheap[i]);
		AdjustUp(minheap, i); // child<parent
	}

	// 从文件挨个读取，寻找TopK
	int val = 0;
	while (fscanf(fr, "%d", &val) != EOF) {
		if (val > *minheap) {
			*minheap = val; 
			// 大的往下沉 child<parent
			AdjustDown(minheap, k, 0); 
		}
	}

	// 打印TopK
	for (int i = 0; i < k; i++) {
		printf("%d ", minheap[i]);
	}
	printf("\n");
	free(minheap);
	minheap = NULL;
	fclose(fr);
}

5. 所有代码

#pragma once

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

// 堆结构
typedef int datatype;
typedef struct Heap {
	datatype* arr;
	int size;
	int capacity;
} Heap;

void HeapInit(Heap* heap);
void HeapDestroy(Heap* heap);

void HeapPush(Heap* heap, datatype val);
void HeapPop(Heap* heap);
// 插入或删除时，堆向上、向下调整
void Swap(datatype* x, datatype* y);
void AdjustUp(datatype* arr, int child);
void AdjustDown(datatype* arr, int size, int parent);

datatype HeapTop(Heap* heap);
size_t HeapSize(Heap* heap);
bool HeapEmpty(Heap* heap);

// 堆排序、求TopK
void HeapSort(datatype* arr, int size);
void PrintTopK(const char* file, int k);

#define _CRT_SECURE_NO_WARNINGS 1

#include "Heap.h"

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

void HeapDestroy(Heap* heap) {
	assert(heap);
	free(heap->arr);
	heap->arr = NULL;
	heap->size = heap->capacity = 0;
}

void HeapPush(Heap* heap, datatype val) {
	assert(heap);
	if (heap->size == heap->capacity) {
		heap->capacity = heap->capacity == 0 ? 10 : heap->capacity * 2;
		datatype* tmp = realloc(heap->arr, sizeof(datatype) * heap->capacity);
		if (tmp == NULL) {
			perror("HeapPush malloc failed.");
			exit(-1);
		}
		heap->arr = tmp;
	}
	heap->arr[heap->size++] = val;
	AdjustUp(heap->arr, heap->size - 1);
}

void HeapPop(Heap* heap) {
	assert(heap && heap->arr && heap->size > 0);
	Swap(&heap->arr[0], &heap->arr[--heap->size]);
	AdjustDown(heap->arr, heap->size, 0);
}

datatype HeapTop(Heap* heap) {
	assert(heap && heap->arr && heap->size > 0);
	return heap->arr[0];
}

size_t HeapSize(Heap* heap) {
	assert(heap);
	return heap->size;
}

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

void Swap(datatype* x, datatype* y) {
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void AdjustUp(datatype* arr, int child) {
	int parent = (child - 1) / 2;
	while (child > 0 && arr[child] < arr[parent]) {
		Swap(&arr[child], &arr[parent]); // up
		child = parent;
		parent = (child - 1) / 2;
	}
}

void AdjustDown(datatype* arr, int size, int parent) {
	int child = parent * 2 + 1; //child+1为右孩子节点
	child = child + 1 < size && arr[child + 1] < arr[child]
										? ++child : child;
	// child<parent调整为小堆，child>parent调整为大堆 
	while (child < size && arr[child] < arr[parent]) {
		Swap(&arr[child], &arr[parent]); // down
		parent = child;
		child = parent * 2 + 1; // left or right
		child = child+1 < size && arr[child+1] < arr[child]
										? ++child : child;
	}
}

// 升序构建大堆，降序构建小堆
void HeapSort(datatype* arr, int size) {
	// 建堆 O(nlogn) 
	//for (int i = 1; i < size; ++i) {
	//	AdjustUp(arr, i);  
	//}

	// 建堆 O(n) 
	for (int i = (size - 1 - 1) / 2; i >= 0; --i) {
		AdjustDown(arr, size, i);
	}

	// 排序 O(nlogn)
	for (int end = size - 1; end > 0; --end) {
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
	}
}

void PrintTopK(const char* file, int k) {
	// 文件
	FILE* fr = fopen(file, "r");
	if (fr == NULL) {
		perror("PrintTopK fopen failed.");
		exit(-1);
	}

	// 大小为k的堆
	datatype* minheap = (datatype*)malloc(sizeof(datatype) * k);
	if (minheap == NULL) {
		perror("PrintTopK malloc failed.");
		exit(-1);
	}
	// 从文件读取前k个建小堆
	for (int i = 0; i < k; i++) {
		fscanf(fr, "%d", &minheap[i]);
		AdjustUp(minheap, i); // child<parent
	}

	// 从文件挨个读取，寻找TopK
	int val = 0;
	while (fscanf(fr, "%d", &val) != EOF) {
		if (val > *minheap) {
			*minheap = val; 
			// 大的往下沉 child<parent
			AdjustDown(minheap, k, 0); 
		}
	}

	// 打印TopK
	for (int i = 0; i < k; i++) {
		printf("%d ", minheap[i]);
	}
	printf("\n");
	free(minheap);
	minheap = NULL;
	fclose(fr);
}

#define _CRT_SECURE_NO_WARNINGS 

#include "Heap.h"
#include <time.h>

static void CreateNData();

int main() {
	//Heap heap;
	//HeapInit(&heap);
	 建堆 nlogn
	//HeapPush(&heap, 67864);
	//HeapPush(&heap, 7432);
	//HeapPush(&heap, 854312);
	//HeapPush(&heap, 909876);
	//HeapPush(&heap, 8765);
	//HeapPush(&heap, 2345678);
	//HeapPush(&heap, 2563);
	//HeapPush(&heap, 12676);
	//HeapPush(&heap, 6543);
	//HeapPush(&heap, 2167);
	//printf("%zd\n", HeapSize(&heap));
	//for (int i = 0; i < heap.size; i++) {
	//	printf("%d ", heap.arr[i]);
	//}
	//printf("\n");

	// top k
	//int k = 3; 
	//while (k--) {
	//	printf("%d ", HeapTop(&heap));
	//	HeapPop(&heap);
	//}
	//printf("\n");

	// Push nlogn + 排序 nlogn =  O(2nlogn)
	//while (!HeapEmpty(&heap)) {
	//	printf("%d ", HeapTop(&heap));
	//	HeapPop(&heap);
	//}
	//HeapDestroy(&heap);
	//printf("\n");

	// 堆排序
	//int arr[] = { 67864,7432,854312,909876,8765,2345678,2563,12676,6543,2167 };
	//HeapSort(arr, sizeof arr / sizeof arr[0]);
	//for (int i = 0; i < sizeof arr / sizeof arr[0]; i++) {
	//	printf("%d ", arr[i]);
	//}

	// 大量数据下的TopK
	//CreateNData(); 
	PrintTopK("data.txt", 6);
	return 0;
}

static void CreateNData() {
	int n = 100000;
	srand((unsigned int)time(0));
	FILE* fw = fopen("data.txt", "w");
	if (fw == NULL) {
		perror("CreateNData fopen failed.");
		exit(-1);
	}
	for (int i = 0; i < n; i++) {
		fprintf(fw, "%d\n", rand() % n);
	}
	fclose(fw);
}

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

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

相关文章

蓝桥杯省赛无忧 课件92 行列式

蓝桥杯省赛无忧 课件92 行列式

01 什么是行列式 02 行列式的性质 03 高斯消元求行列式
阅读更多...
linux之wsl2安装远程桌面

linux之wsl2安装远程桌面

0. 安装后的效果 1. wsl中打开terminal并安装库 sudo apt-get purge xrdp sudo apt install -y xrdp sudo apt install -y xfce4 sudo apt install -y xfce4-goodies 2.优化显示 sudo sed -i s/max_bpp32/#max_bpp32\nmax_bpp128/g /etc/xrdp/xrdp.ini sudo sed -i s/xserverbp…
阅读更多...
Linux下的多线程

Linux下的多线程

前面学习了进程、文件等概念&#xff0c;接下里为大家引入线程的概念 多线程 线程是什么&#xff1f;为什么要有线程&#xff1f;线程的优缺点Linux线程操作线程创建线程等待线程终止线程分离 线程间的私有和共享数据理解线程库和线程id深刻理解Linux多线程&#xff08;重点&a…
阅读更多...
【Linux】gdb调试与make/makefile工具

【Linux】gdb调试与make/makefile工具

目录 导读 1. make/Makefile 1.1 引入 1.2 概念 1.3 语法规则 1.4 示例 2. Linux调试器-gdb 2.1 引入 2.2 概念 2.3 使用 导读 我们在上次讲了Linux编辑器gcc\g的使用&#xff0c;今天我们就来进一步的学习如何调试&#xff0c;以及makefile这个强大的工具。 1. mak…
阅读更多...
Hadoop3.x基础（4）- Yarn

Hadoop3.x基础（4）- Yarn

来源&#xff1a;B站尚硅谷 目录 Yarn资源调度器Yarn基础架构Yarn工作机制作业提交全过程Yarn调度器和调度算法先进先出调度器&#xff08;FIFO&#xff09;容量调度器&#xff08;Capacity Scheduler&#xff09;公平调度器&#xff08;Fair Scheduler&#xff09; Yarn常用命…
阅读更多...
《数电》理论笔记-第2章-组合逻辑电路

《数电》理论笔记-第2章-组合逻辑电路

一&#xff0c;集成门电路 1TTL门电路 TTL门电路中双极型三极管构成,它的特点是速度快、抗静电能力强集成度低、功耗大&#xff0c; 目前广泛应用于中、小规模集成电路中。 TTL门电路有 74 (商用) 和 54 (军用) 两大系列&#xff0c;每个系列中又有若干子系列。 2 CMOS门电路 …
阅读更多...
联合体的深入了解

联合体的深入了解

1.联合体类型的声明 像结构体一样&#xff0c;联合体也是由一个或者多个成员构成&#xff0c;这些成员可以不同的类型。 但是编译器只为最大的成员分配足够的内存空间。联合体的特点是所有成员共用同一块内存空间。所以联合体也叫&#xff1a;共用体。 给联合体其中一个成员赋值…
阅读更多...
洛希极限

洛希极限

L1-3 洛希极限 分数 10 作者 陈越 单位 浙江大学 科幻电影《流浪地球》中一个重要的情节是地球距离木星太近时&#xff0c;大气开始被木星吸走&#xff0c;而随着不断接近地木“…
阅读更多...
华为WLAN无线配置实验

华为WLAN无线配置实验

上面大概讲了配置的思路与原理&#xff0c;这里开始实际配置下。 一般建议采用旁挂AC&#xff0c;然后划分独立的设备管理网段&#xff0c;通过DHCP进行获取地址&#xff0c;其它的地址、接口、路由正常配置即可。 一、基本配置 拓扑图 AR1: # 配置接口地址和路由 interface Gi…
阅读更多...
Vision Transformer(一)：自注意力机制

Vision Transformer(一)：自注意力机制

1. 注意力机制 注意力本质上是模仿人的行为。这种行为可以描述为人在观察一些事物时&#xff0c;会对感兴趣的区域会产生更多的聚焦&#xff0c;而会选择性的忽视&#xff08;或者减少关注&#xff09;另一些区域。 举个简单的例子&#xff0c;一些对跑车感兴趣的人&#xff0…
阅读更多...
个人博客说明

个人博客说明

本人博客主要发布平台为博客园 https://www.cnblogs.com/carmi 更多详细&#xff0c;完整图片的文章还请师傅们动动小手到博客园去看吧。
阅读更多...
npm 上传一个自己的应用(5) 删除自己发送到NPM官网的指定工具版本

npm 上传一个自己的应用(5) 删除自己发送到NPM官网的指定工具版本

上文 npm 上传一个自己的应用(4) 更新自己上传到NPM中的工具版本 并就行内容修改 我们更新了项目内容 然后更新了项目版本 那么 一些已经过时 甚至 当时上传的东西就有问题 我们又该怎么删除版本呢&#xff1f; 首先 我们还是要先登录 npm npm login然后 根据要求填写 Userna…
阅读更多...
vue3 mathjax2.7.7 数学公式

vue3 mathjax2.7.7 数学公式

1. index.html代码部分 <script type"text/x-mathjax-config">MathJax.Hub.Config({extensions: ["tex2jax.js"],jax: ["input/TeX","output/HTML-CSS"],tex2jax: {inlineMath: [["$","$"],["\\(&quo…
阅读更多...
【C++航海王：追寻罗杰的编程之路】类与对象你学会了吗？(下)

【C++航海王：追寻罗杰的编程之路】类与对象你学会了吗？(下)

目录 1 -> 再谈构造函数1.1 -> 构造函数体赋值1.2 -> 初始化列表1.3 -> explicit关键字 2 -> static成员2.1 -> 概念2.2 -> 特性 3 -> 友元3.1 -> 友元函数3.2 -> 友元类 4 -> 内部类5 -> 匿名对象6 -> 拷贝对象时的一些编译器优化 1 -…
阅读更多...
Java基于微信小程序的学生实习管理小程序

Java基于微信小程序的学生实习管理小程序

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
自定义npm包从vue2升级到vue3遇到的问题解决

自定义npm包从vue2升级到vue3遇到的问题解决

1.执行npm run build时报错&#xff1a; (node:16724) UnhandledPromiseRejectionWarning: SyntaxError: Unexpected token ‘??’ at Loader.moduleStrategy (internal/modules/esm/translators.js:149:18 解决&#xff1a;更新node版本 查看了我使用的node版本是14.21.3&…
阅读更多...
精酿啤酒：啤酒的后熟与包装过程的品质保障

精酿啤酒：啤酒的后熟与包装过程的品质保障

啤酒的后熟与包装过程是确保产品品质的重要环节。对于Fendi Club啤酒来说&#xff0c;这一环节同样关键&#xff0c;它关系到啤酒的口感、风味和保质期的长短。 在啤酒的后熟过程中&#xff0c;Fendi Club啤酒酿造团队采用适当的温度和时间控制&#xff0c;让啤酒逐渐发展出更加…
阅读更多...
pycharm 配置 conda 新环境

pycharm 配置 conda 新环境

1. conda 创建新环境 本章利用pycharm将conda新建的环境载入进去 关于conda的下载参考上一章博文&#xff1a;深度学习环境配置&#xff1a;Anaconda 安装和 pip 源 首先利用conda 新建虚拟环境 这里按 y 确定 安装好如下&#xff1a;这里两行命令代表怎么激活和关闭新建的虚…
阅读更多...
前端JavaScript篇之数组的遍历方法有哪些？forEach和map方法有什么区别？

前端JavaScript篇之数组的遍历方法有哪些？forEach和map方法有什么区别？

目录 数组的遍历方法有哪些&#xff1f;forEach和map方法有什么区别&#xff1f;forEach()map()filter()for…ofevery() 和 some()find() 和 findIndex()reduce() 和 reduceRight()forEach和map方法有什么区别总结 数组的遍历方法有哪些&#xff1f;forEach和map方法有什么区别…
阅读更多...
辅助Qi2磁吸快充，新标准，新体验 - CPS8200

辅助Qi2磁吸快充，新标准，新体验 - CPS8200

前言 11月17日&#xff0c;随著Qi2认证Soft Launch 的结束&#xff0c;搭载易冲CPS8200的两款产品在韩国TTA实验室通过了Qi2 认证&#xff0c;预计WPC会在下周&#xff08; ~11月30号&#xff09;为这两款产品正式核发认证证书。 而CPS8200也成为目前唯一拥有两款产品通过认证的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023