探索数据结构：堆的具体实现与应用

news2024/11/18 15:33:52

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 堆的概念

堆(Heap)是计算机科学中一类特殊的数据结构。堆通常是一个可以被看作一棵完全二树的数组对象，若满足：

  • 任意节点的值>=其子节点的值。则称为大根堆。
  • 任意节点的值<=其子节点的值。则称为小根堆。

img

img

2. 堆的实现方式

虽然堆是一种特殊的二叉树，它既可以用数组存储也可以用链式存储。但是考虑到其完全二叉树的特性，我们最好采用数组存储的方式，因为这样既方便访问，也并不会浪费格外的空间。

img

假设某个合法下标为i：

  • 若双亲节点存在，下标为(i-1)/2。
  • 若孩子节点存在，左孩子下标为2i+1，右孩子为2i+2。

3. 堆的功能

  1. 堆的初始化。
  2. 堆的插入。
  3. 堆的删除。
  4. 获取堆顶的元素。
  5. 堆的元素个数。
  6. 堆的判空。
  7. 输出堆。
  8. 建堆。
  9. 销毁堆。

4. 堆的声明

因为我用数组实现堆，所以堆的声明与顺序表类似。

typedef int HpDataType;
typedef struct Heap 
{
	HpDataType* a;//存储数据
	int size;//大小
	int capacity;//容量
}Heap;

5. 堆的实现

5.1. 堆的初始化

5.1.1. 代码实现
void HeapInit(Heap* hp)//堆的初始化
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}
5.1.2. 复杂度分析
  • 时间复杂度：没有额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.2. 堆的插入

当我们堆进行插入时可能会破坏堆的原有结构，这时就需要我们对其进行向上调整。

img

5.2.1. 代码实现
void AdjustUp(Heap* hp, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (hp->a[child] > hp->a[parent])
		{
			swap(&hp->a[child], &hp->a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(Heap* hp, HpDataType x)//堆的插入
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HpDataType* tmp = (HpDataType*)realloc(hp->a, newCapacity * sizeof(HpDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newCapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp, hp->size - 1);//向上调整
}
5.2.2. 复杂度分析
  • 时间复杂度：假设有N个节点，高度为h，2h -1=N。至少调整log2(N+1)-1次，所以时间复杂度为logN。
  • 空间复杂度：没有开辟额外的空间，空间复杂度为O(1)。

5.3. 堆的删除

堆的删除是指删除堆顶的数据，如果我们删除堆顶元素并往前覆盖就可能打乱原有的亲缘关系。所以我们可以先将堆顶的元素与末尾元素交换，然后再进行向下调整·。

img

5.3.1. 代码实现
void swap(HpDataType* x1, HpDataType* x2)
{
	HpDataType tmp = *x1;
	*x1 = *x2;
	*x2 = tmp;
}
void 
void AdjustDown(int* 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])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else 
		{
			break;
		}
	}
}

void HeapPop(Heap* hp)//删除堆顶元素
{
	assert(hp);
	assert(hp->size > 0);
	swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;//删除最后一个数据
	AdjustDown(hp->a, hp->size, 0);//向下调整
}
5.3.2. 复杂度分析
  • 时间复杂度：假设有N个节点，高度为h，2h -1=N。至少调整log2(N+1)-1次，所以时间复杂度为logN。
  • 空间复杂度：没有开辟额外的空间，空间复杂度为O(1)。

5.4. 获取堆顶元素

5.4.1. 代码实现
HpDataType HeapTop(Heap* hp)//获取堆顶元素
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}
5.4.2. 复杂度分析
  • 时间复杂度：没有额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.5. 获取堆的元素个数

5.5.1. 代码实现
size_t HeapSize(Heap* hp)//堆的大小
{
	assert(hp);
	return hp->size;
}
5.5.2. 复杂度分析
  • 时间复杂度：没有额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.6. 判断堆是否为空

5.6.1. 代码实现
bool HeapEmpty(Heap* hp)//判断堆是否为空
{
	assert(hp);
	return hp->size == 0;
}
5.6.2. 复杂度分析
  • 时间复杂度：没有额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.7. 输出堆

5.7.1. 代码实现
void HeapDisplay(Heap* hp)//堆的打印
{
	for (int i = 0; i < hp->size; ++i)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}
5.7.2. 复杂度分析
  • 时间复杂度：遍历整个数组，时间复杂度为O(N)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.8. 建堆

