【408篇】C语言笔记-第十四章（ 二叉树的建树和遍历&考研真题实战）

已于 2022-12-14 23:20:29 修改
阅读量593 收藏 3
点赞数
分类专栏： 408考研-C语言 文章标签： c语言 考研 开发语言
于 2022-12-13 23:07:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45842494/article/details/128309431
版权

文章目录

第一节：树与二叉树原理解析

1. 树

树是n(n>=0)个节点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足：

  1. 有且仅有一个特定的称为根的结点。
  2. 当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2,……,Tm，其中每个集合本身又是一棵树，并且称为根的子树。

树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点：

  1. 树的根节点没有前驱，除根节点外的所有结点有且只有一个前驱。
  2. 树种所有的节点可以有零个或多个后继。

树的结构：

2. 二叉树

二叉树是另一种树形结构，其特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。

与树相似，二叉树也以递归的形式定义。二叉树是n(n>=0)个结点的有限集合：

  1. 或者为空的二叉树，即n=0.
  2. 或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树分别是一棵二叉树。

二叉树的顺序存储：

二叉树的链式存储：

树节点数据结构：

typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

树中任何一个结点都是一个结构体，它的空间我们通过malloc申请。

第二节：二叉树层次建树实战

function.h

//
// Created by Administrator on 2022/12/11.
//

#ifndef INC_14_4_TREE_FUNCTION_H
#define INC_14_4_TREE_FUNCTION_H
#include <stdio.h>
#include <stdlib.h>

typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

// tag结构体是辅助队列使用的
typedef struct tag{
    BiTree p;// 树的某一个结点的地址值
    struct tag *pnext;
}tag_t,*ptag_t;
#endif //INC_14_4_TREE_FUNCTION_H

main.cpp

#include "function.h"

int main() {
    BiTree pnew; // 新申请的树结点
    BiTree tree=NULL; // tree指向树根，代表树
    // 这些都是指针类型。phead就是队列头，ptail就是队列尾。listpnew指向新申请的结点，pcur指向当前放入数据的父节点
    ptag_t phead=NULL,ptail=NULL,listpnew=NULL,pcur=NULL;
    char c;
    while (scanf("%c",&c)){
        if(c=='\n'){
            break; // 读到换行就结束
        }
        // calloc申请的大小就是两个参数的乘积
        pnew= (BiTree)calloc(1, sizeof(BiTNode));
        pnew->c=c;
        listpnew= (ptag_t)calloc(1, sizeof(tag_t)); // 给队列结点申请空间
        listpnew->p=pnew;
        if(NULL==tree){
            tree=pnew;
            phead=listpnew; // 队列头和队列尾指向第一个结点
            ptail=listpnew;
            pcur=listpnew;// pcur要指向要进入树的父亲元素
        } else{
            // 把结点放入队列中
            ptail->pnext=listpnew;
            ptail=listpnew;
            // 把结点放入树中
            if(NULL==pcur->p->lchild){
                pcur->p->lchild=pnew;  // 父亲结点的左孩子为空
            } else if(NULL==pcur->p->rchild){
                pcur->p->rchild=pnew;  // 父亲结点的右孩子为空
                pcur=pcur->pnext;  // 左右结点都满了，pcur指向下一个
            }
        }
    }
    return 0;
}

F:\Computer\Project\practice\14\14.4-tree\cmake-build-debug\14_4_tree.exe
abcdefghijk

进程已结束，退出代码为 0

原理图：

解析：

  1. listpnew始终指向新申请的空间。phead始终指向队列的头结点，ptail始终指向队列尾结点。pcur始终指向队列最后一个元素对应的父结点，比如i的父结点为d。
  2. 每次有新的元素，先将元素放入队列，ptail向后移。然后pcur指针对应的节点会判断左右两个孩子节点是否为空，如果左为空，就放入左孩子。如果右为空，就放入右孩子。然后再次向后移。
  3. pnew和tree是结构体类型。phead,ptail,listpnew,pcur是结构体指针类型。

