【数据结构】二叉树问题总结

news2024/9/25 7:21:21

目录

1.二叉树前序遍历，中序遍历和后序的实现

2.层序遍历

3.求二叉树中的节点个数

4.求二叉树中的叶子节点个数

5.求二叉树的高度

6.求二叉树第k层节点个数

7.二叉树查找值为x的节点

8.单值二叉树

9.二叉树最大深度

10.翻转二叉树

11. 检查两颗树是否相同

12. 对称二叉树

13. 另一颗树的子树

14.二叉树的前序遍历

15.通过前序遍历的数组构建二叉树 

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

17.判断二叉树是否是平衡二叉树 

18.二叉树销毁  

1.二叉树前序遍历，中序遍历和后序的实现

我们回顾以下二叉树的遍历：

前序遍历（先序遍历）：访问根节点的操作发生在遍历其左右子树之前

中序遍历：访问根节点的操作发生在遍历其左右子树之间

后序遍历：访问根节点的操作发生在遍历其左右子树之后

二叉树的遍历通过递归实现，下图为二叉树前序的递归遍历图解：

从根节点开始，先遍历根节点，再遍历左子树，左子树的遍历又分为先遍历根节点再遍历左子树，以根左子树右子树的顺序递归遍历，直至根节点为NULL

前序递归遍历的参考代码如下：

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

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}

//二叉树的前序遍历
TreeNode* PreOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	PreOrder(root);

	return 0;
}

 输出结果如下：

同理，可以使用递归实现 中序遍历和后序遍历

//二叉树的中序遍历
TreeNode* InOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);

}
//二叉树的后序遍历
TreeNode* PostOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);

}

2.层序遍历

二叉树的层序遍历要基于队列实现，上一层节点出队，其孩子节点依次入队，依次访问直到队列为空

📖Note：

采用链式队列实现时，队列中每个元素的数据域存放的是二叉树节点的指针，类型为TreeNode* 

// 队列的定义
typedef struct QueueNode
{
    TreeNode* data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;
 

// 层序遍历
void BinaryTreeLevelOrder(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    //根节点入队
    if (root)
    {
        QueuePush(&q, root);
    }
    //队列不为空时
    while (!QueueEmpty(&q))
    {
        //访问队头元素并出队
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        printf("%d", front->val);

        //队头元素的孩子节点入队
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
    }
    printf("\n");
    QueueDestroy(&q);
}

 队列相关操作如下：

//队列初始化
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}
//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL && pq->tail == NULL;
}
//队列销毁
void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;
        free(del);
    }
    pq->head = pq->tail = NULL;
}
//访问队头数据
TreeNode* QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;

}
//数据入队
void QueuePush(Queue* pq, TreeNode* x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    else
    {
        newnode->data = x;
        newnode->next = NULL;
    }
    //空队列时插入
    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    //非空队列时插入
    else
    {
        pq->tail->next = newnode;//链接新元素
        pq->tail = newnode;//更新队尾
    }
}
//数据出队
void QueuePop(Queue* pq)
{
    assert(pq);
    //空队列不能进行出队操作
    assert(!QueueEmpty(pq));
    //队列中只有一个元素
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;
        free(del);
        del = NULL;
    }
}

 

3.求二叉树中的节点个数

求一棵树中的节点个数，有两种解决思路

  1. 暴力求解，遍历计数
  2. 转换成子问题求解

暴力求解时，变量size的定义可能出现问题，定义1如下：

函数中直接定义size，每次递归调用函数size都被置0，所以最后的返回结果为1，不能求出二叉树的长度

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

定义2：将size定义成静态变量，但仍在函数内

这种定义方法解决了每次函数内递归size置0的问题，但是static定义的变量只有在第一次定义的时候才会初始化，所以当我们在其他函数中重复调用TreeSize函数时，size的值会累加

解决方法：将size定义成全局变量，每次调用函数前初始化size

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	static int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

正确的定义与调用

#include<stdio.h>
#include<stdlib.h>
int size = 0;

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}
//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	printf("%d\n", TreeSize(root));
	size = 0;//初始化size
	printf("%d\n", TreeSize(root));

	return 0;
}

