【数据结构】二叉树的链式结构的实现 -- 详解

news2024/12/25 10:35:23

一、前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习。 
typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

// 动态申请一个新节点
BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	assert(newnode);

	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

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

注意：上述代码并不是创建二叉树的方式。

二、构建二叉树

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (*pi >= n)
	{
		return NULL;
	}

	char ch = a[*pi];
	(*pi)++;

	if (ch == '#')
	{
		return NULL;
	}

	BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
	newNode->data = ch;
	newNode->left = BinaryTreeCreate(a, n, pi);
	newNode->right = BinaryTreeCreate(a, n, pi);

	return newNode;
}

三、二叉树的遍历

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

二叉树的遍历方式主要有四种，先介绍三种，最后再介绍第四种。（利用了分治的思想）

  1. 前序遍历 (Preorder Traversal 亦称先序遍历)，方式为先遍历根结点，左子树，右子树。
  2. 中序遍历 (Inorder Traversal)，方式为先遍历左子树，根结点，右子树。
  3. 后序遍历 (Postorder Traversal)，方式为先遍历左子树，右子树，根结点。
// 二叉树前序遍历
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);

其中这三种遍历方式一般都用递归进行实现。

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

1️⃣ 深度优先遍厉：前序遍厉、中序遍厉、后序遍厉，注意有些说法只认同前序遍厉。

2️⃣ 广度优先遍厉：层序遍厉。

1、前序遍历

按照前序遍历的方式，我们应该先遍历根结点 A，然后再去遍历左子树。当进入左子树后，我们需要再执行前序遍历方式，即遍历 A 的左子树中的根结点 B，然后再遍历 B 的左子树。当我们再进入左子树，又是先遍历根结点D，然后又遍历左子树，按照顺序遍历到 R，此时终于完成根结点，左子树，接下来遍历右子树。进入右子树后，又遍历根结点T... ...，所以这种遍历方式属于递归性质的。（遍历顺序为：A–>B–>D–>R–>T–>E–>Y–>C–>Q–>U–>W）

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root) // 根->左子树->右子树
{
	if (root == NULL)
	{
		printf("# "); // 用#代表NULL
		return;
	}
	printf("%c ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}
【递归图解】

2、中序遍历

中序遍历方式为左子树，根结点，右子树。仍以上面的图为例，遍历顺序为：

R–>D–>T–>B–>E–>Y–>A–>Q–>U–>C–>W

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)// 左子树->根->右子树
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	BinaryTreeInOrder(root->left);
	printf("%c ", root->data);
	BinaryTreeInOrder(root->right);
}

3、后序遍历

后序遍历方式为 左子树，右子树，根结点。仍以上面的图为例，遍历顺序应该为：

R–>T–>D–>Y–>E–>B–>U–>Q–>W–>C–>A

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root) // 左子树->右子树->根
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->data);
}

【总结】 

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

4、层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。
设二叉树的根节点所在层数为 1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第 2 层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。 
// 层序遍历
void LevelOrder(BTNode* root);

注意：层序遍历一般需要使用队列。 （队列内容前面已经详细介绍过了）

【思路】先让根入队列，然后再让根出队列，当左子树不为 NULL 时让左子树入队列，当右子树不为NULL时让右子树入队列，然后不断地迭代下去，直至队列为空。记得出队列前要保存当前值来访问到该元素，Pop 到队列当中的值是地址，通过该地址来访问其中的 data。

层序遍历结果为： 3->4->3->8->6->6->7

我们该如何利用队列实现呢？

  1. 判断当前队列是否为空。
  2. 队列为空：结束；队列非空：取出队列第一个元素入队列。
  3. 上一层出来后，再入下一层（即它的左右孩子节点）。

  ​

由于前面已经对队列的各种操作进行了详解，这里就不展开讲了。（直接运用之前写的 Queue.c 和 Queue.h）

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root) // 树的根节点root不为空 将根节点入队列
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q); // 获取队列头部元素
		printf("%c ", front->data); // 打印节点值
		QueuePop(&q); // 出队列

		// 如果当前树根的左右孩子不为空 则分别入队列
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

​

四、二叉树其它接口的实现

1、二叉树的节点个数

按照递归的思想，计算二叉树的节点数量，我们可以认为 二叉树的节点个数 = 左子树数量 + 右子树数量 + 1，其中 1 是当前根节点数量（前提条件是存在根节点）。

⚪【思想 1】

