DS:二叉树的链式结构及实现

news2024/11/27 8:24:46

                                                    创作不易，友友们给个三连吧！！

一、前言

       前期我们解释过二叉树的顺序结构（堆）为什么比较适用于完全二叉树，因为如果用数组来实现非完全二叉树，那么数组的中间部分就可能会存在大量的空间浪费。

      而二叉树的链式结构即用链表结构来存储二叉树，这里就没有什么限制了，所有的二叉树都可以用链式结构来存储，因为链式结构存在两个指针分别指向自己的左右孩子，无论是少了左孩子还是少了右孩子，只需要让相应的指针指向NULL就可以了。

       虽然链式结构可以表示所有类型的二叉树，但是由于二叉树本身存储数据的价值并不大（链表、顺序表远远优于二叉树），所以实现增删查改是没有太大意义的，学习链式二叉树真正的意义是学会如何去控制、遍历二叉树的结构，为我们后期学习搜索二叉树做好铺垫。而以下的学习中要重点理解二叉树中的递归思想和分治思想 !

二、链式二叉树的实现

2.1 节点结构体的创建

      创建的方式和单链表的很相似，唯一的区别就是要有两个指针，一个指向自己的左孩子，一个指向自己的右孩子！

typedef int BTDataType;//方便我们后面要存储其他类型的数据的时候方便修改！
typedef struct BinaryTreeNode
{
	BTDataType data;//二叉树节点的数据域
	struct BinaryTreeNode* left;//左孩子
	struct BinaryTreeNode* right;//右孩子
}BTNode;

2.2 二叉树节点的创建

      二叉树节点构建方式和单链表节点的构建方式相同！

BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)//如果创建不成功
	{
		perror("malloc fail");
		exit(1);
	}
	//如果创建成功
	newnode->data = x;
	newnode->left = newnode->right = NULL;
	return newnode;
}

2.3 前序遍历

为了能够深入前中后续遍历，我们先手动创建一个二叉树，后面都按照这个二叉树来研究

 下面我先给出前中后续的遍历结果，再逐个分析，要注意，没有箭头默认指向空！

 分析前序：

       前序的顺序是根、左子树、右子树：首先1是根，接着访问1的左子树2,2也是根，再访问2的左子树3，3也是根，再访问3的左子树N，接着访问3的右子树N，，回归到2，对于2来说，他的左子树已经访问完了，然后访问右子树N，回归1，对于1来说，他的左子树已经访问完了，该访问他的右子树4了，4是根，接着访问4的左子树5,5也是根，接着访问5的左子树N，再访问5的右子树N，然后回归5，对于4来说，左子树访问完了，接着访问6,6的左子树是N，然后访问6的右子树N。此时所有节点都访问完了。

      大家可以看看上面的图我画的框框，1这个根右边的2 3 N N N  和4 5 N N 6 N N 分别表示1的左右子树，而对于2这个根来说，3 N N  和  N分别代表2的左右子树，对于4这个根来说，5 N N和6 N N分别代表4的左右子树，对于3、5、6 这三个根来说，他们的左右子树都是N和N。

       那么怎么写前序遍历的代码呢？根据上一段的思路我们可以发现，对于根1来说，他的左子树是以2为根的树，他的右子树是以4为根的树，而对于2来说，他的左子树是以3为根的树，右子树是N，对于4来说，他的左子树是以5为根的树，他的右子树是以6为根的树， 而对于3、5、6来说，他们其实也是根，左右子树都是N。所以将问题转化为递归问题。

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

画一下递归展开图：

时间复杂度是O（N）  因为每个节点都遍历了一次

空间复杂度也是O（h） 通过上图可以看出，当开辟h个的函数栈帧后，后续的空间都是在前一个空间释放后复用的，所以最多同时只有h个栈帧空间被开辟，根据空间可以重复利用的特点，空间复杂度是o（N）!

中序遍历和后序遍历的方法是一样的，后面就不分析了

2.4 中序遍历

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

