【C语言 数据结构】堆与二叉树（下）

news2025/1/19 3:02:57

接着上次的，这里主要介绍的是堆排序，二叉树的遍历，以及之前讲题时答应过的简单二叉树问题求解

堆排序

给一组数据，升序（降序）排列

思路

思考：如果排列升序，我们应该建什么堆？

首先，如果排升序，数列最后一个数是 最大数，我们的思路是通过 向上调整 或者 向下调整，数组存放的第一个数不是最小值（小堆）就是最大值（大堆），此时我们将最后一个数与第一个数交换，使得最大值放在最后，此时再使用向上调整 或者 向下调整，得到第二大的数，重复上述动作，很明显，我们需要的第一个数是最大值，因此我们需要建大堆

反之，排降序，建立小堆

代码

#include<stdio.h>
void downAdjust(int* pa, int parent, int n)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && pa[child] > pa[child + 1])
		{
			child++;
		}
		if (pa[parent] > pa[child])
		{
			swap(&pa[parent], &pa[child]);
		}
		else
		{
			break;
		}
		parent = child;
		child = parent * 2 + 1;
	}
}
int main()
{
	int arr[] = { 1,3,2,5,7,4,7,4,2,5,6,8};
	int n = sizeof(arr) / sizeof(arr[0]);
	  for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	  {
		downAdjust(arr, i, n);
	  }
		for (int i = n; i > 0; )
		{
			swap(&arr[0], &arr[i - 1]);
			downAdjust(arr, 0, --i);
		}
		for (int i = 0; i < n; i++)
		{
			printf("%d ", arr[i]);
		}

	return 0;
}

topK算法

在一组数据中，选出k个最大（最小）的数

思路

如果我们选择k个最大的数，假设数组的前k个数就是最大的数，这 k个数建立 小堆，带一个数与 后面的从第 k + 1个数开始，进行比较，如果比第一个数的就换下来，然后向下调整，直到每个所有数都比较完了

代码