迭代，使用栈来模拟递归的过程，用全局变量 / 静态局部变量来记录节点个数，遍历二叉树的所有节点，并累加节点的个数。

⚪【思想 2】

递归，利用分治的思想，函数使用带返回值的方式，其内部的递归本质上是一个后序遍厉（左子树->右子树->根节点）。

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

​

2、二叉树叶子节点个数

按照递归的思想，计算二叉树的叶子节点数量，我们可以认为 叶子节点个数 = 左子树叶子节点个数 + 右子树叶子节点个数 + 0，0 是因为当前根结点有子树，说明根结点不是叶子结点。

⚪【思想】

以 left 和 right 为标志，如果都为 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);
}

​

3、二叉树第k层节点个数

⚪【思想】

求当前树的第 k 层节点个数 = 左子树的第 k-1 层节点个数 + 右子树的第 k-1 层节点个数 (当 k=1 时，说明此层就是目标层)

image-20220218182106525​

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k >= 1);
	if (root == NULL) // 先判断当前访问的节点是否为空
	{
		return 0;
	}

	if (k == 1) // 当前节点不为空，而k已经减到1了，说明遍历到了第k层，说明该节点是第k层的
	{
		return 1;
	}

    // 还没有遍历到第k层，我们就继续往下遍历
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
如何知道这个节点是不是第 k 层的？

求二叉树第 k 层的节点个数，我们从根节点开始往下遍历（按根->左->右的顺序），每遍历一次 k 就减 1一次，当 k==1 时，说明我们遍历到了第 k 层，此时访问该层的节点。如果它不为空，则二叉树第 k 层的节点个数就要 +1。

4、二叉树查找值为x的节点

⚪【思想】

按照递归思想，先判断当前结点是否是目标节点，然后查找左子树，再查找右子树。

如果左右子树都没有找到，就返回NULL。

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL) // 先判断当前访问的节点是否为空
	{
		return NULL;
	}

	if (root->data == x) // 判断要找的x值节点是不是当前节点
	{
		return root;
	}

    // 不是当前节点，则继续去该节点的左子树中找
	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
	{
		return ret1;
	}

    // 还没找到，再继续去该节点的右子树中找
	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
	{
		return ret2;
	}
	return NULL; // 当前节点及其左右子树中都没找到，返回NULL
}

5、销毁二叉树

// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	// 如果使用前中序遍历销毁，节点会先被销毁，变成随机值，就不知道它的左右子树位置了 所以采用后序遍历销毁
	if (*root == NULL)
	{
		return;
	}
	BinaryTreeDestory(&((*root)->left));
	BinaryTreeDestory(&((*root)->right));
	free(*root);
	*root = NULL; // 将根节点设置为NULL 防止野指针
}

注意：如果这里使用前序遍历或中序遍历进行销毁，节点会先被销毁，变成随机值，就不知道它的左右子树位置了，所以应该采用后序遍历来销毁二叉树。

如果这里传进来的是一级指针，由于要在函数内改变形参的值，无法改变外部实参的值，所以我们需要在函数外置头节点指针为NULL。

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

⚪【思想】

层序遍历时，把空节点也入队列。

  • 完全二叉树中，非空节点是连续的，则空节点是连续的。
  • 非完全二叉树中，非空节点不是连续的，则空节点不是连续的。

所以在出队时，判断一下，出到第一个空节点时，跳出循环；

在下面重新写一个循环继续出队，并检查出队元素：

  • 如果第一个空节点后面的全是空节点，说明是完全二叉树。
  • 如果第一个空节点后面的有非空节点，说明是非完全二叉树。

image-20220223131453733​

// 判断二叉树是否是完全二叉树（利用层序遍历的思想来判断）
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root) // 树的根节点root不为空 将根节点入队列
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q); // 获取队列头部元素
		QueuePop(&q); //出队列

		if (front)
		{
			// 不管当前树根的左右孩子是否为空，都分别入队列
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			break; //遇到空后，跳出层序遍历
		}
	}

	// 如果后面全是空，则是完全二叉树，否则不是完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true; // 出队的节点中，如果没有出现非空节点，说明是完全二叉树出队的节点中，如果没有出现非空节点，说明是完全二叉树
}

五、代码整合

1、Queue.h

// Queue.h
#pragma once

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

struct BinaryTreeNode;

typedef struct BinaryTreeNode* QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}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);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

2、Queue.c

// Queue.c
#define _CRT_SECURE_NO_WARNINGS 1

#include "Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	int n = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		++n;
		cur = cur->next;
	}
	return n;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

