数据结构从入门到精通——二叉树的实现

news2024/11/13 9:59:35

二叉树的实现

  • 前言
  • 一、二叉树链式结构的实现
    • 1.1前置说明
    • 1.2二叉树的手动创建
  • 二、二叉树的遍历
    • 2.1 前序、中序以及后序遍历
    • 二叉树前序遍历
    • 二叉树中序遍历
    • 二叉树后序遍历
    • 2.2 层序遍历
    • 练习
  • 三、二叉树的具体代码实现
    • 二叉树的节点个数
    • 二叉树叶子节点个数
    • 二叉树第k层节点个数
    • 二叉树查找值为x的节点
    • 二叉树的销毁
    • 二叉树的创建
    • 判断二叉树是否是完全二叉树
  • 四、二叉树的选择练习题
    • 答案
  • 五、二叉树基础oj练习
  • 六、二叉树的完整代码
    • Tree.h
    • Tree.c
    • Test.c

前言

二叉树是一种常见的数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。实现二叉树通常涉及定义节点类（包含数据和指向子节点的指针）以及相应的插入、删除和查找操作。遍历二叉树则是访问其所有节点的过程，常见的遍历方式有前序遍历（根-左-右）、中序遍历（左-根-右）和后序遍历（左-右-根）。这些遍历方法可以递归或迭代实现，对于理解二叉树结构和操作非常重要。

一、二叉树链式结构的实现

1.1前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在各位读者对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

1.2二叉树的手动创建

typedef int BTDataType;
typedef struct BinaryTreeNode
{
 	BTDataType _data;
 	struct BinaryTreeNode* _left;
 	struct BinaryTreeNode* _right;
}BTNode;
 
BTNode* CreatBinaryTree()
{
 	BTNode* node1 = BuyNode(1);
 	BTNode* node2 = BuyNode(2);
 	BTNode* node3 = BuyNode(3);
 	BTNode* node4 = BuyNode(4);
 	BTNode* node5 = BuyNode(5);
 	BTNode* node6 = BuyNode(6);
 
 	node1->_left = node2;
 	node1->_right = node4;
 	node2->_left = node3;
 	node4->_left = node5;
 	node4->_right = node6;
 	return node1;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式见下文

再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：

  1. 空树
  2. 非空：根节点，根节点的左子树、根节点的右子树组成的。

在这里插入图片描述

从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

二、二叉树的遍历

2.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

在这里插入图片描述

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

// 二叉树前序遍历 
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);

二叉树前序遍历

// 二叉树前序遍历 
void PreOrder(BTNode* root);

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

二叉树中序遍历

// 二叉树中序遍历
void InOrder(BTNode* root);

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

二叉树后序遍历

// 二叉树后序遍历
void PostOrder(BTNode* root);

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

下面主要分析前序递归遍历，中序与后序图解类似。

前序遍历递归图解：

在这里插入图片描述

在这里插入图片描述

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1

2.2 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
在这里插入图片描述

// 层序遍历
void LevelOrder(BTNode* root);

使用队列的形式来实现层序遍历——队列

void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if(root)QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			printf("%c ", front->val);
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			printf(" N ");
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

层序遍历（也称为广度优先遍历）是一种树的遍历方法，它按照树的层次顺序访问节点。具体来说，从根节点开始，先访问所有相邻的子节点，然后逐层向下遍历，每访问一层的节点，就转向下一层，直到遍历完所有节点。这种遍历方法常用于二叉树、多叉树和图等数据结构。在二叉树中，通常使用队列来实现层序遍历，首先将根节点入队，然后不断从队列中出队节点并访问，同时将该节点的子节点入队，直到队列为空。层序遍历的时间复杂度通常为O(n)，其中n为节点数，空间复杂度取决于队列的大小，最坏情况下为O(n)。

练习

请写出下面的前序/中序/后序/层序遍历
在这里插入图片描述

三、二叉树的具体代码实现

二叉树的节点个数

// 二叉树节点个数
int BinaryTreeSize(BTNode* root);

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

该段代码定义了一个名为BinaryTreeSize的函数，用于计算二叉树中节点的总数。函数接受一个指向二叉树根节点的指针root作为参数。如果root为空，则返回0；否则，递归计算左子树和右子树的节点数，并将它们相加，再加上根节点本身，最终返回整个二叉树的节点总数。