第三节：二叉树前、中、后序遍历

在上一节建树的基础上增加前、中、后序遍历。

前序遍历：先打印自身，再打印左子树，然后打印右子树。

中序遍历：先打印左子树，再打印自身，然后打印右子树。

后序遍历：先打印左子树，再打印右子树，然后打印自身。

前序遍历也叫深度优先遍历。

function.h

//
// Created by Administrator on 2022/12/11.
//

#ifndef INC_14_4_TREE_FUNCTION_H
#define INC_14_4_TREE_FUNCTION_H
#include <stdio.h>
#include <stdlib.h>

typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

// tag结构体是辅助队列使用的
typedef struct tag{
    BiTree p;// 树的某一个结点的地址值
    struct tag *pnext;
}tag_t,*ptag_t;
#endif //INC_14_4_TREE_FUNCTION_H

main.cpp

#include "function.h"

// 前序遍历
void PreOrder(BiTree p){
    if(p!=NULL){
        putchar(p->c);  // 打印自身
        PreOrder(p->lchild); // 打印左子树
        PreOrder(p->rchild); // 打印右子树
    }
}
// 中序遍历
void InOrder(BiTree p){
    if(p!=NULL){
        InOrder(p->lchild);
        putchar(p->c);
        InOrder(p->rchild);
    }
}
// 后序遍历
void PostOrder(BiTree p){
    if(p!=NULL){
        PostOrder(p->lchild);
        PostOrder(p->rchild);
        putchar(p->c);
    }
}
int main() {
    BiTree pnew; // 新申请的树结点
    BiTree tree=NULL; // tree指向树根，代表树
    // 这些都是指针类型。phead就是队列头，ptail就是队列尾。listpnew指向新申请的结点，pcur指向当前放入数据的父节点
    ptag_t phead=NULL,ptail=NULL,listpnew=NULL,pcur=NULL;
    char c;
    // abcdefghij
    while (scanf("%c",&c)){
        if(c=='\n'){
            break; // 读到换行就结束
        }
        // calloc申请的大小就是两个参数的乘积
        pnew= (BiTree)calloc(1, sizeof(BiTNode));
        pnew->c=c;
        listpnew= (ptag_t)calloc(1, sizeof(tag_t)); // 给队列结点申请空间
        listpnew->p=pnew;
        if(NULL==tree){ // 判断是否有跟结点
            tree=pnew;
            phead=listpnew; // 队列头和队列尾指向第一个结点
            ptail=listpnew;
            pcur=listpnew;// pcur要指向要进入树的父亲元素
        } else{
            // 把结点放入队列中
            ptail->pnext=listpnew;
            ptail=listpnew;
            // 把结点放入树中
            if(NULL==pcur->p->lchild){
                pcur->p->lchild=pnew;  // 父亲结点的左孩子为空
            } else if(NULL==pcur->p->rchild){
                pcur->p->rchild=pnew;  // 父亲结点的右孩子为空
                pcur=pcur->pnext;  // 左右结点都满了，pcur指向下一个
            }
        }
    }

    printf("--------PreOrder-----------\n");
    PreOrder(tree);
    printf("\n--------InOrder-----------\n");
    InOrder(tree);
    printf("\n--------PostOrder-----------\n");
    PostOrder(tree);
    return 0;
}

"F:\Computer\Project\practice\14\14.5-tree - front-in-end\cmake-build-debug\14_4_tree.exe"
abcdefghij
--------PreOrder-----------
abdhiejcfg
--------InOrder-----------
hdibjeafcg
--------PostOrder-----------
hidjebfgca
进程已结束，退出代码为 0

前序，中序，后序其实就是使用递归的思想，传入一个结点，按照顺序打印出来即可。

第四节：二叉树的层序遍历