2.5 后序遍历

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

2.6 层序遍历

       层序遍历是一层一层遍历，之前无论是前序、中序、还是后序遍历，都是根据父子关系（父亲会指向自己的左右孩子）转化成递归问题去遍历的， 但是链式二叉树的指针指向并不指向兄弟节点，所以这边如果要一层一层遍历，需要用到队列。

     选择队列的原因是利用队列队头出队尾进的特点，下面进行分析：

Queue.h

 

void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)//如果不为NULL，就进队列
		QueuePush(&q, root);
	while (!QueueEmpty(&q))//队列为空，就是遍历完成
	{
		BTNode* front = QueueFront(&q);//让每一次循环过来的节点变成根部，再去访问左右子树
		QueuePop(&q);//记录完一个元素就出队列
		printf("%d ", front->data);
		if(front->left)
			QueuePush(&q, front->left);//左节点不为空，进队列
		if (front->right)
			QueuePush(&q, front->right);//右节点不为空，进队列
	}
	printf("\n");
	//遍历完了就可以销毁队列了
	QueueDestory(&q);
}

2.7 二叉树节点个数

我们先按照按照军棋里的模式来解释分治思想：

       假设军长要统计总人数，有两个方法，一个是军长一级一级去视察数人，这显然是效率比较低的， 而另一个方法就是分而治之——利用自己的职权将任务移交给下级，军长把任务分配给两个旅长，然后旅长统计过来的人数加上自己就是全军人数，旅长又分配给连长，将两个连长统计的人数加上自己就是全旅人数，以此类推……

     

int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

2.8 二叉树叶子节点个数

    还是利用分治思想，叶子节点的特征是左右子树都为NULL，我们还是按照分治思想将这个任务拆分下去

int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

2.9 二叉树第k层节点

还是利用分治思想，将求第k层节点转化为求左子树的k-1层节点加上右子树的k-1层节点。

int BinaryTreeLevelKSize(BTNode* root,int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->left,k-1) + BinaryTreeLevelKSize(root->right,k-1);
}

2.10 二叉树的高度

还是利用分治思想，求高度转化为比较左右子树的大小再+1

​​int BinaryTreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	return BinaryTreeHeight(root->left) > BinaryTreeHeight(root->right) ? BinaryTreeHeight(root->left) + 1 : BinaryTreeHeight(root->right) + 1;
}

 其实这样写是有问题的！！！因为每次我递归比较完后，并没有记录最大值，所以导致每次递归的时候最大值都得再重新递归一次！！如果树节点高度特别高的话，就很可能会出现这样的问题。

改进版：

int BinaryTreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	int LeftHeight = BinaryTreeHeight(root->left);
	int RightHeight = BinaryTreeHeight(root->right);
	return LeftHeight > RightHeight ? LeftHeight + 1 : RightHeight + 1;
}

 所以我们在递归时使用三目表达式要注意：如果比较的过程已经递归一次了，比较的结果就不要再去递归了！！可以及时的记录值！！

2.11 二叉树查找值为x的节点

还是利用分治思想,转化为在左子树和右子树中找

BTNode* BTFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
		return root;
	BTNode* ret1 = BTFind(root->left, x);
	if (ret1)
		return ret1;
	BTNode* ret2 = BTFind(root->right, x);
	if (ret2)
		return ret2;
	return NULL;
}

2.12 通过前序遍历数组构建二叉树

     之前我们构建二叉树是一个节点一个节点去手动连接，这次我们尝试自己利用前序遍历数组去构建二叉树，比如abc##de#g##f###