3、test.c

// test.c
#define _CRT_SECURE_NO_WARNINGS 1

#include "Queue.h"

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

//动态申请一个新节点
BTNode* BuyNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	assert(newnode);

	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (*pi >= n)
	{
		return NULL;
	}

	char ch = a[*pi];
	(*pi)++;

	if (ch == '#')
	{
		return NULL;
	}

	BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
	newNode->data = ch;
	newNode->left = BinaryTreeCreate(a, n, pi);
	newNode->right = BinaryTreeCreate(a, n, pi);

	return newNode;
}

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : 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);
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k >= 1);
	if (root == NULL) // 先判断当前访问的节点是否为空
	{
		return 0;
	}

	if (k == 1) // 当前节点不为空，而k已经减到1了，说明遍历到了第k层，说明该节点是第k层的
	{
		return 1;
	}

    // 还没有遍历到第k层，我们就继续往下遍历
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL) // 先判断当前访问的节点是否为空
	{
		return NULL;
	}

	if (root->data == x) // 判断要找的x值节点是不是当前节点
	{
		return root;
	}

    // 不是当前节点，则继续去该节点的左子树中找
	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
	{
		return ret1;
	}

    // 还没找到，再继续去该节点的右子树中找
	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
	{
		return ret2;
	}
	return NULL; // 当前节点及其左右子树中都没找到，返回NULL
}

// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	// 如果使用前中序遍历销毁，节点会先被销毁，变成随机值，就不知道它的左右子树位置了 所以采用后序遍历销毁
	if (*root == NULL)
	{
		return;
	}
	BinaryTreeDestory(&((*root)->left));
	BinaryTreeDestory(&((*root)->right));
	free(*root);
	*root = NULL; // 将根节点设置为NULL 防止野指针
}

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root) // 根->左子树->右子树
{
	if (root == NULL)
	{
		printf("# "); // 用#代表NULL
		return;
	}
	printf("%c ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)// 左子树->根->右子树
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	BinaryTreeInOrder(root->left);
	printf("%c ", root->data);
	BinaryTreeInOrder(root->right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root) // 左子树->右子树->根
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root) // 树的根节点root不为空 将根节点入队列
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q); // 获取队列头部元素
		printf("%c ", front->data); // 打印节点值
		QueuePop(&q); // 出队列

		// 如果当前树根的左右孩子不为空 则分别入队列
		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

// 判断二叉树是否是完全二叉树（利用层序遍历的思想来判断）
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root) // 树的根节点root不为空 将根节点入队列
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q); // 获取队列头部元素
		QueuePop(&q); //出队列

		if (front)
		{
			// 不管当前树根的左右孩子是否为空，都分别入队列
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			break; //遇到空后，跳出层序遍历
		}
	}

	// 如果后面全是空，则是完全二叉树，否则不是完全二叉树
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true; // 出队的节点中，如果没有出现非空节点，说明是完全二叉树出队的节点中，如果没有出现非空节点，说明是完全二叉树
}