层序遍历必须使用到辅助队列。

在上一节的基础上新增加了层序遍历函数LevelOrder。

层序遍历也叫层次遍历，也叫广度优先遍历。

function.h

//
// Created by Administrator on 2022/12/11.
//

#ifndef INC_14_4_TREE_FUNCTION_H
#define INC_14_4_TREE_FUNCTION_H
#include <stdio.h>
#include <stdlib.h>

typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

// tag结构体是辅助队列使用的
typedef struct tag{
    BiTree p;// 树的某一个结点的地址值
    struct tag *pnext;
}tag_t,*ptag_t;

// 队列相关的结构体
typedef BiTree ElemType;
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct {
    LinkNode *front,*rear; // 链表头，链表尾
}LinkQueue; // 先进先出
void InitQueue(LinkQueue &Q);
void EnQueue(LinkQueue &Q,ElemType x);
bool DeQueue(LinkQueue &Q,ElemType &x);
bool IsEmpty(LinkQueue &Q);
#endif //INC_14_4_TREE_FUNCTION_H

queue.cpp

#include "function.h"

// 初始化队列
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode*) malloc(sizeof(LinkNode)); // 头和尾指向同一个结点
    Q.front->next=NULL; // 头结点的next指针为NULL
}

// 入队 尾部插入法
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode*) malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s; // rear始终指向尾部
    Q.rear=s;
}

// 出队 头部删除法
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear){
        return false; // 队列尾空
    }
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;  // 断链
    if(Q.rear==p){
        Q.rear=Q.front; // 队列置为空
    }
    free(p);
    return true;
}
// 判空函数
bool IsEmpty(LinkQueue &Q){
    if(Q.front==Q.rear){
        return true;
    } else{
        return false;
    }
}

main.cpp

#include "function.h"

// 前序遍历  也叫深度优先遍历
void PreOrder(BiTree p){
    if(p!=NULL){
        putchar(p->c);  // 打印自身
        PreOrder(p->lchild); // 打印左子树
        PreOrder(p->rchild); // 打印右子树
    }
}
// 中序遍历
void InOrder(BiTree p){
    if(p!=NULL){
        InOrder(p->lchild);
        putchar(p->c);
        InOrder(p->rchild);
    }
}
// 后序遍历
void PostOrder(BiTree p){
    if(p!=NULL){
        PostOrder(p->lchild);
        PostOrder(p->rchild);
        putchar(p->c);
    }
}
// 层次遍历，也叫广度优先遍历
void LevelOrder(BiTree T){
    LinkQueue Q; // 辅助队列
    InitQueue(Q);
    BiTree p;
    EnQueue(Q,T); // 树根入队
    while (!IsEmpty(Q)){
        DeQueue(Q,p); // 出队当前结点并打印
        putchar(p->c);
        if(p->lchild!=NULL){ // 入队左孩子
            EnQueue(Q,p->lchild);
        }
        if(p->rchild!=NULL){ // 入队右孩子
            EnQueue(Q,p->rchild);
        }
    }
}
int main() {
    BiTree pnew; // 新申请的树结点
    BiTree tree=NULL; // tree指向树根，代表树
    // 这些都是指针类型。phead就是队列头，ptail就是队列尾。listpnew指向新申请的结点，pcur指向当前放入数据的父节点
    ptag_t phead=NULL,ptail=NULL,listpnew=NULL,pcur=NULL;
    char c;
    // abcdefghij
    while (scanf("%c",&c)){
        if(c=='\n'){
            break; // 读到换行就结束
        }
        // calloc申请的大小就是两个参数的乘积
        pnew= (BiTree)calloc(1, sizeof(BiTNode));
        pnew->c=c;
        listpnew= (ptag_t)calloc(1, sizeof(tag_t)); // 给队列结点申请空间
        listpnew->p=pnew;
        if(NULL==tree){ // 判断是否有跟结点
            tree=pnew;
            phead=listpnew; // 队列头和队列尾指向第一个结点
            ptail=listpnew;
            pcur=listpnew;// pcur要指向要进入树的父亲元素
        } else{
            // 把结点放入队列中
            ptail->pnext=listpnew;
            ptail=listpnew;
            // 把结点放入树中
            if(NULL==pcur->p->lchild){
                pcur->p->lchild=pnew;  // 父亲结点的左孩子为空
            } else if(NULL==pcur->p->rchild){
                pcur->p->rchild=pnew;  // 父亲结点的右孩子为空
                pcur=pcur->pnext;  // 左右结点都满了，pcur指向下一个
            }
        }
    }

    printf("--------PreOrder-----------\n");
    PreOrder(tree);
    printf("\n--------InOrder-----------\n");
    InOrder(tree);
    printf("\n--------PostOrder-----------\n");
    PostOrder(tree);
    printf("\n--------LevelOrder-----------\n");
    LevelOrder(tree);
    return 0;
}