BTNode* BTCreate(char*arr,int*pi)
{
	if (arr[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = BuyNode(arr[*pi]);
	(*pi)++;
	root->left = BTCreate(arr, pi);
	root->right = BTCreate(arr, pi);
	return root;
}

 递归展开图：

2.13 二叉树销毁

       二叉树要销毁，就要遍历每个节点，因为我们如果先销毁根，那么就很可能找不到他的左子树和右子树了，除非销毁根之前记录一下，但是这样比较麻烦，所以我们选择后序遍历，先销毁左子树，再销毁右子树，再销毁根。

void BTDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BTDestory(root->left);
	BTDestory(root->right);
	free(root);
	//root = NULL;没用
}

注意：这里的参数是一级指针，而root本身也是指针，所以在这里对root置NULL，是没有意义的，所以要使用的话，要在main函数中手动置空（这里不用二级指针的原因是为了保持接口一致性）！！

2.14 判断二叉树是否是完全二叉树

         完全二叉树的特点就是：前h-1层是满的，最后一层从前往后要到最后才会访问到NULL，所以们可以分析一下他的特点：

bool BTComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);//记录该结果，然后再pop出去
		QueuePop(&q);

		if (front == NULL)
			break;
		QueuePush(&q, root->left);
		QueuePush(&q, root->right);
	}
	//跳出循环后，检查后面的节点是不是还有非空节点，有的话就是非完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);//记录该结果，然后再pop出去
		QueuePop(&q);
		if (front)
		{
			QueueDestory(&q);//队列一定别忘了销毁
			return false;
		}
		QueueDestory(&q);
		return true;
	}
}

2.15 判断两颗二叉树是否完全相同

我们还是用分治思想，前序遍历比较

bool IsBTSame(BTNode* root1, BTNode* root2)
{
	if (root1 == NULL && root2 == NULL)
		return true;
	if (root1 == NULL || root2 == NULL)
		return false;
	//此时节点肯定不为NULL了，可以解引用找到val
	if (root1->data != root2->data)
		return false;
	//不相等的话只能去找自己的左右子树，左右子树都返回true最后结果才能返回true
	return IsBTSame(root1->left, root2->left) && IsBTSame(root1->right, root2->right);
}

三、链式二叉树实现的全部代码

前两个文件只是因为层序遍历和判断完全二叉树会用到，重点还是看后面两个文件

3.1 queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
struct BinaryTreeNode;//为了防止嵌套调用，这里声明一下
typedef struct BinaryTreeNode* QDatatype;//方便后面修改存储数据的数据类型
typedef struct QueueNode//队列结点的数据结构
{
	QDatatype data;//存储数据
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;//指向队头，用于出队（头删）
	QNode* ptail;//指向队尾，用于入队（尾插）
	int size;//记录有效元素个数
}Queue;//创建一个队列相关结构体
void QueueInit(Queue* pq);//队列的初始化
void QueuePush(Queue* pq, QDatatype x);//队列的入队（尾插）
void QueuePop(Queue* pq);//队列的出队(头删)
QDatatype QueueFront(Queue* pq);//获取队列头部元素
QDatatype QueueBack(Queue* pq);//获取队列尾部元素
int QueueSize(Queue* pq);//获取队列中有效元素个数
bool QueueEmpty(Queue* pq);//判断队列是否为空
void QueueDestory(Queue* pq);//队列的销毁

3.2 queue.c

#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);//判断传的是不是空指针
	pq->phead = pq->ptail = NULL;
	pq->size = 0;//因为队列不像栈一样，有一个top表示栈顶元素的下标
	//所以如果我们想知道这个队列的有效数据个数，就必须遍历队列
	//由于其先进先出的特性，我们默认只能访问到头元素和尾元素
	//所以必须访问一个头元素，就出队列一次，这样才能实现遍历
	//但是这样的代价太大了，为了方便，我们直接用size
}