void downAdjust(int* pa, int parent, int n)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && pa[child] > pa[child + 1])
		{
			child++;
		}
		if (pa[parent] > pa[child])
		{
			swap(&pa[parent], &pa[child]);
		}
		else
		{
			break;
		}
		parent = child;
		child = parent * 2 + 1;
	}
}
#include<stdio.h>
int main()
{
	int arr[] = { 1,6,10,3,5,8,46,23,6,25,3,40 };
	int n = sizeof(arr) / sizeof(arr[0]);
	int k = 0;
	scanf("%d", &k);
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		downAdjust(arr, i, n);
	}
	for (int i = k; i < n; i++)
	{
		if (arr[i] > arr[0])
		{
			swap(&arr[i], &arr[0]);
			downAdjust(arr, 0, k);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

五. 二叉树的实现

1. 链接结构搭建二叉树

代码

typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL *creatnode(TLType x)
{
	TL*pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL *tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(3);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	return tree1;
}
#include<stdio.h>
int main()
{
	TL* p = NULL;
	p = CreatTree();
}

我们搭建了一个这样的树结构：

2. 二叉树的遍历

二叉树的遍历可以分三种：前序，中序，后序，层序

a. 前序遍历：（根，左子树，右子树）

举例

这棵树的前序遍历是怎样的？（包括空树，用N表示）

val1 val2 val4 N N val5 N N val3 val6 N N val7 N N

代码实现 

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL *creatnode(TLType x)
{
	TL*pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL *tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
#include<stdio.h>
void PrevOrder(TL *root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	PrevOrder(p);
}

运行结果：

b. 中序遍历：（左子树，根，右子树）

举例

这棵树的中序遍历是怎样的？（包括空树，用N表示）

N val4 N val2 N val5 N val1 N val6 N val3 N val7 N

 代码实现

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL *creatnode(TLType x)
{
	TL*pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL *tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
#include<stdio.h>
void InOder(TL* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOder(root->left);
	printf("%d ", root->val);
	InOder(root->right);
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	InOder(p);
}

运行结果：

c. 后序遍历：（左子树，右子树，根）

举例

这棵树的后序遍历是怎样的？（包括空树，用N表示）

N N val4 N N val5 val2 N N val6 N N val7 val3 val1

代码实现 

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
void PostOder(TL* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	PostOder(root->left);
	PostOder(root->right);
	printf("%d ", root->val);
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	PostOder(p);
}

运行结果：

d. 层序遍历

一排排的遍历

画图举例

实现思路 

这里我们借助队列（可以先进先出），开辟的数组里面存放根节点的地址（通过地址可以找到左右子树，否则如果存值是没有办法找到左右子树），打印完根节点的值，就释放，存入左右子树的节点

代码实现

实现的二叉树是这样的：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
typedef struct QueueNode
{
	struct QueueNode* next;
	TL* data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;


void QueueInit(Que* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Que* pq, TL* x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

bool QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;
}
void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}

TL* QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}




int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}
void leverOrder(TL* root, Que* pq)
{
	QueuePush(pq, root);
	while (!QueueEmpty(pq))
	{
		TL* pa = QueueFront(pq);
		printf("%d ", pa->val);
		QueuePop(pq);
		if (pa->left != NULL)
		{
			QueuePush(pq, pa->left);
		}
		if (pa->right != NULL)
		{
			QueuePush(pq, pa->right);
		}
	}

}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	Que q;
	QueueInit(&q);
	leverOrder(p, &q);
	return 0;
}

运行结果：

3. 简单二叉树经典问题求解

a. 求二叉树的节点个数

思路

想要求二叉树的节点可以分成 根节点 + 左子树 + 右子树

这里的遍历类似 前序遍历

代码

实现的树是这样的：

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
int TreeSize(TL* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return 1 + TreeSize(root->left) + TreeSize(root->right);
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	int size = TreeSize(p);
	printf("%d ", size);
	return 0;
}

b. 求树的高度

思路

求二叉树的高度，我们需要找到到那个最长的路径，这里采用分治的思想，如果为空树，返回 0 （空树高度为 0），调用左子树和右子树都会 + 1（+ 1可以理解成加上节点的高度），对比左子树和右子树，返回高度最大的那个

注：每求一次左右节点个数时，一定要保存，否则会有很大的时间浪费

代码

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	TL* tree8 = creatnode(8);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	tree4->left = tree8;
	return tree1;
}
int TreeHigh(TL* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int Left = 1 + TreeHigh(root->left);
	int Right = 1 +  TreeHigh(root->right) ;
	return Left > Right ? Left : Right;
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	int high = TreeHigh(p);
	printf("%d ", high);
	return 0;
}

c. 求根节点的个数

思路

判断是否是根节点的方法就是判断它的左右子树是否是 空树，我们只需要遍历这棵树就行，但如果遍历时，根节点遇到空树这也是一种结束条件

代码

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	TL* tree8 = creatnode(8);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	tree4->left = tree8;
	return tree1;
}
int RootSize(TL* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return RootSize(root->left) + RootSize(root->right);
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	int root = RootSize(p);
	printf("%d ", root);
	return 0;
}

d. 求倒数第k排节点的个数

思路

这个可以是求树的高度的变形，将计数倒过来

代码 

#include<stdio.h>
#include<stdlib.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	TL* tree8 = creatnode(8);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	tree4->left = tree8;
	return tree1;
}

int TreeHigh(TL* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int Left = 1 + TreeHigh(root->left);
	int Right = 1 +  TreeHigh(root->right) ;
	return Left > Right ? Left : Right;
}
int RootKsize(TL* root,int n,int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (n == k)
	{
		return 1;
	}
	return RootKsize(root->left, n - 1, k) + RootKsize(root->right, n - 1, k);
}
int main()
{
	int k = 0;
	scanf("%d", &k);
	TL* p = NULL;
	p = CreatTree();
	int high = TreeHigh(p);
	int rootk = RootKsize(p, high, k);
	printf("%d ", rootk);
	return 0;
}

e. 判断是否是相同的树

思路

采用前序，先比较根节点是否相同，再比较左右子树是否相同

