树、二叉树、堆及其应用（堆排序、top-k问题）

目录

树的概念与结构

概念：

与树相关的概念:

树的表示：

二叉树

概念：

特殊的二叉树：

二叉树性质：

二叉树的存储结构：

堆

堆的概念:

堆的实现：

堆的创建：

堆的插入：

堆的删除：

堆的应用

堆排序：

TOP-K问题：

树的概念与结构

概念：

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

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

 需要注意的是：树形结构中，子树之间不能有交集。

如上图一中B节点和A节点有交集，图二中A节点和C节点有交集，图三中C节点和D节点有交集，因此三个结构都不是树形结构。

与树相关的概念:

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

树的表示：

树结构相对线性表比较复杂，要存储表示起来就比较麻烦，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。其中最常用的是孩子兄弟表示法。                                                                                结构代码如下：

typedef int DataType;
struct Node
{struct Node* child; //孩子结点struct Node* brother; //指向其下一个兄弟结点DataType data; //数据域
};

二叉树

概念：

顾名思义，就是每个节点最多只有两个分叉即每个父节点至多有两个子节点的树形结构。

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

注意：对于任意二叉树，都可以由以下情况复合而成：

特殊的二叉树：

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K（根节点层数为1），且结点总数是 2^k-1，则它就是满二叉树。

完全二叉树：完全二叉树是由满二叉树而引出来的，满二叉树是一种特殊的完全二叉树。对于一个层数为k（根节点层数为1）的二叉树，前k-1层为满二叉树，第k层中所有节点从左至右是连续的，则此二叉树为完全二叉树。高度为h的完全二叉树节点个数范围为：[2^(h-1)+1 , 2^h-1]。

