【数据结构】堆的实现堆排序Top-K

news2025/1/11 20:42:34

文章目录

  • 一、堆的概念及结构
  • 二、堆实现
    • （1）创建结构体
    • （2）具体函数实现及解析
      • 1.0 交换函数
      • 1.1 堆的打印
      • 1.2 堆的初始化
      • 1.3 堆的销毁
      • 1.4 堆的插入
      • 1.5堆的向上调整算法
      • 1.6 堆的删除
      • 1.7堆的向下调整算法
      • 1.8 取堆顶的数据
      • 1.9 堆的数据个数
      • 2.0 堆的判空
    • （3） 堆实现代码
      • （1）Heap.h
      • （2）Heap.c
      • （3）Test.c
    • （4）堆测试结果
  • 三、建堆比较
    • （1）建堆方法
    • （2）向下调整建堆时间复杂度证明
  • 四、堆排序
    • （1）堆排序建堆
    • （2）堆排序思想
    • （3）堆排序实现核心代码
    • （4）堆排序实现代码
      • （1）HeapSort.c
      • （2）堆排序测试结果
  • 五、Top-K
    • （1）认识TopK
    • （2）核心代码及解析
    • （3）TopK完整代码
    • （4）测试结果

一、堆的概念及结构

认识堆之前先简单认识一下俩种树：

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

在这里插入图片描述

如果有一个关键码的集合K = { 0,1,2,3,4…i }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： i<2i+1且i<2i+2称为小堆，反之则为大堆。如图
在这里插入图片描述

二、堆实现

（1）创建结构体

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

先使用typedef int HPateType,是为了方便改类型，在结构体里创建3个成员变量，HPDataType a，为了方便增容，用指针的形式，int size代表a指向空间里的个数，int capacity代表a指向空间里的容量。

（2）具体函数实现及解析

1.0 交换函数

void Swap(HPDataType* p1, HPDataType* p2)//交换数据
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

交换数据为堆的向上，向下调整及堆的删除做铺垫，创建临时变量进行交换。

1.1 堆的打印

void HeapPrintf(Heap* hp)//堆的打印
{
	assert(hp);
	for (int i = 0; i < hp->size; i++)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}

断言hp，不能为空，用for循环进行打印。

1.2 堆的初始化

void HeapInit(Heap* hp)//堆的初始化
{
	assert(hp);
	hp->a =NULL;
	hp->capacity = hp->size = 0;
}

初始化堆，置a指针为空，容量大小和堆个数为0。

1.3 堆的销毁

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

堆销毁释放指针啊，并置为空，容量大小和堆个数置为0。

1.4 堆的插入

void HeapPush(Heap* hp, HPDataType x)// 堆的插入（相当于在建堆），并保持它是一个堆(O(logN))
{
	assert(hp);
	if (hp->capacity == hp->size)//扩容
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail ");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size-1);
}

堆的插入也是核心内容，其实是在建堆，假设建大堆，那么首先插入数据前，要先考虑扩容的问题，如果capacity和size大小相等，说明满了需要扩，之后进行数据插入，因为此过程是插入数据并且使它成为大堆，所以当插完数据之后，需要调用向上调整函数，让它成为大堆。

1.5堆的向上调整算法

void AdjustUp(HPDataType* a, int child)//向上调整
{
	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;
		}
	}

}

假设是建大堆，向上调整的算法思路是从孩子结点开始，从下到上比较孩子结点和父亲结点的大小，如果比父亲大，就交换父子结点，并更新孩子结点，即让孩子结点到父亲的位置，并求出此时父亲的大小，继续比较，直到孩子结点为0停止，也就是到根了；反之如果比父亲结点小就停止循环，不用调整。

1.6 堆的删除

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);
}

堆的删除主要用于TopK问题,找最大或最小的前K个，根位置与最后一个交换，方便删除)时间复杂度为O(logN)。
需要断言两次，堆为空不能删除。调用Swap函数，把堆顶数据和最后一个数据交换，再–，删掉数据，再调用向下调整算法，进行调整。

1.7堆的向下调整算法

void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
	assert(a);
	int child = 2 * parent + 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 = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}

