数据结构10：堆和堆排序

文章目录

  • 树的概念及结构
    • 树的概念
    • 树的相关概念
    • 树的表示
    • 树在实际中的应用
      • 表示文件系统的目录树结构
  • 二叉树概念及结构
    • 概念
    • 特殊的二叉树
    • 二叉树的性质
    • 二叉树的存储结构
    • 顺序存储
    • 链式存储
  • 二叉树的顺序结构及实现
    • 二叉树的顺序结构
    • 堆的概念及结构
  • 堆的实现
    • 堆的插入
    • 堆的删除
    • 堆的创建
      • 向上调整法
      • 向下调整法
    • 堆的销毁
    • 取堆顶的数据
    • 堆的数据个数
    • 堆的判空
  • 堆的应用
    • 堆排序
    • 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->size和hp->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;
}

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

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

相关文章

C# winfrom 超详细UI创建过程 实现双色球选号器UI界面设计过程

C# winfrom 超详细UI创建过程 实现双色球选号器UI界面设计过程

一、 效果展示 1. 无点击效果展示&#xff1a;不选中——双色球为灰色&#xff0c;字体也为灰色 2.点击双色器效果展示&#xff1a;选中——双色球为红或者蓝&#xff0c;字体为白色 二、 使用控件标注说明 三、界面特点介绍 双色球代码控制生成---------由于红色33个球&…
阅读更多...
上位机工作感想-从C#到Qt的转变-1

上位机工作感想-从C#到Qt的转变-1

0.前言 接触Qt开发也有一年多的时间了&#xff0c;还记得去年初从杭州回合肥时&#xff0c;刚来公司面临的几个问题&#xff1a; 1.C#转上位机的迷茫2.新公司管理模式的差异3.试用期的各种紧急任务。 当时也是加班加点学习C和Qt的基础知识&#xff0c;做了两个考核项目后&am…
阅读更多...
生态短讯 | Tapdata 与 TDengine 完成产品兼容性互认证，打造物联网实时数据生态

生态短讯 | Tapdata 与 TDengine 完成产品兼容性互认证，打造物联网实时数据生态

近月&#xff0c;深圳钛铂数据有限公司&#xff08;以下简称钛铂数据&#xff09;自主研发的实时数据平台&#xff08;Tapdata Live Data Platform&#xff09;与北京涛思数据科技有限公司&#xff08;以下简称涛思数据&#xff09;自主研发的大数据平台 TDengine&#xff0c;已…
阅读更多...
arm版Linux下安装大数据集群各种组件

arm版Linux下安装大数据集群各种组件

背景&#xff1a;由于本人是用的Macbookpro m2来进行开发的&#xff0c;很多环境和Intel芯片的都不一样&#xff0c;期间安装各种软件遇到各种问题&#xff0c;为了以后不走之前的老路&#xff0c;现记录各种软件的安装步骤。 系统安装组件说明 序号组件名称组件版本1jdkjdk-…
阅读更多...
SpringMvc的核心组件和执行流程

SpringMvc的核心组件和执行流程

一、 springmvc的核心组件及作用 1.DispatcherServlet:前置控制器&#xff0c;是整个流程控制的核心&#xff0c;用来控制其他组件的执行&#xff0c;降低了其他组件的耦合性 2.Handler:控制器&#xff0c;完成具体的业务逻辑&#xff0c;当DispatcherServlet接收到请求后&am…
阅读更多...
Linux华硕笔记本安装ROG Asusctl

Linux华硕笔记本安装ROG Asusctl

基础环境 适用系统&#xff1a; linux mint 21ubuntu 22.04 安装版本&#xff1a; asusctl-5.0.10rust 1.77.2 构建 安装编译环境 sudo apt-get update sudo apt-get install -y \libasound2-dev \libfreetype6-dev \libexpat1-dev \libxcb-composite0-dev \libssl-dev …
阅读更多...
mysql基础2——字段类型

mysql基础2——字段类型

整数类型 需要考虑存储空间和可靠性的平衡 浮点类型 浮点数类型不精准 将十进制数转换为二进制数存储 浮点数类型&#xff1a;float double real(默认是&#xff0c;double ) 如果需要将real设定为float &#xff0c;那么通过以下语句实现 set sql_mode "real_as…
阅读更多...
Token 在 LLM

Token 在 LLM

大语言模型不能理解原始文本，所以需要把原始文本转换成大语言模型可以理解的数字表示形式，经过大模型处理以后，需要将该数字表示形式转换为人可以理解的文本。 原始文本到 token 原始文本转换为token序列的过程通常是在LLM的预处理阶段完成的。 在大型语言模型(LLM)中,tok…
阅读更多...
restful请求风格的增删改查-----查询and添加

restful请求风格的增删改查-----查询and添加

一、restful风格的介绍 restful也称之为REST ( Representational State Transfer )&#xff0c;可以将它理解为一种软件架构风格或设计风格&#xff0c;而不是一个标准。简单来说&#xff0c;restful风格就是把请求参数变成请求路径的一种风格。例如&#xff0c;传统的URL请求…
阅读更多...
Windows bat实现循环往txt文件插入1000条数据内容

Windows bat实现循环往txt文件插入1000条数据内容