二叉树性质：

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h-1.
3. 对任何一棵二叉树, 如果度为0的叶结点个数为 n0, 度为2的分支结点个数为 n2,则有 n0＝n2＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1) . (log2(n+1) 是以2
为底，(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否则无右孩子

二叉树的存储结构：

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

  • 顺序存储

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

观察数据存储和节点间的关系，可以发现：

父节点下标=(相应子节点下标-1)/2（子节点不分左右）；

左孩子下标=相应父节点下标*2+1；

右孩子下标=相应父节点下标*2+2。

  • 链式存储

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

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode_2
{struct BinTreeNode* Left; // 指向当前节点左孩子struct BinTreeNode* Right; // 指向当前节点右孩子BTDataType data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode_3
{struct BinTreeNode* Parent; // 指向当前节点的父节点struct BinTreeNode* Left; // 指向当前节点左孩子struct BinTreeNode* Right; // 指向当前节点右孩子BTDataType data; // 当前节点值域
}；

堆

相对于普通二叉树，完全二叉树更适合使用顺序结构存储。而现实中通常用顺序结构储存堆(和操作系统中存储数据的堆区不是一回事，此处的堆是一种存储数据的结构，也是一种二叉树)。

堆的概念:

一个数集中的所有元素按照完全二叉树的顺序存储方式存储在一个一维数组中，并满足：在二叉树结构中任一父节点值都大于等于子节点（任一父节点值都小于等于子节点值），则称为大堆或大根堆（小堆或小根堆）。

堆的性质：

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

堆的实现：

堆的创建：

想要创建一个堆，有两种方法：

向上调整建堆 (前边的数据必须是堆)  

向下调整建堆 (左右子树必须是堆)

给定一个数组arr，arr数组逻辑上是一个完全二叉树，但还不是一个堆，存储顺序完全是随机的，当我们想要把arr数组变为一个堆时，也是可以用两种方法：

1、向下调整（时间复杂度：O(N)、空间复杂度：O(1)（不计算堆所占的空间））：因为向下调整时，要保证左右子树是堆，因此我们可以从数组倒数第一个非叶子节点开始，逐个元素向下调整，一直调整到根节点。

代码如下：

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//打印
void HeapPrint(HP* php)
{assert(php);int i = 0;for (i = 0; i < php->size; i++){printf("%d ", php->a[i]);}printf("\n");
}//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType k = *p1;*p1 = *p2;*p2 = k;
}//向下调整(小堆)
void AdjustDown(HPDataType* a, int n, int parent)
{assert(a);int child = parent * 2 + 1;while (child < n){//找出小的if (child + 1 < n && a[child] > a[child + 1]){child += 1;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}//初始化
void HeapInitArray(HP* php, HPDataType* a, int n)
{assert(php);assert(a);php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (php->a == NULL){perror("malloc failed");exit(-1);}php->capacity = n;php->size = n;//移入数据memcpy(php->a, a, sizeof(HPDataType) * n);//调整建堆	//向下调整for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(php->a, n, i);}
}//销毁
void HeapDestroy(HP* php)
{assert(php);free(php->a);php->a = NULL;php->capacity = 0;php->size = 0;
}int main()
{HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };HP hp;HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));HeapPrint(&hp);HeapDestroy(&hp);return 0;
}

运行结果：

可以发现转换为二叉树形式后是一个小堆结构。

2、向上调整（时间复杂度：O(NlogN)、空间复杂度：O(1)（不计算堆所占的空间））：因为向上调整时，要保证前边的数据是堆，因此我们可以从数组的第二个元素开始，逐个元素向上调整，一直调整到最后一个叶子结点。

代码如下：

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//打印
void HeapPrint(HP* php)
{assert(php);int i = 0;for (i = 0; i < php->size; i++){printf("%d ", php->a[i]);}printf("\n");
}//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType k = *p1;*p1 = *p2;*p2 = k;
}//向上调整(小堆)
void AdjustUp(HPDataType* 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 HeapInitArray(HP* php, HPDataType* a, int n)
{assert(php);assert(a);php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (php->a == NULL){perror("malloc failed");exit(-1);}php->capacity = n;php->size = n;//移入数据memcpy(php->a, a, sizeof(HPDataType) * n);//调整建堆	//向上调整int i = 0;for (i = 1; i < n; i++){AdjustUp(php->a, i);}
}//销毁
void HeapDestroy(HP* php)
{assert(php);free(php->a);php->a = NULL;php->capacity = 0;php->size = 0;
}int main()
{HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };HP hp;HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));HeapPrint(&hp);HeapDestroy(&hp);return 0;
}

运行结果：

与向下调整的运行结果相同，因此该组数也是一个小堆结构。

堆的插入：

想要在一个堆中插入数据，只需将想要插入的数据插入到堆尾，然后再对其进行向上调整，直至满足堆的结构即可。

代码如下：

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;void HeapPrint(HP* php)
{assert(php);int i = 0;for (i = 0; i < php->size; i++){printf("%d ", php->a[i]);}printf("\n");
}void AdjustUp(HPDataType* 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 HeapInitArray(HP* php, HPDataType* a, int n)
{assert(php);assert(a);php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (php->a == NULL){perror("malloc failed");exit(-1);}php->capacity = n;php->size = n;//移入数据memcpy(php->a, a, sizeof(HPDataType) * n);//调整建堆//向上调整int i = 0;for (i = 1; i < n; i++){AdjustUp(php->a, i);}
}void HeapPush(HP* php, HPDataType x)
{assert(php);if (php->capacity == php->size)//扩容{int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;HPDataType* tem = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);//当php->a为空时，realloc将执行malloc的功能if (tem == NULL){perror("malloc failed");exit(-1);}php->capacity = newcapacity;php->a = tem;}php->a[php->size] = x;AdjustUp(php->a, php->size);php->size++;
}int main()
{HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };HP hp;HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));HeapPrint(&hp);HeapPush(&hp, 0);HeapPrint(&hp);HeapDestroy(&hp);return 0;
}

运行结果：

可以发现插入0前是小堆，插入0后还是小堆，没有改变数据的存储结构。