void QueuePush(Queue* pq, QDatatype x)
{
	assert(pq);
    //入队必须从队尾入！
	QNode* newnode = (QNode*)malloc(sizeof(QNode));//创建一个新节点
	if (newnode==NULL)//如果新节点申请失败，退出程序
	{
		perror("malloc fail");
	}
	//新节点创建成功，给新节点初始化一下
	newnode->data = x;
	newnode->next = NULL;
	//开始入队
	//如果直接尾插的话，由于会用到ptail->next,所以得考虑队列为空的情况
	if (pq->ptail== NULL)//如果为空，直接把让新节点成为phead和ptail
	{
		//按道理来说，如果ptail为空，phead也应该为空
		// 但是有可能会因为我们的误操作使得phead不为空，这个时候一般是我们写错的问题
		//所以使用assert来判断一下，有问题的话会及时返回错误信息
		assert(pq->phead == NULL);
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	//如果队列为空，没有删除的必要
	assert(!QueueEmpty(pq));
	//队列中的出队列相当于链表的头删
	//如果直接头删，那么如果队列只有一个有效数据的话，那么我们将phead的空间释放掉，但是没有将ptail给置空
	//这样会导致ptail成为一个野指针，所以我们需要考虑只有一个节点多个节点的情况
	if (pq->phead->next == NULL)//一个节点的情况,直接将这个节点释放并置空即可
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;//置空，防止野指针
	}
	else//多个节点的情况，直接头删

	{
		QNode* next = pq->phead->next;//临时指针记住下一个节点
		free(pq->phead);
		pq->phead = next;//让下一个节点成为新的头
	}
	pq->size--;
}

QDatatype QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//队列如果为空，则不可能找得到队列头元素
	//队列不为空的时候，直接返回phead指向的数据
	return pq->phead->data;
}

QDatatype QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//队列如果为空，则不可能找得到队尾元素
	//队列不为空的时候，直接返回ptail指向的数据
	return pq->ptail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Queue* pq)//链表为空的情况，可以根据容量，也可以根据ptail==NULL&&phead==NULL
{
	assert(pq);
	return pq->ptail == NULL && pq->phead == NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);//判断传的是不是空指针
	//要逐个节点释放
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

3.3 BT.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include"Queue.h"
typedef int BTDataType;//方便我们后面要存储其他类型的数据的时候方便修改！
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x);
void PreOrder(BTNode* root);//前序遍历
void InOrder(BTNode* root);//中序遍历
void PostOrder(BTNode* root);//后序遍历
void LevelOrder(BTNode* root);//层序遍历
int BTSize(BTNode* root);//二叉树节点个数
int BTLeafSize(BTNode* root);//二叉树的叶子节点个数
int BTLevelKSize(BTNode* root, int k);//二叉树第k层的节点个数
int BTHeight(BTNode* root);//二叉树的高度
BTNode* BTFind(BTNode* root, BTDataType x);//二叉树找值为x的点
BTNode* BTCreate(char* arr,int*pi);//根据前序数组创建二叉树
void BTDestory(BTNode* root);//销毁二叉树
bool BTComplete(BTNode* root);//判断是否完全二叉树
bool IsBTSame(BTNode* root1, BTNode* root2);//判断两个二叉树是否完全相等

3.4 BT.c

#include"BTtree.h"

BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)//如果创建不成功
	{
		perror("malloc fail");
		exit(1);
	}
	//如果创建成功
	newnode->data = x;
	newnode->left = newnode->right = NULL;
	return newnode;
}

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)//如果不为NULL，就进队列
		QueuePush(&q, root);
	while (!QueueEmpty(&q))//队列为空，就是遍历完成
	{
		BTNode* front = QueueFront(&q);//让每一次循环过来的节点变成根部，再去访问左右子树
		QueuePop(&q);//记录完一个元素就出队列
		printf("%d ", front->data);
		if(front->left)
			QueuePush(&q, front->left);//左节点不为空，进队列
		if (front->right)
			QueuePush(&q, front->right);//右节点不为空，进队列
	}
	printf("\n");
	//遍历完了就可以销毁队列了
	QueueDestory(&q);
}

int BTSize(BTNode* root)
{
	return root == NULL ? 0 : BTSize(root->left) + BTSize(root->right) + 1;
}

int BTLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return BTLeafSize(root->left) + BTLeafSize(root->right);
}

