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

二叉树的实现

  • 前言
  • 一、二叉树链式结构的实现
    • 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.mzph.cn/news/762239.shtml

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

相关文章

个人网站制作 Part 14 添加网站分析工具 | Web开发项目

个人网站制作 Part 14 添加网站分析工具 | Web开发项目

文章目录 &#x1f469;‍&#x1f4bb; 基础Web开发练手项目系列&#xff1a;个人网站制作&#x1f680; 添加网站分析工具&#x1f528;使用Google Analytics&#x1f527;步骤 1: 注册Google Analytics账户&#x1f527;步骤 2: 获取跟踪代码 &#x1f528;使用Vue.js&#…
阅读更多...
实体框架EF（Entity Framework）简介

实体框架EF（Entity Framework）简介

实体框架EF&#xff08;Entity Framework&#xff09;简介 文章目录 实体框架EF&#xff08;Entity Framework&#xff09;简介一、概述二、O/R Mapping是什么采用O/R Mapping带来哪些好处 三、Entity Framework架构3.1 下图展示了Entity Framework的整体架构3.2 Entity Framew…
阅读更多...
MyBatis：XML操作

MyBatis：XML操作

&#x1f451;专栏内容&#xff1a;MyBatis⛪个人主页&#xff1a;子夜的星的主页&#x1f495;座右铭&#xff1a;前路未远&#xff0c;步履不停 目录 一、MyBatis XML方式1、配置数据库2、指明XML路径3、写持久层代码 二、基础操作1、新增2、删除3、更新4、查找Ⅰ、开启驼峰命…
阅读更多...
配置视图解析器

配置视图解析器

我们在指定视图的时候路径是有重复的&#xff0c;重复的操作可以用视图解析器&#xff0c;让框架帮我们&#xff1a; mv.setViewName("/WEB-INF/view/show.jsp");mv.setViewName("/WEB-INF/view/other.jsp"); 配置视图解析器&#xff1a; 注册视图解析器:帮…
阅读更多...
202112青少年软件编程（Scratch图形化）等级考试试卷（三级）

202112青少年软件编程（Scratch图形化）等级考试试卷（三级）

第1题：【 单选题】 下列程序哪个可以实现： 按下空格键， 播放完音乐后说“你好！ ” 2 秒？ （ ） A: B: C: D: 【正确答案】: C 【试题解析】 : 第2题：【 单选题】 执行下列程序， 变量 N 的值不可能是？ （ ） A:1 B:4 C:5 D:6 【正确答案】: D 【试题解析】…
阅读更多...
制作一个RISC-V的操作系统六-bootstrap program（risv 引导程序）

制作一个RISC-V的操作系统六-bootstrap program（risv 引导程序）

文章目录 硬件基本概念qemu-virt地址映射系统引导CSR![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/86461c434e7f4b1b982afba7fad0256c.png)machine模式下的csr对应的csr指令csrrwcsrrs mhartid引导程序做的事情判断当前hart是不是第一个hart初始化栈跳转到c语言的…
阅读更多...
分治法排序：原理与C语言实现

分治法排序：原理与C语言实现

分治法排序&#xff1a;原理与C语言实现 一、分治法与归并排序概述二、归并排序的C语言实现三、归并排序的性能分析四、归并排序的优化 在计算机科学中&#xff0c;分治法是一种解决问题的策略&#xff0c;它将一个难以直接解决的大问题&#xff0c;分割成一些规模较小的相同问…
阅读更多...
Expert Prompting-引导LLM成为杰出专家

Expert Prompting-引导LLM成为杰出专家

ExpertPrompting: Instructing Large Language Models to be Distinguished Experts 如果适当设计提示&#xff0c;对齐的大型语言模型&#xff08;LLM&#xff09;的回答质量可以显著提高。在本文中&#xff0c;我们提出了ExpertPrompting&#xff0c;以激发LLM作为杰出专家回…
阅读更多...
运动想象 (MI) 迁移学习系列 (14) : EEGNet-Fine tuning

运动想象 (MI) 迁移学习系列 (14) : EEGNet-Fine tuning

运动想象迁移学习系列:EEGNet-Fine tuning 0. 引言1. 主要贡献2. 提出的方法2.1 EEGNet框架2.2 微调 3. 实验结果3.1 各模型整体分类结果3.2 算法复杂度比较3.3 不同微调方法比较 4. 总结欢迎来稿 论文地址&#xff1a;https://www.nature.com/articles/s41598-021-99114-1#cit…
阅读更多...
【算法训练营】周测4

【算法训练营】周测4

清华大学驭风计划课程链接 学堂在线 - 精品在线课程学习平台 (xuetangx.com) 如果需要答案代码可以私聊博主 有任何疑问或者问题&#xff0c;也欢迎私信博主&#xff0c;大家可以相互讨论交流哟~~ 考题11-4 题目描述 输入格式 从标准输入读入数据。 输入第一行为两个正整…
阅读更多...
将main打包成jar；idea打包main为jar包运行