int main()
{
	BTDataType a[] = { 'A', 'B', 'D', '#', '#', 'E', '#', 'H', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#' };
	int n = sizeof(a) / sizeof(a[0]) - 1; // 减去末尾的'\0'
	int pos = 0;
	BTNode* root = BinaryTreeCreate(a, n, &pos); // 构建二叉树

	printf("TreeSize:%d\n", BinaryTreeSize(root)); // 二叉树节点个数
	printf("TreeLeafSize:%d\n", BinaryTreeLeafSize(root)); // 二叉树叶子节点个数
	printf("Tree2LevelSize:%d\n", BinaryTreeLevelKSize(root, 2)); // 二叉树第k层节点个数
	printf("TreeFindB:%p\n", BinaryTreeFind(root, 'B')); // 二叉树查找值为x的节点
 
	// 前序遍历
	BinaryTreePrevOrder(root);
	printf("\n");
	// 中序遍历
	BinaryTreeInOrder(root);
	printf("\n");
	// 后序遍历
	BinaryTreePostOrder(root);
	printf("\n");
	BinaryTreeLevelOrder(root); // 层序遍历

	printf("TreeComplete:%d\n", BinaryTreeComplete(root)); // 判断二叉树是否是完全二叉树
	BinaryTreeDestory(&root);// 二叉树销毁
	printf("二叉树已销毁\n");
	return 0;
}

六、程序运行整体效果

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

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

相关文章

管理类联考——逻辑——真题篇——按知识分类——汇总篇——一、形式逻辑——模态——-句式转换+性质

管理类联考——逻辑——真题篇——按知识分类——汇总篇——一、形式逻辑——模态——-句式转换+性质

文章目录 第三节　模态命题-句式转换性质题-模态命题-句式转换性质-句式转换-逻辑转换&#xff1a;①不一定不可能&#xff1b;②不一定可能不未必。句式转换-语文转换&#xff1a;①一定不可能不必然&#xff1b;②一定不不可能必然不。性质-两命题间的关系-包含&#xff1a;①…
阅读更多...
c语言——计算两个数的乘积

c语言——计算两个数的乘积

//计算两个数的乘积 #include<stdio.h> #include<stdlib.h> int main() {double firstNumber,secondNumber,product;printf("两个浮点数&#xff1a;");scanf("%lf,%lf",&firstNumber,&secondNumber);productfirstNumber*secondNumber…
阅读更多...
shell scripts 学习记录

shell scripts 学习记录

shell scripts 学习记录 1. 环境变量的使用2. Shell中的数组使用Array关联数组 (理解为python中的字典) 3. shell中的基本运算符4. shell 中流程控制语法case...esac使用 5. 函数定义与调用5.1 带返回值的函数5.2 带传参数的函数 6. shell 中的输入/输出重定向6.1 输出重定向6.…
阅读更多...
糖尿病视网膜病变，黄斑病变，年龄相关检测研究（Matlab代码）

糖尿病视网膜病变，黄斑病变，年龄相关检测研究（Matlab代码）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
sCrypt于8月12日在上海亮相BSV数字未来论坛

sCrypt于8月12日在上海亮相BSV数字未来论坛

2023年8月12日&#xff0c;由上海可一澈科技有限公司&#xff08;以下简称“可一科技”&#xff09;、 临港国际科创研究院发起&#xff0c;携手美国sCrypt公司、福州博泉网络科技有限公司、复旦大学区块链协会&#xff0c;举办的BSV数字未来论坛在中国上海成功落下帷幕。 本次…
阅读更多...
好消息！多地明确鼓励提取公积金作首付

好消息！多地明确鼓励提取公积金作首付

大家好&#xff01; 我是老洪&#xff0c;看到一则公积金资讯&#xff0c;聊两句。 据媒体报道&#xff0c;多地明确鼓励提取公积金作首付。 我个人觉得鼓励提取公积金作首付&#xff0c;对于购房者来说挺好的。 这种做法不仅可以减轻首付资金压力&#xff0c;还可以提高购房者…
阅读更多...
出现丢包问题的情况以及解决方法

出现丢包问题的情况以及解决方法

为什么会出现丢包&#xff1f; 我们在网络上传输数据的时候&#xff0c;数据需要经过很多的路由器/交换机&#xff08;交通枢纽&#xff09;进行传输&#xff0c;而路由器/交换机的结构是很复杂的&#xff0c;传输的数据量也是不确定的&#xff0c;可能这一会传输的数据比较少&…
阅读更多...
mysql 03.查询（重点）

mysql 03.查询（重点）

先准备测试数据&#xff0c;代码如下&#xff1a; -- 创建数据库 DROP DATABASE IF EXISTS mydb; CREATE DATABASE mydb; USE mydb;-- 创建student表 CREATE TABLE student (sid CHAR(6),sname VARCHAR(50),age INT,gender VARCHAR(50) DEFAULT male );-- 向student表插入数据…
阅读更多...
vscode用ssh远程连接linux

vscode用ssh远程连接linux

1、vscode是利用ssh远程连接linux的&#xff0c;所以首先确保vscode已经安装了这两个插件 2、点击左下角的连接 3、选择Connect to Host…… 5、按格式输入 ssh 主机名ip 比如我的&#xff1a;ssh mnt192.168.198.128 6、选择第一个打开配置文件&#xff0c;确保输入正确 7、…
阅读更多...
el-table :span-method合并单元格

el-table :span-method合并单元格

2023.8.17今天我学习了如何使用el-table进行单元格的合并&#xff0c;效果如下&#xff1a; 在开发的过程中&#xff0c;如果有多个重复的值&#xff0c;我们希望可以进行合并显示&#xff0c;这样就不会显得重复太多&#xff0c;el-table有自带的方法&#xff1a; Element - …
阅读更多...
安装编译器

安装编译器

安装MinGW&#xff0c;下载地址&#xff1a; MinGW-w64 - for 32 and 64 bit Windows - Browse Files at SourceForge.net 下载x86_64-win32-seh&#xff0c;下载完解压到相应的路径下。
阅读更多...
Leetcode-每日一题【剑指 Offer 32 - I. 从上到下打印二叉树】

Leetcode-每日一题【剑指 Offer 32 - I. 从上到下打印二叉树】

题目 从上到下打印出二叉树的每个节点&#xff0c;同一层的节点按照从左到右的顺序打印。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回&#xff1a; [3,9,20,15,7] 提示&#xff1a; 节点总数 < 1000 解题思路 1.题目要求我们从…
阅读更多...
创建SpringBoot项目报错 - Process finished with exit code 1

创建SpringBoot项目报错 - Process finished with exit code 1

错误信息 [ERROR] The build could not read 1 project -> [Help 1] [ERROR] [ERROR] The project com.example:ruoyi-excel-demo:0.0.1-SNAPSHOT (D:\Java\work\ruoyiExcelDemo\pom.xml) has 1 error [ERROR] Non-resolvable parent POM for com.example:ruoyi-e…
阅读更多...
爬虫逆向实战（十六）--某建筑市场平台

爬虫逆向实战（十六）--某建筑市场平台

一、数据接口分析 主页地址&#xff1a;某建筑市场平台 1、抓包 通过抓包可以发现数据接口是list 2、判断是否有加密参数 请求参数是否加密&#xff1f; 无请求头是否加密&#xff1f; 无响应是否加密&#xff1f; 通过查看“响应”模块可以发现&#xff0c;返回的响应是…
阅读更多...
【共同缔造 情暖襄阳】 暑期关爱未成年人志愿服务活动合集（三）

【共同缔造 情暖襄阳】 暑期关爱未成年人志愿服务活动合集（三）

结合2023年襄阳市民政局“共同缔造 情暖襄阳”社会工作服务项目&#xff0c;在襄阳市民政局、襄州区民政局支持下&#xff0c;襄州社工协会联合肖湾街道育红社区开展暑期“希望家园”志愿服务活动&#xff0c;关爱未成年人。 8月4日&#xff0c;为培育孩子们广泛的兴趣爱好和动…
阅读更多...
【JVM】垃圾回收算法

【JVM】垃圾回收算法

目录 一、判断对象已“死” 1.1、引用计数算法 1.2、可达性分析算法 1.3、引用的概念 二、垃圾收集算法理论 2.1、分代收集理论 三、垃圾收集算法 3.1、标记--清除算法 3.2、标记--复制算法 3.3、标记--整理算法 一、判断对象已“死” 在堆里面存放着Java世界中几乎所…
阅读更多...
AGI 在网易云信的技术提效和业务创新

AGI 在网易云信的技术提效和业务创新

We believe our research will eventually lead to artificial general intelligence, a system that can solve human-level problems. Building safe and beneficial AGI is our mission. ---- OpenAI 通用人工智能 AGI 作为 AI 的终极形态&#xff0c;是 AI 行业内追求的演…
阅读更多...
【制作npm包2】了解 package.json 相关配置

【制作npm包2】了解 package.json 相关配置

制作npm包目录 本文是系列文章&#xff0c; 作者一个橙子pro&#xff0c;本系列文章大纲如下。转载或者商业修改必须注明文章出处 一、申请npm账号、个人包和组织包区别 二、了解 package.json 相关配置 三、 了解 tsconfig.json 相关配置 四、 api-extractor 学习 五、npm包…
阅读更多...
TECHnalysis Research：关于生成式AI的几个意外发现

TECHnalysis Research：关于生成式AI的几个意外发现

TECHnalysis Research是一家美国的独立市场调查公司&#xff0c;该调查公司于2023年5月份对于全美10个行业的1000家企业IT决策负责人进行了调研&#xff0c;调研围绕生成式AI及其对于企业业务的影响。就在全球持续升温的生成式AI热度中&#xff0c;TECHnalysis Research的调研结…
阅读更多...
第二章 搜索 No.2多源bfs，最小步数与双端队列广搜

第二章 搜索 No.2多源bfs，最小步数与双端队列广搜

文章目录 多源bfs&#xff1a;173. 矩阵距离最小步数&#xff1a;1107. 魔板双端队列bfs&#xff1a;175. 电路维修 根据Dijkstra的正确性可以验证bfs的正确性 多源bfs&#xff1a;173. 矩阵距离 173. 矩阵距离 - AcWing题库 输出01矩阵中的所有点到1的最短曼哈顿距离&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023