bat脚本实现&#xff1a; echo off for /L %%i in (1,1,1000) do (echo "I am from 192.168.10.171" >> c:\ztj.txt ) echo off --在批处理运行命令的时候不会一条一条的显示执行的命令 for /L %variable in (start,step,end) do command [command-p…
阅读更多...
SQLite导出数据库至sql文件

SQLite导出数据库至sql文件

SQLite是一款实现了自包含、无服务器、零配置、事务性SQL数据库引擎的软件库。SQLite是世界上部署最广泛的SQL数据库引擎。 SQLite 是非常小的&#xff0c;是轻量级的&#xff0c;完全配置时小于 400KiB&#xff0c;省略可选功能配置时小于250KiB。 SQLite 源代码不受版权限制。…
阅读更多...
BST+二分

BST+二分

二叉搜索树 二叉查找树是指一棵有下列性质的[二叉树]&#xff1a; 若任意节点的左子树不空&#xff0c;则左子树上所有节点的值均小于它的根节点的值&#xff1b;若任意节点的右子树不空&#xff0c;则右子树上所有节点的值均大于它的根节点的值&#xff1b;任意节点的左、右…
阅读更多...
《计算思维导论》笔记：《第10章 数据化思维-数据聚集与管理》计算思维第17讲-从表的管理看数据库

《计算思维导论》笔记：《第10章 数据化思维-数据聚集与管理》计算思维第17讲-从表的管理看数据库

《大学计算机—计算思维导论》&#xff08;战德臣 哈尔滨工业大学&#xff09; 《计算思维第17讲-从表的管理看数据库----结构化与非结构化数据管理》 一、引言 今天我们从表的管理看数据库&#xff0c;给大家讲一下结构化与非结构化数据管理的思维。 二、为什么需要数据库–工…
阅读更多...
ExpertPrompting：指导大语言模型成为杰出专家

ExpertPrompting：指导大语言模型成为杰出专家

&#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ 论文标题&#xff1a;ExpertPrompting: Instructing Large Language Models to be Distinguished Experts 论文地址&#xff1a;https://arxiv.org/abs/2305.14688 作者 & 机构&#xff1a;Benfen…
阅读更多...
cd /op-bash: 无法为立即文档创建临时文件: 设备上没有空间

cd /op-bash: 无法为立即文档创建临时文件: 设备上没有空间

问题 在shell输入命令按tab键时出现以下报错 (base) [link999hadoop102 ~]$ cd /op-bash: 无法为立即文档创建临时文件: 设备上没有空间 -bash: cd: /op: 没有那个文件或目录原因分析 磁盘空间不够 df -Th # 通过命令查看具体情况解决 1、清理大文件 进入到 容量-已用 使…
阅读更多...
【未完成】【QT+OpenCV】车牌号检测 学习记录 遇到的问题

【未完成】【QT+OpenCV】车牌号检测 学习记录 遇到的问题

【QTOpenCV】车牌号检测 学习记录 首先在QT里面配置好OpenCV .pro文件中加入&#xff1a; INCLUDEPATH G:/opencv/build/include LIBS -L"G:/opencv/build/x64/vc14/lib"\-lopencv_core \-lopencv_imgproc \-lopencv_highgui \-lopencv_ml \-lopencv_video \-lo.c…
阅读更多...
【c++】stack和queue使用 stack和queue模拟实现

【c++】stack和queue使用 stack和queue模拟实现

主页&#xff1a;醋溜马桶圈-CSDN博客 专栏&#xff1a;c_醋溜马桶圈的博客-CSDN博客 gitee&#xff1a;mnxcc (mnxcc) - Gitee.com 目录 1. stack的介绍和使用 1.1 stack的介绍 1.2 stack的使用 1.3 stack的模拟实现 2. queue的介绍和使用 2.1 queue的介绍 2.2 queue的…
阅读更多...
react之组件与JSX

react之组件与JSX

第一章 - 描述用户界面 概述&#xff1a;React是一个用于构建用户界面&#xff08;UI&#xff09;的JavaScript库&#xff0c;用户界面由按钮&#xff0c;文本和图像等小单元内容构建而成。React帮助你把它们组合成可重用&#xff0c;可嵌套的组件。从web端网站到移动端应用&a…
阅读更多...
【Node.js】02 —— Path模块全解析

【Node.js】02 —— Path模块全解析

&#x1f31f;Node.js之Path模块探索&#x1f308; &#x1f4da;引言 在Node.js的世界中&#xff0c;path模块就像一把万能钥匙&#x1f511;&#xff0c;它帮助我们理解和操作文件与目录的路径。无论你是初入Node.js殿堂的新手&#xff0c;还是久经沙场的老兵&#xff0c;理…
阅读更多...
如何在PostgreSQL中使用CTE（公共表表达式）来简化复杂的查询逻辑？

如何在PostgreSQL中使用CTE（公共表表达式）来简化复杂的查询逻辑？

文章目录 解决方案步骤示例代码 结论 在处理复杂的SQL查询时&#xff0c;我们经常会遇到需要多次引用子查询或中间结果的情况。这可能会使得查询变得冗长且难以理解。为了解决这个问题&#xff0c;PostgreSQL&#xff08;以及其他一些SQL数据库系统&#xff09;引入了公共表表达…
阅读更多...
最新文章

Copyright @ 2022~2023