代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree1()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	TL* tree8 = creatnode(8);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	tree4->left = tree8;
	return tree1;
}
TL* CreatTree2()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(3);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	return tree1;
}
bool IsSameTree(TL* root1,TL* root2)
{
	if (root1 == NULL && root2 == NULL)
	{
		return true;
	}
	if (root1 == NULL || root2 == NULL)
	{
		return false;
	}
	if (root1->val != root2->val)
	{
		return false;
	}
	return IsSameTree(root1->left, root2->left) && IsSameTree(root1->right, root2->right);
}
int main()
{
	TL* p = NULL;
	p = CreatTree1();
	TL* q = CreatTree2();
	printf("%d ", IsSameTree(p, q));
	return 0;
}

f. 找到某个值，返回节点的地址

思路

前序遍历完数组，如果对比左右子树，判断是否找到节点的地址

代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int TLType;
typedef struct TreeList
{
	TLType val;
	struct TreeList* left;
	struct TreeList* right;
}TL;
TL* creatnode(TLType x)
{
	TL* pa = (TL*)malloc(sizeof(TL));
	if (pa == NULL)
	{
		perror("malloc");
		return;
	}
	TL* newnode = pa;
	newnode->left = newnode->right = NULL;
	newnode->val = x;
	return newnode;
}
TL* CreatTree()
{
	TL* tree1 = creatnode(1);
	TL* tree2 = creatnode(2);
	TL* tree3 = creatnode(2);
	TL* tree4 = creatnode(4);
	TL* tree5 = creatnode(5);
	TL* tree6 = creatnode(6);
	TL* tree7 = creatnode(7);
	TL* tree8 = creatnode(8);
	tree1->left = tree2;
	tree1->right = tree3;
	tree2->left = tree4;
	tree2->right = tree5;
	tree3->left = tree6;
	tree3->right = tree7;
	tree4->left = tree8;
	return tree1;
}
TL* FindRoot(TL* root,int m)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->val == m)
	{
		return root;
	}
	TL* Left = FindRoot(root->left, m);
	TL* Right = FindRoot(root->right, m);
	if (Left == NULL && Right == NULL)
	{
		return NULL;
	}
	if (Left == NULL && Right != NULL)
	{
		return Right;
	}
	else 
	{
		return Left;
	}
	
}
int main()
{
	TL* p = NULL;
	p = CreatTree();
	int m = 0;
	scanf("%d", &m);
	TL *root = FindRoot(p,m);
	if (root == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%d ", root->val);
	}
	return 0;
}

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

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

相关文章

Redis面试题（答案版）2024

Redis面试题（答案版）2024

基础内容 1、简单介绍以下你了解的Redis &#xff08;1&#xff09;高性能&#xff1a;Redis是基于内存的&#xff0c;读写速度非常快&#xff0c;可以支持10w的QPS。 &#xff08;2&#xff09;用途多样&#xff1a;缓存、消息队列、分布式锁等 &#xff08;3&#xff09;支持…
阅读更多...
物联网电气融合实训室建设方案

物联网电气融合实训室建设方案

1 教学实训总体设计 1.1 建设背景 &#xff08;一&#xff09;政策推动与战略部署 近年来&#xff0c;物联网技术在全球范围内得到了广泛的关注和应用。作为信息技术的重要组成部分&#xff0c;物联网在推动经济转型升级、提升社会管理水平、改善民生福祉等方面发挥着重要作…
阅读更多...
ChatGPT高效提问——说明提示技巧

ChatGPT高效提问——说明提示技巧

ChatGPT高效提问——说明提示技巧 现在&#xff0c;让我们开始体验“说明提示技巧”&#xff08;IPT, Instructions Prompt Technique&#xff09;和如何用它生成来自ChatGPT的高质量的文本。说明提示技巧是一个通过向ChatGPT提供需要依据的具体的模型的说明来指导ChatGPT输出…
阅读更多...
FPGA-串口接收图像写入RAM并读出在TFT显示屏上显示

FPGA-串口接收图像写入RAM并读出在TFT显示屏上显示

