【笔记】线索二叉树

最新推荐文章于 2024-07-29 08:47:18 发布
最新推荐文章于 2024-07-29 08:47:18 发布
阅读量746 收藏 18
点赞数 5
分类专栏： 基础整理 数据结构 文章标签： 线索二叉树 线索化二叉树 遍历线索二叉树 线索二叉树应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cbwem/article/details/78383731
版权

  采用二叉链表作为二叉树的存储结构，只能找到结点的左、右孩子结点，而不能直接找到该结点的直接前驱和后继结点信息，这种信息只能在对二叉树的遍历过程中才能找到，显然这不是最直接、最简便的方法。为了能快速找到任何一个结点的直接前驱和后继结点信息，需要对二叉树进行线索化。

1.线索二叉树的概念

  为了能快速找到任何一个结点的直接前驱和后继结点信息，可以在二叉链表结点中增加两个指针域，一个用来指示结点的前驱， 另一个用来指向结点的后继。如果这样做，需要为每个结点增加两个指针域，一个用来指示结点的前驱，另一个用来指向结点的后继。但这样做需要为每个结点增加两个域的存储单元，也会使结点结构的利用率大大下降。
  在二叉链表的存储结构中，n个结点的二叉链表需要2n个指针域，其中只有n-1个用来表示结点的左右子树，其余n+1个指针域为空。为了不浪费存储空间，设法把这些空链域利用起来，存储结点的直接前驱和直接后继的信息。
  假定若结点存在左子树，则指针域lchild指示其左孩子结点，否则指针域lchild指示其直接前驱结点；若结点存在右子树，则指针域rchild指示右孩子结点，否则指针域lchild指示其直接后继结点。
  另外增加两个标志域ltag和rtag，分别用来区分指针域指向的是左孩子结点还是直接前驱结点，右孩子结点还是直接后继结点。当ltag=0时，lchild指示结点的左孩子；当ltag=1时，lchild指示结点的直接前驱结点。当rtag=0时，rchild指示结点的右孩子；当rtag=1时，rchild指示结点的直接后继结点。


这里写图片描述

  由这种存储结构构成的二叉链表称为二叉树的线索二叉树，采用这种存储结构的二叉链表称为线索链表。其中，指向结点直接前驱和直接后继的指针称为线索。二叉树按照某种遍历方式使二叉树变为线索二叉树的过程称为二叉树的线索化。


这里写图片描述

  线索二叉树的存储结构类型描述为：

typedef char DataType;              
typedef enum {Link,Thread}PointerTag;
typedef struct Node/*结点类型*/
{
    DataType data;
    struct Node *lchild, *rchild;   /*左右孩子子树*/
    PointerTag ltag,rtag;           /*线索标志域*/
}BiThrNode; 
typedef BiThrNode *BiThrTree;       /*二叉树类型*/

2.线索化二叉树

  在二叉树的遍历过程中，可得到结点的前驱信息和后继信息，同时将结点的空指针域修改为其直接前驱或直接后继信息。因此二叉树的线索化就是对二叉树的遍历过程。下面以中序线索化为例介绍二叉树的线索化。
  为了便于算法操作，在二叉链表中增加一个头结点，头结点的数据域可以存放二叉树的结点信息，也可以为空。令头结点的指针域lchild指向二叉树的根结点，指针域rchild指向二叉树中序遍历时的最后一个结点。在初始化时，使二叉树的头结点指针域rchild指向头结点自身，并将头结点的标志域ltag置为Link，标志域rtag置为Thread。
  线索化后的二叉树像一个循环链表，既可以从线索二叉树的第一个结点出发沿着结点的后继线索指针遍历整个二叉树，也可以从线索二叉树中的第一个结点出发沿着结点的后继线索指针遍历整个二叉树，也可以从线索二叉树的最后一个结点出发沿着结点的前驱线索指针遍历整个二叉树。


这里写图片描述

  中序线索二叉树的算法实现如下：