转换成子问题：一棵二叉树节点的个数 = 左子树节点的个数+右子树节点的个数+1

左子树和右子树节点的个数也是其对于的左右子树节点个数之和+1

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

这种求解方法避免了定义变量的问题 

4.求二叉树中的叶子节点个数

求一棵树中叶子节点的个数，首先要清楚如何判断一个节点为叶子节点：

一个叶子节点的左右孩子都为空

求解叶子节点的个数问题也可以转换成子问题，一棵树中的叶子节点的个数为左子树中叶子节点的个数+右子树中叶子节点的个数 

//二叉树叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

5.求二叉树的高度

求解二叉树高度的问题转换成子问题：一棵树的高度 = max{左子树高度，右子树高度}+1

//二叉树的高度
int TreeHeight(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	int left = TreeHeight(root->left);
	int right = TreeHeight(root->right);
	return  left > right ? left + 1 : right + 1;

}

6.求二叉树第k层节点个数

求一棵树的第k层节点的个数转换成子问题：一棵树第k层节点的额个数 = 左子树第k-1层节点个数+右子树第k-1层节点个数

//二叉树第k层节点的个数
int TreeKLevel(TreeNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}

	k = k - 1;
	return TreeKLevel(root->left, k) + TreeKLevel(root->right, k);
	
}

7.二叉树查找值为x的节点

查找值为x的节点转换成子问题：先检查根节点是否符合条件，不符合条件再去左子树找，左子树没找到去右子树查找，右子树没找到则返回NULL，载其中任何一个环节中如果中找到值为x的节点，则返回

//二叉树查找值为x的节点
TreeNode* TreeFind(TreeNode* root, int x)
{
	if(root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}

	//在左子树查找
	TreeNode* ret = TreeFind(root->left, x);
	if (ret)
	{
		return ret;
	}
	//左子树没找到，再在右子树查找
	ret = TreeFind(root->right, x);
	if (ret)
	{
		return ret;
	}

	//整棵树都没找到
	return NULL;
}

 8.单值二叉树

单值二叉树题目链接：. - 力扣（LeetCode）

题目分析：

对于一棵单值二叉树，当其根节点的值等于左右孩子的值时，问题就可以转换成子问题，判断它的左右子树是否为单值二叉树，其左右子树的判断又重复之前的操作

📖Note：

对于一个节点，可能存在四种情况：

  • 有左右孩子
  • 只有左孩子
  • 只有右孩子
  • 没有孩子（叶子节点）

有左孩子节点时，父节点与左孩子节点比较，不相等返回false，相等则比较父节点与右孩子节点，不相等则返回false，相等则返回true

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    //有左右孩子
    if (root->left && root->left->val != root->val)
    {
        return false;
    }
    if (root->right && root->right->val != root->val)
    {
        return false;
    }

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

9.二叉树最大深度

二叉树最大深度：. - 力扣（LeetCode）

题目分析：

当二叉树为空时，其最大深度为0

当二叉树不为空时，求二叉树的最大深度转换成子问题为1加左右子树中深度较大者

int maxDepth(struct TreeNode* root) {
    if(root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

10.翻转二叉树

翻转二叉树题目链接：226. 翻转二叉树 - 力扣（LeetCode）

题目分析：

翻转二叉树有两种方法

1️⃣使用递归实现

先序遍历二叉树的框架：先交换根节点的左右子树，再分别递归左子树右子树，即可实现二叉树的翻转

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return root;
    }
    //交换左右子树
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    invertTree(root->left);
    invertTree(root->right);

    return root;
}

2️⃣层序遍历法

层序遍历法基于队列实现

从根节点开始，层序遍历二叉树，依次翻转每一个节点的左右子树

struct TreeNode* invertTree(struct TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    //根节点入队
    if (root)
    {
        QueuePush(&q, root);
    }
    //队列不为空时
    while (!QueueEmpty(&q))
    {
        //访问队头元素并交换其左右子树
        struct TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        struct TreeNode* tmp = front->left;
        front->left = front->right;
        front->right = tmp;

        //队头元素的孩子节点入队
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
    }
    return root;
    QueueDestroy(&q);
}