5.8.1. 代码实现
void HeapCreatUp(Heap* hp,HpDataType* arr,int n)//向上调整建堆
{
	assert(hp && arr);
	for (int i = 0; i < n; i++)
	{
		HeapPush(hp, arr[i]);
	}
}
void HeapCreatDown(Heap* hp, HpDataType* arr, int n)//向下调整建堆
{
	assert(hp && arr);
	HpDataType* tmp = (HpDataType*)malloc(sizeof(HpDataType) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	hp->a = tmp;
	memcpy(hp->a, arr, sizeof(HpDataType) * n);
	hp->size = n;
	hp->capacity = n;
	for (int i = ((n - 1) - 1) / 2; i >= 0; i--)//从最后一个元素开始
	{
		AdjustDown(hp->a, n, i);
	}
}
5.8.2. 复杂度分析

假设高度为h，节点个数为N。如果是向上调整建堆：

img

F ( N ) = 2 1 × 1 + 2 2 × 2 + . . . + 2 h − 1 × ( h − 1 ) 2 F ( N ) = 2 2 × 1 + 2 3 × 2 + . . . + 2 h − 1 × ( h − 1 ) + 2 h × ( h − 1 ) 2 F ( N ) − F ( N ) = − 2 1 − 2 2 − 2 3 − . . . 2 h − 1 + 2 h × ( h − 1 ) = − 2 h + 2 − 2 h + 2 h × h F ( N ) = 2 h × ( h − 2 ) + 2 , N = 2 h − 1 F ( N ) = ( N + 1 ) × ( l o g 2 ( N + 1 ) − 2 ) + 2 F(N)=2^1×1+2^2×2+...+2^{h-1}×(h-1)\\ 2F(N)=2^2×1+2^3×2+...+2^{h-1}×(h-1)+2^h×(h-1)\\ 2F(N)-F(N)=-2^1-2^2-2^3-...2^{h-1}+2^h×(h-1)=-2^h+2-2^h+2^h×h\\ F(N)=2^h×(h-2)+2,N=2^h-1\\ F(N)=(N+1)×(log2(N+1)-2)+2 F(N)=21×1+22×2+...+2h−1×(h−1)2F(N)=22×1+23×2+...+2h−1×(h−1)+2h×(h−1)2F(N)−F(N)=−21−22−23−...2h−1+2h×(h−1)=−2h+2−2h+2h×hF(N)=2h×(h−2)+2,N=2h−1F(N)=(N+1)×(log2(N+1)−2)+2

如果是向下调整建堆：

img
F ( N ) = 2 h − 2 × 1 + 2 h − 3 × 2 + . . . + 2 0 × ( h − 1 ) 2 F ( N ) = 2 h − 1 × 1 + 2 h − 2 × 2 + . . . + 2 1 × ( h − 1 ) 2 F ( N ) − F ( N ) = 2 h − 1 + 2 h − 2 + . . . 2 1 − 2 0 × ( h − 1 ) = 2 h − 1 − h F ( N ) = 2 h − 1 − h , N = 2 h − 1 F ( N ) = N − l o g 2 ( N + 1 ） F(N)=2^{h-2}×1+2^{h-3}×2+...+2^0×(h-1)\\ 2F(N)=2^{h-1}×1+2^{h-2}×2+...+2^1×(h-1)\\ 2F(N)-F(N)=2^{h-1}+2^{h-2}+...2^1-2^0×(h-1)=2^h-1-h\\ F(N)=2^h-1-h,N=2^h-1\\ F(N)=N-log2(N+1） F(N)=2h−2×1+2h−3×2+...+20×(h−1)2F(N)=2h−1×1+2h−2×2+...+21×(h−1)2F(N)−F(N)=2h−1+2h−2+...21−20×(h−1)=2h−1−hF(N)=2h−1−h,N=2h−1F(N)=N−log2(N+1）

  • 时间复杂度：向上调整建堆最后一排调整h-1次，倒数第二排调整h-2次…时间复杂度为NlogN。向下调整建堆倒数第二排调整1次，倒数第二排调整2…第一排调整h-1次。时间复杂为O(N)。
  • 空间复杂度：无论是向上调整建堆还是向下调整建堆都需开辟N个空间，所以空间复杂度为O(N)。

5.9. 销毁堆

5.9.1. 代码实现
void HeapDestroy(Heap* hp)//销毁堆
{
	assert(hp);
	free(hp->a);
	hp->size = hp->capacity = 0;
}
5.9.2. 复杂度分析
  • 时间复杂度：没有额外的时间消耗，时间复杂度为O(1)。
  • 空间复杂度：没有额外的空间消耗，空间复杂度为O(1)。

5.10. 完整代码

5.10.1. Heap.h
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
typedef int HpDataType;
typedef struct Heap 
{
	HpDataType* a;//存储数据
	int size;//大小
	int capacity;//容量
}Heap;
void HeapInit(Heap* hp);//堆的初始化
void AdjustUp(Heap* hp, int child);//向上调整
void HeapPush(Heap* hp, HpDataType x);//堆的插入
bool HeapEmpty(Heap* hp);//判断堆是否为空
size_t HeapSize(Heap* hp);//堆的大小
void AdjustDown(int* a, int n, int parent);//向下调整
void HeapPop(Heap* hp);//删除堆顶元素
HpDataType HeapTop(Heap* hp);//获取堆顶元素
void HeapDisplay(Heap* hp);//堆的打印
void HeapDestroy(Heap* hp);//销毁堆
void HeapCreatUp(Heap* hp,HpDataType* arr, int n);//向上调整建堆
void HeapCreatDown(Heap* hp,HpDataType* arr, int n);//向下调整建堆
5.10.2. Heap.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
void HeapInit(Heap* hp)//堆的初始化
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}
void swap(HpDataType* x1, HpDataType* x2)
{
	HpDataType tmp = *x1;
	*x1 = *x2;
	*x2 = tmp;
}
void AdjustUp(Heap* hp, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (hp->a[child] > hp->a[parent])
		{
			swap(&hp->a[child], &hp->a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(Heap* hp, HpDataType x)//堆的插入
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HpDataType* tmp = (HpDataType*)realloc(hp->a, newCapacity * sizeof(HpDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newCapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp, hp->size - 1);//向上调整
}
void AdjustDown(int* 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])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else 
		{
			break;
		}
	}
}

void HeapPop(Heap* hp)//删除堆顶元素
{
	assert(hp);
	assert(hp->size > 0);
	swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;//删除最后一个数据
	AdjustDown(hp->a, hp->size, 0);//向下调整
}

HpDataType HeapTop(Heap* hp)//获取堆顶元素
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}

bool HeapEmpty(Heap* hp)//判断堆是否为空
{
	assert(hp);
	return hp->size == 0;
}

size_t HeapSize(Heap* hp)//堆的大小
{
	assert(hp);
	return hp->size;
}

void HeapDisplay(Heap* hp)//堆的打印
{
	for (int i = 0; i < hp->size; ++i)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}
void HeapCreatUp(Heap* hp,HpDataType* arr,int n)//向上调整建堆
{
	assert(hp && arr);
	for (int i = 0; i < n; i++)
	{
		HeapPush(hp, arr[i]);
	}
}
void HeapCreatDown(Heap* hp, HpDataType* arr, int n)//向下调整建堆
{
	assert(hp && arr);
	HpDataType* tmp = (HpDataType*)malloc(sizeof(HpDataType) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	hp->a = tmp;
	memcpy(hp->a, arr, sizeof(HpDataType) * n);
	hp->size = n;
	hp->capacity = n;
	for (int i = ((n - 1) - 1) / 2; i >= 0; i--)//从最后一个元素开始
	{
		AdjustDown(hp->a, n, i);
	}
}
void HeapDestroy(Heap* hp)//销毁堆
{
	assert(hp);
	free(hp->a);
	hp->size = hp->capacity = 0;
}

6. Top-K问题

6.1. 问题分析

Top-K问题简单来说就是求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。这个问题在我们日常生活中非常常见，比如说：游戏中活跃度前十的玩家，世界五百强企业等等。

解决这个问题常见的思路就是遍历或者排序，但是当数据量较大时这种方法就并不适用了。这时我们就需要建堆来处理，具体操作方法如下：

  1. 用数据集合中前K个元素来建堆。
  • 前k个最大的元素，则建小堆。
  • 前k个最小的元素，则建大堆。
  • 用剩余的N - K个元素依次与堆顶元素来比较，不满足条件则替换堆顶元素。
void TopK(int* a, int n, int k)
{
	//建堆
	int* kminHeap = (int*)malloc(sizeof(int) * k);
	if (kminHeap == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//将前k个数据放入堆中
	for (int i = 0; i < k; i++)
	{
		kminHeap[i] = a[i];
	}
	//向下调整法建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminHeap, k, i);
	}
	//依次比较
	for (int i = k; i < n; i++)
	{
		if (a[i] > kminHeap[0])
		{
			kminHeap[0] = a[i];
			AdjustDown(kminHeap, k, 0);
		}
	}
	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);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		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;
	TopK(a, n, 10);
}

img

6.2. 复杂度分析

  • 时间复杂度：建堆时间为K，向下调整的最坏时间为(N-K)*logK。所以时间复杂度为NlogK。
  • 空间复杂度：建堆会开辟K的个空间，所以空间复杂度为logK。

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

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

相关文章

vue2人力资源项目8员工详情

vue2人力资源项目8员工详情

页面结构 <template><div class"dashboard-container"><div class"app-container"><div class"edit-form"><el-form ref"userForm" label-width"220px"><!-- 姓名 部门 --><el-row…
阅读更多...
自定义el-select下拉菜单的内容以及数据回显的内容

自定义el-select下拉菜单的内容以及数据回显的内容

最终的效果 下拉选项的自定义内容好实现&#xff0c;因为他有默认插槽&#xff0c;所以直接在el-option标签里面写自定义内容就可以实现 <el-selectref"seriesBorderTypeRef"class"series-border-type"change"changeSeriesBorderType"v-model…
阅读更多...
Linux 磁盘分区工具 gdisk / fdisk

Linux 磁盘分区工具 gdisk / fdisk

fdisk 是传统的 Linux 磁盘分区工具&#xff0c;磁盘容量有2T的大小限制&#xff1b;gdisk 又叫 GPT fdisk, 作为 fdisk 的升级版&#xff0c;主要使用的是GPT分区类型&#xff0c;用来划分容量大于2T的硬盘&#xff0c;本文介绍使用方法。 简介 早期的磁盘使用 fdisk 工具分区…
阅读更多...
推荐网站（8）iconfinder图标网站，包含大量图标

推荐网站（8）iconfinder图标网站，包含大量图标

今天推荐网站iconfinder&#xff0c;他是一个包含大量图标网站&#xff0c;你可以找到自己想要的图标在里面&#xff0c;各种图标任你选择。 比如搜索appple图标 链接直达&#xff1a;https://www.iconfinder.com
阅读更多...
堆排序 之实现数据流中的中位数

堆排序 之实现数据流中的中位数

实现语言&#xff1a;Python3.9 题目来源&#xff1a;牛客 实现步骤&#xff1a; 1、使用堆的方式实现&#xff0c;具体实现思路&#xff1a;我们把数据从中点位置分为两个部分&#xff0c;前一部分构建成大顶堆A&#xff0c;后一部分构建成小顶堆B&#xff08;注意前半部分的…
阅读更多...
嵌入式Linux：编译和使用Protobuf库

嵌入式Linux：编译和使用Protobuf库

目录 1、开发环境和工具 2、安装和编译Protobuf、Protobuf-C库 3、编写和编译proto文件 4、修改makefile文件 5、测试示例 6、参考资料 Protobuf&#xff08;Protocol Buffers&#xff09;是由 Google 开发的一种轻量级、高效的结构化数据序列化方式&#xff0c;用于在不同应用…
阅读更多...
运维别卷系列 - 云原生监控平台 之 01.prometheus 入门和部署

运维别卷系列 - 云原生监控平台 之 01.prometheus 入门和部署

文章目录 [toc]什么是 PrometheusPrometheus 架构及其一些生态系统组件Prometheus 的工作模式Prometheus 的适用场景Prometheus 的不适用场景Prometheus 词汇表 Prometheus 启动参数Prometheus 配置文件通用占位符定义配置文件示例解释服务发现 Prometheus 部署创建 namespace创…
阅读更多...
c++编程（11）——string类的模拟实现

c++编程（11）——string类的模拟实现

欢迎来到博主的专栏——c编程 博主ID&#xff1a;代码小豪 文章目录 前言string类的模拟实现string的成员对象构造、赋值、析构访问成员对象的接口访问字符串中的元素迭代器对字符序列的插入、删除元素操作mystring类的相关操作 mystring类的所有模拟实现以及测试案例 前言 本…
阅读更多...
探索 Canva 的功能以及如何有效使用 Canva

探索 Canva 的功能以及如何有效使用 Canva

『创意瞬间变现&#xff01;Canva AI Drawing 让你的文字描绘成艺术』 在数字设计和创意领域&#xff0c;Canva 是创新和用户友好性的灯塔。这个平台不仅简化了图形设计&#xff0c;还引入了 AI Drawing 等强大工具&#xff0c;使其成为专业人士和初学者的首选解决方案。让我们…
阅读更多...
589.N叉树的前序遍历

589.N叉树的前序遍历

刷算法题&#xff1a; 第一遍&#xff1a;1.看5分钟&#xff0c;没思路看题解 2.通过题解改进自己的解法&#xff0c;并且要写每行的注释以及自己的思路。 3.思考自己做到了题解的哪一步&#xff0c;下次怎么才能做对(总结方法) 4.整理到自己的自媒体平台。 5.再刷重复的类…
阅读更多...
MySQL数据库核心面试题

MySQL数据库核心面试题

数据库中的引擎 常用的引擎有InnoDB、MyIsam、Memory三种。 MyIsam&#xff1a;组织形式分为三种&#xff1a; frm文件存储表结构、MyData文件存储表中的数据、MyIndex文件存储表的索引数据。是分开存储的。 Memory&#xff1a;基于内存的&#xff0c;访问速度快&#xff0…
阅读更多...
【Vue】更换vue-element-admin左侧 logo

【Vue】更换vue-element-admin左侧 logo

准备&#xff1a;目标svg格式的 logo&#xff0c;并将目标logo命名为 vuejs-fill.svg替换路径&#xff1a;/icons 文件夹下&#xff0c;覆盖掉原本的 vuejs-fill.svg 原因&#xff1a;配置项的logo设置的是 vuejs-fill
阅读更多...
element-ui的表单中，输入框、级联选择器的长度设置

element-ui的表单中，输入框、级联选择器的长度设置

使用<el-col>控制输入框的长度 <el-form-item label"姓名" label-width"80px"><el-col :span"15"><el-input v-model"form.name" autocomplete"off"></el-input></el-col></el-form…
阅读更多...
天锐绿盾｜设计院图纸透明加密软件、制造业文件资料防止外泄

天锐绿盾｜设计院图纸透明加密软件、制造业文件资料防止外泄

#图纸加密软件# 天锐绿盾是一家专注于数据安全解决方案的提供商&#xff0c;其产品主要为企业级用户设计&#xff0c;旨在保护敏感信息和知识产权免遭未经授权的访问或泄露。"天锐绿盾"的图纸透明加密软件和机械制造业文件资料防止外泄系统&#xff0c;是专为设计院…
阅读更多...
【NodeMCU实时天气时钟温湿度项目 7】和风天气API返回JSON数据信息的解压缩实现——ArduinoUZlib功能库

【NodeMCU实时天气时钟温湿度项目 7】和风天气API返回JSON数据信息的解压缩实现——ArduinoUZlib功能库

今天是第七专题&#xff0c;主要内容是&#xff1a;导入ArduinoUZlib功能库&#xff0c;借助该库把从【和风天气】官网返回的经过Gzip压缩的JSON数据&#xff0c;进行解压缩和t解析&#xff0c;在串口监视器上输出解析后的JSON信息。 如您需要了解其它专题的内容&#xff0c;请…
阅读更多...
做抖店不能踩的几个坑，新手要照做，老玩家要听劝~

做抖店不能踩的几个坑，新手要照做，老玩家要听劝~

我是王路飞。 很多人都说抖店的运营很简单&#xff0c;选选品、对接一下达人&#xff0c;就可以坐等店铺出单了。 这话骗骗还没开店的小白也就得了&#xff0c;但凡做抖店超过一个月的&#xff0c;都不会相信这句话。 细心耐心是做抖店最基本的态度。 拿到一个好结果的前提…
阅读更多...
24深圳杯C题18页高质量论文＋可执行代码＋图表

24深圳杯C题18页高质量论文＋可执行代码＋图表

比赛题目的完整版思路可执行代码数据参考论文都会在第一时间更新上传的&#xff0c;大家可以参考我往期的资料&#xff0c;所有的资料数据以及到最后更新的参考论文都是一次付费后续免费的。注意&#xff1a;&#xff08;建议先下单占坑&#xff0c;因为随着后续我们更新资料数…
阅读更多...
Host is not allowed to connect to this MySQL server解决方法

Host is not allowed to connect to this MySQL server解决方法

在阿里云服务器上安装了Mysql数据库&#xff0c;在阿里云上使用一切正常。我用navicat 去连接服务器时显示Host is not allowed to connect to this MySQL server。 ​ 看见这个错误&#xff0c;第一反应是是不是阿里云服务器防火墙没有配置mysq的出入站规则。去阿里云检查了一…
阅读更多...
08 必会框架 - Spring全家桶

08 必会框架 - Spring全家桶

本课时主要介绍 Java 中常用的应用框架&#xff0c;重点讲解如下三部分内容。 Spring 框架中的主要知识点&#xff1b; NIO 框架 Netty 以及基于 Netty 实现的主流 RPC 框架 Motan、Dubbo 和 gRPC&#xff1b; ORM 框架 MyBatis。 常用框架汇总 先来看常用框架的知识点汇总…
阅读更多...
基于springboot实现的在线动漫信息平台

基于springboot实现的在线动漫信息平台

开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09; 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023