堆的删除：

一般说删除堆，都是要求删除堆顶元素即根节点，要达到此目的，只需将堆顶元素与堆尾元素互换，然后删除堆尾，再对新的堆顶元素进行向下调整，直至满足堆结构即可。

代码如下：

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;void HeapPrint(HP* php)
{assert(php);int i = 0;for (i = 0; i < php->size; i++){printf("%d ", php->a[i]);}printf("\n");
}void AdjustDown(HPDataType* a, int n, int parent)
{assert(a);int child = parent * 2 + 1;while (child < n){//找出小的if (child + 1 < n && a[child] > a[child + 1]){child += 1;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}void HeapInitArray(HP* php, HPDataType* a, int n)
{assert(php);assert(a);php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);if (php->a == NULL){perror("malloc failed");exit(-1);}php->capacity = n;php->size = n;//移入数据memcpy(php->a, a, sizeof(HPDataType) * n);//调整建堆int i = 0;for (i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(php->a, n, i);}
}//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType k = *p1;*p1 = *p2;*p2 = k;
}void HeapPop(HP* php)
{assert(php);assert(php->size > 0);Swap(&php->a[0], &php->a[php->size-1]);php->size--;//向下调整AdjustDown(php->a, php->size, 0);
}void HeapDestroy(HP* php)
{assert(php);free(php->a);php->a = NULL;php->capacity = 0;php->size = 0;
}int main()
{HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };HP hp;HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));HeapPrint(&hp);HeapPop(&hp);HeapPrint(&hp);HeapDestroy(&hp);return 0;
}

运行结果：

可以发现删除堆顶后并没有改变其数据的存储结构。

堆的应用

堆排序：

堆排序即利用堆的思想来进行排序，思路如下：
1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序
因为堆顶元素一定是最大值（或最小值）每次把堆顶元素与最后一个元素交换，然后把数组尾指针向前移动1，再对新的堆顶元素进行向下调整，重复上述操作，直至数组尾指针指向第一个元素，此时的数组中的数据就是一个有序的序列。

代码如下：

typedef int HPDataType;
typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//获取根数据
HPDataType HeapTop(HP* php)
{assert(php);assert(php->size > 0);return php->a[0];
}
//判空
bool HeapEmpty(HP* php)
{assert(php);return php->size == 0;
}//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType k = *p1;*p1 = *p2;*p2 = k;
}//向下调整(小堆)
void AdjustDown(HPDataType* a, int n, int parent)
{assert(a);int child = parent * 2 + 1;while (child < n){//找出小的if (child + 1 < n && a[child] > a[child + 1]){child += 1;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}//升序
//void HeapSort(int* a, int n)
//{
//	HP hp;
//	HeapInit(&hp);
//	//建堆（小堆）
//	for (int i = 0; i < n; i++)
//	{
//		HeapPush(&hp, a[i]);
//	}
//	
//	int i = 0;
//	while (!HeapEmpty(&hp))
//	{
//		a[i++] = HeapTop(&hp);//每次取堆顶元素依次放入数组
//		HeapPop(&hp);
//	}
//
//	HeapDestroy(&hp);
//}
// 这种写法的缺点：
// 1、先要创建一个堆的结构
// 2、空间复杂度、时间复杂度的消耗//降序
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--;}
}int main()
{int a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };HeapSort(a, sizeof(a) / sizeof(int));int i = 0;for (i = 0; i < sizeof(a) / sizeof(int); i++){printf("%d ", a[i]);}return 0;
}

运行结果：

TOP-K问题：

即求一组数据中前K个最大的元素或者最小的元素。

对于Top-K问题，能想到的最简单直接的方式就是排序，然后取前k个元素（或后k个元素），但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆的特点来解决，基本思路如下：
1. 用数据集合中前K个元素建堆
若求前k个最大的元素，则建小堆
若求前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素比较，不满足则替换堆顶元素，将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