BiThrTree pre;  
int InOrderThreading(BiThrTree *Thrt,BiThrTree T)
/*通过中序遍历二叉树T，使T中序线索化。Thrt是指向头结点的指针*/
{ 

    if(!(*Thrt=(BiThrTree)malloc(sizeof(BiThrNode)))) /*为头结点分配内存单元*/
        exit(-1);
    /*将头结点线索化*/
    (*Thrt)->ltag=Link;             /*修改前驱线索标志*/
    (*Thrt)->rtag=Thread;           /*修改后继线索标志*/
    (*Thrt)->rchild=*Thrt;          /*将头结点的rchild指针指向自己*/
    if(!T)                          /*如果二叉树为空，则将lchild指针指向自己*/
        (*Thrt)->lchild=*Thrt;
    else
    { 
        (*Thrt)->lchild=T;          /*将头结点的左指针指向根结点*/
        pre=*Thrt;                  /*将pre指向已经线索化的结点*/
        InThreading(T);             /*中序遍历进行中序线索化*/
        /*将最后一个结点线索化*/
        pre->rchild=*Thrt;          /*将最后一个结点的右指针指向头结点*/
        pre->rtag=Thread;           /*修改最后一个结点的rtag标志域*/        
        (*Thrt)->rchild=pre;        /*将头结点的rchild指针指向最后一个结点*/
    }
    return 1;
}

void InThreading(BiThrTree p)
/*二叉树中序线索化*/
{ 
    if(p)
    {
        InThreading(p->lchild); /*左子树线索化*/
        if(!p->lchild)              /*前驱线索化*/
        {
            p->ltag=Thread;
            p->lchild=pre;
        }
        if(!pre->rchild)            /*后继线索化*/
        {
            pre->rtag=Thread;
            pre->rchild=p;
        }
        pre=p;                      /*pre指向的结点线索化完毕，使p指向的结点成为前驱*/
        InThreading(p->rchild); /*右子树线索化*/
    }
}

3.遍历线索二叉树

  遍历线索二叉树就是根据线索查找结点的前驱和后继。

在中序线索二叉树中查找结点的直接前驱

  在中序线索二叉树中，结点*p的直接前驱就是其左子树的最右下端结点。若p->ltag=1，那么p->lchild指向的结点就是p的直接前驱结点。

BiThrNode *InOrderPre(BiThrNode *p)
/*在中序线索树中找结点*p的中序直接前趋*/
{
    BiThrNode *pre;
    if (p->ltag==Thread)        /*如果p的标志域ltag为线索，则p的左子树结点即为前驱*/
        return p->lchild; 
    else{ 
        pre=p->lchild;          /*查找p的左孩子的最右下端结点*/
        while (pre->rtag==Link) /*右子树非空时，沿右链往下查找*/
            pre=pre->rchild;
        return pre;             /*pre就是最右下端结点*/
    }
}

在中序线索二叉树中查找结点的直接后继

  在中序线索二叉树中，查找结点*p的中序直接后继与查找结点的直接前驱类似。若p->rtag=1，那么p->rchild指向的结点就是p的直接后继结点。

BiThrNode *InOrderPost(BiThrNode *p)
/*在中序线索树中查找结点*p的中序直接后继*/
{
    BiThrNode *pre;
    if (p->rtag==Thread)        /*如果p的标志域ltag为线索，则p的右子树结点即为后继*/
        return p->rchild; 
    else
    { 
        pre=p->rchild;          /*查找p的右孩子的最左下端结点*/
        while (pre->ltag==Link) /*左子树非空时，沿左链往下查找*/
            pre=pre->lchild; 
        return pre;             /*pre就是最左下端结点*/
    }
}

中序遍历线索二叉树

  中序遍历线索二叉树可分为3步：

  1. 从根结点出发，找到二叉树的最左下端结点并访问；
  2. 判断该结点的右标志域是否为线索指针，若为线索指针即p->rtag=Thread，表明p->rchild指向的是后继节点，则将指针移动到右孩子结点；
  3. 将当前指针指向该右孩子结点。

  重复以上3步，就可访问完二叉树中的所有结点。中序遍历线索二叉树的过程就是线索查找后继和查找右子树的最左下端结点的过程。

