数据结构10:堆和堆排序

ops/2024/9/20 1:28:51/ 标签: 数据结构, c语言

文章目录

  • 树的概念及结构
    • 树的概念
    • 树的相关概念
    • 树的表示
    • 树在实际中的应用
      • 表示文件系统的目录树结构
  • 二叉树概念及结构
    • 概念
    • 特殊的二叉树
    • 二叉树的性质
    • 二叉树的存储结构
    • 顺序存储
    • 链式存储
  • 二叉树的顺序结构及实现
    • 二叉树的顺序结构
    • 堆的概念及结构
  • 堆的实现
    • 堆的插入
    • 堆的删除
    • 堆的创建
      • 向上调整法
      • 向下调整法
    • 堆的销毁
    • 取堆顶的数据
    • 堆的数据个数
    • 堆的判空
  • 堆的应用
    • 堆排序
    • TOP-k问题
  • 堆的实现参考代码
    • 头文件
      • Heap.h
    • 实现文件
      • Heap.c
    • 测试文件
      • test.c

树的概念及结构

树的概念

树是一种非线性数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。

有一个特殊的结点,称为根结点,根节点没有前驱结点。
除根节点外,其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm,其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱,可以有0个或多个后继。因此,树是递归定义的

二叉树
注意:树形结构中,子树之间不能有交集,否则就不是树形结构
树与非树

树的相关概念

在这里插入图片描述
节点的度:一个节点含有的子树的个数称为该节点的度; 如上图:A的为6
叶节点或终端节点:度为0的节点称为叶节点; 如上图:B、C、H、I…等节点为叶节点
非终端节点或分支节点:度不为0的节点; 如上图:D、E、F、G…等节点为分支节点
双亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点; 如上图:A是B的父节点
孩子节点或子节点:一个节点含有的子树的根节点称为该节点的子节点; 如上图:B是A的孩子节点
兄弟节点:具有相同父节点的节点互称为兄弟节点; 如上图:B、C是兄弟节点
树的度:一棵树中,最大的节点的度称为树的度; 如上图:树的度为6
节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推;
树的高度或深度:树中节点的最大层次; 如上图:树的高度为4
堂兄弟节点:双亲在同一层的节点互为堂兄弟;如上图:H、I互为兄弟节点
节点的祖先:从根到该节点所经分支上的所有节点;如上图:A是所有节点的祖先
子孙:以某节点为根的子树中任一节点都称为该节点的子孙。如上图:所有节点都是A的子孙
森林:由m(m>0)棵互不相交的树的集合称为森林;

树的表示

树结构相对线性表就比较复杂了,要存储表示起来就比较麻烦了,既要保存值域,也要保存结点和结点之间的关系,实际中树有很多种表示方式如:双亲表示法,孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法

typedef int DataType;
struct Node
{struct Node* _firstChild1;    //第一个孩子结点struct Node* _pNextBrother;   //下一个兄弟节点DataType _data;               //数据域
};

在这里插入图片描述

树在实际中的应用

表示文件系统的目录树结构

在这里插入图片描述

二叉树概念及结构

概念

一棵二叉树是结点的一个有限集合,该集合:

  1. 或者为空
  2. 或者由一个根节点加上两棵别称为左子树和右子树的二叉树组成

在这里插入图片描述
从上图可以上出:

  1. 二叉树不存在度大于2的结点
  2. 二叉树的子树有左右之分,次序不能颠倒,因此二叉树是有序树

注意:对于任意的二叉树都是由以下几种情况复合而成的:
在这里插入图片描述

特殊的二叉树

  1. 满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是(2k-1),则它就是满二叉树。
  2. 完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

在这里插入图片描述

二叉树的性质

  1. 若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2(i-1)个结点.
  2. 若规定根节点的层数为1,则深度为h的二叉树的最大结点数是2h-1.
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0,度为2的分支结点个数为 n2,则有:n0=n2+1.
  4. 若规定根节点的层数为1,具有n个结点的满二叉树的深度,h=log2(n+1)
  5. 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的数组顺序对所有节点从0开始编号,则对于序号为i的结点有:
    1. 若i > 0,i位置节点的双亲序号:(i - 1) / 2;若i = 0,i为根节点编号,无双亲节点
    2. 若2i + 1 < n,左孩子序号:2i + 1;若2i + 1 >= n,则无左孩子
    3. 若2i + 2 < n,右孩子序号:2i + 2;若2i + 2 >= n,则无右孩子

