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

目录

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Redis介绍

Redis介绍

一、 Redis介绍 1. NoSQL的引言 NoSQL(Not Only SQL )&#xff0c;意即不仅仅是SQL, 泛指非关系型的数据库。Nosql这个技术门类,早期就有人提出,发展至2009年趋势越发高涨。 2. 为什么是NoSQL 随着互联网网站的兴起&#xff0c;传统的关系数据库在应付动态网站&#xff0c;…
阅读更多...
HTML--图片

HTML--图片

HTML中使用 img标签来显示一张图片 它有三个属性&#xff1a; src alt tiltle src属性&#xff1a; 图片路径建议为相对路径&#xff0c;以免文件移动造成无法正常工作 用法&#xff1a; <img src"图片路径和名字"><!DOCTYPE html> <html> <…
阅读更多...
【数据库】sql优化有哪些？从query层面和数据库层面分析

【数据库】sql优化有哪些？从query层面和数据库层面分析

目录 归纳sql本身的优化数据库层面的优化 归纳 这类型问题可以称为&#xff1a;Query Optimization&#xff0c;从清华AI4DB的paper list中&#xff0c;该类问题大致可以分为&#xff1a; Query RewriterCardinality EstimationCost EstimationPlan Optimization 从中文的角…
阅读更多...
20240110在ubuntu20.04下重启samba服务

20240110在ubuntu20.04下重启samba服务

20240110在ubuntu20.04下重启samba服务 百度搜索&#xff1a;samba restart https://www.python100.com/html/78028.html 重启samba命令详解 更新&#xff1a;2023-05-17 16:04 一、重启samba命令 重启samba可以使用以下命令&#xff1a; /etc/init.d/smb restart 或者 syste…
阅读更多...
debian12部署Gitea服务之二——部署git-lfs

debian12部署Gitea服务之二——部署git-lfs

Debian安装gitlfs: 先更新下软件包版本 sudo apt update 安装 sudo apt install git-lfs 验证是否安装成功 git lfs version cd到Gitea仓库目录下 cd /mnt/HuHDD/Git/Gitea/Repo/hu/testrepo.git 执行lfs的初始化命令 git lfs install客户机Windows端在官网下载并安装Git-Lfs 再…
阅读更多...
基于kkFileView实现万能文件预览

基于kkFileView实现万能文件预览

基于kkFileView实现万能文件预览 1.简介 文档在线预览项目解决方案&#xff0c;项目使用流行的spring boot搭建&#xff0c;易上手和部署。万能的文件预览开源项目&#xff0c;基本支持主流文档格式预览 官网&#xff1a;https://kkview.cn/zh-cn/docs/home.html github地址…
阅读更多...
sectigo dv证书适合场景买一年送一月

sectigo dv证书适合场景买一年送一月

Sectigo是成立于美国的知名CA认证机构&#xff0c;随着互联网的发展&#xff0c;Sectigo颁发了越来越多的SSL数字证书。这些SSL证书产品不仅可以对网站传输数据进行加密服务&#xff0c;还可以对服务器身份进行认证服务。Sectigo旗下的DV证书产品比较齐全&#xff0c;适用场景也…
阅读更多...
【动态规划】【记忆化搜索】C++算法：546移除盒子

【动态规划】【记忆化搜索】C++算法：546移除盒子

作者推荐 【动态规划】458:可怜的小猪 本文涉及知识点 动态规划 记忆化搜索 LeetCode546. 移除盒子 给出一些不同颜色的盒子 boxes &#xff0c;盒子的颜色由不同的正数表示。 你将经过若干轮操作去去掉盒子&#xff0c;直到所有的盒子都去掉为止。每一轮你可以移除具有相…
阅读更多...
[C++]多态

[C++]多态

目录 C多态&#xff1a;&#xff1a; 多态的概念 多态的定义及实现 多态的构成条件 虚函数 虚函数的重写 虚函数重写的特例 C11 override和final 重载、重写重定义的对比 抽象类 概念 接口继承和实现继承 多态的原理 虚函数表 多态的原理 动态绑定和静态绑定 单继承和…
阅读更多...
智能分析网关V4：搭建智慧幼儿园视频AI智能监管方案

智能分析网关V4：搭建智慧幼儿园视频AI智能监管方案

一、背景需求 随着科技的日新月异&#xff0c;智慧化监管在幼儿园管理领域的应用已成为不可逆转的趋势。在传统的幼儿园管理模式中&#xff0c;校园安全管理往往依赖于人工查看监控&#xff0c;难以及时发现安全隐患。智慧幼儿园监管解决方案通过引入物联网、大数据、人工智能…
阅读更多...
C# IOC 容器实战：KeyedService和生命周期

C# IOC 容器实战：KeyedService和生命周期