int InOrderTraverse(BiThrTree T,int (* visit)(BiThrTree e))
/*中序遍历线索二叉树。其中visit是函数指针，指向访问结点的函数实现*/
{
    BiThrTree p;
    p=T->lchild;                            /*p指向根结点*/
    while(p!=T)                             /*空树或遍历结束时，p==T*/
    {
        while(p->ltag==Link) 
            p=p->lchild;
        if(!visit(p))                           /*打印*/
            return 0;       
        while(p->rtag==Thread&&p->rchild!=T)    /*访问后继结点*/
        {
            p=p->rchild;
            visit(p);
        }
        p=p->rchild;
    }
    return 1;
}

  结论：对于中序线索二叉树，若ltag=0，则直接前驱为左子树的最右下端结点；若rtag=0，则其直接后继为右子树的最左下端结点。

在后续线索二叉树中查找后继结点

  在后续线索二叉树中查找后继结点较复杂些，分为3种情况：若结点x是二叉树的根，则其后继为空；若结点x是其双亲结点的有孩子或者是双亲结点的左孩子且双亲没有有孩子，则其后继即为双亲结点；若结点x是其双亲结点的左孩子，且其双亲有右孩子，则其后继为双亲的右子树上按后序遍历得到的第一个结点。

4.线索二叉树应用示例

  创建如下图所示的二叉树，并将其中序线索化。任给一个结点，要求查找该结点的直接前驱和直接后继。例如，结点F的直接前驱是A，其直接后继是I。


这里写图片描述 