二叉树是每个节点最多有两个子节点的树结构，通常子节点被称为“左子节点”和“右子节点”。二叉树的节点个数是指树中所有节点的总数，包括根节点、内部节点（非叶子节点）和叶子节点。计算二叉树的节点个数可以通过遍历树的所有节点来实现，例如使用前序遍历、中序遍历或后序遍历等方法。在遍历过程中，每访问一个节点，就将计数器加1，最终计数器的值就是二叉树的节点个数。此外，对于完全二叉树和满二叉树等特殊类型的二叉树，其节点个数可以通过特定的公式直接计算得出。

二叉树叶子节点个数

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);

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);
}

该函数BinaryTreeLeafSize计算二叉树的叶子节点数量。如果根节点为空，返回0；如果根节点是叶子节点（即没有左右子节点），返回1；否则，递归计算左子树和右子树的叶子节点数量并返回它们的和。

二叉树的叶子节点是指没有子节点的节点。要计算二叉树的叶子节点个数，可以采用递归或迭代的方法。递归方法的基本思路是，对于每个节点，如果它是叶子节点，则计数加1；否则，递归计算其左右子树的叶子节点个数并相加。迭代方法则可以利用队列或栈等数据结构，层次遍历或深度优先遍历二叉树，统计叶子节点的个数。无论采用哪种方法，最终得到的叶子节点个数即为二叉树的叶子节点总数。

二叉树第k层节点个数

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);

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

该函数BinaryTreeLevelKSize计算了二叉树中第k层的节点数量。首先，它检查k是否大于0并确认根节点root是否存在。如果root为空，则返回0。如果k等于1，表示要求的是第一层的节点数，直接返回1。否则，它递归地对左子树和右子树调用自身，计算第k-1层的节点数，然后将这两个结果相加得到第k层的节点数。

二叉树第k层的节点个数可以通过递归或迭代方法计算。在递归方法中，对于给定的二叉树，我们首先检查根节点是否为空。如果为空，则树为空，返回0。否则，我们递归地计算左子树和右子树的第k-1层节点数，并将它们相加得到第k层的节点数。在迭代方法中，我们使用队列进行层序遍历，记录每一层的节点数，直到找到第k层或遍历完整个树。最终，返回第k层的节点数。这两种方法的时间复杂度均为O(n)，其中n为二叉树中节点的总数。

二叉树查找值为x的节点

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)return NULL;
	if (root->val == x)return root;
	BTNode* left = BinaryTreeFind(root->left, x);
	if (left)
		return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right)
		return right;
	return NULL;
}

该函数是一个在二叉树中查找指定值的函数。它接受一个二叉树的根节点和一个要查找的值x作为参数。如果根节点为空，则返回NULL。如果根节点的值与x相等，则返回根节点。否则，它递归地在左子树和右子树中查找x。如果在左子树或右子树中找到x，则返回对应的节点。如果在整棵树中都没有找到x，则返回NULL。

二叉树的销毁

二叉树的构建及遍历

//二叉树销毁 
 void Binary Tree Destory (BTNode** root) ; 

void BinaryTreeDestroy(BTNode** root)
{
	if ((*root) == NULL)return;
	BinaryTreeDestroy(&(*root)->left);
	BinaryTreeDestroy(&(*root)->right);
	free(*root);
	*root = NULL;
}

该函数BinaryTreeDestroy是一个用于销毁二叉树的递归函数。它接受一个指向二叉树根节点指针的指针root。首先，它检查根节点是否为空，如果为空则直接返回。否则，它递归地销毁左子树和右子树，然后释放根节点的内存，并将根节点指针设置为NULL，从而完成整个二叉树的销毁。

二叉树的创建

// 通过前序遍历的数组" A B D # # E # H # # C F # # G # # " 构建二叉树
 BTNode* Binary TreeCreate(BTDataType* a,int n,int* pi) ; 

BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (a == NULL || n <= 0)return NULL;
	if (a[*pi] == ' ')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	root->val = a[(*pi)++];
	root->left = BinaryTreeCreate(a, n, pi);
	root->right = BinaryTreeCreate(a, n, pi);
	return root;
}

该段代码实现了一个二叉树的创建函数。它接收三个参数：一个数据类型数组a，一个整数n表示数组长度，以及一个整数指针pi指向数组中当前要处理的元素索引。函数首先检查输入是否有效，若数组为空或n小于等于0，则返回NULL。若当前元素为空格，则递增索引并返回NULL。否则，创建一个新的二叉树节点，将当前元素赋值给节点的值，并递归地创建左右子树。最后返回新创建的根节点。

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

// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);

bool BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			printf("%c ", front->val);
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		while (!QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			if (front)
			{
				QueueDestroy(&q);
				return false;
			}
		}
	}
	QueueDestroy(&q);
	return true;
}