系统框图&#xff1a; 需要用到的模块有&#xff1a; 1&#xff0c;UART_RX(串口接收模块)&#xff1b; 2&#xff0c;串口接受的数据存放到RAM模块&#xff1b; 3&#xff0c;RAM IP核&#xff1b; 4&#xff0c;时钟IP核 &#xff08;TFT显示屏驱动时钟的产生&#xff09…
阅读更多...
理解循环神经网络（RNN）

理解循环神经网络（RNN）

文章目录 1. 引言&#xff1a;什么是RNN以及它的重要性RNN简介RNN在机器学习中的作用和应用场景 2. RNN的工作原理神经网络基础RNN的结构和运作方式循环单元的作用 3. RNN的关键特点与挑战参数共享长期依赖问题门控机制&#xff08;例如LSTM和GRU&#xff09;代码示例&#xff…
阅读更多...
【Vue】vue3 在图片上渲染 OCR 识别后的文本框、可复制文本组件

【Vue】vue3 在图片上渲染 OCR 识别后的文本框、可复制文本组件

需求 后面返回解析后的文本和四角坐标&#xff0c;在图片上渲染成框&#xff0c;并且可复制。图片还可以缩放、拖拽 实现 这里要重点讲下关于OCR文本框的处理&#xff1a; 因为一些文字可能是斜着放的&#xff0c;所有我们要特殊处理&#xff0c;根据三角函数来计算出它的偏…
阅读更多...
openEuler学习——部署MGR集群

openEuler学习——部署MGR集群

本文介绍如何利用GreatSQL 8.0.25构建一个三节点的MGR集群。 1.安装准备 IP端口角色192.168.20.1103306mgr1192.168.20.1113306mgr2192.168.20.1123306mgr3 配置hosts解析 [rootMGR1 ~]# cat >> /etc/hosts << EOF > 192.168.20.110 MGR1 > 192.168.20.1…
阅读更多...
小程序商城营业执照办哪种类型的？

小程序商城营业执照办哪种类型的？

在数字化浪潮的推动下&#xff0c;越来越多的商家选择通过微信小程序商城来拓展线上业务。但在启动小程序商城之前&#xff0c;有一项关键性的准备工作不可忽视——那就是营业执照的办理。本文将为您详细解读小程序商城营业执照的办理类型及相关流程步骤&#xff0c;帮助您顺利…
阅读更多...
虚拟机时间同步主机

虚拟机时间同步主机

1.查看是否设置同步 2.查看时区 date -R 0800 表示时区东八区 明显不对 执行指令&#xff1a; tzselect &#xff1b;找到亚洲-中国-北京 3.覆盖一下文件 复制文件到 /etc/localtime 目录下&#xff1a;#sudo cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime 4.重现查…
阅读更多...
【DAY08 软考中级备考笔记】机组：计算机组成和数据转换

【DAY08 软考中级备考笔记】机组：计算机组成和数据转换

机组&#xff1a;计算机组成和数据转换 3月2日 – 天气&#xff1a;晴 1. 计算机的基本组成结构 计算机的硬件由运算器&#xff0c;控制器&#xff0c;存储器&#xff0c;输入和输出设备组成其中&#xff0c;控制器和运算器成为CPU控制器又分为了内部存储器和外部存储器。内部…
阅读更多...
Python与FPGA——膨胀腐蚀

Python与FPGA——膨胀腐蚀

文章目录 前言一、膨胀腐蚀二、Python实现腐蚀算法三、Python实现膨胀算法四、Python实现阈值算法五、FPGA实现腐蚀算法总结 前言 腐蚀是指周围的介质作用下产生损耗与破坏的过程&#xff0c;如生锈、腐烂等。而腐蚀算法也类似一种能够产生损坏&#xff0c;抹去部分像素的算法。…
阅读更多...
FX110网：判断行情是真突破还是假突破？用这几招就够了

FX110网：判断行情是真突破还是假突破？用这几招就够了