二叉树的存储结构

二叉树一般可以使用两种结构存储,一种顺序结构,一种链式结构

顺序存储

顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费。而现实中使用中只有才会使用数组来存储。二叉树顺序存储在物理上是一个数组,在逻辑上是一颗二叉树
在这里插入图片描述

链式存储

二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用指针来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链。
在这里插入图片描述
在这里插入图片描述

typedef int BTDataType;// 二叉链
struct BinaryTreeNode
{struct BinTreeNode* _pLeft;  // 指向当前节点左孩子struct BinTreeNode* _pRight; // 指向当前节点右孩子BTDataType _data;            // 当前节点值域
}// 三叉链
struct BinaryTreeNode
{struct BinTreeNode* _pParent; // 指向当前节点的双亲struct BinTreeNode* _pLeft;   // 指向当前节点左孩子struct BinTreeNode* _pRight;  // 指向当前节点右孩子BTDataType _data; 			  // 当前节点值域
}

二叉树的顺序结构及实现

二叉树的顺序结构

普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储,需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。

在这里插入图片描述

堆的概念及结构

堆分为大堆(或称大根堆)和小堆(或称小根堆),大堆就是堆中的每一个结点都满足:父节点大于或等于他的两个子节点;小堆就是堆中的每一个结点都满足:父节点小于或等于他的两个子节点。

堆的性质:

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

堆的实现

堆的插入

首先来看如何在堆中插入数据。假设我们现在有一个大堆,其结构如下,我们想在堆中插入一个数据,数据大小为48,该如何操作呢?
在这里插入图片描述
首先我们使用了数组来存储堆的数据,那么我们的插入操作最方便的就是尾插,所以我们首先将48尾插到数组的最后,那么插入之后的逻辑结构表示为:
在这里插入图片描述
很显然,我们插入数据后破坏了堆,我们接下来要调整48的位置,使其恢复成堆。我们可以将48和他的父节点进行比较,如果48比父节点大,则将他们调换位置,这样他们两个结点就满足了堆的结构
在这里插入图片描述
然后将48继续和他新的父节点进行比较,如果48比父节点大,则将他们调换位置
在这里插入图片描述

可以保证的是,所有和48交换过的结点是仍可以满足堆的结构的,因为48只是在寻找合适的位置插入,并没有改变他们之间的相对位置(如经过上述两次操作后的45和25,45是25的父节点,满足大堆的要求,48并没有将25改变为45的父节点),而且经过如此循环的操作,直到48小于等于他的父节点或48已经成为了根节点,则停止循环。这样我们就将48成功插入到了堆中。

这种将结点逐步向上调整寻找位置的方式称为:堆的向上调整。

代码实现如下:

// 调整堆的大小
void CheckCapacity(Heap* hp)
{assert(hp);if (hp->size == hp->capacity){hp->capacity *= 2;HeapDataType* new = (HeapDataType*)realloc(new, sizeof(HeapDataType) * hp->capacity);if (new == NULL){perror("malloc fail");return;}hp->a = new;}
}//交换数据
void Swap(HeapDataType* x, HeapDataType* y)
{HeapDataType tmp = *x;*x = *y;*y = tmp;
}// 堆的向上调整
void AdjustUp(HeapDataType* a, int child)
{assert(a);int parent = (child - 1) / 2;while (child){if (a[child] > a[parent]){Swap(&a[child], &a[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}
}// 堆的插入
void HeapPush(Heap* hp, HeapDataType x)
{assert(hp);CheckCapacity(hp);hp->a[hp->size] = x;AdjustUp(hp->a, hp->size);hp->size++;
}

堆的删除

堆的删除,首先我们要确定删除的是那个元素,如果删除的是数组最后的元素,直接hp->size--就可以了,而且并没有什么实际意义,所以我们讲的堆的删除,一般是指删除堆顶元素。

想实现堆的删除,我们首先将堆顶元素和数组的最后一个元素交换位置,然后hp->szie--,使最后的50成为无效数据,就实现了删除的操作。
在这里插入图片描述
但很显然,我们这样也破坏了堆的结构,所以接下来我们要调整15的位置,恢复堆的结构。

首先让15的两个子结点(如果都存在)比较大小,选出大的子结点,和他们的父节点,也就是15,比较大小,如果父节点的值小于子节点的值,就将父节点和子节点的值交换
在这里插入图片描述
然后重复上述操作,即可将15置于合适的位置。
在这里插入图片描述
这种将结点逐步向下调整寻找位置的方式称为:堆的向下调整。

代码实现如下:

// 堆的向下调整
void AdjustDown(HeapDataType* a, int n, int parent)
{assert(a);assert(!HeapEmpty(a));int child = parent * 2 + 1;while (child < n){if (child + 1 < n && a[child + 1] > a[child]){child++;}if (a[parent] < a[child]){Swap(&a[parent], &a[child]);parent = child;child = child * 2 + 1;}else{break;}}
}

堆的创建

向上调整法

有了以上的向上调整函数以后,我们很容易就可以想到创建堆的方式:从数组的第二个元素开始,一直到最后一个元素,挨个使用向上调调整法,同时使ph->size++,这样可以将数组调整为堆。

代码实现如下:

void HeapCreate(Heap* hp, HeapDataType* a, int n)
{assert(hp);//将数组a中的数据调整为堆for (int i = 1; i < n; i++){AdjustUp(a, i);}//判断创建数组的大小hp->capacity = 4;while (hp->capacity < n){hp->capacity *= 2;}//动态内存开辟HeapDataType* new = (HeapDataType*)malloc(sizeof(HeapDataType) * hp->capacity);if (new == NULL){perror("malloc fail");return;}hp->a = new;hp->size = n;//将给定数组中的值拷贝的hp->a中for (int i = 0; i < n; i++){hp->a[i] = a[i];}
}

向下调整法

除了最容易想到的向上调整法,还可以使用向下调整法创建堆。对于向上调整法和向下调整法,他们的应用前提都是在原始数据已经构成堆的前提下,将新数据插入堆,所以向下插入法并不能直接对数组的第一个元素使用,因为其余元素并不构成堆。那么我们可以从后向前使用向下调整法,因为叶结点是堆(只有一个结点,左右子树都是NULL),所以我们要找到从后向前除了叶结点之外的第一个结点。我们知道数组的元素个数为n,那么数组中最后一个元素的下标为n - 1,它的父结点的下标为(n - 1 - 1) / 2,只要从该结点向前对每个结点依次向下调整,即可把数组调整为堆。
代码实现如下:

void HeapCreate(Heap* hp, HeapDataType* a, int n)
{assert(hp);//将数组a中的数据调整为堆for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}//判断创建数组的大小hp->capacity = 4;while (hp->capacity < n){hp->capacity *= 2;}//动态内存开辟HeapDataType* new = (HeapDataType*)malloc(sizeof(HeapDataType) * hp->capacity);if (new == NULL){perror("malloc fail");return;}hp->a = new;hp->size = n;//将给定数组中的值拷贝的hp->a中for (int i = 0; i < n; i++){hp->a[i] = a[i];}
}

堆的销毁

堆的销毁是要销毁动态开辟的空间,也就是hp->a,然后将其置空,将hp->sizehp->capacity赋值为0。
代码实现如下:

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

取堆顶的数据

HeapDataType HeapTop(Heap* hp)
{assert(hp);assert(!HeapEmpty(hp));return hp->a[0];
}

堆的数据个数

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

堆的判空

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

堆的应用

堆排序

如果想排升序,就创建大堆,然后将首元素和尾元素交换,同时hp->size--,然后重复上述过程,即可将堆中元素排为升序。
代码如下:

void HeapSort(int* a, int n)
{assert(a);for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}int end = n - 1;while (end){Swap(&(a[0]), &(a[end]));end--;AdjustDown(a, end, 0);}
}int main()
{int arr[10] = { 2,4,7,1,4,6,3,7,9,0 };HeapSort(arr, 10);for (int i = 0; i < 10; i++){printf("%d ", arr[i]);}return 0;
}

TOP-k问题

如果要非常多数据中选出top-k个数据,这时对所有数据排序就显得不太现实,这时我们可以应用堆来选出top-k个数据。
如果想找出最大的k个元素,可以对数组的前k个元素建小堆,然后其他元素分别与堆顶元素比较,如果比堆顶元素大,则交换两个元素,并向下调整堆顶元素,然后判断下一个元素。
代码如下:

//Top-k
void top_k(int* a, int n, int k)
{assert(a);//前k个元素建堆for (int i = (k - 1 - 1) / 2; i >= 0; i--){//这里的向下调整要更换为建小堆AdjustDown(a, k, i);}for (int i = k; i < n; i++){if (a[i] > a[0]){Swap(&a[i], &a[0]);AdjustDown(a, k, 0);}}
}int main()
{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;top_k(a, 10000, 10);for (int i = 0; i < 10; i++){printf("%d ", a[i]);}free(a);a = NULL;return 0;
}

堆的实现参考代码

头文件

Heap.h

#pragma once#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<time.h>typedef int HeapDataType;typedef struct Heap {HeapDataType* a;int size;int capacity;
}Heap;// 堆的构建
void HeapCreate(Heap* hp, HeapDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HeapDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HeapDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
bool HeapEmpty(Heap* hp);
// 堆的向上调整
void AdjustUp(HeapDataType* a, int child);
// 堆的向下调整
void AdjustDown(HeapDataType* a, int n, int parent);

实现文件

Heap.c

#define _CRT_SECURE_NO_WARNINGS 1#include"Heap.h"// 堆的构建
void HeapCreate(Heap* hp, HeapDataType* a, int n)
{assert(hp);//将数组a中的数据调整为堆//1. 向下调整法for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}//2. 向上调整法//for (int i = 1; i < n; i++)//{//	AdjustUp(a, i);//}//判断创建数组的大小hp->capacity = 4;while (hp->capacity < n){hp->capacity *= 2;}//动态内存开辟HeapDataType* new = (HeapDataType*)malloc(sizeof(HeapDataType) * hp->capacity);if (new == NULL){perror("malloc fail");return;}hp->a = new;hp->size = n;//将给定数组中的值拷贝的hp->a中for (int i = 0; i < n; i++){hp->a[i] = a[i];}
}//交换数据
void Swap(HeapDataType* x, HeapDataType* y)
{HeapDataType tmp = *x;*x = *y;*y = tmp;
}// 堆的向上调整
void AdjustUp(HeapDataType* a, int child)
{assert(a);int parent = (child - 1) / 2;while (child > 0){if (a[child] > a[parent]){Swap(&a[child], &a[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}
}// 堆的向下调整
void AdjustDown(HeapDataType* a, int n, int parent)
{assert(a);assert(!HeapEmpty(a));int child = parent * 2 + 1;while (child < n){if (child + 1 < n && a[child + 1] > a[child]){child++;}if (a[parent] < a[child]){Swap(&a[parent], &a[child]);parent = child;child = child * 2 + 1;}else{break;}}
}// 堆的销毁
void HeapDestory(Heap* hp)
{assert(hp);free(hp->a);hp->a = NULL;hp->capacity = 0;hp->size = 0;
}// 调整堆的大小
void CheckCapacity(Heap* hp)
{assert(hp);if (hp->size == hp->capacity){hp->capacity *= 2;HeapDataType* new = (HeapDataType*)realloc(hp->a, sizeof(HeapDataType) * hp->capacity);if (new == NULL){perror("malloc fail");return;}hp->a = new;}
}// 堆的插入
void HeapPush(Heap* hp, HeapDataType x)
{assert(hp);CheckCapacity(hp);hp->a[hp->size] = x;AdjustUp(hp->a, hp->size);hp->size++;
}// 堆的删除
void HeapPop(Heap* hp)
{assert(hp);assert(!HeapEmpty(hp));Swap(&(hp->a[0]), &(hp->a[hp->size - 1]));hp->size--;AdjustDown(hp->a, hp->size, 0);
}// 取堆顶的数据
HeapDataType HeapTop(Heap* hp)
{assert(hp);assert(!HeapEmpty(hp));return hp->a[0];
}// 堆的数据个数
int HeapSize(Heap* hp)
{assert(hp);return hp->size;
}// 堆的判空
bool HeapEmpty(Heap* hp)
{assert(hp);return hp->size == 0;
}

测试文件

test.c

#define _CRT_SECURE_NO_WARNINGS 1#include"Heap.h"int main()
{Heap a;int arr[10] = { 9,2,4,6,1,5,3,8,0,7 };HeapCreate(&a, arr, 10);while (!HeapEmpty(&a)){int tmp = HeapTop(&a);printf("%d ", tmp);HeapPop(&a);}HeapDestory(&a);return 0;
}

http://www.ppmy.cn/ops/7866.html

相关文章

研究生,该学单片机还是plc。?

PLC门槛相对较低&#xff0c;但是在深入学习和应用时&#xff0c;仍然有很高的技术要求。我这里有一套单片机入门教程&#xff0c;不仅包含了详细的视频 讲解&#xff0c;项目实战。如果你渴望学习单片机&#xff0c;不妨点个关注&#xff0c;给个评论222&#xff0c;私信22&am…

写一个函数实现:将一个5*5的矩阵中最大的元素放在中心,4个角分别放4个最小的元素(顺序为从左到右,从上到下依次从小到大存放)之解法改写

#include<stdio.h> void change(int *p){ int i,j,temp; int *pmax,*pmin; // 初始化最大值和最小值的指针 pmaxp; pminp; // 遍历矩阵&#xff0c;寻找最大和最小值 for(i0;i<5;i) for(ji;j<5;j) { if(*pm…

nginx开启basic认证

basic认证也叫做http基本认证&#xff0c;防止恶意访问 首先用在线网站生成一个叫做htpasswd的账号密码文件。 将生成结果复制到/etc/nginx/htpasswd文件中 在server的location中配置 server { listen 80; server_name a.com;location / { root html;index index.…

UE5 C++ 对项目工程的再认识

一.Intermediate 中间文件Intermediate&#xff0c;涉及到反射。胶水文件&#xff0c;与代码产生关联。通过Generate生成出来。 1.C#编译出第三方文件&#xff1a; 反射文件 头文件关联&#xff0c;UHT里的文件.h cpp的关联&#xff0c;UE将所有的cpp放到 gen.cpp里,实现自动关…

Python第四次作业

主程序 import MyTriangles1 float(input("请输入边长1:")) s2 float(input("请输入边长2:")) s3 float(input("请输入边长3:"))r MyTriangle.isvalid(s1, s2, s3) if r:a MyTriangle.area(s1, s2, s3)print("面积为&#xff1a;&quo…

es6编程风格

目录 1、变量let和常量const 2、静态字符串与动态字符串 3、解构赋值&#xff08;数组&#xff0c;对象&#xff09; 4、对象 5、数组 6、函数 7、Map结构 8、class类 9、模块 10、ESLint的使用 1、变量let和常量const ES6 提出了两个新的声明变量的命令&#xff1a;…

数据结构--图

图 1.图的基本介绍 1&#xff09;图的定义&#xff1a; 图(Graph)G由两个集合V和E组成&#xff0c;记为G(V, E)&#xff0c;其中V是顶点的有穷非空集合&#xff0c;E是V中顶点偶对的有穷集合&#xff0c;这些顶点偶对称为边。V(G)和E(G)通常分别表示图G的顶点集合和边集合&a…

javascrip中的class

在JavaScript中&#xff0c;class是一种用于创建对象的模板或蓝图。它是ES6引入的一种语法糖&#xff0c;用于简化对象的创建和继承过程。下面是一个示例代码&#xff0c;详细说明了JavaScript中class的使用&#xff1a; javascript class Animal { constructor(name, age) …

Android优化RecyclerView图片展示:Glide成堆加载批量Bitmap在RecyclerView成片绘制Canvas,Kotlin(b)

Android优化RecyclerView图片展示&#xff1a;Glide成堆加载批量Bitmap在RecyclerView成片绘制Canvas&#xff0c;Kotlin&#xff08;b&#xff09; 对 Android GridLayoutManager Glide批量加载Bitmap绘制Canvas画在RecyclerView&#xff0c;Kotlin&#xff08;a&#xff09;-…

Linux配置腾讯云yum源(保姆级教学)

1. 备份原有的 yum 源配置文件 例如&#xff1a; mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup 2. 下载腾讯云的 yum 源配置文件 例如&#xff1a; wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.cloud.tencent.com/repo/…

python爬虫(Selenium案列)第二十四

&#x1f388;&#x1f388;作者主页&#xff1a; 喔的嘛呀&#x1f388;&#x1f388; &#x1f388;&#x1f388;所属专栏&#xff1a;python爬虫学习&#x1f388;&#x1f388; ✨✨谢谢大家捧场&#xff0c;祝屏幕前的小伙伴们每天都有好运相伴左右&#xff0c;一定要天天…

go处理json

在 Go 中&#xff0c;你可以使用内置的 encoding/json 包来处理 JSON 格式数据。该包提供了函数和类型&#xff0c;使你能够将 JSON 数据解析为 Go 对象&#xff08;反序列化&#xff09;或将 Go 对象转换为 JSON 数据&#xff08;序列化&#xff09;。 下面是一些常见的 JSON…

ubuntu22安装宝塔面板

方法一&#xff1a;运行安装宝塔命令 wget -O install.sh https://download.bt.cn/install/install-ubuntu_6.0.sh && sudo bash install.sh ed8484bec 安装成功后&#xff0c;需到服务器管理后台的安全组中配置新规则&#xff0c;放行宝塔面板的端口&#xff08;以阿…

从IoTDB的发展回顾时序数据库演进史

面向工业物联网时代&#xff0c;以 IoTDB 为代表的时序数据库加速发展。 时序数据的主要产生来源之一是设备与传感器&#xff0c;具有监测点多、采样频率高、存储数据量大等多类不同于其他数据类型的特性&#xff0c;从而导致数据库在实现高通量写入、存储成本、实时查询等多个…

【Kyuubi】Apache Kyuubi 1.8 特性解读

Apache Kyuubi 1.8 特性解读 1.Apache Kyuubi 简介2.场景扩展 —— 在线分析&#xff0c;离线跑批3.流式增强 —— 流批一体&#xff0c;面向未来4.企业特性 —— 行业沉淀&#xff0c;持续打磨5.开源社区 —— 开放包容&#xff0c;合作共赢 本文来自于 Apache Kyuubi PMC Mem…

.NET Core中间件管道MAP的作用和使用

在ASP.NET Core中&#xff0c;中间件是构建HTTP请求管道的基本组件。中间件组件负责在ASP.NET Core应用程序中处理请求和响应。中间件可以执行多种任务&#xff0c;例如身份验证、记录、异常处理等。你可以按顺序将多个中间件组件组合在一起&#xff0c;形成一个请求处理管道。…

Linux - Docker 安装 Nacos

拉取 Nacos 镜像 使用以下命令从 Docker Hub 拉取最新版本的 Nacos 镜像&#xff1a; docker pull nacos/nacos-server启动 Nacos 容器 使用以下命令启动 Nacos 容器&#xff1a; docker run -d \--name nacos \--privileged \--cgroupns host \--env JVM_XMX256m \--env M…

Docker之构建镜像

一、基于容器生成镜像 容器启动后是可写的&#xff0c;所有写操作都保存在顶部的可写层中。可以通过docker commit命令将现有的容器进行提交来生成新的镜像。 具体的实现原理是通过对可写层的修改生成新的镜像&#xff0c;因为联合文件系统所允许的层数是有限的&#xff0c;建议…

windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流

windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流 整体流程1.下载所需文件1. 1下载rtsp推流服务器1.2 下载ffmpeg2. 开启RTSP服务器3. opencv 读取摄像头并调用ffmpeg进行推流4. opencv进行拉流5. opencv异步拉流整体流程 1.下载所需文件 1. 1下载rtsp推流服务器 下…

2025考研数学武忠祥强化班视频,百度网盘课程+讲义PDF更新

25考研的小伙伴们现在应该基础都学习的差不多了吧&#xff01; 是时候进入强化阶段的学习啦。 2025考研数学强化班全程网盘&#xff1a;https://pan.baidu.com/s/1Z029fuCLkyyhIRFqd5QKcg 提取码&#xff1a;p3ue 晚上好&#xff0c;聊聊17堂课的看课攻略。 今年的17堂课还…