此函数BinaryTreeComplete检查给定的二叉树root是否是完全二叉树。它使用一个队列q进行层序遍历。首先，如果根节点存在，则将其入队。然后在队列不为空的情况下，反复取出队首节点并打印其值，然后将它的左右子节点入队。如果在遍历过程中发现队列中出现了空节点，则立即销毁队列并返回false，因为完全二叉树在层序遍历中不应出现空节点。如果遍历结束，即队列为空，且没有发现空节点，则销毁队列并返回true，说明是完全二叉树。

四、二叉树的选择练习题

  1. 某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为（ ）
    A、 ABDHECFG
    B、 ABCDEFGH
    C、 HDBEAFCG
    D、 HDEBFGCA
  2. 二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为（ ）
    A 、E
    B、 F
    C、 G
    D、 H
  3. 设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列____。
    A、 adbce
    B 、decab
    C、 debac
    D、 abcde
  4. 某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出（同一层从左到右）的序列为( )
    A 、FEDCBA
    B、 CBAFED
    C、 DEFCBA
    D、 ABCDEF

答案

1.A
2.A
3.D
4.A

五、二叉树基础oj练习

  1. 单值二叉树
  2. 检查两颗树是否相同
  3. 对称二叉树
  4. 二叉树的前序遍历
  5. 二叉树中序遍历
  6. 二叉树的后序遍历
  7. 另一颗树的子树

六、二叉树的完整代码

Tree.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType val;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;

}BTNode;
typedef BTNode* QDatatype;
typedef struct QueueNode
{
	QDatatype val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
//队列的初始化
void QueueInit(Queue* pq);
//队列的销毁
void QueueDestroy(Queue* pq);

//入队列
void QueuePush(Queue* pq, QDatatype x);
//出队列
void QueuePop(Queue* pq);

//队头元素
QDatatype QueueFront(Queue* pq);
//队尾元素
QDatatype QueueBack(Queue* pq);

//检测是否为空
bool QueueEmpty(Queue* pq);

//检测元素个数
int QueueSize(Queue* pq);

//创建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);

//二叉树的销毁
void BinaryTreeDestroy(BTNode** root);

// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);

Tree.c

#include "Tree.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueuePush(Queue* pq, QDatatype x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("newnode malloc :");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail)
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	else
	{
		pq->phead = pq->ptail = newnode;
	}
	pq->size++;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	//assert(!QueueEmpty(pq));
	assert(pq->phead != NULL);
	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(pq->phead != NULL);
	return pq->phead->val;
}
QDatatype QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail != NULL);
	return pq->ptail->val;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (a == NULL || n <= 0)return NULL;
	if (a[*pi] == ' ')
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	root->val = a[(*pi)++];
	root->left = BinaryTreeCreate(a, n, pi);
	root->right = BinaryTreeCreate(a, n, pi);
	return root;
}
void BinaryTreeDestroy(BTNode** root)
{
	if ((*root) == NULL)return;
	BinaryTreeDestroy(&(*root)->left);
	BinaryTreeDestroy(&(*root)->right);
	free(*root);
	*root = NULL;
}
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)return 0;
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
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);
}
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)return 0;
	if (k == 1)return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)return NULL;
	if (root->val == x)return root;
	BTNode* left = BinaryTreeFind(root->left, x);
	if (left)
		return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right)
		return right;
	return NULL;
}
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	printf("%c ", root->val);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%c ", root->val);
	BinaryTreeInOrder(root->right);
}
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->val);
}

bool BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			printf("%c ", front->val);
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		while (!QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			if (front)
			{
				QueueDestroy(&q);
				return false;
			}
		}
	}
	QueueDestroy(&q);
	return true;
}

Test.c

#include "Tree.h"
int main()
{
	char a[] = { 'a','b','c',' ',' ','d','e',' ','g',' ',' ','f',' ',' ',' ' };
	int pi = 0;
	BTNode* root = BinaryTreeCreate(a, sizeof(a) / sizeof(a[0]), &pi);
	BinaryTreePrevOrder(root);
	printf("\n");

	BinaryTreeInOrder(root);
	printf("\n");

	BinaryTreePostOrder(root);
	printf("\n");

	printf("TreeSize : %d\n", BinaryTreeSize(root));
	printf("TreeKLevel : %d\n", BinaryTreeLevelKSize(root, 3));

	BTNode* ret = BinaryTreeFind(root, 3);
	printf("TreeFind : %p\n", ret);
	

	BinaryTreeLevelOrder(root);
	printf("\n");
	printf("BinaryTreeComplete %d\n ", BinaryTreeComplete(root));
	BinaryTreeDestroy(&root);
	root = NULL;

	return 0;
}

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=1bgxnv3eldfha

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

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