#include <stdio.h>
#include <malloc.h>
#include<stdlib.h>
#define MaxSize 100 
/*线索二叉树类型定义*/
typedef char DataType;              
typedef enum {Link,Thread}PointerTag;
typedef struct Node/*结点类型*/
{
    DataType data;
    struct Node *lchild, *rchild;                   /*左右孩子子树*/
    PointerTag ltag,rtag;                           /*线索标志域*/
}BiThrNode; 
typedef BiThrNode *BiThrTree;                       /*二叉树类型*/
/*函数声明*/
void CreateBitTree2(BiThrTree *T,char str[]);           /*创建线索二叉树*/
void InThreading(BiThrTree p);                      /*中序线索化二叉树*/
int InOrderThreading(BiThrTree *Thrt,BiThrTree T);      /*通过中序遍历二叉树T，使T中序线索化。Thrt是指向头结点的指针*/
int InOrderTraverse(BiThrTree T,int (* visit)(BiThrTree e));        /*中序遍历线索二叉树*/
int Print(BiThrTree T);                             /*打印二叉树中的结点及线索标志*/
BiThrNode *FindPoint(BiThrTree T,DataType e);       /*在线索二叉树中查找结点为e的指针*/
BiThrNode *InOrderPre(BiThrNode *p);                /*查找中序线索二叉树的中序前驱*/
BiThrNode *InOrderPost(BiThrNode *p);               /*查找中序线索二叉树的中序后继*/
BiThrTree pre;                                      /*pre始终指向已经线索化的结点*/
void DestroyBitTree(BiThrTree *T);/*销毁线索二叉树*/
void main()
/*测试程序*/
{ 
    DataType ch;
    BiThrTree T,Thrt;
    BiThrNode *p,*pre,*post;
    CreateBitTree2(&T,"(A(B(D,E(H)),C(F(,I),G)))");
    printf("输出线索二叉树的结点、前驱及后继信息：\n");
    InOrderThreading(&Thrt,T);
    printf("序列   前驱标志   结点  后继标志\n");
    InOrderTraverse(Thrt,Print);
    printf("请输入要查找哪个结点的前驱和后继:");
    ch=getchar();
    p=FindPoint(Thrt,ch);
    pre=InOrderPre(p);
    printf("元素%c的中序直接前驱元素是:%c\n",ch,pre->data);
    post=InOrderPost(p);
    printf("元素%c的中序直接后继元素是:%c\n",ch,post->data);
    DestroyBitTree(&Thrt);
}
int Print(BiThrTree T)
/*打印线索二叉树中的结点及线索*/
{
    static int k=1;
    printf("%2d\t%s\t  %2c\t  %s\t\n",k++,T->ltag==0?"Link":"Thread",
                          T->data,
                          T->rtag==1?"Thread":"Link");
    return 1;
}
void DestroyBitTree(BiThrTree *T)
/*销毁二叉树*/
{
    if(*T)                          /*如果是非空二叉树*/
    {
        if((*T)->lchild)
            DestroyBitTree(&((*T)->lchild));
        if((*T)->rchild)
            DestroyBitTree(&((*T)->rchild));
        free(*T);
        *T=NULL;
    }
}
void CreateBitTree2(BiThrTree *T,char str[])
/*利用括号嵌套的字符串建立二叉链表*/
{
    char ch;
    BiThrTree stack[MaxSize];           /*定义栈，用于存放指向二叉树中结点的指针*/
    int top=-1;                         /*初始化栈顶指针*/
    int flag,k;
    BiThrNode *p;
    *T=NULL,k=0;
    ch=str[k];
    while(ch!='\0')                     /*如果字符串没有结束*/
    {
        switch(ch)
        {
        case '(':
            stack[++top]=p;
            flag=1;
            break;
        case ')':
            top--;
            break;
        case ',':
            flag=2;
            break;
        default:
            p=(BiThrTree)malloc(sizeof(BiThrNode));
            p->data=ch;
            p->lchild=NULL;
            p->rchild=NULL;

            if(*T==NULL)                    /*如果是第一个结点，表示是根结点*/
                *T=p;
            else
            {
                switch(flag)
                {
                case 1:
                    stack[top]->lchild=p;
                    break;
                case 2:
                    stack[top]->rchild=p;
                    break;
                }
                if(stack[top]->lchild)
                    stack[top]->ltag=Link;
                if(stack[top]->rchild)
                    stack[top]->rtag=Link;
            }

        }
        ch=str[++k];
    }
}
BiThrNode *FindPoint(BiThrTree T,DataType e)
/*中序遍历线索二叉树，返回元素值为e的结点的指针。*/
{
    BiThrTree p;
    p=T->lchild;                            /*p指向根结点*/
    while(p!=T)                         /*如果不是空二叉树*/
    {
        while(p->ltag==Link) 
            p=p->lchild;
        if(p->data==e)                      /*找到结点，返回指针*/
            return p;       
        while(p->rtag==Thread&&p->rchild!=T)    /*访问后继结点*/
        {
            p=p->rchild;
            if(p->data==e)                  /*找到结点，返回指针*/
                return p;
        }
        p=p->rchild;
    }
    return NULL;
}
BiThrNode *InOrderPre(BiThrNode *p)
/*在中序线索树中找结点*p的直接前趋*/
{
    BiThrNode *pre;
    if (p->ltag==Thread)        /*如果p的标志域ltag为线索，则p的左子树结点即为前驱*/
        return p->lchild; 
    else
{ 
        pre=p->lchild;          /*查找p的左孩子的最右下端结点*/
        while (pre->rtag==Link) /*右子树非空时，沿右链往下查找*/
            pre=pre->rchild;
         return pre;                /*pre就是最右下端结点*/
    }
}
BiThrNode *InOrderPost(BiThrNode *p)
/*在中序线索树中查找结点*p的直接后继*/
{
    BiThrNode *pre;
    if (p->rtag==Thread)        /*如果p的标志域ltag为线索，则p的右子树结点即为后继*/
        return p->rchild; 
    else
    { 
        pre=p->rchild;          /*查找p的右孩子的最左下端结点*/
        while (pre->ltag==Link) /*左子树非空时，沿左链往下查找*/
            pre=pre->lchild; 
        return pre;             /*pre就是最左下端结点*/
    }
}
int InOrderTraverse(BiThrTree T,int (* visit)(BiThrTree e))
/*中序遍历线索二叉树。其中visit是函数指针，指向访问结点的函数实现*/
{
    BiThrTree p;
    p=T->lchild;                            /*p指向根结点*/
    while(p!=T)                         /*空树或遍历结束时，p==T*/
    {
        while(p->ltag==Link) 
            p=p->lchild;
        if(!visit(p))                           /*打印*/
            return 0;       
        while(p->rtag==Thread&&p->rchild!=T)    /*访问后继结点*/
        {
            p=p->rchild;
            visit(p);
        }
        p=p->rchild;
    }
    return 1;
}
BiThrTree pre;                      /*pre始终指向已经线索化的结点*/
int InOrderThreading(BiThrTree *Thrt,BiThrTree T)
/*通过中序遍历二叉树T，使T中序线索化。Thrt是指向头结点的指针*/
{ 

    if(!(*Thrt=(BiThrTree)malloc(sizeof(BiThrNode)))) /*为头结点分配内存单元*/
        exit(-1);
    /*将头结点线索化*/
    (*Thrt)->ltag=Link;             /*修改前驱线索标志*/
    (*Thrt)->rtag=Thread;           /*修改后继线索标志*/
    (*Thrt)->rchild=*Thrt;              /*将头结点的rchild指针指向自己*/
    if(!T)                          /*如果二叉树为空，则将lchild指针指向自己*/
        (*Thrt)->lchild=*Thrt;
    else
    { 
        (*Thrt)->lchild=T;          /*将头结点的左指针指向根结点*/
        pre=*Thrt;                  /*将pre指向已经线索化的结点*/
        InThreading(T);             /*中序遍历进行中序线索化*/
        /*将最后一个结点线索化*/
        pre->rchild=*Thrt;          /*将最后一个结点的右指针指向头结点*/
        pre->rtag=Thread;           /*修改最后一个结点的rtag标志域*/        
        (*Thrt)->rchild=pre;            /*将头结点的rchild指针指向最后一个结点*/
    }
    return 1;
}
void InThreading(BiThrTree p)
/*二叉树的中序线索化*/
{ 
    if(p)
    {
        InThreading(p->lchild);     /*左子树线索化*/
        if(!p->lchild)              /*前驱线索化*/
        {
            p->ltag=Thread;
            p->lchild=pre;
        }
        if(!pre->rchild)                /*后继线索化*/
        {
            pre->rtag=Thread;
            pre->rchild=p;
        }
        pre=p;                      /*pre指向的结点线索化完毕，使p指向的结点成为前驱*/
        InThreading(p->rchild);         /*右子树线索化*/
    }
}
  • 测试结果