"F:\Computer\Project\practice\14\14.6-tree - cengxubianli\cmake-build-debug\14_4_tree.exe"
abcdefghij
--------PreOrder-----------
abdhiejcfg
--------InOrder-----------
hdibjeafcg
--------PostOrder-----------
hidjebfgca
--------LevelOrder-----------
abcdefghij
进程已结束，退出代码为 0

总结：

  1. 前序遍历也叫深度优先遍历。
  2. 层序遍历也叫层次遍历，也叫广度优先遍历。
  3. 层序遍历使用到了辅助队列。
  4. 每一种遍历方式均使用到了递归的思想。
  5. 前中后序遍历是对于每一棵树来说，按照它的本身，左子树，右子树的相应的顺序打印出来。
  6. 层序遍历是按照树从上到下一层一层打印。

第五节：考研真题解析

解析：

树的带权路径长度（Weighted Length of Tree），简记为WPL。

二叉树的带权路径长度为每个叶子结点的深度与权值之积的总和。

使用先序遍历或层次遍历解决问题。

解答：

1）算法的基本设计思想：

基于先序递归遍历的算法思想，用一个static变量记录wpl，把每个结点的深度作为递归函数的一个参数传递。步骤如下：

若该结点是叶子结点，那么变量wpl加上该结点深度与权值之积。

如该结点非叶子结点，那么若左子树不为空，对左子树调用递归算法。若右子树不为空，对右子树调用递归算法。深度参数均为本节点的深度参数加1。最后返回计算出的wpl即可。

2）二叉树结点的数据类型定义如下：