相关文章

springboot Thymeleaf模版引擎使用

springboot Thymeleaf模版引擎使用

1.引入依赖 <!--thymeleaf视图引擎--> <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> html中要声明约束&#xff0c;这样就可以使用themelraf视…
阅读更多...
美摄科技剪同款SDK解决方案全面升级

美摄科技剪同款SDK解决方案全面升级

视频内容已成为企业宣传、品牌塑造和市场营销的重要载体。然而&#xff0c;如何快速、高效地制作出高质量的视频内容&#xff0c;成为摆在众多企业面前的一大难题。针对这一挑战&#xff0c;美摄科技凭借深厚的技术积累和创新能力&#xff0c;推出了全新的剪同款SDK解决方案&am…
阅读更多...
基于SpringBoot+Layui的社区物业管理系统

基于SpringBoot+Layui的社区物业管理系统

项目介绍 社区物业管理系统是基于java程序开发，本系统分为业主和管理员两个角色 业主可以登陆系统，查看车位费用信息，查看物业费用信息，在线投诉，查看投诉，在线报修； 管理员可以车位收费信息，物业收费信息，投诉信息，楼宇信息，房屋信息，业主信息，车位信息，抄表信…
阅读更多...
什么是物联网远程模块

什么是物联网远程模块

在数字化和信息化的浪潮下&#xff0c;物联网技术正在以惊人的速度改变着我们的生活和生产方式。物联网远程模块&#xff0c;作为物联网技术的核心组件之一&#xff0c;正引领着这场变革。HiWoo Box就是这样一款出色的物联网远程模块&#xff0c;它通过支持远程透传、远程锁机、…
阅读更多...
刷题DAY30 | LeetCode 332-重新安排行程 51-N皇后 37-解数独

刷题DAY30 | LeetCode 332-重新安排行程 51-N皇后 37-解数独

332 重新安排行程&#xff08;hard&#xff09; 给你一份航线列表 tickets &#xff0c;其中 tickets[i] [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 所有这些机票都属于一个从 JFK&#xff08;肯尼迪国际机场&#xff09;出发的先生&…
阅读更多...
Vue中的状态管理Vuex，基本使用

Vue中的状态管理Vuex，基本使用

1.什么是Vuex？ Vuex是专门为Vue.js设计的状态管理模式；特点：集中式存储和管理应用程序中所有组件状态，保证状态以一种可预测的方式发生变化。 1.1.什么是状态管理模式？ 先看一个单向数据流的简单示意图 state:驱动应用的数据源 view:以声明方式将state映射到视图 actions：…
阅读更多...
运动想象 (MI) 分类学习系列 (2) : EEG-FMCNN

运动想象 (MI) 分类学习系列 (2) : EEG-FMCNN

运动想象分类学习系列:EEG-FMCNN 0. 引言1. 主要贡献2. 提出的网络结构2.1 SE模块2.2 多分支一维卷积神经网络 3. 实验结果3.1 消融实验结果3.2 与基线模型比较 4. 总结欢迎来稿 论文地址&#xff1a;https://link.springer.com/article/10.1007/s11517-023-02931-x 论文题目&a…
阅读更多...
ES 8.x的多实例集群搭建与角色规划

ES 8.x的多实例集群搭建与角色规划

ES 8 多实例集群搭建与角色规划 ES 8版本与之前版本存在较大改变&#xff0c;第一个区别就是启动时默认开启了安全模式&#xff0c;也就是即便是测试环境也需要用户名密码和https传输层安全证书。此外&#xff0c;集群节点的角色也与之前不同&#xff0c;除了新增角色外在配置…
阅读更多...
MySQL学习笔记（一）

MySQL学习笔记（一）

1、什么是数据库&#xff1f;什么是数据库管理系统&#xff1f;什么是SQL&#xff1f;他们之间的关系是什么&#xff1f; 数据库&#xff1a;英文单词DataBase&#xff0c;简称DB。按照一定格式存储数据的一些文件的组合。顾名思义&#xff0c;存储数据的仓库&#xff0c;实际…
阅读更多...
安卓实现翻转时间显示效果

安卓实现翻转时间显示效果

效果 废话不多说上代码 自定义组件 import android.content.Context; import android.content.res.TypedArray; import android.graphics.Camera; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.…
阅读更多...
学点儿Java_Day8_接口、final、static

学点儿Java_Day8_接口、final、static