注意：当找到前k个元素后，若不单独进行排序操作，最后输出的结果并不一定是有序的！！！

代码如下：

//交换函数
void Swap(int* p1, int* p2)
{int k = *p1;*p1 = *p2;*p2 = k;
}//向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{assert(a);int child = parent * 2 + 1;while (child < n){//找出小的if (child + 1 < n && a[child] > a[child + 1]){child += 1;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 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--;}
}//前k个最大的
void PrintTopK(int * a, int k, int n)
{//建堆  前k个元素建堆(小堆)for (int i = (k - 2) / 2; i >= 0; --i){AdjustDown(a, k, i);}//将剩余n-k个元素依次与堆顶元素比较int i = k;while (i<n){if (a[i]>a[0]){//替换a[0] = a[i];//向下调整AdjustDown(a, k, 0);}i++;}for (int i = 0; i < k; i++){printf("%d ", a[i]);}printf("\n");
}int main()
{int a1[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };int n = sizeof(a1) / sizeof(a1[0]);HeapSort(a1, n);int i = 0;for (i = 0; i < n; i++){printf("%d ", a1[i]);}printf("\n");int a2[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };PrintTopK(a2, 5, n);return 0;
}

运行结果：

可以发现，虽然找出来最大的前 k 个元素，但是它们并不是有序的，这是因为我们在程序中找最大的前k个元素时，利用了堆结构，因此，当程序找到最大的前k个元素后，这k个元素是按照堆结构存储的，因此打印出来后并不是有序的。

想要打印出来的结果也是有序的，可以在找到后，再对数组前k个元素进行一次排序即可。

代码如下：

//交换函数
void Swap(int* p1, int* p2)
{int k = *p1;*p1 = *p2;*p2 = k;
}//向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{assert(a);int child = parent * 2 + 1;while (child < n){//找出小的if (child + 1 < n && a[child] > a[child + 1]){child += 1;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 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--;}
}//前k个最大的
void PrintTopK(int * a, int k, int n)
{//建堆  前k个元素建堆(小堆)for (int i = (k - 2) / 2; i >= 0; --i){AdjustDown(a, k, i);}//将剩余n-k个元素依次与堆顶元素比较int i = k;while (i<n){if (a[i]>a[0]){//替换a[0] = a[i];//向下调整AdjustDown(a, k, 0);}i++;}for (int i = 0; i < k; i++){printf("%d ", a[i]);}printf("\n");
}int main()
{int a1[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };int n = sizeof(a1) / sizeof(a1[0]);HeapSort(a1, n);int i = 0;for (i = 0; i < n; i++){printf("%d ", a1[i]);}printf("\n");int a2[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };PrintTopK(a2, 5, n);//单独对前5个元素排序HeapSort(a2, 5);for (i = 0; i < 5; i++){printf("%d ", a2[i]);}return 0;
}

运行结果：

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

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

相关文章

【算法思想-排序】排序数组-力扣 912 题

【算法思想-排序】排序数组-力扣 912 题

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
OJ练习第180题——颠倒二进制位

OJ练习第180题——颠倒二进制位

颠倒二进制位 力扣链接&#xff1a;190. 颠倒二进制位 题目描述 颠倒给定的 32 位无符号整数的二进制位。 提示&#xff1a; 请注意&#xff0c;在某些语言&#xff08;如 Java&#xff09;中&#xff0c;没有无符号整数类型。在这种情况下&#xff0c;输入和输出都将被指…
阅读更多...
2023华为杯数学建模研赛E题全解析

2023华为杯数学建模研赛E题全解析

2023华为杯数学建模研赛E题解析&#xff0c;完整版已出!!! 包含所有模型、代码、结果&#xff0c;39页技术文档&#xff0c;详细内容如下! 免费版链接已放在下面&#xff0c;需要的同学可以直接自取~ 【云顶数模】2023研究生数学建模免费链接&#xff1a; https://pan.baid…
阅读更多...
【Redis】专栏合集，从入门到高级业务场景实战