typedef int BiElemType;
typedef struct BiTNode{
    BiElemType weight;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

3）代码实现如下：

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

typedef int BiElemType;
typedef struct BiTNode{
    BiElemType weight;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

typedef struct tag{
    BiTree p; // 树的某一个结点的地址值
    struct tag *pnext;
}tag_t,*ptag_t;


int wpl_PreOrder(BiTree root,int deep){
    // wpl为静态局部变量，类似于全局变量，只会初始化一次
    static int wpl=0;
    if(root->lchild==NULL && root->rchild==NULL){
        // 若为叶子节点，累计wpl
        wpl+=deep*root->weight;
    }
    if(root->lchild!=NULL){
        wpl_PreOrder(root->lchild,deep+1);
    }
    if(root->rchild!=NULL){
        wpl_PreOrder(root->rchild,deep+1);
    }
    return wpl;
}

int WPL(BiTree root){
    return wpl_PreOrder(root,0);
}

int main() {
    BiTree pnew;
    int i,j,pos;
    char c;
    BiTree tree=NULL;// 树根
    ptag_t phead=NULL,ptail=NULL,listpnew=NULL,pcur=NULL; // phead就是队列头，ptail就是队列尾。
    // 1234567
    while (scanf("%c",&c)){
        if(c=='\n'){
            break;
        }
        pnew= (BiTree)calloc(1, sizeof(BiTNode)); // calloc申请空间并对空间进行初始化，赋值为0
        pnew->weight=c; // 数据传进去
        listpnew= (ptag_t)calloc(1, sizeof(tag_t));
        listpnew->p=pnew;
        if(NULL==tree){
            tree=pnew; // 树的跟
            phead=listpnew;// 队列头
            ptail=listpnew; // 队列尾
            pcur=listpnew;
            continue;
        } else{
            ptail->pnext=listpnew; // 新结点放入链表，通过尾插法
            ptail=listpnew;
        }
        // pcur始终指向要插入的节点的位置
        if(NULL==pcur->p->lchild){ // 如何把新结点放到要插入的节点的左边
            pcur->p->lchild=pnew;
        } else if(NULL==pcur->p->rchild){
            pcur->p->rchild=pnew; // 把新结点放到插入节点的右边
            pcur=pcur->pnext; // 左右都放了节点，pcur指向队列的下一个
        }
    }
    printf("%d\n",WPL(tree));
    return 0;
}

F:\Computer\Project\practice\14\14.7-2014-41\cmake-build-debug\14_7_2014_41.exe
1234567
428

进程已结束，退出代码为 0

说明：对于初试不需要写全部代码，写出WPL和wpl_PreOrder两个子函数即可。

傻啦猫@_@
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C语言二叉树遍历实例】C语言二叉树遍历实例
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
数据结构第五章-树与二叉树 二叉树的C语言实现代码
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到... - 求二叉树第K层结点数的递归实现 - 求二叉树叶结点数的递归实现 - 功能测试函数的实现——通过层序遍历创建二叉树、创建BST 3. 队列基本功能实现文件
C语言-中级阶段-14二叉树的建树和遍历&考研真题实战
monkey_body的博客
09-05 87
1.二叉树的存储* 树结点数据结构2.二叉树层次建树原理分析。
【408篇】C语言笔记-第十五章（ 考研必会的查找算法&考研真题实战）
weixin_45842494的博客
12-20 584
折半查找的基本思想：首先将给定值key与表中中间位置的元素比较，若相等，则查找成功，返回该元素的存储位置；compare：比较规则，需要我们传递一个函数名，这个函数由我们自己编写，返回值必须是int类型，形参是两个void类型指针，这个函数我们编写，但是是qsort内部调用的，相当于我们传递一种行为给qsort。b.若ab，则舍弃序列A中较大的一半，同时舍弃序列B中较小的一半，要求舍弃的长度相等。
根据前序遍历和中序遍历创建二叉树
MitchHong的博客
08-18 7100
Contents前言四种遍历树的方法简介简介两种快速获得遍历结果的方法根据前序遍历和后续遍历创建树代码实现四种遍历树的方法的代码前言昨天参加了两场笔试，都考了这个题。第一场是根据pre_...
6_7二叉树的层序遍历uva122（刷题笔记）
abc1152028936的博客
03-06 331
但如果一旦执行，就再也无法找到先前的那些内存了，使用不到，但是那些内存依然存在，这就称为—内存泄露，意味着有一些内存被白白浪费了。分析题意，需要采用动态结构，根据需要建立新的节点，首先识别输入数据（节点值、路径方向），再将其建立成树，然后使用队列实现层序遍历。若字符串1<字符串2，则函数返回一个负数。以输入(11,LL)为例，则&s[1]即为11,LL)，sscanf将读入的字符串解析为%d，并存入v中。输入输出函数，作用是从一个字符串中提取字符串、浮点数、整数等值，并将其保存到指定的变量中。
C语言数据结构二叉树的建立，前序后序层序和中序创建二叉树
qq1263152915菜鸟小波的博客
07-10 2391
二叉树定义 二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态： (1)空二叉树——如图(a)； (2)只有一个根结点的二叉树——如图(b)； (3)只有左子树——如图©； (4)只有右子树——如图(d)； (5)完全二叉树——如图(e)。 注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。 [1]...
二叉树非递归遍历
wywzb的博客
04-26 241
最后贴上我上一个帖子写的dfs代码，dfs（递归深搜）是真好用啊（doge）（树的图片在我另外一篇文章二叉树遍历里面有，不过各位ｄａｌａｏ应该能一眼看出来（膜拜））再往下就是纯c语言版的代码了，鼠鼠我啊偷懒用AI转换了下，不得不说，是真强大啊！
【数据结构初学笔记11】第三章二叉树MOOC练习题
m0_50662459的博客
10-29 367
浙江大学慕课MOOC数据结构学习笔记第三章PTA练习题
数据结构（C语言版） 第 五 章 树与二叉树 知识梳理 + 作业习题详解
热门推荐
繁凡さん的博客
05-18 2万+
目录树和二叉树一.树2.有序树和无序树3.森林4.树的基本性质 本系列博客为《数据结构》（C语言版）的学习笔记（上课笔记），仅用于学习交流和自我复习 数据结构合集链接： 《数据结构》C语言版（严蔚敏版） 全书知识梳理（超详细清晰易懂） 树和二叉树 一.树 树：是N(N≥0)个结点的有限集合，N=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当N>1时，其余结点可分为m(m>0)个互不相交的有限集合T1,T2,…,Tm，其中每一个集合本身
(六)C语言中阶--二叉树
m0_57093468的博客
12-03 314
树，二叉树，前序遍历，中序遍历，后序遍历，层序遍历
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先...
erchashu.rar_C语言 二叉树 遍历 C语言_二叉树遍历
09-22
本文将深入探讨C语言中实现二叉树遍历的方法，包括先根遍历、中根遍历和后根遍历，并通过程序分析帮助理解这些概念。 **先根遍历（Preorder Traversal）** 先根遍历的顺序是：先访问根节点，然后递归地遍历左子树，...
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
C/C++进阶 （8）哈希表（STL）
敲代码嘞~的博客
07-24 853
个人主页：专题分栏：本文着重于模拟实现哈希表，并非是哈希表的使用。实现的哈希表的底层用的是线性探测法，并非是哈希桶。
嵌入式初学-C语言-前言
MaBaB的博客
07-24 1062
原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如：如果是8位二进制：[+1]原= 0000 0001[-1]原= 1000 0001第一位是符号位，因为第一位是符号位，所以8位二进制数的取值范围就是：（即第一位不表示值，只表示正负。[1111 1111 , 0111 1111] 即 [-127 , 127]原码是人脑最容易理解和计算的表示方式。
西电网络空间安全综合953考研分享||西安电子科技大学
最新发布
qq_30953547的博客
07-24 849
线代看的是李永乐的强化视频，资料用的他的《线性代数辅导讲义》，说到他的这本书，真的特别推荐，而且老师真的讲得非常非常好，这本书强化复习我看了两遍，后期做真题的时候遇到忘记的知识点也经常翻，它每章节前都有一个知识框架，复习每一章节之前，可以先看框架，然后再看知识点和对应的题型总结，每章节过完可以做一下后面的练习题。做完上册之后，针对自己的不擅长的题型，去看武忠祥老师的17堂课，他这个是类似专项练习，不需要全看，只挑着自己不擅长的部分看看就可以。英语血的教训，不要拉下阅读，不要拉下阅读，不要拉下阅读！
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1241
主流开发语言和开发环境介绍
根据二叉树打印前序遍历和中序遍历,后序遍历C语言代码
11-25
以下是根据二叉树打印前序遍历、中序遍历和后序遍历的C语言代码： 前序遍历： ```c void preorderTraversal(struct TreeNode* root){ if(root == NULL){ return; } printf("%d ", root->val); // 输出当前结点 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

傻啦猫@_@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值