大小堆的实现（C语言）

目录

前言

一种完全二叉树：堆

堆的概念

堆的性质

建堆的时间复杂度

建堆的空间复杂度：

小堆的实现

必要补充

堆的初始化

堆的销毁

向上调整算法

堆的插入

向下调整算法

堆的删除

获取堆顶元素

获取堆中元素个数

堆的判空

最终代码

Heap.h文件

Heap.c文件

test.c文件

大堆的实现

思考：堆的意义是什么？

1、堆排序

2、top k问题

前言        

        在上一篇中，我们学习了二叉树的基本概念：C语言二叉树的基本概念（一）现在我们来学习一种完全二叉树堆，以及大小堆的实现......

一种完全二叉树：堆

堆的概念

概念：如果有一个关键码的集合K = { k0，k1，k2，…}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，若分别满足以下两种情况，则称该堆为小/大堆： 

根节点为最大值的堆叫做最大堆或大根堆，根节点为最小值的堆叫做最小堆或小根堆

堆的性质

  1. 堆是一个完全二叉树；
  2. 堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值

建堆的时间复杂度

1、我们将一个高度为h的满二叉树转变成一个小堆，该小堆的结点总数为log(N+1)

一般来说对数的底我们将其忽略，所以这里原本是log(以2为底N+1的对数)

第一层的结点个数为2^0、第二层的结点个数为2^1......第h层的结点个数为2^(h-1)

结点总数为：2^0 + 2^1 +......+2^(h-1) = 2^h - 1 

（等比数列求和公式：Sn=a1 (1-q^n)/ (1-q)）
假设结点总数为N，则N与h的关系是N = 2^h - 1 == h = log(N+1)

即一个高h的满二叉树的结点个数为log(N+1)

2、进行堆的调整，得到最终的时间复杂度为O(N*logN)

第一层元素向上调整0次，第二层元素向上调整1次......第h层元素向上调整h-1次

同时每一层元素中的结点个数又分别为2^0、2^1......2^(h-1)

总调整次数T为：T = 2^0×0 + 2^1×1 +......2^(h-1)×(h-1)     ① 

利用错位相减法列出第二个式子：2*T = 2^1×0 + 2^2×1 +......2^h×(h-1)     ②

由① - ②得： T = 2 + 2^h * (h-2)     ③

将h = log（以2为底N+1的对数）代入③得④：

T = （N+1）log（以2为底N+1的对数）- 2 * N     ④

将④利用大O渐进表示法转换为 T(N) = O(N*log以2为底N的对数)

结论：建堆的时间复杂度为O(N*logN)

建堆的空间复杂度：

        小堆的空间复杂度为O(n)，其中n是小堆中元素的个数。在建堆的过程中，需要额外的空间来存储数组中的元素。

结论：建堆的空间复杂度为O(N)

小堆的实现

我们利用顺序表（顺序存储方式）实现堆

必要补充

堆的任何一个父结点的编号parent与其左孩子结点的编号leftchild满足如下关系式:

理解这里是我们后续在编写向上调整算法与向下调整算法时的基础 

堆的初始化

//初始化堆
void HeapInit(HP* php)
{
	//检查堆的有效性
	assetr(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;

}

堆的销毁

free可以用来检查是否为空，若指针为空，则free不执行任何操作，指针不为空就释放内存空间

//堆的销毁
void HeapDestroy(HP* php)
{
	assert(php);
	//释放a指针的内存空间并将a指针置为空
	free(php->a);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}

向上调整算法

//向上调整
void AdjustUP(HPDataType* a,int child)
{
	int parent = (child - 1) / 2;
	//当孩子等于0的时候它已经位于树顶了没有父亲了就应该结束循环
	while(child > 0)
	{
        //if (a[child] > a[parent])，就是它
		if (a[child] < a[parent])
		{
			//如果儿子小于父亲就交换父子位置，同时将此时
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		//由于是写一个小堆，所以当孩子大于等于父亲时不需要交换，直接退出循环即可
		else
		{
			break;
		}
	}
}

堆的插入

//堆的插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//扩容
	if (php->size == php->capacity)
	{
		size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));

		if (tmp == NULL)
		{
			perror("realloc error");
			return -1;
		}
		php->a = tmp;
		php->capacity = newCapacity;

	}

	php->a[php->size] = x;
	php->size++;

	//向上调整,从顺序表最后一个元素开始调整，该元素的下标为size-1
	AdjustUP(php->a, php->size - 1);

}