众所周知&#xff0c;在交易过程中&#xff0c;趋向线的突破对买入、卖出时机等选择具有重要的分析意义。因此&#xff0c;搞清趋势线何时突破&#xff0c;是有效的突破还是非有效的突破&#xff0c;于投资者而言是至关重要的。 本文将提供一些对于趋向线突破的判断方法和市场原…
阅读更多...
学习Java的第三天

学习Java的第三天

如何使用IDEA工具编写Java语言 上一节课已经讲过了&#xff0c;如何使用文本文档写出代码并在管理员控制台打印出来 接下来给大家分享的是使用IntelliJ IDEA工具 一、如何将IntelliJ IDEA设置成中文 1、点击右上角的图标&#xff0c;有人的图标会不一样&#xff0c;但位置是…
阅读更多...
停工待料，责任真的全在PMC吗？天行健深度剖析背后的原因

停工待料，责任真的全在PMC吗？天行健深度剖析背后的原因

在现代制造业中&#xff0c;停工待料的现象时有发生&#xff0c;这不仅影响了生产进度&#xff0c;还增加了企业的运营成本。很多人会自然而然地将责任归咎于生产物料控制&#xff08;PMC&#xff09;部门&#xff0c;认为是他们没有做好物料计划和管理。但事实上&#xff0c;停…
阅读更多...
【Web】浅浅地聊SnakeYaml反序列化两条常见利用链

【Web】浅浅地聊SnakeYaml反序列化两条常见利用链

目录 关于Yaml 关于SnakeYaml SnakeYaml反序列化利用 JdbcRowSetImpl链 ScriptEngineManager链 复现 基本原理 继续深入 关于Yaml 学过SpringBoot开发的师傅都知道&#xff0c;YAML和 Properties 文件都是常见的配置文件格式&#xff0c;用于存储键值对数据。 这里举…
阅读更多...
公车5.0优化内容

公车5.0优化内容

1、首屏加载速度慢&#xff0c;原因是commons重复打包了&#xff0c;删除即可&#xff0c;首屏加载速度提升了10几秒&#xff0c;本地打包速度提升了2分钟 2、删除$dogShanXi重复方法&#xff0c;并全局替换dogShanXi方法 3、Tab打开太多页面卡死&#xff0c;设置最多打开10个 …
阅读更多...
2024小红书商家投放策略怎么制定？广告形式有哪些

2024小红书商家投放策略怎么制定？广告形式有哪些

据平台的消息&#xff0c; 截止2021年11月&#xff0c;小红书月活已达到2亿。其中 有72%为90后&#xff0c;超50%来自一二线城市。如何充分把握好这一趋势&#xff0c;这就需要一些行之有效的小红书投放策略。今天我们和大家分享下2024小红书商家投放策略怎么制定&#xff0c;广…
阅读更多...
【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理

【C++庖丁解牛】C++内存管理 | new和delete的使用以及使用原理

&#x1f4d9; 作者简介 &#xff1a;RO-BERRY &#x1f4d7; 学习方向&#xff1a;致力于C、C、数据结构、TCP/IP、数据库等等一系列知识 &#x1f4d2; 日后方向 : 偏向于CPP开发以及大数据方向&#xff0c;欢迎各位关注&#xff0c;谢谢各位的支持 目录 1. C/C内存分布2. C语…
阅读更多...
Go程序是如何编译并运行起来的（图文详解）

Go程序是如何编译并运行起来的（图文详解）

Go程序是如何编译的 从hello RdrB1te开始 package main import "fmt" func main() { fmt.Println("hello RdrB1te") }不实际编译它&#xff0c;只输出它的编译过程&#xff1a; go build -n简单的编译过程分析&#xff1a; 上面的过程确认了两个…
阅读更多...
打印机扫描无法识别u盘怎么办？

打印机扫描无法识别u盘怎么办？

相信不少朋友经常会有打印或者扫描的经历&#xff0c;特别是用公司的那种硕大的打印机。 打印的时候还好说&#xff0c;扫描的时候就老会出问题。 如果按正常的流程&#xff0c;先把文稿放在面板上&#xff0c;盖上盖儿。然后在控制屏幕上选择扫描&#xff0c;然后插入u盘。正…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023