11. 检查两颗树是否相同

检查两颗树是否相同题目链接：. - 力扣（LeetCode）

题目分析：

两棵二叉树相同，不仅结构上相同，而且对应节点的值相同

1️⃣对于两颗空二叉树，则它们是相同的树

2️⃣对于一颗空树和一颗非空树，它们是不相同的树

3️⃣对于两颗非空树，先判断它们根节点的值是否相同，不相同则它们是不相同的树，相同则转换成子问题：依次比较它们的左右子树。当左右子树都相同时它们为相同的树

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

12. 对称二叉树

对称二叉树题目链接：. - 力扣（LeetCode）

题目分析：

1️⃣对于一颗空树和只有一个节点的树，其为对称的树

2️⃣对于不止一个节点的树，如果其为对称的树，则其右子树翻转后和左子树是相同的树，这里需要用到我们已经写过的翻转二叉树和判断相同的树的函数

 //相同的二叉树
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);

}
//翻转二叉树
struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return root;
    }
    //交换左右子树
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    invertTree(root->left);
    invertTree(root->right);

    return root;
}
//对称二叉树
bool isSymmetric(struct TreeNode* root) {
    //空树
    if (root == NULL)
    {
        return true;
    }
    //只有一个节点的树
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    //有左右孩子,且左右孩子为相同的树
    invertTree(root->right);
    return isSameTree(root->left,root->right);
}

13. 另一颗树的子树

另一颗树的子树题目链接：572. 另一棵树的子树 - 力扣（LeetCode）

 

题目分析：

1️⃣当一棵树为空时，任何树都不是其子树

2️⃣特殊情况：两棵树相同时，一颗是另一颗的子树

3️⃣当两棵树不相同时，递归判断主树的左子树与右子树是否与已知子树相同，只要左子树或右子树中存在与已知子树相同的树，则已知子树为主树的子树

//另一棵树的子树
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if (root == NULL)
    {
        return false;
    }
    if (isSameTree(root,subRoot))
    {
        return true;
    }
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

14.二叉树的前序遍历

二叉树的前序遍历题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

​

题目分析：

本题的前序遍历不是单纯的打印，而是通过函数接口返回一个前序遍历序列数组（该数组是动态开辟的）

首先，要动态开辟数组，我们需要知道要开辟数组的大小，即二叉树节点的个数，调用题目3的函数接口TreeSize即可

然后，先序遍历二叉树，将二叉树节点按先序遍历的顺序依次存入我们动态开辟的数组，返回数组首元素地址即可

📖Note：

这里我们需要对先序遍历二叉树的函数接口增加一个参数，整型指针pi，用来指示每次存储的数组下标。如果在PreOrder函数内定义下标指针，每次递归都会使其初始化为0，所以采用参数的形式定义。

//求二叉树节点个数
int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//二叉树的前序遍历
void PreOrder(struct TreeNode* root, int* a, int* pi)
{
    if (root == NULL)
    {
        return;
    }
    //static int i = 0;
    a[*pi] = root->val;
    printf("a[%d] = %d\n", pi, a[*pi]);
    ++(*pi);

    PreOrder(root->left, a, pi);
    PreOrder(root->right, a, pi);
}

//二叉树的前序遍历，返回序列数组
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    //开辟数组空间
    int n = TreeSize(root);
    //printf("%d\n",n);
    int* a = (int*)malloc(sizeof(int) * n);

    int i = 0;
    PreOrder(root, a, &i);

    *returnSize = n;
    return a;
}

15.通过前序遍历的数组构建二叉树 

 题目链接：二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

题目分析：

对已知字符串序列进行遍历，遇到空节点（#代表空节点）则访问下一个，需要对非空节点开辟空间并为其数据域赋值，递归构造左子树和右子树即可

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

