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

李斯啦果2024-01-18 14:16

目录

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

2.层序遍历

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

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

5.求二叉树的高度

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

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

8.单值二叉树

9.二叉树最大深度

10.翻转二叉树

[11. 检查两颗树是否相同](#11. 检查两颗树是否相同)

[12. 对称二叉树](#12. 对称二叉树)

[13. 另一颗树的子树](#13. 另一颗树的子树)

14.二叉树的前序遍历

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

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

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

18.二叉树销毁

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

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

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

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

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

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

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

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

cpp 复制代码 
#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;
}

输出结果如下：


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

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

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

}

2.层序遍历

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

📖Note：

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

cpp 复制代码 
// 队列的定义
typedef struct QueueNode
{
    TreeNode* data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;
cpp 复制代码 
// 层序遍历
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);
}

队列相关操作如下：

cpp 复制代码 
//队列初始化
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，不能求出二叉树的长度

cpp 复制代码 
//求二叉树节点个数
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

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

}

正确的定义与调用

cpp 复制代码 
#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

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

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

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

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

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

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

cpp 复制代码 
//二叉树叶子节点的个数
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

cpp 复制代码 
//二叉树的高度
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层节点个数

cpp 复制代码 
//二叉树第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的节点，则返回

cpp 复制代码 
//二叉树查找值为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

cpp 复制代码 
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加左右子树中深度较大者

cpp 复制代码 
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️⃣使用递归实现

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

cpp 复制代码 
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️⃣层序遍历法

层序遍历法基于队列实现

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

cpp 复制代码 
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️⃣对于两颗非空树，先判断它们根节点的值是否相同，不相同则它们是不相同的树，相同则转换成子问题：依次比较它们的左右子树。当左右子树都相同时它们为相同的树

cpp 复制代码 
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️⃣对于不止一个节点的树，如果其为对称的树，则其右子树翻转后和左子树是相同的树，这里需要用到我们已经写过的翻转二叉树和判断相同的树的函数

cpp 复制代码 
 //相同的二叉树
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️⃣当两棵树不相同时，递归判断主树的左子树与右子树是否与已知子树相同，只要左子树或右子树中存在与已知子树相同的树，则已知子树为主树的子树

cpp 复制代码 
//另一棵树的子树
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，所以采用参数的形式定义。

cpp 复制代码 
//求二叉树节点个数
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)

题目分析：

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

cpp 复制代码 
#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，则跳出循环，判断后续队列中是否存在非空节点，不存在则为完全二叉树，否则为非完全二叉树。

cpp 复制代码 
//判断一棵树是否为完全二叉树
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

cpp 复制代码 
//二叉树的最大高度
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️⃣二叉树的销毁转换成分治子问题：采用后续遍历二叉树的框架，对每一个节点，先释放左子树所占用的空间，再释放右子树所占用的空间，最后释放根节点所占用的空间

cpp 复制代码 
//二叉树的额销毁
void BinaryTreeDestroy(TreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    
    BinaryTreeDestroy(root->left);
    BinaryTreeDestroy(root->right);
    free(root);
}
相关推荐
zsc_11821 分钟前
(C++回溯算法)微信小程序“开局托儿所”游戏
c++·算法·游戏
攻城狮7号1 小时前
【5.7】指针算法-快慢指针解决环形链表
数据结构·c++·算法·链表
L_cl1 小时前
数据结构与算法——Java实现 51.力扣700题——二叉搜索树中的搜索操作
算法·leetcode·职场和发展
passer__jw7671 小时前
【LeetCode】【算法】160.相交链表
算法·leetcode·链表
观音山保我别报错1 小时前
C语言中的希尔排序
c语言·算法·排序算法
白榆maple1 小时前
(蓝桥杯C/C++）——基础算法(上）
c语言·c++·算法·蓝桥杯
道亦无名1 小时前
WAPI加密算法
算法
q567315231 小时前
Python 中的字符串匹配算法
android·java·javascript·python·算法
C++忠实粉丝2 小时前
Linux系统基础-多线程超详细讲解(5)_单例模式与线程池
linux·运维·服务器·c++·算法·单例模式·职场和发展
2401_877158732 小时前
什么是垃圾回收（Garbage Collection）?
java·开发语言·算法
热门推荐
01Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04制冷毛细管的计算方法介绍05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】09RAG 实践- Ollama+RagFlow 部署本地知识库10MacBook外接键盘修改键位