向下调整算法有一个条件：左右子树必须是一个堆，才能调整。正好可以被堆删除函数（因为它除去堆顶，左右是一个堆，但整体不是堆）调用。如图：
在这里插入图片描述
整体思路是：假设是大堆，从根节点即父亲结点开始，和他两个孩子结点最大的比较，从上到下调整。我先假设左孩子child就是最大，之后再来个if函数进行比较，如果child + 1 < n，确保有右孩子，并且child+1如果大于child，说明右孩子大，就++。之后如果最大的孩子比父亲节点大，那就调整，并更新父亲结点，让父亲到孩子结点的位置，并求出它下一个孩子结点下标，如果小于就停止。

1.8 取堆顶的数据

HPDataType HeapTop(Heap* hp)// 取堆顶的数据
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}

取堆顶数据直接返回0位置的数据。

1.9 堆的数据个数

int HeapSize(Heap* hp)// 堆的数据个数
{
	assert(hp);
	return hp->size;
}

取堆的数据个数就更简单，直接返回hp->size。

2.0 堆的判空

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

判空如果size为0，即为空。

（3） 堆实现代码

（1）Heap.h

#pragma once 
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<string.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}Heap;

void Swap(HPDataType* p1, HPDataType* p2);//交换数据
void HeapPrintf(Heap* hp);//堆的打印
void HeapInit(Heap* hp);//堆的初始化

void HeapDestroy(Heap* hp);// 堆的销毁

void HeapPush(Heap* hp, HPDataType x);// 堆的插入，并保持它是一个堆(O(logN))
void AdjustUp(HPDataType* a, int child);//向上调整

void HeapPop(Heap* hp);// 堆的删除，并保持它是一个堆(用于TopK,找最大或最小的前K个)(根位置与最后一个交换，方便删除)O(logN)s
void AdjustDown(HPDataType* a,int n,int parent);//向下调整
HPDataType HeapTop(Heap* hp);// 取堆顶的数据

HPDataType HeapSize(Heap* hp);// 堆的数据个数

bool HeapEmpty(Heap* hp);// 堆的判空

void HeapCreate(Heap* hp, HPDataType* aa, int n);// 堆的构建

（2）Heap.c

#include"Heap.h"
void Swap(HPDataType* p1, HPDataType* p2)//交换数据
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void HeapPrintf(Heap* hp)//堆的打印
{
	assert(hp);
	for (int i = 0; i < hp->size; i++)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}
void HeapInit(Heap* hp)//堆的初始化
{
	assert(hp);
	hp->a =NULL;
	hp->capacity = hp->size = 0;
}
void HeapDestroy(Heap* hp)// 堆的销毁
{
	assert(hp);
	free(hp->a);
	hp->a = NULL;
	hp->capacity = hp->size = 0;
}
void AdjustUp(HPDataType* a, int child)//向上调整
{
	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 HeapPush(Heap* hp, HPDataType x)// 堆的插入(相当于在建堆)，并保持它是一个堆(O(logN))
{
	assert(hp);
	if (hp->capacity == hp->size)//扩容
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail ");
			exit(-1);
		}
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	AdjustUp(hp->a, hp->size-1);
}

void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
	assert(a);
	int child = 2 * parent + 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 = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}
void HeapPop(Heap* hp)// 堆的删除，并保持它是一个堆(用于TopK,找最大或最小的前K个)(根位置与最后一个交换，方便删除)O(logN)
{
	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];
}

int HeapSize(Heap* hp)// 堆的数据个数
{
	assert(hp);
	return hp->size;
}
bool HeapEmpty(Heap* hp)// 堆的判空
{
	assert(hp);
	return hp->size == 0;
}

void HeapCreate(Heap* hp, HPDataType* aa, int n)// 堆的构建 最优算法
{
	assert(hp);
    hp->a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
  memcpy(hp->a, aa, sizeof(HPDataType)*n);
	hp->capacity = hp->size = n;
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(hp->a, n, i);
	}
}

（3）Test.c