int BTLevelKSize(BTNode* root,int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return BTLevelKSize(root->left,k-1) + BTLevelKSize(root->right,k-1);
}

int BTHeight(BTNode* root)
{
	if (root == NULL)
		return 0;
	int LeftHeight = BTHeight(root->left);
	int RightHeight = BTHeight(root->right);
	return LeftHeight > RightHeight ? LeftHeight + 1 : RightHeight + 1;
}

BTNode* BTFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
		return root;
	BTNode* ret1 = BTFind(root->left, x);
	if (ret1)
		return ret1;
	BTNode* ret2 = BTFind(root->right, x);
	if (ret2)
		return ret2;
	return NULL;
}

BTNode* BTCreate(char*arr,int*pi)
{
	if (arr[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = BuyNode(arr[*pi]);
	(*pi)++;
	root->left = BTCreate(arr, pi);
	root->right = BTCreate(arr, pi);
	return root;
}

void BTDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BTDestory(root->left);
	BTDestory(root->right);
	free(root);
	//root = NULL;没用
}

bool BTComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);//记录该结果，然后再pop出去
		QueuePop(&q);

		if (front == NULL)
			break;
		QueuePush(&q, root->left);
		QueuePush(&q, root->right);
	}
	//跳出循环后，检查后面的节点是不是还有非空节点，有的话就是非完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);//记录该结果，然后再pop出去
		QueuePop(&q);
		if (front)
		{
			QueueDestory(&q);//队列一定别忘了销毁
			return false;
		}
		QueueDestory(&q);
		return true;
	}
}

bool IsBTSame(BTNode* root1, BTNode* root2)
{
	if (root1 == NULL && root2 == NULL)
		return true;
	if (root1 == NULL || root2 == NULL)
		return false;
	//此时节点肯定不为NULL了，可以解引用找到val
	if (root1->data != root2->data)
		return false;
	//不相等的话只能去找自己的左右子树，左右子树都返回true最后结果才能返回true
	return IsBTSame(root1->left, root2->left) && IsBTSame(root1->right, root2->right);
}

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

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

相关文章

JVM（3）高级篇

JVM（3）高级篇

1 GraalVM 1.1 什么是GraalVM GraalVM是Oracle官方推出的一款高性能JDK&#xff0c;使用它享受比OpenJDK或者OracleJDK更好的性能。 GraalVM的官方网址&#xff1a;https://www.graalvm.org/ 官方标语&#xff1a;Build faster, smaller, leaner applications。 更低的CPU、内…
阅读更多...
vivim复习

vivim复习

vi/vim常用命令 vi&vim常用命令 set nu 显示行号 gg 跳转到文件开头 / 向后搜索 ? 向前搜索 n 查找下一处N 查找上一处 | 光标所在行行首L 屏幕所显示的底行{ 段首} 段尾- 前一行行首 后一行行首 ( 句首 ) 下一句首 $ 行末 M 屏…
阅读更多...
Javaweb基础-tomcat，servlet

Javaweb基础-tomcat，servlet

一.配置文件基础&#xff1a; properties配置文件&#xff1a; 由键值对组成 键和值之间的符号是等号 每一行都必须顶格写&#xff0c;前面不能有空格之类的其他符号 xml配置文件&#xff1a;&#xff08;xml语法HTML语法HTML约束&#xff09;xml约束-DTD / Schema DOM4…
阅读更多...
单测的思路

单测的思路

文章目录 单测的定义方法的单测几种生成工具的对比生成步骤 接口的单测场景的单测总结参考 单测的定义 单元测试&#xff08;Unit Testing&#xff09;是一种软件开发中的测试方法&#xff0c;它的主要目的是确保软件中的最小可测试单元&#xff08;通常是函数、方法或类&…
阅读更多...
今日arXiv最热NLP大模型论文：清华提出LongAlign，打破长上下文对齐瓶颈，数据、训练策略、评估基准一网打尽