typedef char BTDataType;
typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTNode;
//由前序序列构造二叉树
BTNode* BinaryTreeCreate(BTDataType* a,int* pi)
{
    if(a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));
    if(root == NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }
    root->data = a[*pi];
    (*pi)++;
    root->left = BinaryTreeCreate(a, pi);
    root->right = BinaryTreeCreate(a, pi);
    return root;
}
//中序遍历
void InOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    InOrder(root->left);
    printf("%c ",root->data);
    InOrder(root->right);
}

int main() {
    char str[100];
    scanf("%s", str);
    int i = 0;
    BTNode* root = BinaryTreeCreate(str, &i);
    InOrder(root);

    return 0;
}

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

一颗完全二叉树可能为满二叉树，也可能非满，此时最后一层的节点连续排列

判断方法：层序遍历二叉树，将所有节点依次入队，再依次出队，遇到NULL，则跳出循环，判断后续队列中是否存在非空节点，不存在则为完全二叉树，否则为非完全二叉树。

//判断一棵树是否为完全二叉树
int BinaryTreeComplete(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q,root);
    }
    //节点入队
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
        {
            break;
        }
        QueuePush(&q, root->left);
        QueuePush(&q, root->right);

    }
    //判断后续队列中是否有非空节点，有则不是完全二叉树
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        //存在非空元素
        if (front != NULL)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

17.判断二叉树是否是平衡二叉树 

平衡二叉树题目链接：110. 平衡二叉树 - 力扣（LeetCode）

 

题目分析：

对于一颗空树和只有一个节点的树，其为平衡二叉树

平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1

因此判断每个节点的左右左子树的高度差，调用题目9中二叉树的高度计算函数maxdepth

//二叉树的最大高度
int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

//平衡二叉树
bool isBalanced(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    int left_heigh = maxDepth(root->left);
    int right_heigh = maxDepth(root->right);
    if (left_heigh - right_heigh == -1 || left_heigh - right_heigh == 0 
         || left_heigh - right_heigh == 1)
    {
        if(isBalanced(root->left) && isBalanced(root->right))
            return true;
    }
    return false;
}

18.二叉树销毁  

1️⃣对于一颗空树，直接返回即可

2️⃣对于一颗只有一个节点的树，直接释放该节点所占用的空间

3️⃣二叉树的销毁转换成分治子问题：采用后续遍历二叉树的框架，对每一个节点，先释放左子树所占用的空间，再释放右子树所占用的空间，最后释放根节点所占用的空间

//二叉树的额销毁
void BinaryTreeDestroy(TreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    
    BinaryTreeDestroy(root->left);
    BinaryTreeDestroy(root->right);
    free(root);
}

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

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

相关文章

【Linux实用篇】Linux常用命令（2）

【Linux实用篇】Linux常用命令（2）

目录 1.3 拷贝移动命令 1.3.1 cp 1.3.2 mv 1.4 打包压缩命令 1.5 文本编辑命令 1.5.1 vi&vim介绍 1.5.2 vim安装 1.5.3 vim使用 1.6 查找命令 1.6.1 find 1.6.2 grep 1.3 拷贝移动命令 1.3.1 cp 作用: 用于复制文件或目录 语法: cp [-r] source dest ​ 说明: …
阅读更多...
数据分析概述2（详细介绍机器学习

数据分析概述2（详细介绍机器学习

目录 1.名词解释&#xff1a;1.1算法和模型1.2参数和超参数 2.基础算法&#xff1a;3.高级算法&#xff1a;4.数据准备5.常用python包小结&#xff1a; 1.名词解释&#xff1a; 1.1算法和模型 算法&#xff1a;用于训练模型的方法&#xff0c;分为有监督学习、无监督学习、半…
阅读更多...
Centos7安装K8S

Centos7安装K8S

Centos7安装K8S 安装过程中没有出现的错误可以往下 根据以前一些博主写的博客&#xff0c;在小阳翻了不下几十篇博客之后&#xff0c;我果断是放弃了&#xff0c;于是找到了官网地址&#xff0c;然后也有坑 1. 关闭防火墙 systemctl stop firewalld systemctl disable firew…
阅读更多...
算法通关村番外篇-LeetCode编程从0到1系列四

