数据结构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->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.mzph.cn/pingmian/1499.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【数据结构】08排序

08 排序 1. 冒泡排序&#xff08;BubbleSort&#xff09;1.1 循环嵌套实现1.2 递归实现 2. 选择排序2.1 嵌套循环实现2.2 递归实现 3. 插入排序4. 希尔排序4.1 代码实现 5. 快速排序5.1 代码实现6. 归并排序6.1 递归实现6.2 循环实现 7. 堆排序7.1 构建大顶堆7.2 堆排序7.3 代码…

春秋云镜 CVE-2023-51048

靶标介绍&#xff1a; S-CMS v5.0 被发现存在SQLI。 开启靶场 根据题目查找S-CMS v5.0漏洞&#xff0c;百度没有查询到&#xff0c;使用必应搜索S-CMS v5.0 查找到githubCVE-2023-51052的描述 S-CMS v5.0 was discovered to contain a SQL injection... CVE-2023-51052 Git…

达梦数据库的AWR报告

达梦数据库的AWR报告 数据库快照是一个只读的静态的数据库。 DM 快照功能是基于数据库实现的&#xff0c;每个快照是基于数据库的只读镜像。通过检索快照&#xff0c;可以获取源数据库在快照创建时间点的相关数据信息。 为了方便管理自动工作集负载信息库 AWR&#xff08;Auto…

C++修炼之路之多态---多态的原理(虚函数表)

目录 一&#xff1a;多态的原理 1.虚函数表 2.原理分析 3.对于虚表存在哪里的探讨 4.对于是不是所有的虚函数都要存进虚函数表的探讨 二&#xff1a;多继承中的虚函数表 三&#xff1a;常见的问答题 接下来的日子会顺顺利利&#xff0c;万事胜意&#xff0c;生活明朗--…

Vue3+TS版本Uniapp:封装uni.request请求配置

作者&#xff1a;前端小王hs 阿里云社区博客专家/清华大学出版社签约作者✍/CSDN百万访问博主/B站千粉前端up主 封装请求配置项 封装拦截器封装uni.request 封装拦截器 uniapp的封装逻辑不同于Vue3项目中直接使用axios.create()方法创建实例&#xff08;在create方法中写入请求…

【探讨】RocketMQ消息灰度方案-消息逻辑隔离

vivo 鲁班平台 RocketMQ 消息灰度方案 - 稀土掘金分布式- vivo鲁班RocketMQ平台的消息灰度方案MQ消息在生产环境和灰度环境隔离一般怎么实现?消息隔离的原则 中心正常消费者,可以同时消费正常的消息和特定标签的消息(自动识别);特定标签的消费者,只能消费特定标签的消息。灰…

内存管理下及模板初阶

嗨喽&#xff0c;今天阿鑫给大家带来内存管理下以及模板初阶的博客&#xff0c;下面让我们开始今天的学习吧&#xff01; 内存管理下及模板初阶 new和delete的实现原理定位new表达式(placement-new)常见面试题泛型编程函数模板类模板 1. new和delete的实现原理 1.1 内置类型…

用全连接对手写数字识别案例(附解决TensorFlow2.x没有examples问题)

数据集介绍 数据集直接调用可能出现问题&#xff0c;建议从官网直接下载下来&#xff0c;下载存在这四个文件 手写数字识别数据集下载&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1nqhP4yPNcqefKYs91jp9ng?pwdxe1h 提取码&#xff1a;xe1h 55000行训练数据集&a…

【树莓派Linux内核开发】入门实操篇(虚拟机Ubuntu环境搭建+内核源码获取与配置+内核交叉编译+内核镜像挂载)

【树莓派Linux内核开发】入门实操篇&#xff08;虚拟机Ubuntu环境搭建内核源码获取与配置内核交叉编译内核镜像挂载&#xff09; 文章目录 【树莓派Linux内核开发】入门实操篇&#xff08;虚拟机Ubuntu环境搭建内核源码获取与配置内核交叉编译内核镜像挂载&#xff09;一、搭建…

判断完数(C语言)