#include"Heap.h"
void Test1()
{
	int arr[] = { 56, 99, 14, 23, 53, 87, 22, 36, 45, 12 };
	Heap  hp;
	HeapInit(&hp);
	for (int i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
	{
		HeapPush(&hp, arr[i]);//建立大堆
	}
	HeapPrintf(&hp);


	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));//从大到小打印
		HeapPop(&hp);
	}
	printf("\n");
	HeapDestroy(&hp);

}
void Test2()
{
	int array[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	Heap hp;
	HeapCreate(&hp, array, sizeof(array) / sizeof(int));
	HeapPrintf(&hp);

	HeapDestroy(&hp);
}
int main()
{
	Test1();
	Test2();
	return 0;
}

（4）堆测试结果

在这里插入图片描述

三、建堆比较

（1）建堆方法

建堆可以有两种方法：
第一种是用堆的插入（里面简介使用向上调整）进行建堆，但效率不高，时间复杂度为O(N*logN)。
第二种是向下调整算法，因为使用必须满足左右子树必须是一个堆，才能调整。所以需要倒着进行向下调整，从非叶子结点开始。最后一个结点下标是n-1，有孩子算父亲结点，再减1除2，找到非叶子结点，之后就从这开始，每减一次1，就向下调整，直到为0，就能使之成为大堆或小堆。它的时间复杂度为O(N)
如下代码：

//第一种
void HeapCreate(Heap* hp, HPDataType* aa, int n)//时间复杂度不优
{
	aasert(hp);
	HeapInit(hp);
	for (int i = 0; i < n; i++)
	{
		HeapPush(hp, aa[i]);(效率不高)(N*logN)-时间复杂度
	}
}
//第二种
void HeapCreate(Heap* hp, HPDataType* aa, int n)//最优算法
{
	assert(hp);
    hp->a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
  memcpy(hp->a, aa, sizeof(HPDataType)*n);
	hp->capacity = hp->size = n;
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(hp->a, n, i);
	}
}

（2）向下调整建堆时间复杂度证明

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明。向下调整建堆 O(N)
在这里插入图片描述
我们用的是向下调整算法从倒数第一层进行，也就是h-1层到根节点。(按最坏的情况)
第h-1层：2^h-2个结点，需要向下移动1层。
第h-2层：2^h-3个结点，需要向下移动2层。
…
第4层：2^3个结点，需要向下移动h-4层
第3层：2^2个结点，需要向下移动h-3层
第2层：2^1个结点，需要向下移动h-2层
第1层：2^0个结点，需要向下移动h-1层
得到：
在这里插入图片描述
用错位相减2-1得到：

在这里插入图片描述

向上调整建堆  N*logN
	for (int i = 1; i < n; ++i)
	{
	AdjustUp(a, i);
	}

向下调整建堆 O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

向下和向上时间复杂度比较，向下更优，所以建堆用向下调整建。

四、堆排序

（1）堆排序建堆

如果降序，就建小堆
如果升序，就建大堆

（2）堆排序思想

堆排序用堆删除思想，堆删除是在已经是大堆或小堆的条件下，把堆顶和尾进行交换，再把它删除。我们就利用这一思想，把大的或小的换到后面，不删除最后一个即保留它，到最后就形成了从小到大或从大到小的序列。而且它们都是用了向下调整。

用堆排序也是倒着用向下调整算法去排，在调整的过程中，因为最后一层结点数占了总结点一半，向下调整是从倒数二层开始，最后一层所有结点直接跳过并且高度越高调整的次数越少，更快。比如倒数第二层只调整1次

（3）堆排序实现核心代码

void HeapSort(int* a, int n)
{

	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}// 向下调整建堆 时间复杂度O(N)

	int end = n - 1;
	while (end > 0)	//时间复杂度 O（N*logN）
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

首先用向下调整算法建堆，之后用变量end记录最后一个数的下标，交换之后，用向下调整算法恢复原来的大堆或小堆，最后需要保留最后一个数据，直接end–，即是把倒数第二个赋为end。相当于假删除。

（4）堆排序实现代码

（1）HeapSort.c

#include<stdio.h>
#include<assert.h>
void Swap(int* p1, int* p2)//交换数据
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)//向下调整
{
	assert(a);
	int child = 2 * parent + 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 = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}
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;
	}
}

void TestHeap1()
{
	int array[] = { 26, 14, 17, 59, 29, 33, 99, 46, 22, 36 };
	HeapSort(array, sizeof(array) / sizeof(int));

	for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}
int main()
{
	TestHeap1();
	return 0;
}

（2）堆排序测试结果