【Redis】专栏合集，从入门到高级业务场景实战

作者简介 目录 1.概述 2.下载安装 3.基础操作 4.集群 5.实战场景 1.概述 诸如数mysql、Oracle之类的关系型数据库或者NTFS、HDFS之类的文件存储系统&#xff0c;其本质上数据都是存在磁盘上的。这是现代计算机体系架构的架构所决定的&#xff0c;要持久化存储的数据都会落…
阅读更多...
卸载Visual Studio 2010学习版 —— 卸载VCExpress

卸载Visual Studio 2010学习版 —— 卸载VCExpress

目录 最初安装Visual Studio 2010学习版是因为计算机二级 C语言考试而装&#xff0c;现如今考完试后便可卸载掉了&#xff0c;安装简便而卸载却没有uninstall.exe文件。故本文提供卸载方式。 进入到程序目录&#xff0c;找到setup.exe文件&#xff0c;也可以在程序目录搜索set…
阅读更多...
RDMA编程杂记

RDMA编程杂记

目录 编程杂记什么是P_Key建链基于Socket API的建链基于CM API的建链 编程杂记 什么是P_Key P_Key&#xff08;Partition Key&#xff09;用于提供InfiniBand网络的隔离机制&#xff0c;只有在一个分区内的节点可以互相通信。 P_Key是一个16位的值&#xff0c;有两部分 msb…
阅读更多...
CRM客户管理系统英文专业版

CRM客户管理系统英文专业版

外资公司日常沟通的语言以英文为主&#xff0c;业务往来也是涉及到国内外&#xff0c;专业的英文版CRM系统很适合这样的业务团队&#xff0c;尤其CRM供应商是国际化企业&#xff0c;在海外也有分公司、办事处。 多语言 ZOHO支持多语种如英语、汉语、日语等28种语言&#xff0…
阅读更多...
Android面试题汇总（三）

Android面试题汇总（三）

Android 四大组件相关 1、Activity与Fragment之间常见的通讯方式 对于Activity与Fragment直接的相互调用&#xff1a; 1、Activity调用Fragment直接调用就好了&#xff0c;Activity一般是持有Fragment实例的。或者通过Fragment的id或者tag获取Fragment的实例 2、Fragment调用A…
阅读更多...
攻防世界做题

攻防世界做题

xff_referer 进来之后显示ip地址必须为123.123.123.123 抓包看一下 要求ip是123.123.123.123 就可以用xff伪造即X-Forwarded-For: 123.123.123.123 得到显示&#xff1a; 说必须来自google&#xff0c;伪造referer Referer: https://www.google.com 我的要在右边的 inspec…
阅读更多...
[学习记录] 设计模式 3. 观察者模式

[学习记录] 设计模式 3. 观察者模式

观察者模式 参考&#xff1a; bugstack 虫洞栈Refactoringhttps://www.cnblogs.com/myseries/p/8735490.htmlhttps://www.jianshu.com/p/4f1cd513a72d 当一个行为发生时传递信息给另外一个用户接收做出相应的处理&#xff0c;两者之间没有直接的耦合关联。 在我们编程开发中也…
阅读更多...
计算机视觉: 三维物体生成

计算机视觉: 三维物体生成

三维物体生成与编辑 论文地址: Controllable Mesh Generation Through Sparse Latent Point Diffusion Models 背景 数据是目前数字化和AI领域最宝贵的财富之一&#xff0c;但是对于目前的开发者来说&#xff0c;收集数据都意味着极大的成本。所以建立一个高效的生成模型能极…
阅读更多...
Java多线程篇(5)——cas和atomic原子类

Java多线程篇(5)——cas和atomic原子类