将main打包成jar；idea打包main为jar包运行

将main打包成jar&#xff1b;idea打包main为jar包运行 适用场景&#xff1a;可以封装一些小工具。 配置jar Maven中添加 <packaging>jar</packaging>将其打包为jar。 设置运行入口main 编译jar 看到jar输出 运行效果&#xff1a; 其中&#xff0c;三方依赖也被…
阅读更多...
【Unity】获取游戏对象或组件的常用方法

【Unity】获取游戏对象或组件的常用方法

前言 在Unity开发过程中&#xff0c;我们经常需要获取组件&#xff0c;那么在Unity里如何获取组件呢&#xff1f; 一、获取游戏对象 1.GameObject.Find GameObject.Find 是通过物体的名称获取对象的 所以会遍历当前整个场景&#xff0c;效率较低 而且只能获取激活状态的物体…
阅读更多...
pytorch多层感知机

pytorch多层感知机

目录 1. 多层感知机2. 多层感知机loss梯度推导3. pytorch示例 1. 多层感知机 有多个输入节点、多个中间节点和多个输出节点 2. 多层感知机loss梯度推导 3. pytorch示例
阅读更多...
MySQL 字段定义时的属性设置

MySQL 字段定义时的属性设置

开发的时候第一步就是建表&#xff0c;在创建表的时候&#xff0c;我们需要定义表的字段&#xff0c;每个字段都有一些属性&#xff0c;比如说是否为空&#xff0c;是否允许有默认值&#xff0c;是不是逐渐等。 这些约束字段的属性&#xff0c;可以让字段的值更符合我们的预期&…
阅读更多...
HCIP—BGP路由聚合

HCIP—BGP路由聚合

在大型网络中&#xff0c;路由条目通常多达成千上万条&#xff0c;甚至几十万条&#xff0c;这给路由设备带来的挑战是&#xff1a;如何存储并有效管理如此众多的路由信息&#xff1f; BGP是一种无类路由协议&#xff0c;支持CIDR、VLSM和路由聚合。路由聚合技术的使用…
阅读更多...
[Linux开发工具]——gcc/g++的使用

[Linux开发工具]——gcc/g++的使用

Linux编译器——gcc/g的使用 一、快速认识gcc/g二、程序的翻译过程2.1 预处理&#xff08;.i文件&#xff09;2.2 编译&#xff08;.s文件&#xff09;2.3 汇编&#xff08;.o文件&#xff09;2.4 链接&#xff08;生成可执行文件或库文件&#xff09; 三、认识函数库3.1 静态库…
阅读更多...
微调alpaca-lora遇到的一些问题

微调alpaca-lora遇到的一些问题

1、环境简介 环境&#xff1a; 系统&#xff1a;Ubuntu torch&#xff1a;2.2.1 python&#xff1a;3.10 gpu&#xff1a;V100 16g peft&#xff1a;0.9.0 使用PEFT中的lora方式微调llama-2-7b-hf&#xff0c;项目地址&#xff1a;alpaca-lora 2、混合精度训练Tensor相互计算会…
阅读更多...
Jupyter Notebook介绍、安装及使用教程

Jupyter Notebook介绍、安装及使用教程

Jupyter Notebook介绍、安装及使用教程 一、什么是Jupyter Notebook&#xff1f;简介组成部分网页应用文档Jupyter Notebook的主要特点 二、安装Jupyter Notebook先试用&#xff0c;再决定安装安装前提使用Anaconda安装使用pip命令安装 三、运行Jupyter Notebook帮助启动默认端…
阅读更多...
macOS 通过 MacPorts 正确安装 MySQL 同时解决无法连接问题

macOS 通过 MacPorts 正确安装 MySQL 同时解决无法连接问题

如果你通过 sudo port install 命令正常安装了 MySQL&#xff0c;再通过 sudo port load 命令启动了 MySQL Server&#xff0c;此刻却发现使用 Navicat 之类的 GUI 软件无法连接&#xff0c;始终返回无法连接到 127.0.0.1 服务器。这是一个小坑&#xff0c;因为他默认使用了 So…
阅读更多...
零代码编程：用kimichat将srt字幕文件进行批量转换合并

零代码编程：用kimichat将srt字幕文件进行批量转换合并

文件夹里面有多个srt字幕文件&#xff0c;借助kimichat可以很方便的对其进行批量合并。 在kimichat中输入提示词&#xff1a; 你是一个Python编程专家&#xff0c;写一个Python脚本&#xff0c;完成一个处理整理文档内容的任务&#xff0c;具体步骤如下&#xff1a; 打开文件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023