在这里插入图片描述

五、Top-K

（1）认识TopK

求TOP-K问题就是求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
对于Top-K问题，可以用最简单直接的方式就是排序，但如果数据量非常大，排序就不可取(数据量太多都不能一下子全部加载到内存中)。可以用堆来解决。
基本思路是：

1、用数据集合中前K个元素来建堆
如果找前K个最大元素建小堆，反之建大堆
2、依次遍历剩余的N-K个元素与堆顶元素来比较，如果比堆顶大就替换，最后向下调整。
3、将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

（2）核心代码及解析

void TestHeap()
{
	// 造数据
	int n, k;
	printf("请输入n和k:>");
	scanf("%d%d", &n, &k);
	srand(time(0));
	FILE* fin = fopen("data.txt", "w");//创建文件
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (size_t i = 0; i < n; ++i)
	{
		int val = rand() ;
		fprintf(fin, "%d\n", val);//把随机产生的数写入fin中
	}
	fclose(fin);


	FILE* fout = fopen("data.txt", "r");//找Topk，先以读的方式打开
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}

	
	int* minHeap = malloc(sizeof(int)*k);//开辟k个空间
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}

	for (int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);//从文件中依次先读k个数据到minHeap中
	}


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

	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		if (val > minHeap[0])//在N-K个数据里读一个数到val中，与堆顶进行比较
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}

	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);//打印前K个最大元素
	}
	printf("\n");
	fclose(fout);
}

假设求前K个最大元素
1、先造数据，这里用到了rand函数，并使用srand函数设置随机数种子，生成随机数。先以写的方式创建一个文件，把生成的随机数写到该文件中，关闭文件。
2、之后再以读的方式打开，并开辟K个空间，把文件前K个数据读到k个空间里。
3、再对这个K个数据进行建小堆
4、再从N-K个数据 ，剩下的数据中依次读到变量val中，与堆顶进行比较，如果比堆顶大，就交换，并进行向下调整。这样在堆中大的数据就沉到了底下。
5、打印数据。

（3）TopK完整代码

#include<assert.h>
#include<time.h>
void Swap(int* p1, int* p2)//交换数据
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)//向下调整
{
	assert(a);
	int child = 2 * parent + 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 = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}
void TestHeap()
{
	// 造数据
	int n, k;
	printf("请输入n和k:>");
	scanf("%d%d", &n, &k);
	srand(time(0));
	FILE* fin = fopen("data.txt", "w");//创造文件
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (size_t i = 0; i < n; ++i)
	{
		int val = rand() ;
		fprintf(fin, "%d\n", val);//把随机产生的数写入fin中
	}
	fclose(fin);


	FILE* fout = fopen("data.txt", "r");//找Topk，先以读的方式打开
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}

	
	int* minHeap = malloc(sizeof(int)*k);//开辟k个空间
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}

	for (int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);//从文件中依次先读k个数据到minHeap中
	}


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

	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		if (val > minHeap[0])//在N-K个数据里读一个数到val中，与堆顶进行比较
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}

	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);//打印前K个最大元素
	}
	printf("\n");
	fclose(fout);
}

int main()
{
	TestHeap();
	return 0;
}

（4）测试结果

在这里插入图片描述

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

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

相关文章

【力扣练习】找一个字符串中不含有重复字符的最长字串的长度

【力扣练习】找一个字符串中不含有重复字符的最长字串的长度

class Solution: def lengthOfLongestSubstring(self, s: str) -> int: # 哈希集合&#xff0c;记录每个字符是否出现过 occ set() n len(s) # 右指针&#xff0c;初始值为 -1&#xff0c;相当于我们在字符串的左边界的左侧&#xff…
阅读更多...
【项目实战】Spring Boot项目抵御XSS攻击

【项目实战】Spring Boot项目抵御XSS攻击

本专栏将为大家总结项目实战相关的知识&#xff01; 点击即可关注本专栏&#xff0c;获取更多知识&#xff01; 文章目录前言一、什么是XSS攻击二、如何抵御XSS攻击三、实现抵御XSS攻击结语前言 作为Web网站来说&#xff0c;抵御XSS攻击是必须要做的事情&#xff0c;这是非常常…
阅读更多...
C++基础知识