1 接口interface 1.1 概念 接口是一个纯粹的抽象类&#xff08;接口里面所有的方法都是抽象方法&#xff09; 接口就是一个规范(标准)&#xff0c;他没有提供任何是实现&#xff0c;具体的功能由实现接口的子类去实现。 接口就是一个规范&#xff0c;可插拔&#xff08;可以被…
阅读更多...
3/21 work

3/21 work

自由发挥登录窗口的应用场景&#xff0c;实现一个登录窗口界面。&#xff08;不要使用课堂上的图片和代码&#xff0c;自己发挥&#xff0c;有利于后面项目的完成&#xff09; 要求&#xff1a; 1. 需要使用Ui界面文件进行界面设计 2. ui界面上的组件相关设置&#xff0c;通…
阅读更多...
深度学习项目-基于深度学习的股票价格预测研究

深度学习项目-基于深度学习的股票价格预测研究

概要 随着经济的发展&#xff0c;中国股票市场的规模持续扩大&#xff0c;早已成为金融投资的重要部分&#xff0c;掌握股票市场的变化规律无论是对监管者还是投资者都具有极其重要的意义。正因如此&#xff0c;人们不断探索着股票市场的变化规律&#xff0c;其中使用深度学习预…
阅读更多...
【C++】1416. 求长方形的周长和面积

【C++】1416. 求长方形的周长和面积

问题&#xff1a;1416. 求长方形的周长和面积 类型&#xff1a; 基本运算、整数运算 题目描述&#xff1a; 从键盘读入2个整数&#xff0c;分别代表一个长方形的长和宽&#xff0c;请计算长方形的周长和面积&#xff1b; 输入&#xff1a; 从键盘读入2个整数&#xff0c;用…
阅读更多...
【网站项目】291校园疫情防控系统

【网站项目】291校园疫情防控系统

&#x1f64a;作者简介&#xff1a;拥有多年开发工作经验&#xff0c;分享技术代码帮助学生学习&#xff0c;独立完成自己的项目或者毕业设计。 代码可以私聊博主获取。&#x1f339;赠送计算机毕业设计600个选题excel文件&#xff0c;帮助大学选题。赠送开题报告模板&#xff…
阅读更多...
windows下使用压缩包安装mysql8.0数据库

windows下使用压缩包安装mysql8.0数据库

获取安装包 可以访问mysql 官网下载压缩安装包 &#xff08;官网地址&#xff1a;https://downloads.mysql.com/archives/community/&#xff09; 根据自己的需要&#xff0c;下载对应mysql版本&#xff0c;我选择是是8.0.16版本 安装 解压之后&#xff0c;可以看到压缩包…
阅读更多...
德勤：《亚太地区半导体行业展望》

德勤：《亚太地区半导体行业展望》

2024年2月22日&#xff0c;德勤联合全球半导体联盟&#xff08;GSA&#xff09;对亚洲半导体产业链相关企业展开调研&#xff0c;邀请数位亚太地区主要半导体企业领导人&#xff0c;共同探讨半导体企业在当前环境下应如何通过数字技术曲线的领先优势保持业务竞争力和盈利能力&a…
阅读更多...
GESP图形化编程二级认证真题 2024年3月

GESP图形化编程二级认证真题 2024年3月

GESP 图形化二级试卷 &#xff08;满分&#xff1a;100 分 考试时间&#xff1a;120 分钟&#xff09; 一、单选题&#xff08;共 10 题&#xff0c;每题 3 分&#xff0c;共 30 分&#xff09; 1、小杨的父母最近刚刚给他买了一块华为手表&#xff0c;他说手表上跑的是鸿…
阅读更多...
（day 15）JavaScript学习笔记（对象3）

（day 15）JavaScript学习笔记（对象3）

概述 这是我的学习笔记&#xff0c;记录了JavaScript的学习过程。在写博客的时候我会尽量详尽的记录每个知识点。如果你完全没接触过JavaScript&#xff0c;那么这一系列的学习笔记可能会对你有所帮助。 今天继续学习对象&#xff0c;主要是Object.create()、原型链、修改原型指…
阅读更多...
Autosar的前世今生：E2E通信校验

Autosar的前世今生：E2E通信校验

在浏览项目整体框架的时候&#xff0c;发现E2E是一个不可绕开的点&#xff0c;而且处处可见Autosar框架的踪迹&#xff0c;因此开一个专栏&#xff0c;每天学习一点相关知识点 E2E&#xff08;end to end&#xff09;是Autosar规范里规定的一种用于保证数据传输正确的概念&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023