算法通关村番外篇-LeetCode编程从0到1系列四

大家好我是苏麟 , 今天带来算法通关村番外篇-LeetCode编程从0到1系列四 . 矩阵 1672. 最富有客户的资产总量 描述 : 给你一个 m x n 的整数网格 accounts &#xff0c;其中 accounts[i][j] 是第 i​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产…
阅读更多...
【UEFI基础】EDK网络框架（IP4）

【UEFI基础】EDK网络框架（IP4）

IP4 IP4协议说明 IP全称Internet Protocol&#xff0c;它属于网络层&#xff0c;对其下各种类型的数据链路层进行了包装&#xff0c;这样网络层可以跨越不同的数据链路&#xff0c;即使是在不同的数据链路上也能实现两端节点之间的数据包传输。 IP层的主要作用就是“实现终端…
阅读更多...
java应用CPU过高查找原因

java应用CPU过高查找原因

用top查到占用cpu最高的进程pid 根据进程ID找到占用CPU高的线程 ps -mp 60355 -o THREAD,tid | sort -r 用 printf "%x \n" 将tid换为十六进制&#xff1a;xid printf "%x \n" 6036 根据16进制格式的线程ID查找线程堆栈信息 jstack 60355 |grep ebcb -A…
阅读更多...
Fiddler怎么抓请求做接口

Fiddler怎么抓请求做接口

第一步:安装fiddler 可以在官网下载最新版本 VIP小伙伴可以在课前准备下载,如果已经安装,请忽略 打开fiddler开始抓取测试对象的请求,以教管系统登录为例 打开fiddler,准备开始抓取,清空会话,开启抓取状态,因为fiddler默认抓取http协议,所以这里不需要设置什么。 打开系统登…
阅读更多...
Windows项目部署流程

Windows项目部署流程

一、部署前需要的工作 ①配置环境变量&#xff1a;将所需的软件和工具的安装路径添加到系统的环境变量中&#xff0c;以便在命令行中可以直接使用。 ②部署项目文件&#xff1a;将项目的文件和代码复制到服务器上的指定目录中&#xff0c;例如Web服务器的网站根目录。 ③配置…
阅读更多...
idea使用谷歌翻译 有道翻译 百度翻译

idea使用谷歌翻译 有道翻译 百度翻译

中文版&#xff1a;文件——设置——工具——Translation&#xff0c;然后选择需要配置的翻译 英文版&#xff1a;File——settings——Tools——Translation&#xff0c;然后选择需要配置的翻译 谷歌翻译大家可以度娘直接搜索Google_translation_win 有道和百度翻译得去注册申…
阅读更多...
什么是有机搜索引擎优化以及如何入门

什么是有机搜索引擎优化以及如何入门

什么是有机搜索引擎优化&#xff1f; 有机搜索引擎优化&#xff0c;简称 SEO&#xff0c;是指从搜索引擎的无偿搜索结果中增加网站流量的做法。 未付费搜索结果是获得的列表&#xff0c;而不是付费的。 这样做的目的是让您的网页在与您业务相关的未付费搜索结果中排名靠前。…
阅读更多...
Spring自带分布式锁你用过吗？

Spring自带分布式锁你用过吗？

环境&#xff1a;SpringBoot2.7.12 本篇文章将会为大家介绍有关spring integration提供的分布式锁功能。 1. 简介 Spring Integration 是一个框架&#xff0c;用于构建事件驱动的应用程序。在 Spring Integration 中&#xff0c;LockRegistry 是一个接口&#xff0c;用于管理…
阅读更多...
无需任何三方库，在 Next.js 项目在线预览 PDF 文件

无需任何三方库，在 Next.js 项目在线预览 PDF 文件

前言&#xff1a; 之前在使用Vue和其它框架的时候&#xff0c;预览 PDF 都是使用的 PDFObject 这个库&#xff0c;步骤是&#xff1a;下载依赖&#xff0c;然后手动封装一个 PDF 预览组件&#xff0c;这个组件接收本地或在线的pdf地址&#xff0c;然后在页面中使用组件的车时候…
阅读更多...
黑马程序员 Docker笔记