C++基础知识

目录 C的基本使用 C数据的输入与输出 C使用命令行 具体案例 C生成随机数 关键字 标识符命名规则 数据类型 整形 实型&#xff08;浮点型&#xff09; 浮点型变量分为2种 表示小数的两种方式 案例演示 字符型 案例演示 字符串类型 两种风格 两种风格字符串之间…
阅读更多...
【MyBatis】MyBtis入门程序

【MyBatis】MyBtis入门程序

1. 目录结构 2. 数据库表的设计 /*Navicat Premium Data TransferSource Server : MysqlSource Server Type : MySQLSource Server Version : 50726Source Host : localhost:3306Source Schema : mybatisTarget Server Type : MySQLTarget Se…
阅读更多...
python_循环

python_循环

一、while循环的基础语法程序中的循环&#xff1a;while 条件&#xff1a;条件满足时&#xff0c;做的事情1条件满足时&#xff0c;做的事情2......即只要条件满足&#xff0c;会无限循环执行代码示例&#xff1a;# 简单示例&#xff1a;向Vivian表白100次i 0 while i < 10…
阅读更多...
RabbitMQ系列【13】优先级队列

RabbitMQ系列【13】优先级队列

有道无术&#xff0c;术尚可求&#xff0c;有术无道&#xff0c;止于术。 文章目录前言1. 设置优先级队列2. 消息设置优先级前言 RabbitMQ将消息写入队列中都是按顺序写的&#xff0c;消费时也是按顺序进行消费&#xff0c;队列中的消息是先进先出(FIFO).。 首先测试一下没有优…
阅读更多...
多数银行人都会忽略5个影响系统性能的因素总结

多数银行人都会忽略5个影响系统性能的因素总结

性能测试往往在投产上线前开展&#xff0c;无法对整个系统变更进行全面的覆盖测试&#xff0c;因此性能测试需求提出十分关键。 性能测试需求交付过程中&#xff0c;需要对开发团队提出的测试需求进行审查&#xff0c;重点分析交付的测试需求是否充分覆盖了影响系统性能的因素…
阅读更多...
【OpenCV-Python】教程：3-7 Canny边缘检测

【OpenCV-Python】教程：3-7 Canny边缘检测

OpenCV Python Canny 边缘检测 【目标】 Canny 边缘检测的概念cv2.Canny 【原理】 1. 去噪 由于边缘检测非常容易收到图像的噪声影响&#xff0c;第一步使用 5x5 高斯滤波去除图像中的噪声。 2. 寻找图像的亮度梯度 在平滑后&#xff08;去噪后&#xff09;的图像利用 S…
阅读更多...
1.5 阻塞与非阻塞I/O

1.5 阻塞与非阻塞I/O

文章目录1、阻塞I/O2、非阻塞I/O3、异步I/O4、同步I/O5、epoll原理函数5.1、int epoll_create(int size)5.2、int epoll_ctl(int epfd,int op,int fd,struct epoll_event* event)5.3、int epoll_wait(int epfd,struct epoll_event* events,int maxevents,int timeout)5.4、内核…
阅读更多...
【Linux 线程介绍】

【Linux 线程介绍】

Linux 线程线程一定越多越好吗&#xff1f;线程的实现方式&#xff1a;API:pthread_exit函数演示获取线程的返回值多线程的不安全性查看进程中的线程数进程&#xff1a;一个正在运行的程序 &#xff0c;资源分配的基本单位 线程&#xff1a;进程内部的一条执行序列&#xff08;…
阅读更多...
接口自动化测试

接口自动化测试

接口自动化测试1.基础知识1.接口测试原理2.接口测试点及用例设计方法3.接口测试返回值的处理4.接口测试要点5.常见HTTP状态码6.HTTP基础知识7.接口自动化测试工具2.抓包工具1.chrom抓包2.Fiddle抓包&#xff08;PC端&#xff0c;手机端&#xff09;1.原理2.下载安装3. 认识界面…
阅读更多...
HIbernate多表学习

HIbernate多表学习

一&#xff0c;表与表之间关系&#xff1a; 1.一对多&#xff1a;多的表用一个外键存一的表的主键id。 2.多对多&#xff1a;新建第三张表&#xff0c;两个外键分别存两个多的表的主键id。 3.一对一 二&#xff0c;Hibernate一对多练习&#xff1a; 一对多映射配置&#…
阅读更多...
国际通用回收标准-GRS、RCS的答疑

国际通用回收标准-GRS、RCS的答疑

【国际通用回收标准-GRS、RCS的答疑】 GRS & RCS 国际通用回收标准 GRS和 RCS是目前现行国际公认的回收材料标准。许多国际知名品牌如 ADDIDAS、3M、PUMA、H&M、NIKE等都是此标准的会员。GRS与 RCS最早开始于纺织产业&#xff0c;用以证明其产品或原料含有一定的回收材…
阅读更多...
yolov5剪枝实战4: 正常训练和稀疏化训练

yolov5剪枝实战4: 正常训练和稀疏化训练

1. 准备自己的数据集 1.1 下载项目文件 准备好备注的数据集进行训练，我这里给出了标注好的足球的数据集。从百度网盘下载到项目目录下并解压，网盘地址见文末 VOCdevkit_ball.ziptestfiles.zipprepare_data.py1.2 解压建立或自行建立数据集 使用PASCAL VOC数据集的目录结构，…
阅读更多...
怎么批量把图片转文字？教你几招轻松完成

怎么批量把图片转文字？教你几招轻松完成

工作中我们经常要与图片、文字打交道&#xff0c;特别是做资料收集的小伙伴&#xff0c;当收到图片资料的时候&#xff0c;就需要将其输出为文字进行保存&#xff0c;如果是单张的时候我们还可以使用手机或者微信直接拍照识别转&#xff0c;但是图片不止一张的时候&#xff0c;…
阅读更多...
nvcc编译器之GPU代码编译（chapter 5）

nvcc编译器之GPU代码编译（chapter 5）

目录 5. GPU编译 5.1 GPU多代架构 5.2 GPU特性列表 5.3 应用兼容性 5.4 虚拟架构 5.5 虚拟架构特性列表 5.6 兼容性补全机制 5.7 nvcc示例 5. GPU编译 本章描述了由nvcc与CUDA驱动协同维护的GPU编译模型。本文介绍了一些技术部分&#xff0c;并在最后给出了具体的示例…
阅读更多...
100家！第一批5G应用解决方案供应商推荐名录

100家！第一批5G应用解决方案供应商推荐名录

近日&#xff0c;5G应用产业方阵&#xff08;5G AIA&#xff09;在“2022年中国5G发展大会5G应用产业发展论坛”发布了“5G应用解决方案供应商推荐名录&#xff08;第一批&#xff09;”入库名单&#xff0c;旨在强化5G应用供需对接&#xff0c;推动5G应用解决方案成熟&#xf…
阅读更多...
RDD缓存机制及持久化技术

RDD缓存机制及持久化技术

文章目录RDD缓存RDD缓存API介绍RDD缓存代码演示示例RDD缓存执行原理RDD CheckPointCheckPoint代码演示示例CheckPoint与Cache对比RDD缓存 RDD之间进行Transformation计算&#xff0c;当执行开启之后&#xff0c;就会有新的RDD生成&#xff0c;而之前老的RDD就会消失&#xff0…
阅读更多...
js逆向基础篇-某音乐网站-xx音乐

js逆向基础篇-某音乐网站-xx音乐

提示！本文章仅供学习交流，严禁用于任何商业和非法用途，如有侵权，可联系本文作者删除！ 网站链接：aHR0cHM6Ly9tdXNpYy4xNjMuY29tLyMvc2VhcmNoL20vP3M9JUU1JUE0JUE5JUU0JUI4JThCJnR5cGU9MQ== 案例分析： 搜索歌曲名称，找到列表接口，如上图能看到列表数据的，之后看下传参，…
阅读更多...
249 h221 最大岛屿面积

249 h221 最大岛屿面积

方式1 错误的动态规划 递归公式为 if (matrix[i][j]‘1’&&matrix[i-1][j-1]‘1’){ int edge(int) Math.pow(dp[i][j],0.5); // 边长 int addCount addCount(matrix, i, j, edge); dp[i][j]dp[i-1][j-1]addCount; maxMath.max(max,dp[i][j]); } 只根据 dp[i-1][j-1]…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023