文章目录 CASAtomic 原子类一般原子类针对aba问题 —— AtomicStampedReference针对大量自旋问题 —— LongAdder CAS 原理大致如下&#xff1a; 在java的 Unsafe 类里封装了一些 cas 的api。以 compareAndSetInt 为例&#xff0c;来看看其底层实现。 可以发现&#xff0c;最…
阅读更多...
GPT，GPT-2，GPT-3，InstructGPT的进化之路

GPT，GPT-2，GPT-3，InstructGPT的进化之路

ChatGPT 火遍圈内外&#xff0c;突然之间&#xff0c;好多人开始想要了解 NLP 这个领域&#xff0c;想知道 ChatGPT 到底是个什么&#xff1f;作为在这个行业奋斗5年的从业者&#xff0c;真的很开心让人们知道有一群人在干着这么样的一件事情。这也是我结合各位大佬的文章&…
阅读更多...
【AIGC】Stable Diffusion Prompt 每日一练0916

【AIGC】Stable Diffusion Prompt 每日一练0916

一、前言 1.1 写在前面 本文是一个系列&#xff0c;有点类似随笔&#xff0c;每天一次更新&#xff0c;重点就Stable Diffusion Prompt进行专项训练&#xff0c;本文是第022篇《Stable Diffusion Prompt 每日一练0916》。上一篇《Stable Diffusion Prompt 每日一练0915》 1.…
阅读更多...
Android Jetpack Compose之UI的重组和自动刷新

Android Jetpack Compose之UI的重组和自动刷新

1.概述 我们都知道&#xff0c;在传统的View中&#xff0c;若要改变UI&#xff0c;需要我们修改View的私有属性&#xff0c;比如要修改一个TextView的文字&#xff0c;我们需要通过它的setText(“xxx”)方法去修改。而Compose 则是通过重组来刷新UI。在之前的状态管理的文章中…
阅读更多...
基于SSM的田径运动会成绩管理系统的设计与实现

基于SSM的田径运动会成绩管理系统的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用Vue技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
MySQL详解六：备份与恢复

MySQL详解六：备份与恢复

文章目录 1. 数据库备份的分类1.1 从物理和逻辑上分类1.1.1 物理备份1.1.2 逻辑备份 1.2 从数据库的备份策略角度上分类1.2.1 完全备份1.2.2 差异备份1.2.3 增量备份 1.3 常见的备份方法 2. MySQL完全备份2.1 完全备份简介2.2 优点与缺点2.3 实现物理冷备份与恢复2.3.1 实现流程…
阅读更多...
MongoDB（一） windows 和 linux 之 Ubuntu 安装

MongoDB（一） windows 和 linux 之 Ubuntu 安装

数据库分类 一、关系型数据库&#xff08;RDBMS&#xff09; mysql 、Oracle、DB2、SQL Server 关系数据库中全都是表 二、非关系型数据库&#xff08;NO SQL&#xff09; MongoDB、Redis 键值对数据库 文档数据库MongoDB 下载 mongoDB https://www.mongodb.com/try/downloa…
阅读更多...
渗透中 POC、EXP、Payload、Shellcode 的区别

渗透中 POC、EXP、Payload、Shellcode 的区别

渗透中 PoC、Exp、Payload、Shellcode 的区别 不同含义&#xff1a; POC Proof of Concept中文意思是“观点证明”。这个短语并非仅仅在漏洞报告中使用&#xff0c;甲方在项目招标过程中也常常要求乙方提供POC&#xff0c;即证明你的方案或者产品能达到声称的功能或性能&…
阅读更多...
Tomcat部署、优化、以及操作练习

Tomcat部署、优化、以及操作练习

一.Tomcat的基本介绍 1.1.Tomcat是什么&#xff1f; Tomcat服务器是一个免费的开放源代码的Web应用服务器&#xff0c;属于轻量级应用服务器&#xff0c;在中小型系统和并发访问用户不是很多的场合下被普遍使用&#xff0c;是开发和调试JSP程序的首选。一般来说&#xff0c;T…
阅读更多...
最新文章

Copyright @ 2022~2023