每插入一个新的元素都需要进行一次向上调整的判断 

向下调整算法

//向下调整算法
void AdjustDown(HPDataType* a, int size, int parent)
{
	//根据之前的推论，左孩子的下标值为父亲下标值的两倍+1，左孩子的下标值为父亲下标值的两倍+2
	int child = parent * 2 + 1;
	//循环结束的条件是走到叶子结点
	while (child < size)
	{
        //if (child + 1< size && a[child + 1] > a[child])，它也是
		//假设左孩子小，若假设失败则更新child，转换为右孩子小，同时保证child的下标不会越界
		if (child + 1< size && 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(HP* php)
{
	assert(php);
	assert(php->size > 0);
	//这里并不采用惯用的顺序表头删的办法（向前覆盖），因为那样会引起堆的顺序被完全打乱的问题，我们在这里选择交换堆顶元素与堆尾元素然后再进行一次顺序表的尾删（直接size--即可）
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	//在交换完并尾删完后，可能此时的堆并不能满足小堆的要求（堆顶元素比它的两个孩子都大），所以我们必须再次对堆进行调整，经过向下调整算法将堆恢复至小堆（由于是堆顶元素开始调整所以还需传入堆顶元素对应的下标0）
	AdjustDown(php->a, php->size, 0);
}

 每删除一个元素都需要进行一次向下调整的判断  

获取堆顶元素

//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	//获取堆顶元素则堆里应该有元素，故首先要保证size不小于等于零
	assert(php->size > 0);

	//确定堆中有元素后返回a[0]即可
	return php->a[0];
}

获取堆中元素个数

//获取堆中元素个数
size_t HeapSize(HP* php)
{
	assert(php);

	//判断size大于零后返回size大小即可
	return php->size;
}

堆的判空

//堆的判空
bool HeapEmpty(HP* php)
{
	assert(php);
	//返回对php->size == 0的判断结果
	return php->size == 0;
}

最终代码

Heap.h文件

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

#pragma once
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;  //指向存储元素的指针
	int capacity;	//当前顺序表容量
	int size;		//当前顺序表的长度
}HP;

//初始化堆
void HeapInit(HP* php);

//销毁堆
void HeapDestroy(HP* php);

//向上调整算法
void AdjustUP(HPDataType* a, int child);

//堆的插入
void HeapPush(HP* php,HPDataType x);

//向下调整算法
void AdjustDown(HPDataType* a, int child);

//堆的删除（删除堆顶的数据）
void HeapPop(HP* php);

//获取堆顶元素
HPDataType HeapTop(HP* php);

//获取堆中元素个数
size_t HeapSize(HP* php);

//堆的判空
bool HeapEmpty(HP* php);

Heap.c文件

#include "Heap.h"

//初始化堆
void HeapInit(HP* php)
{
	//检查堆的有效性
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

//堆的销毁
void HeapDestroy(HP* php)
{
	assert(php);
	//释放a指针的内存空间并将a指针置为空
	free(php->a);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}

//交换父子位置
void Swap(HPDataType* p1,HPDataType* p2)
{
	HPDataType* tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
} 


//向上调整，此时传递过来的是最后一个孩子的元素下标我们用child表示
void AdjustUP(HPDataType* a,int child)
{
	//由于我们要调整父亲与孩子的位置所以此时也需要父亲元素的下标，而0父亲元素的下标值 = （任意一个孩子的下标值-1）/ 2 
	int parent = (child - 1) / 2;
	//当孩子等于0的时位于树顶（数组首元素的位置），树顶元素没有父亲，循环结束
	while(child > 0)
	{
		//如果孩子还未到顶且它的下标对应的元素值小于它的父亲的下标对应的元素值，就将父子位置交换，交换玩后还要将下标对应的值“向上移动”
        //if (a[child] > a[parent])，就是它
		if (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, newCapacity * sizeof(HPDataType));

		if (tmp == NULL)
		{
			perror("realloc error");
			return -1;
		}
		php->a = tmp;
		php->capacity = newCapacity;

	}

	php->a[php->size] = x;
	php->size++;

	//向上调整,从顺序表最后一个元素开始调整，该元素的下标为size-1
	AdjustUP(php->a, php->size-1);
}

//向下调整算法
void AdjustDown(HPDataType* a, int size, int parent)
{
	//根据之前的推论，左孩子的下标值为父亲下标值的两倍+1，左孩子的下标值为父亲下标值的两倍+2
	int child = parent * 2 + 1;
	//循环结束的条件是走到叶子结点
	while (child < size)
	{
		//假设左孩子小，若假设失败则更新child，转换为右孩子小，同时保证child的下标不会越界
		//if (child + 1 < size && a[child + 1] < a[child])，它也是
        if (child + 1 < size && 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(HP* php)
{
	assert(php);
	assert(php->size > 0);
	//这里并不采用惯用的顺序表头删的办法（向前覆盖），因为那样会引起堆的顺序被完全打乱的问题，我们在这里选择交换堆顶元素与堆尾元素然后再进行一次顺序表的尾删（直接size--即可）
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	//在交换完并尾删完后，可能此时的堆并不能满足小堆的要求（堆顶元素比它的两个孩子都大），所以我们必须再次对堆进行调整，经过向下调整算法将堆恢复至小堆（由于是堆顶元素开始调整所以还需传入堆顶元素对应的下标0）
	AdjustDown(php->a, php->size, 0);
}

//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	//获取堆顶元素则堆里应该有元素，故首先要保证size不小于等于零
	assert(php->size > 0);

	//确定堆中有元素后返回a[0]即可
	return php->a[0];
}

//获取堆中元素个数
size_t HeapSize(HP* php)
{
	assert(php);

	//判断size大于零后返回size大小即可
	return php->size;
}

//堆的判空
bool HeapEmpty(HP* php)
{
	assert(php);
	//返回对php->size == 0的判断结果
	return php->size == 0;
}

test.c文件

#include "Heap.h"

int main()
{
	int arr[] = { 4,6,2,1,5,8,2,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	HP hp;
	HeapInit(&hp);

	for (int i = 0;i < sz; ++i)
	{
		HeapPush(&hp,arr[i]);
	}
	
	//堆不为空就获取堆顶元素并删除
	while (!HeapEmpty(&hp))
	{
		printf("%d ",HeapTop(&hp));
		HeapPop(&hp);
	}
	printf("\n");
	return 0;
}

大堆的实现

大堆的实现只需要将向上调整算法和向下调整算法中，只需要将注释掉的语句重新启用即可

思考：堆的意义是什么？

1、堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：建堆与利用堆删除思想进行排序

  1. 建堆：升序：建大堆、降序：建小堆（很重要，下一篇我们会对升序建大堆的办法进行详细介绍）
  2. 利用堆删除思想来进行排序：建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序（重要）

当一棵树为满二叉树时，高度h与结点总数N的关系是：h = log (N + 1)

当一棵树为完全二叉树时，高度h与结点总数N最坏的关系是：h = log N + 1

所以如果有一百万个数据组成一棵二叉树，那么这棵树的高度仅为20，十亿个数据，高度仅仅为30，即如果我们要用堆排序去查找100w个数据中的其中一个大概只需要查找二十次......

补充：在使用堆排序时，并不能说它能更高效地维护数据的有序性。相反，建立和调整一个完整的二叉树结构以及频繁进行元素交换和下沉操作可能会带来一些额外开销，并且在某些情况下可能比其他简单算法慢。但是，由于其稳定而可预测性能表现，在某些特殊情况下仍然被认为是有效和实用的算法之一。

2、top k问题

问题描述：获取N个数里找最大的前K个数（N远大于K）

解决思路一：

N个数插入进大堆中，Pop K次

时间复杂度：N*logN + K*logN == O(N*logN)

但如果N为100亿（100亿个整数需要40GB左右的内存空间），而只要查找前10个数（K为10）？ 

解决思路二：

1、取前K个值，建立K个数的小堆

2、再读取后面的值，跟堆顶元素比较，若大于堆顶元素，交换二者位置然后重新堆化成小堆

时间复杂度：O(N*logK)

注意事项：必须要建立小堆，不能建立大堆，如果建立大堆，一旦第一大的数字在建堆时位于堆顶，后续第n大的数字就无法进堆，同时第二大的数字可能还会被挤出去，如果不信可以用[4,6,1,2,8,9,5,3]这个我随机想出来数组用以上方法取前三个最大的数字试一试

        有时候你可能会很想刨根问底的知道这些办法都是怎么想出来的，其实我也不知道，这就跟你骑自行车的时候去思考这些链子为什么要这样组合在一起，为什么组合在一起就可以产生这样的效果，其实我们根本不需要思考那么多，我们只需要骑上自行车去干我们要干的事情即可，它只是一个用于解决我们问题的工具，我们说的解题思路也是一样的，这些东西都是哪些很nb的人发明出来的，如果你是一个很nb的人你也不会看到这里不是，前人栽树后人乘凉，作为一个还没有完全深入学习数据结构的菜鸟既然已经知道了有这种解决办法那么你就直接用，等你什么时候感觉自己已经很nb了再来思考为什么吧......（当然也不是说都不要思考一些必要的思考还是需要的）别钻牛角尖了🤡

模拟实现：

使用数组[7, 8, 15, 4, 20, 23, 2, 50]演示如何使用最小堆找出前3个最大的元素。

首先，我们创建一个最小堆，并将数组的前3个元素[7, 8, 15]插入堆中，初始堆的表示如下：

       7
     /   \
    8     15

接下来遍历数组，发现 4 < 7，因此我们不做任何操作

继续遍历数组，发现 20 > 7，因此将 7 替换为 20 并重新堆化成小堆

       8
     /   \
    20    15

继续遍历数组，发现 23 大于 8，因此我们将 8 替换为 23 并重新堆化成小堆

       15
     /    \
    20     23

继续遍历数组，发现 2 < 15，因此我们不做任何操作

继续遍历数组，发现 50 > 15，因此我们将 15 替换为 50 并重新堆化成小堆

       20
     /    \
    50     23

最后，数组遍历完成，得到了最终的最小堆

       20
     /    \
    50     23

此时，堆中的前3个最大元素为 `[20, 50, 23]`，它们就是原数组中的前3个最大元素

~over~

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

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

相关文章

保育员个人简历精选7篇

保育员个人简历精选7篇

想要在保育员职位的求职过程中脱颖而出吗&#xff0c;参考这7篇精选的保育员简历案例&#xff01;无论您的经验如何&#xff0c;都能找到适合自己的简历样式及参考内容。 保育员个人简历模板下载&#xff08;可在线编辑制作&#xff09;&#xff1a;来幻主简历&#xff0c;做好…
阅读更多...
免费HTTPS证书

免费HTTPS证书

什么是HTTPS呢&#xff1f;HTTPS全称为Hyper Text Transfer Protocol Secure&#xff0c;即超文本传输安全协议。它是在HTTP的基础上加入了SSL/TLS协议&#xff0c;可以对传输的数据进行加密&#xff0c;有效防止数据被第三方截取或篡改&#xff0c;从而保障了用户的信息安全。…
阅读更多...
Docker Compose简单入门

Docker Compose简单入门

Docker Compose 简介 Docker Compose 是一个编排多容器发布式部署的工具&#xff0c;提供命令集管理容器化应用的完整开发周期&#xff0c;包括服务构建&#xff0c;启动和停止。 Docker Compose 真正的作用是在一个文件&#xff08;docker-compose.yml&#xff09;中定义并运…
阅读更多...
Fiddler抓包工具之fiddler设置抓HTTPS的请求证书安装

Fiddler抓包工具之fiddler设置抓HTTPS的请求证书安装

设置抓HTTPS的请求包 基础配置&#xff1a; 路径&#xff1a;启动Fiddler 》Tools》Options》HTTPS 注意&#xff1a;Option更改完配置需重启Fiddler才能生效 选中"Decrpt HTTPS traffic", Fiddler就可以截获HTTPS请求&#xff0c;如果是第一次会弹出证书安装提…
阅读更多...
JS构造函数

JS构造函数

构造函数是一种特殊的函数&#xff0c;主要用来初始化对象 使用场景&#xff1a;比如我对象与其他对象都相似&#xff0c;此时可以通过构造函数来快速创建多个类似的对象。 举个例子&#xff1a; // 大头儿子const Son {name:"大头儿子",age:6,gender:"男"…
阅读更多...
C++基础 -33- 单目运算符重载

C++基础 -33- 单目运算符重载

单目运算符重载格式 a和a通过形参确定 data1 operator() {this->a;return *this; }data1 operator(int) {data1 temp*this;this->a;return temp; }举例使用单目运算符重载 #include "iostream"using namespace std;class data1 {public :int a;data1(int…
阅读更多...
maven篇---第一篇

maven篇---第一篇

系列文章目录 文章目录 系列文章目录前言一、什么是maven？二、Maven能为我们解决什么问题？三、说说maven有什么优缺点？前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码…
阅读更多...
react native 环境准备

react native 环境准备

一、必备安装 1、安装node 注意 Node 的版本应大于等于 16&#xff0c;安装完 Node 后建议设置 npm 镜像&#xff08;淘宝源&#xff09;以加速后面的过程&#xff08;或使用科学上网工具&#xff09;。 node下载地址&#xff1a;Download | Node.js设置淘宝源 npm config s…
阅读更多...
qnx修改tcp和udp缓冲区默认大小

qnx修改tcp和udp缓冲区默认大小

拷贝/home/test/qnx/qos223/target/qnx7/aarch64le/sbin/sysctl进系统中 https://www.qnx.com/developers/docs/7.1/#com.qnx.doc.neutrino.utilities/topic/s/sysctl.html kern.sbmax 默认262144&#xff0c;这个限制住了发送、接收缓冲器大小 ./sysctl -w kern.sbmax10000…
阅读更多...
免费AI洗稿软件【2023最新】

免费AI洗稿软件【2023最新】

很多时候我们需要通过文字来表达观点、推广产品或服务。然而&#xff0c;长时间的文稿创作不仅费时费力&#xff0c;还容易陷入表达瓶颈。许多写手和从业者纷纷寻找一款方便、高效的AI洗稿工具。 文心一言洗稿软件。这款软件以其独特的文风生成和洗稿功能而备受瞩目。用户只需…
阅读更多...
【Qt开发流程】之事件系统3：键盘事件

【Qt开发流程】之事件系统3：键盘事件

序章 以下链接是拖放事件介绍和使用示例&#xff1a; 【Qt开发流程】之拖放操作1:介绍链接: https://blog.csdn.net/MrHHHHHH/article/details/134626484 【Qt开发流程】之拖放操作2:使用链接: https://blog.csdn.net/MrHHHHHH/article/details/134632006 以下链接是事件系统…
阅读更多...
页面表格高度自适应

页面表格高度自适应

前言 现在后端管理系统主页面基本都是由三部分组成 查询条件&#xff0c;高度不固定&#xff0c;可能有的页面查询条件多&#xff0c;有的少表格&#xff0c;高度不固定&#xff0c;占据页面剩余高度分页&#xff0c;高度固定 这三部分加起来肯定是占满全屏的&#xff0c;那么我…
阅读更多...
JavaWeb 分页查询

JavaWeb 分页查询

由于html不能直接从域当中直接拿数据 所以我们引入了jsp文件 数据存在了requets域当中 如果数据量很大,不可能把所有数据全部在页面展示: 数据全部在页面展示缺点: SQL执行时间过长 用户查看数据,滚动滚动条,用户体验不高 在实际开发中,分页查询&#xff0c; 实现: sql语句…
阅读更多...
idea新建spring boot starter

idea新建spring boot starter

什么是spring boot starter Spring Boot Starter 是一种 Maven 或 Gradle 依赖&#xff0c;它能够轻松地将相关库和框架集成到 Spring Boot 应用程序中。Starter 是一种对常见依赖项和设置的易于复用的封装&#xff0c;它们通常被开发人员用于创建可插拔的 Spring Boot 应用程序…
阅读更多...
卫星影像数据查询网址（WORLDVIEW1/2/3/4、PLEIADES、SPOT系列、高景、高分1-7、资源系列、吉林一号等）

卫星影像数据查询网址（WORLDVIEW1/2/3/4、PLEIADES、SPOT系列、高景、高分1-7、资源系列、吉林一号等）

商业卫星影像数据查询网址&#xff08;WORLDVIEW1/2/3/4、PLEIADES、SPOT系列、高景、高分1-7、资源系列、吉林一号等&#xff09; 1、资源卫星应用中心 网址&#xff1a;http://www.cresda.com/CN/ 可查询国产高分1、2、3、4、5、6、7号卫星&#xff0c;资源三号、资源三号…
阅读更多...
kafka3.6.0部署

kafka3.6.0部署

部署zk https://mirrors.tuna.tsinghua.edu.cn/apache/zookeeper/zookeeper-3.9.1/apache-zookeeper-3.9.1.tar.gz tar -xf apache-zookeeper-3.9.1.tar.gz -C /apps cd /apps/ && ln -s apache-zookeeper-3.9.1 zookeeper 修改配置bash grep -vE ^$|^# conf/zo…
阅读更多...
springmvc+mybatis+mysql8+idea+jqgrid前端

springmvc+mybatis+mysql8+idea+jqgrid前端

一、背景 主要是为了学习jqgrid前端技术&#xff0c;熟练一下前后端交互数据 二、效果图 访问地址&#xff1a;http://localhost:8080/cr/views/jqGridDemo.jsp 三、代码展示 控制层JqGridController.java Controller RequestMapping("/jqgrid") public class Jq…
阅读更多...
将多个字节对象组成的列表中的多个字节对象连接成为一个字节对象bytes.join()

将多个字节对象组成的列表中的多个字节对象连接成为一个字节对象bytes.join()

【小白从小学Python、C、Java】 【计算机等考500强证书考研】 【Python-数据分析】 将多个字节对象组成的列表 中的多个字节对象 连接成为一个字节对象 bytes.join() [太阳]选择题 请以下代码输出的结果是&#xff1f; byte_list [bK,be,by] print("【显示】byte_list&q…
阅读更多...
[力扣题]1.判断一棵树是否是平衡二叉树

[力扣题]1.判断一棵树是否是平衡二叉树

1.判断一棵树是否是平衡二叉树 1.1 题目描述 给你一棵二叉树的根节点 root &#xff0c;请你判断这棵树是否是一棵 完全二叉树 。 在一棵 完全二叉树 中&#xff0c;除了最后一层外&#xff0c;所有层都被完全填满&#xff0c;并且最后一层中的所有节点都尽可能靠左。最后一层…
阅读更多...
法学毕业生个人简历16篇

法学毕业生个人简历16篇

想要从众多法学毕业求职者中脱颖而出&#xff0c;找到心仪的相关工作&#xff1f;可以参考这16篇精选的法学专业应聘简历案例&#xff0c;无论是应届比预算还是有工作经验&#xff0c;都能从中汲取灵感&#xff0c;提升简历质量。希望对大家有所帮助。 法学毕业生简历模板下载…
阅读更多...
最新文章

Copyright @ 2022~2023