这里写图片描述

  
  

  
  
  
  

Time-space
关注
专栏目录
【数据结构笔记12】数据结构之线索二叉树介绍及其线索化（构造线索二叉树、寻找前驱、后继结点）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
12-12 484
线索二叉树，是指：将二叉树链表中的【n+1】个空链域指向对应结点的前驱结点以及后继结点，满足这种结构的二叉树就是线索二叉树。左孩子不为空，右孩子为空。左孩子为空，右孩子不为。左、右孩子都为空。针对上面三种情况，为了能够描述前驱和后继，我们规定：对于某个结点R来说。如果R结点的【左孩子结点不为空】，则R的左指针域【指向左孩子】。如果R结点的【左孩子结点为空】，则R的左指针域【指向R结点的前驱结点】。如果R结点的【右孩子结点不为空】，则R的右指针域指向R结点的右孩子。
[数据结构笔记] 线索二叉树
SegmentationFault
11-15 265
线索链表 线索：将二叉链表中的空指针域指向前驱结点和后继结点的指针被称为线索； 线索化：使二叉链表中结点的空链域存放其前驱或后继信息的过程称为线索化； 线索二叉树：加上线索的二叉树称为线索二叉树。 结点结构 enum flag {Child, Thread}; template <class T> struct ThrNode { T da...
线索二叉树
TechEngineer的专栏
06-06 2960
一、线索二叉树的原理     通过考察各种二叉链表，不管儿叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共有2n个链域，非空链域为n-1个，但其中的空链域却有n+1个。如下图所示。 因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。     记ptr指向二叉链表中的一个结点，以下是建立线索的规则：
详解线索二叉树
最新发布
kusunoki的博客
07-29 1165
对线索二叉树的概念进行说明，并分别介绍了中序线索二叉树、先序线索二叉树和后序线索二叉树找其前驱和后继的方法。
数据结构学习笔记 --- 线索二叉树
whz_zb的专栏
02-26 1433
1. 引言 为了更方便、快捷地遍历二叉树，最好在二叉树的结点上增加2个指针，它们分别指向遍历二叉树时该结点的前驱和后继。这 样，从二叉树的任一结点都可以方便的找到其他结点。但这样做大大降低了结构的存储密度。 另外，根据二叉树的性质，有：n0 = n2 + 1。空链域=2n0 + n1(叶子结点有两个空链域，度为1的结点有一个空链域)=n0+n2+1
线索二叉树学习笔记
m0_52286166的博客
11-23 667
线索二叉树的原理 二叉树中存在较多的空闲指针。 一棵具有n个结点的二叉树，如果按二叉链表形式来存储，那么总共有2n个指针，其中只有(n-1)个用来指向子结点，另外（n+1）个指针是空的 可以用来指向遍历中的前驱和后继结点 因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。 记ptr指向二叉链表中的一个结点，以下是建立线索的规则： （1）如果ptr->lchild为空，则存放指向中序遍历序列中该结点的前驱结点。这个结点称为ptr的中序前驱； ...
学习笔记-线索化二叉树
touteng55的博客
03-18 206
线索化二叉树 线索化二叉树的介绍： 对于这个普通二叉树来说，节点8，10，14的左右指针是空的，6的右指针是空的，也就是说并没有充分的利用到所有的指针。那么，我们可以对该树线索化，使得空闲的指针被充分利用。 中序线索化二叉树 对于一个线索二叉树（如上图），我们让空余节点的左指针指向它的前驱结点，右指针指向它的后继节点。这样一来，该节点的左指针有可能指向它的左子树，也可能指向前驱节点，该节点的右指针有可能指向它的右子树，也有可能指向后继节点。 所以，为了区分，我们在普通树节点的基础上设置leftType
学习笔记：线索二叉树
张小憨憨的博客
12-13 1653
线索二叉树线索二叉树内容回顾：线索二叉树：1. 线索二叉树基本概念线索二叉树的结点结构：线索二叉树的分类：2. 二叉树线索化线索化的实现方法：线索化实现算法：3. 线索二叉树的遍历 线索二叉树 内容回顾： 二叉树的遍历过程较为复杂，需要用到递归或栈。 二叉树结点的遍历序列是一个线性系列。 二叉链表难以获得遍历序列前驱，后继结点信息。 二叉链表中，N个结点，2N个指针，N+1个空指针。 线索二叉树： 1. 线索二叉树基本概念 指向遍历序列前驱，后继结点的指针称为线索。 把空指针修改为线索的过程称为线索化。
先序后继线索二叉树
03-04
设计算法，在先序后继线索二叉树T中，查找给定结点*p在先序序列中的后继(假设二叉树T的根结点未知)。
数据结构学习笔记——线索二叉树
小宇y的博客
07-31 4667
# 一、线索二叉树的结点结构 > 在由n个结点组成的二叉链表中，含有n+1个空指针域，含有n-1个非空指针域。 如前面文章介绍的，含有n个结点的二叉树中，有n+1个空指针，对于叶子结点，它有两个空指针；对于度为1的结点（只有一个子结点），它只有一个空指针。将这些空指针利用起来，例如可以让其存放指向该结点的前驱或后驱，从而使遍历二叉树更加简便，即`线索二叉树`。 如下图，由中序遍历序列（DBEAFCG）可以推出，其中结点D和结点G的中序前驱和中序后继为NULL：............
03线索二叉树_ThreadBinaryTree
AKK188888881的博客
10-06 401
#include<stdio.h> #include<stdlib.h> #include<math.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */ typedef char TElemType; typed
中序线索化二叉树的实现
岁月平添了我的愁
09-14 621
思路分析： 在这里只做中序线索化二叉树： package com.ran; public class hello { public static void main(String[] args) { HeroNode root = new HeroNode(1, "qqq"); HeroNode root2 = new HeroNode(3, "www"); HeroNode root3 = new HeroNode(6, "eee");
线索二叉树概念与C++实现解析
"这篇文档是关于数据结构课程中线索二叉树的概念及其C++实现的上课笔记，包含2020年5月12日的课程内容。文档提供了三种二叉树序列化的问题示例，并详细解释了线索二叉树的动机、存储结构以及C++实现线索二叉树的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值