今日arXiv最热NLP大模型论文：清华提出LongAlign，打破长上下文对齐瓶颈，数据、训练策略、评估基准一网打尽

随着LLMs的发展&#xff0c;其支持的上下文长度越来越长。仅一年时间&#xff0c;GPT-4就从一开始的4K、8K拓展到了128k。 128k什么概念&#xff1f;相当于一本300页厚的书。这是当初只支持512个tokens的BERT时代不敢想象的事情。 随着上下文窗口长度的增加&#xff0c;可以提…
阅读更多...
【STM32 CubeMX】GPIO的工作模式

【STM32 CubeMX】GPIO的工作模式

文章目录 前言一、有哪些工作模式&#xff1f;1.1 GPIO的详细介绍1.2 GPIO的内部框图输入模式输出部分 总结 前言 在嵌入式系统开发中&#xff0c;对于STM32微控制器的GPIO&#xff08;General Purpose Input/Output&#xff09;引脚的配置和使用是至关重要的。GPIO引脚可以通…
阅读更多...
MySQL 基础知识（六）之数据查询（一）

MySQL 基础知识（六）之数据查询（一）

目录 1 基本查询 1.1 查询相关列 (select * / 列名) 1.2 别名 (as) 1.3 去重 (distinct) 1.4 对列中的数据进行运算 (、-、*、/) 2 条件查询 (where) 2.1 等值查询 () 2.2 非等值查询 (>、<、>、<、!、><) 2.3 逻辑判断 (and、or、not) 2.4 区间判…
阅读更多...
累加器 - 分布式共享写变量

累加器 - 分布式共享写变量

水善利万物而不争&#xff0c;处众人之所恶&#xff0c;故几于道&#x1f4a6; 文章目录 概念注意&#xff1a;应用 概念 因为RDD是可分区的&#xff0c;每个分区在不同的节点上运行&#xff0c;如果想要对某个值进行全局累加&#xff0c;就需要将每个task中的值取到然后进行累…
阅读更多...
【Linux笔记】进程间通信之管道

【Linux笔记】进程间通信之管道

一、匿名管道 我们在之前学习进程的时候就知道了一个概念&#xff0c;就是进程间是互相独立的&#xff0c;所以就算是两个进程是父子关系&#xff0c;其中一个进程退出了也不会影响另一个进程。 也因为进程间是互相独立的&#xff0c;所以两个进程间就不能直接的传递信息或者…
阅读更多...
C++ 特殊类的实现

C++ 特殊类的实现

一、请设计一个类&#xff0c;不能被拷贝 拷贝只会放生在两个场景中&#xff1a;拷贝构造函数以及赋值运算符重载&#xff0c;因此想要让一个类禁止拷贝&#xff0c;只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。 在C98中&#xff1a;将拷贝构造函数与赋值运算符重载…
阅读更多...
【Java记】数据类型与变量

【Java记】数据类型与变量

一、数据类型 在Java中数据类型主要分为两类&#xff1a;基本数据类型和引用数据类型。基本数据类型有四类八种&#xff1a; 四类&#xff1a;整型、浮点型、字符型以及布尔型八种&#xff1a; 数据类型 关键字 内存占用 范围 字节型 byte 1 字节 -128~ 127 短整型 …
阅读更多...
【C语言】数据结构#实现堆

【C语言】数据结构#实现堆

目录 &#xff08;一&#xff09;堆 &#xff08;1&#xff09;堆区与数据结构的堆 &#xff08;二&#xff09;头文件 &#xff08;三&#xff09;功能实现 &#xff08;1&#xff09;堆的初始化 &#xff08;2&#xff09;堆的销毁 &#xff08;3&#xff09;插入数据 …
阅读更多...
Vue3+Vite+TS+Pinia+ElementPlus+Router+Axios创建项目

Vue3+Vite+TS+Pinia+ElementPlus+Router+Axios创建项目