黑马程序员 Docker笔记

本篇学习笔记文档对应B站视频&#xff1a; 暂时无法在飞书文档外展示此内容 同学们&#xff0c;在前两天我们学习了Linux操作系统的常见命令以及如何在Linux上部署一个单体项目。大家想一想自己最大的感受是什么&#xff1f; 我相信&#xff0c;除了个别天赋异禀的同学以外&a…
阅读更多...
学习笔记-mysql基础(DDL,DML,DQL)

学习笔记-mysql基础(DDL,DML,DQL)

一.DDL DDL,Data Definition Language,数据库定义语言,该语言包括以下内容: 对数据库的常用操作对表结构的常用操作修改表结构 1.对数据库的常用操作 -- 查看所有的数据库 show databases -- 创建数据库 create database [if not exists] test [charsetutf8] -- 切换 选择 …
阅读更多...
如何判断 vite 的运行环境是开发模式还是生产模式 production？ development？

如何判断 vite 的运行环境是开发模式还是生产模式 production？ development？

如何判断 vite 的运行环境是开发模式还是生产模式 production&#xff1f; development&#xff1f; vite 有两种获取当前运行环境模式的方法&#xff1a; 官方说明&#xff1a; 完整说明地址&#xff1a; https://cn.vitejs.dev/guide/env-and-mode.html#node-env-and-modes…
阅读更多...
Netty开篇——NIO章上（三）

Netty开篇——NIO章上（三）

Java NIO基本介绍 java non-blocking I/O 称为NIO(也叫New IO)。JDK4开始提供,同步非阻塞相关内容在 java.nio 包及子包下&#xff0c;对java.io 包中的很多类进行改写。三大核心: Channel(通道)&#xff0c;Buffer(缓冲区),Selector(选择器)NIO是面向缓冲区或者面向块编程的。…
阅读更多...
使用Java连接MongoDB (6.0.12) 报错

使用Java连接MongoDB (6.0.12) 报错

报错&#xff1a; Exception in thread "main" com.mongodb.MongoCommandException: Command failed with error 352: Unsupported OP_QUERY command: create. 上图中“The client driver may require an upgrade”说明了“客户端驱动需要进行升级”&#xff0c;解…
阅读更多...
【昕宝爸爸小模块】如何让Java的线程池顺序执行任务

【昕宝爸爸小模块】如何让Java的线程池顺序执行任务

➡️博客首页 https://blog.csdn.net/Java_Yangxiaoyuan 欢迎优秀的你&#x1f44d;点赞、&#x1f5c2;️收藏、加❤️关注哦。 本文章CSDN首发&#xff0c;欢迎转载&#xff0c;要注明出处哦&#xff01; 先感谢优秀的你能认真的看完本文&…
阅读更多...
【Python数据可视化】matplotlib之设置坐标：添加坐标轴名字、设置坐标范围、设置主次刻度、坐标轴文字旋转并标出坐标值

【Python数据可视化】matplotlib之设置坐标：添加坐标轴名字、设置坐标范围、设置主次刻度、坐标轴文字旋转并标出坐标值

文章传送门 Python 数据可视化matplotlib之绘制常用图形&#xff1a;折线图、柱状图&#xff08;条形图&#xff09;、饼图和直方图matplotlib之设置坐标&#xff1a;添加坐标轴名字、设置坐标范围、设置主次刻度、坐标轴文字旋转并标出坐标值matplotlib之增加图形内容&#x…
阅读更多...
进程的创建与回收学习笔记

进程的创建与回收学习笔记

目录 一、进程内容&#xff1a; 二、进程常用命令 三、创建子进程 四、子进程进阶 五、进程的退出 六、进程的回收 一、进程内容&#xff1a; 程序&#xff1a; 存放在磁盘上的指令和数据的有序集合&#xff08;文件&#xff09; 静态的 进程&#xff1a; 执行一个程序所…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023