一、N-S流程图&#xff1b; 二、运行结果&#xff1b; 三、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>int main() {//初始化变量值&#xff1b;int n 0;int i 1;int j 0;int result 1;//提示用户&#xff1b;printf("请输入一个…

目标检测网络YOLO进化之旅

yolo系列网络在目标检测领域取得了巨大的成功&#xff0c; 尤其是在工程实践中&#xff0c; 以其出色的性能优势获得了广泛的应用落地。 YOLO的前3个版本是由同一个作者团队出品&#xff0c; 算是官方版本。 之后的版本都是各个研究团队自己改进的版本&#xff0c; 之间并无明…

基础SQL DDL语句

MySQL的DDL&#xff08;Data Definition Language&#xff09;语句用于定义或修改数据库结构。 DDL数据库操作 查看所有的数据库 show databases; 红色圈起来的是系统数据库&#xff0c;是系统自带的 mysql&#xff1a;包含存储MySQL服务器运行时所需信息的表。这包括数据字典…

【Linux】MySQL的安装及配置(Ubuntu-18.04)

一、安装MySQL 分别安装MySQL服务器、MySQL客户端、C/C开发库 sudo apt-get install mysql-server sudo apt-get install mysql-client sudo apt-get install libmysqlclient-dev 二、配置MySQL 1.查看默认配置文件&#xff0c;此处的user和password为默认提供的&#xff0c;…

Ceph 分布式文件系统 搭建及使用

一、Ceph 介绍 在当今数据爆炸式增长的时代&#xff0c;企业对于可靠、可扩展的存储解决方案的需求日益迫切。Ceph 作为一种开源的、可伸缩的分布式存储解决方案&#xff0c;正逐渐成为企业级存储领域的热门选择。Ceph是一种由Radicalbit公司开发的开源分布式存储系统&#xf…

ElasticSearch虚拟机安装(单机版)

1.下载7.10.2 下载链接&#xff0c;选择LINUX X86_64下载 2.创建用户 useradd es也可以使用系统默认用户&#xff08;非root&#xff09;,root用户会报错 3.解压 tar xvf elasticsearch-7.10.2-linux-x86_64.tar.gz假定目录在/home/es/elasticsearch-7.10.2-linux-x86_64 …

Spring Boot | Spring Boot 默认 “缓存管理“ 、Spring Boot “缓存注解“ 介绍

目录: 一、Spring Boot 默认 "缓存" 管理 :1.1 基础环境搭建① 准备数据② 创建项目③ 编写 "数据库表" 对应的 "实体类"④ 编写 "操作数据库" 的 Repository接口文件⑤ 编写 "业务操作列" Service文件⑥ 编写 "applic…

JavaCard学习笔记: CAP Component 之 Class Component

文章目录 整体结构tag和size字段signature_pool_length和signature_pooltype_descriptor结构导入类型编码导入项签名示例导入类导入数组导入远程方法 interfaces[]interface_info结构flagsinteface_countsuperinterfacesinterface_name class_info_compact classes[]结构flagsi…

基于Springboot的网上商城购物系统

基于SpringbootVue的网上商城购物系统的设计与实现 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringbootMybatis工具&#xff1a;IDEA、Maven、Navicat 系统展示 用户登录 首页 商品信息 商品资讯 后台登录页面 后台管理首页 用户管理 商品分类管…

记录一个hive中跑insert语句说没创建spark客户端的问题

【背景说明】 我目前搭建离线数仓&#xff0c;并将hive的执行引擎改成了Spark&#xff0c;在将ods层的数据装载到dim层&#xff0c;执行insert语句时报如下错误 【报错】 [42000][40000] Error while compiling statement: FAILED: SemanticException Failed to get a spark…

星链全解1

星链基本信息 星链卫星的寿命约为5年&#xff0c;最终目标是发射42000颗卫星。最初&#xff0c;每颗卫星重约260公斤&#xff0c;与1吨以上的大卫星相比属于“小卫星”。现在&#xff0c;向V2版进化的星链卫星重量近800公斤&#xff0c;约为老一代卫星的3倍。 点击“星链地图…