目录 初始项目组成1. 创建项目1.1 下载项目依赖1.2 项目自动启动1.3 src 别名设置vite.config.ts配置文件tsconfig.json配置若新创项目ts提示1.4 运行测试2. 清除默认样式2.1 样式清除代码下载2.2 src下创建公共样式文件夹`style`2.3 main.js中引入样式2.4 安装`sass`解析插件2…
阅读更多...
SpringCloud之Eureka注册中心和负载均衡

SpringCloud之Eureka注册中心和负载均衡

SpringCloud之Eureka注册中心和负载均衡 微服务技术栈认识微服务单体架构分布式架构微服务 微服务拆分及远程调用微服务拆分注意事项 Eureka注册中心提供者与消费者原理分析服务调用出现的问题Eureka的作用 使用流程1、搭建EurekaServer2、注册user-service3、在order-service完…
阅读更多...
代码随想录算法训练营第三十一天 |基础知识，455.分发饼干，376.摆动序列，53.最大子序和（已补充）

代码随想录算法训练营第三十一天 |基础知识，455.分发饼干，376.摆动序列，53.最大子序和（已补充）

基础知识&#xff1a; 题目分类大纲如下&#xff1a; #算法公开课 《代码随想录》算法视频公开课(opens new window)&#xff1a;贪心算法理论基础&#xff01;(opens new window),相信结合视频再看本篇题解&#xff0c;更有助于大家对本题的理解。 #什么是贪心 贪心的本质…
阅读更多...
《区块链公链数据分析简易速速上手小册》第4章：交易数据分析（2024 最新版）

《区块链公链数据分析简易速速上手小册》第4章：交易数据分析（2024 最新版）

文章目录 4.1 解析交易输入和输出4.1.1 基础知识4.1.2 重点案例&#xff1a;追踪比特币交易4.1.3 拓展案例 1&#xff1a;以太坊交易的输入输出解析拓展案例1&#xff1a;以太坊交易的输入输出解析步骤1: 连接到以太坊网络步骤2: 获取交易数据步骤3: 解析交易输入结论 4.1.4 拓…
阅读更多...
PyQt Python 使用 VTK ITK 进行分割 三维重建 医学图像可视化系统 流程

PyQt Python 使用 VTK ITK 进行分割 三维重建 医学图像可视化系统 流程

效果&#xff1a; 重建流程&#xff1a; 1. 输入 可以读取DICOM &#xff0c;nii nrrd 等数据 设置读取器以加载 DICOM 图像系列。 使用 itk::GDCMImageIO 作为 DICOM 图像的输入输出接口。 使用 itk::GDCMSeriesFileNames 获取指定路径下的所有 DICOM 文件名。 使…
阅读更多...
Zabbix图形中文乱码问题（显示口口）解决办法

Zabbix图形中文乱码问题（显示口口）解决办法

一 切换到zabbix安装目录assets/fonts下&#xff0c;下载字体 这里使用是nginxphp作为zabbix-web展示&#xff0c;使用find 命令查找 进入目录下&#xff0c;将原有字体备份&#xff0c;下载msyh字体 wget https://www.xxshell.com/download/sh/zabbix/ttf/msyh.ttf 二 修改配…
阅读更多...
AI换脸（视频换脸）讲解-1

AI换脸（视频换脸）讲解-1

AI换脸是一种人工智能技术&#xff0c;它可以将一个人的面部表情和特征应用到另一个人的脸部上&#xff0c;以创建逼真的视频和图像。 首先&#xff0c;AI换脸技术需要大量的训练数据。这些数据通常是由多个人以不同的表情、姿态、光照条件下的照片或视频组成。通过使用人工智…
阅读更多...
DolphinScheduler安装与配置

DolphinScheduler安装与配置

DolphinScheduler概述 Apache DolphinScheduler是一个分布式、易扩展的可视化DAG工作流任务调度平台。致力于解决数据处理流程中错综复杂的依赖关系&#xff0c;使调度系统在数据处理流程中开箱即用。 DolphinScheduler的主要角色如下&#xff1a; MasterServer采用分布式无…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023