文章目录 前言KeyedServiceKey缺少Key值覆盖 KeyedService.AnyKey生命周期测试代码 总结 前言 我之前写过一篇Ioc容器的使用&#xff0c;用的是微软的IOC容器。这次我们再去深入了解一下IOC 和控制反转 .NET Core 依赖注入 Microsoft.Extensions.DependencyInjection ASP.NET …
阅读更多...
josef约瑟 中间继电器 HJDZ-E440额定电压:AC220V 卡轨安装

josef约瑟 中间继电器 HJDZ-E440额定电压:AC220V 卡轨安装

HJDZ-静态中间继电器 系列型号&#xff1a; HJDZ-A200静态中间继电器&#xff1b;HJDZ-A110静态中间继电器&#xff1b; HJDZ-A002静态中间继电器&#xff1b;HJDZ-A004静态中间继电器&#xff1b; HJDZ-E112静态中间继电器&#xff1b;HJDZ-E112L静态中间继电器&#xff1…
阅读更多...
数据结构入门到入土——栈(Stack)和队列(Queue)

数据结构入门到入土——栈(Stack)和队列(Queue)

目录 一&#xff0c;栈&#xff08;Stack&#xff09; 1.1 概念 1.2 栈的使用 1.3 栈的模拟实现 1.4 栈的应用场景 1.5 栈&#xff0c;虚拟机栈&#xff0c;栈帧有什么区别&#xff1f; 二&#xff0c;队列&#xff08;Queue&#xff09; 2.1 概念 2.2 队列的使用 2.3 …
阅读更多...
luceda ipkiss教程 55：画螺旋型布拉格光栅

luceda ipkiss教程 55：画螺旋型布拉格光栅

案例分享, 画螺旋型布拉格光栅: 所有代码如下&#xff1a; from si_fab import all as pdk import ipkiss3.all as i3 from picazzo3.wg.spirals import FixedLengthSpiralRoundedgrating_size 0.7 grating_wg_width 1.2 wg_width 0.5 pitch 1.4 reference i3.LayoutCel…
阅读更多...
【HuggingFace Transformer库学习笔记】基础组件学习：Datasets

【HuggingFace Transformer库学习笔记】基础组件学习：Datasets

基础组件——Datasets datasets基本使用 导入包 from datasets import *加载数据 datasets load_dataset("madao33/new-title-chinese") datasetsDatasetDict({train: Dataset({features: [title, content],num_rows: 5850})validation: Dataset({features: [titl…
阅读更多...
【Web】NSSCTF Round#16 Basic个人wp(全)

【Web】NSSCTF Round#16 Basic个人wp(全)

出题友好&#xff0c;适合手生复健。 目录 ①RCE但是没有完全RCE ②了解过PHP特性吗 ①RCE但是没有完全RCE 上来就是一段md5八股 (string)就是不让用数组了&#xff0c;然后强比较需要md5碰撞 ?md5_1%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc…
阅读更多...
KVM Vcpu概述

KVM Vcpu概述

KVM Vcpu概述 Intel VTSMP系统CPU过载使用CPU模型CPU绑定和亲和性CPU优化 Intel VT Intel的硬件虚拟化技术大致分为3类&#xff1a; 1、VT-x技术&#xff1a;是指Intel处理器中的一些虚拟化技术支持&#xff0c;包括CPU中最基础的VMX技术&#xff0c;也包括内存虚拟化的硬件支…
阅读更多...
【LangChain学习之旅】—（7） 调用模型：使用OpenAI API还是微调开源Llama2/ChatGLM？

【LangChain学习之旅】—（7） 调用模型：使用OpenAI API还是微调开源Llama2/ChatGLM？

【LangChain学习之旅】—&#xff08;7&#xff09; 调用模型&#xff1a;使用OpenAI API还是微调开源Llama2/ChatGLM&#xff1f; 大语言模型发展史预训练 微调的模式用 HuggingFace 跑开源模型申请使用 Meta 的 Llama2 模型通过 HuggingFace 调用 LlamaLangChain 和 Hugging…
阅读更多...
PHP代码审计基础知识

PHP代码审计基础知识

前言 本文章主要是PHP代码审计的一些基础知识&#xff0c;包括函数的用法&#xff0c;漏洞点&#xff0c;偏向基础部分&#xff0c;个人能力有限&#xff0c;部分可能会出现错误或者遗漏&#xff0c;读者可自行补充。 代码执行 代码执行是代码审计当中较为严重的漏洞&…
阅读更多...
关于LwRB环形缓冲区开源库的纯C++版本支持原子操作

关于LwRB环形缓冲区开源库的纯C++版本支持原子操作

1、LwRB环形缓冲区开源库&#xff1a; GitHub - MaJerle/lwrb: Lightweight generic ring buffer manager libraryLightweight generic ring buffer manager library. Contribute to MaJerle/lwrb development by creating an account on GitHub.https://github.com/MaJerle/l…
阅读更多...
最新文章

Copyright @ 2022~2023