学习《数据结构》有感之新的创建二叉树和新的遍历的方法

最新推荐文章于 2023-11-11 22:58:47 发布
最新推荐文章于 2023-11-11 22:58:47 发布
阅读量748 收藏
点赞数
文章标签： 数据结构 struct 算法 null 存储 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ilekoaiq/article/details/8012092
版权

                             前言

通过看书和上网搜索资料，我觉得目前的创建二叉树的算法以及遍历二叉树和遍历结果的存储都很麻烦。

所以我写了一种新的创建二叉树的算法，相比目前的算法来讲更符合人们输入的习惯，效率有一定的提高，而没有增加复杂度。

我另外还写了一种新的二叉树遍历的算法，相对目前的几种遍历的方法来讲，最大的不同点在于它是一层层往下遍历的，算法可读性较好；而书上所有的遍历都是先从头结点出发到叶子结点，再往回遍历，算法可读性较差。

而目前对二叉树遍历结果的存储一般都是通过栈来实现的，比如书上的130页，但是这个算法不停地入栈出栈，效率低，并且算法可读性差。所以，我在遍历中加了一个双向链表来存储遍历结果，算法效率较高。

建立跟书上 131 页算法 6.4 同样的二叉树，

                      A

                   /                     

                  B    

                /   \

               C     D

                   /   \

                  E     F

                   \

                    G

完整的调试结果如下：

 

 

 

 

 

 

 

一．创建二叉树的新算法

 

目前创建二叉树的方法是按照遍历的顺序输入和按照层序的顺序输入。

1.按照遍历的顺序输入创建二叉树。比如书上的131页，用户必须得先知道要输入的二叉树的遍历结果，而要知道二叉树的遍历结果有两种方法，一种是用已经写好的求二叉树遍历的程序来求，但这需要已经建立好的二叉树才行，这就与前面成了一个矛盾。另一种方法是通过笔算来求遍历结果，但这个也很麻烦。

    2.按照层序的顺序输入创建二叉树。按照满二叉树的形式输入数据，空节点全部都要输入。这个方法相对第一种方法来讲更符合人们的输入习惯，只需要一层层地输入数据就行，但有个缺点，就算某一层只有一个节点的话，也必须要输入很多的空格来表示该层其它的空结点，效率很低，非常麻烦。

   

所以，我写了一种新的创建二叉树的算法。它的优点有：1.相比遍历创建二叉树，它是一层层输入各结点数据的，并且输入都有相应的提示，更符合人们的输入习惯；2.相比层序法，它不需要输入那些空结点，并且有相应的输入提示，大大提高了输入的效率。

这种新的创建二叉树的方法的时间复杂度与遍历方法创建二叉树的时间复杂度相同，都是，n代表二叉树的深度。

 

首先定义二叉树

typedef struct YLNode{

        int data;

        int ceng;

        struct YLNode *lchild;

   struct YLNode *rchild;

}YLNode,*YL;

跟普通的相比，多了int ceng;这个来记录二叉树的层数，也就是深度。

然后创建二叉树，详见第13页附录里面的源程序的main函数。

printf("请输入第");printf("%d",w[b]->ceng); printf("层的结点");printf("%c",w[b]->data);printf("的左子树\n");

                  dl=getchar();    //输入对应的数据

                  getchar();

                  if(dl!=' ')       //如果不为空

                  {

                           YLNode *ll;

          

                           ll=(YLNode *)malloc(sizeof(YLNode));    //新的空间

                           ll->data=dl;

                           ll->ceng=(w[b]->ceng)+1;       //层数为当前结点层数加一

                           e++;

                           w[e]=ll;

           w[b]->lchild=ll;

                  }

                  else w[b]->lchild=NULL;        //否则为空

 

跟层序法类似，但是比层序法的优点在于，不用按照满二叉树的那种方法输入很多的空格。只需要输入必要的左子树和右子树就行。建立书上131页算法6.4同样二叉树，我的算法不需要按照先序遍历的方式输入，只需要按层输入就行。但与层序法相比的优点又在于，不需要输入很多的空结点。

调试结果如下：

 

二．遍历二叉树的新算法（以中序遍历为例）

   首先，定义双向链表。

typedef struct SH{

        int depth;

        YLNode *address;  

        struct SH *prior;

   struct SH *next;

}SH,*SHLinkList;//双向链表

其中的address是YLNode类型的，用来存放每一个结点的空间位置。遍历函数先把头结点加入双向链表，然后对头结点分析，如果有左子树，则把左子树插到头结点的左边。如果有右子树，把子树插到头结点的右边。

if((zz->address)->lchild)

                           {

                         flag=1;

                                    SH *ll;

                                    ll=(SH *)malloc(sizeof(SH));

                                    ll->address=(zz->address)->lchild;

                                    ll->depth=cb+1;

                                    (zz->prior)->next=ll;

                                    ll->prior=zz->prior;

                                    ll->next=zz;

                                    zz->prior=ll;

                           }

 

   以此方法，一层层向下分析。分别设cb和ce为开始层和结尾层，以此来控制循环。直到有一层所有的结点都没有子树，则跳出循环。

zz=tt->next;

                  printf("\n中序遍历的结果是：\n");

                  while((zz->next)!=NULL)

                  {                 

                           printf("%c",(zz->address)->data);

                           zz=zz->next;

                  }

   然后再用双向链表按顺序输出遍历的结果。详见第8页附录里面的源程序的中序遍历。

 

 

 

 

三．新的算法与以前算法的混合检验

1、检验新的创建二叉树的算法。用新的算法创建二叉树，用旧的递归遍历的算法。

void inorder(struct node *T)

{

        if(!T)

                  return;

        else

        {

                  inorder(T->lchild );

                  cout<<T->data;

                  inorder(T->rchild );

        }

}

详见第15页附录里面的混合检验1，用中序遍历检验。调试成功，结果如下：

 

 

 

 

2、检验新的遍历算法。用书上131页的算法6.4先序遍历法创建二叉树，用新的遍历的算法来遍历。

详见第17页附录里面的混合检验2，用书上131页的算法6.4先序建立二叉树，再用新的遍历算法遍历。调试成功，结果如下。

 

                                                                                      巧克力

 

 

附录：
//源程序
#include   <stdlib.h>
#include   <malloc.h>
#include   <stdio.h>
#include <string.h>
#include <conio.h>
#define NULL 0
typedef struct YLNode{
 int data;                  //结点数据
 int ceng;                  //结点的层数
 struct YLNode *lchild;      
    struct YLNode *rchild;
}YLNode,*YL;

typedef struct SH{                //双向链表
 int depth;                  //深度
 YLNode *address;           //在遍历的时候，在链表上存放每个结点的地址
 struct SH *prior;
    struct SH *next;
}SH,*SHLinkList;//双向链表

 

 


void zhongxu(YLNode  *Head)      //中序遍历
{
 
 SH *HH,*tt,*ww,*zz;         
 HH=(SH *)malloc(sizeof(SH));    //对应二叉树头结点
 tt=(SH *)malloc(sizeof(SH));     //链表头结点
 ww=(SH *)malloc(sizeof(SH));    //链表尾结点
 zz=(SH *)malloc(sizeof(SH));     //链表中间的结点
 
 HH->address=Head;           //用来放二叉树头结点的地址
 HH->prior=tt;
 HH->next=ww;
 HH->depth=1;
 tt->prior=NULL;
 tt->next=HH;
 ww->next=NULL;
 ww->prior=HH;
 int cb=1,ce=1;              //cb代表开始的层数，ce代表结束的层数
 zz=tt->next;                //链表头结点的后一个
    while(cb<=ce)
 {
  char flag=0;
  int bb=0;
  zz=tt->next;             //定位链表头结点的后一个
  while((zz->next)!=NULL)           //到达尾结点时跳出
  {
            //跳过不属于这一层的点
   while(zz->depth!=cb) {  if(zz->next==ww)   {bb=1;break; }   zz=zz->next; }
   if(bb==1)   break;           
   if((zz->address)->lchild)    //如果有左子树，则插入当前结点的前面
   {
          flag=1;
    SH *ll;
    ll=(SH *)malloc(sizeof(SH));
    ll->address=(zz->address)->lchild;
    ll->depth=cb+1;
    (zz->prior)->next=ll;
    ll->prior=zz->prior;
    ll->next=zz;
    zz->prior=ll;
   }
            if((zz->address)->rchild)    //如果有右子树，则插入到当前结点的后面
   {
    flag=1;
    SH *rr;
    rr=(SH *)malloc(sizeof(SH));
    rr->depth=cb+1;
    rr->address=(zz->address)->rchild;
    (zz->next)->prior=rr;
    rr->next=zz->next;
    rr->prior=zz;
    zz->next=rr;
   }
    zz=zz->next;               //分析链表上下一个点
  }
  if(flag==1)  ce++;                  //结束层加一
//if(flag==0)  break;
  cb++;                            //分析下一层的点
 }

     zz=tt->next;                          //链表头结点的后一个

  printf("\n中序遍历的结果是：\n");
  while((zz->next)!=NULL)
  {   
   printf("%c",(zz->address)->data);
   zz=zz->next;
  }
   printf("\n");
}

 


void qianxu(YLNode  *Head)   //前序遍历
{
 
 SH *HH,*tt,*ww,*zz;
 HH=(SH *)malloc(sizeof(SH));
 tt=(SH *)malloc(sizeof(SH));
 ww=(SH *)malloc(sizeof(SH));
 zz=(SH *)malloc(sizeof(SH));
 
 HH->address=Head;
 HH->prior=tt;
 HH->next=ww;
 HH->depth=1;
 tt->prior=NULL;
 tt->next=HH;
 ww->next=NULL;
 ww->prior=HH;
 int cb=1,ce=1;
 zz=tt->next;
    while(cb<=ce)
 {
  char flag=0;
  int bb=0;
  zz=tt->next;
  while((zz->next)!=NULL)
  {
   while(zz->depth!=cb) {  if(zz->next==ww)   {bb=1;break; }   zz=zz->next;     }
   if(bb==1)   break;
  
            if((zz->address)->rchild)
   {
    flag=1;
    SH *rr;
    rr=(SH *)malloc(sizeof(SH));
    rr->depth=cb+1;
    rr->address=(zz->address)->rchild;
    (zz->next)->prior=rr;
    rr->next=zz->next;
    rr->prior=zz;
    zz->next=rr;
   }
    if((zz->address)->lchild)
   {
          flag=1;
    SH *ll;
    ll=(SH *)malloc(sizeof(SH));
    ll->address=(zz->address)->lchild;
    ll->depth=cb+1;
    (zz->next)->prior=ll;
    ll->next=zz->next;
    ll->prior=zz;
    zz->next=ll;
   }

    zz=zz->next;
  }
  if(flag==1)  ce++;//if(flag==0)  break;
  cb++;
 }

     zz=tt->next;

  printf("\n前序遍历的结果是：\n");
  while((zz->next)!=NULL)
  {   
   printf("%c",(zz->address)->data);
   zz=zz->next;
  }
   printf("\n");
}


void houxu(YLNode  *Head)                //后序遍历
{
 
 SH *HH,*tt,*ww,*zz;
 HH=(SH *)malloc(sizeof(SH));
 tt=(SH *)malloc(sizeof(SH));
 ww=(SH *)malloc(sizeof(SH));
 zz=(SH *)malloc(sizeof(SH));
 
 HH->address=Head;
 HH->prior=tt;
 HH->next=ww;
 HH->depth=1;
 tt->prior=NULL;
 tt->next=HH;
 ww->next=NULL;
 ww->prior=HH;
 int cb=1,ce=1;
 zz=tt->next;
    while(cb<=ce)
 {
  char flag=0;
  int bb=0;
  zz=tt->next;
  while((zz->next)!=NULL)
  {
   while(zz->depth!=cb) {  if(zz->next==ww)   {bb=1;break; }   zz=zz->next;     }
   if(bb==1)   break;
   if((zz->address)->lchild)
   {
          flag=1;
    SH *ll;
    ll=(SH *)malloc(sizeof(SH));
    ll->address=(zz->address)->lchild;
    ll->depth=cb+1;
    (zz->prior)->next=ll;
    ll->prior=zz->prior;
    ll->next=zz;
    zz->prior=ll;
   }
            if((zz->address)->rchild)
   {
    flag=1;
    SH *rr;
    rr=(SH *)malloc(sizeof(SH));
    rr->depth=cb+1;
    rr->address=(zz->address)->rchild;
    (zz->prior)->next=rr;
    rr->prior=zz->prior;
    rr->next=zz;
    zz->prior=rr;
   }
    zz=zz->next;
  }
  if(flag==1)  ce++;//if(flag==0)  break;
  cb++;
 }

     zz=tt->next;

  printf("\n后序遍历的结果是：\n");
  while((zz->next)!=NULL)
  {   
   printf("%c",(zz->address)->data);
   zz=zz->next;
  }
  printf("\n");
}

 


void main()
{
   
    YLNode *w[100],*Head;        // 定义w[]为100个元素的YLNode的数组
 printf("请输入头结点的数据\n");
 int d,dl,dr,b=0,e=0;              //b为开始层数，e为结束层数
 d=getchar();
 getchar();
 if(d!=' ')
 {
  w[0]=(YLNode *)malloc(sizeof(YLNode));
  w[0]->data=d;
  w[0]->ceng=1;                //头结点的层数
        Head=w[0];
 }
 while(b<=e)
 {
  while(w[b]->data==NULL)  b++;
  printf("请输入第");printf("%d",w[b]->ceng); printf("层的结点");printf("%c",w[b]->data);printf("的左子树\n");
  dl=getchar();
  getchar();
  if(dl!=' ')
  {
   YLNode *ll;
          
   ll=(YLNode *)malloc(sizeof(YLNode));
   ll->data=dl;
   ll->ceng=(w[b]->ceng)+1;     //层数为当前结点层数的下一层
   e++;
   w[e]=ll;
            w[b]->lchild=ll;             //创建关系
  }
  else w[b]->lchild=NULL;            //否则字数为空
        printf("请输入第");printf("%d",w[b]->ceng); printf("层的结点");printf("%c",w[b]->data);printf("的右子树\n");
  dr=getchar();
  getchar();
        if(dr!=' ')
  {
   YLNode *rr;
   rr=(YLNode *)malloc(sizeof(YLNode));
   rr->data=dr;
   rr->ceng=(w[b]->ceng)+1;
   e++;
   w[e]=rr;
   w[b]->rchild=rr;
  }
  else w[b]->rchild=NULL;
  b++;
 }
    printf("\n");
 qianxu(Head);
 zhongxu(Head);
    houxu(Head);
  
}

 

 


//混合检验1
#include   <stdlib.h>
#include   <malloc.h>
#include   <stdio.h>
#include <string.h>
#include <conio.h>
#define NULL 0
typedef struct YLNode{
 int data;
 int ceng;
 struct YLNode *lchild;
    struct YLNode *rchild;
}YLNode,*YL;

typedef struct SH{
 int depth;
 YLNode *address;
 struct SH *prior;
    struct SH *next;
}SH,*SHLinkList;//双向链表

void inorder(YLNode *T)           //递归中序遍历
{
 if(!T)
  return;
 else
 {
  inorder(T->lchild );
  printf("%c",T->data);
  inorder(T->rchild );
 }
}

 

void main()
{
   
    YLNode *w[100],*Head;
 printf("请输入头结点的数据\n");
 int d,dl,dr,b=0,e=0;
 d=getchar();
 getchar();
 if(d!=' ')
 {
  w[0]=(YLNode *)malloc(sizeof(YLNode));
  w[0]->data=d;
  w[0]->ceng=1;
        Head=w[0];
 }
 while(b<=e)
 {
  while(w[b]->data==NULL)  b++;
  printf("请输入第");printf("%d",w[b]->ceng); printf("层的结点");printf("%c",w[b]->data);printf("的左子树\n");
  dl=getchar();
  getchar();
  if(dl!=' ')
  {
   YLNode *ll;
          
   ll=(YLNode *)malloc(sizeof(YLNode));
   ll->data=dl;
   ll->ceng=(w[b]->ceng)+1;
   e++;
   w[e]=ll;
            w[b]->lchild=ll;
  }
  else w[b]->lchild=NULL;
        printf("请输入第");printf("%d",w[b]->ceng); printf("层的结点");printf("%c",w[b]->data);printf("的右子树\n");
  dr=getchar();
  getchar();
        if(dr!=' ')
  {
   YLNode *rr;
   rr=(YLNode *)malloc(sizeof(YLNode));
   rr->data=dr;
   rr->ceng=(w[b]->ceng)+1;
   e++;
   w[e]=rr;
   w[b]->rchild=rr;
  }
  else w[b]->rchild=NULL;
  b++;
 }
    printf("\n");
    inorder(Head);               //递归中序遍历
  printf("\n");
   printf("\n");
 }


//混合检验2
#include   <stdlib.h>
#include   <malloc.h>
#include   <stdio.h>
#include <string.h>
#include <conio.h>
#define NULL 0

typedef struct BitNode{
 int data;
 struct BitNode *lchild;
 struct BitNode *rchild;
}BitNode,*BiTTree;
typedef struct SH{
 int depth;
 BitNode *address;
 struct SH *prior;
    struct SH *next;
}SH,*SHLinkList;//双向链表

struct BitNode * creatbitree(struct BitNode *r)
{
   char a;
   a=getchar();
   getchar();
   if(a==' ')   return r=NULL;
   else
     {  r=(struct BitNode*)malloc(sizeof(BitNode));
        r->data=a;
        r->lchild=creatbitree(r->lchild);
        r->rchild=creatbitree(r->rchild);
     }
   return r;
}


void zhongxu(BitNode  *Head)
{
 
 SH *HH,*tt,*ww,*zz;
 HH=(SH *)malloc(sizeof(SH));
 tt=(SH *)malloc(sizeof(SH));
 ww=(SH *)malloc(sizeof(SH));
 zz=(SH *)malloc(sizeof(SH));
 
 HH->address=Head;
 HH->prior=tt;
 HH->next=ww;
 HH->depth=1;
 tt->prior=NULL;
 tt->next=HH;
 ww->next=NULL;
 ww->prior=HH;
 int cb=1,ce=1;
 zz=tt->next;
    while(cb<=ce)
 {
  char flag=0;
  int bb=0;
  zz=tt->next;
  while((zz->next)!=NULL)
  {
   while(zz->depth!=cb) {  if(zz->next==ww)   {bb=1;break; }   zz=zz->next;     }
   if(bb==1)   break;
   if((zz->address)->lchild)
   {
          flag=1;
    SH *ll;
    ll=(SH *)malloc(sizeof(SH));
    ll->address=(zz->address)->lchild;
    ll->depth=cb+1;
    (zz->prior)->next=ll;
    ll->prior=zz->prior;
    ll->next=zz;
    zz->prior=ll;
   }
            if((zz->address)->rchild)
   {
    flag=1;
    SH *rr;
    rr=(SH *)malloc(sizeof(SH));
    rr->depth=cb+1;
    rr->address=(zz->address)->rchild;
    (zz->next)->prior=rr;
    rr->next=zz->next;
    rr->prior=zz;
    zz->next=rr;
   }
    zz=zz->next;
  }
  if(flag==1)  ce++;//if(flag==0)  break;
  cb++;
 }

     zz=tt->next;

  printf("\n中序遍历的结果是：\n");
  while((zz->next)!=NULL)
  {   
   printf("%c",(zz->address)->data);
   zz=zz->next;
  }
   printf("\n");
}

void main()
{
    printf("先序输入\n");
 BitNode *Head;
    Head=creatbitree(Head);         /*创建二叉树*/
   
    zhongxu(Head);
}
                                                                                     2011年12月22日

ilekoaiq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手把手教你二叉树的四种遍历方式
m0_48046714的博客
05-07 345
二叉树的四种遍历前序遍历中序遍历后序遍历层序遍历 前序遍历 力扣144. 二叉树的前序遍历 1、递归写法 class Solution { List<Integer> ret = new LinkedList<> (); public List<Integer> preorderTraversal(TreeNode root) { if(root == null) { return ret; }
二叉树的创建及遍历实验 matlab,【二叉树的建立和遍历实验报告】 二叉树的遍历实验心得...
weixin_32746239的博客
03-19 1550
[题目] 建立二叉树并求指定结点路径、深度、叶子个数和左右子树交换。[问题描述]要求能够按先序遍历次序输入二叉树 中结点的值来构造二叉树T；然后用递归和非递归算法实现二叉树T 的中序遍历；接着编写算法实现求二叉树T中指定结点的路径，即从键盘输入二叉树T 的任一结点，可以输出从根结点到该 结点所经历的结点；最后编写二叉树的三个应用算法(求二叉树的深度、求二叉树的叶子结点个数、将二叉树左右子树交换)。...
二叉树遍历的总结
Key Board的博客
06-15 1843
二叉树是一棵树，其中每个节点都不能有多于两个的孩子。 理解二叉树的遍历可以帮助我们很好地理解递归以及栈。在前端的应用中也或多或少地会接触到树的遍历和操作(DOM树以及当前热门框架的各种diff算法)， 除此之外，在数据库中建立索引，高效的查找也是得益于二叉搜索树这种特殊的数据结构。其基本思想都是大同小异。 因此，掌握二叉搜索树的相关的遍历算法是一个合格工程师基本的技能。 对于二叉树的遍历，根据根节点的访问顺序，可以被分为先序遍历、中序遍历以及后序遍历。 作为广度优先搜索思想的体现，层次遍历(补充在最后)也需
关于二叉树的遍历和建立总结
qq_41228922的博客
07-04 1426
一 树 1.树是包含N（node）个节点的有穷集。其中： 1）每个元素称为结点。 2）每个结点有零个或多个子结点，单个结点是一棵树，树根就是该结点本身。空集合也是树，称为空树。空树中没有结点。 3） 2.结点是数据结构中的基础，是构成复杂数据结构的基本组成单位。 结点拥有的子树数目称为结点的度。 结点子树的根结点为该结点的孩子结点。相应该结点称为孩子结点的双亲结点。 图中，A为B的双亲结点，B为...
数据结构 树、二叉树（前半） 学习心得代码
最新发布
FellAveal的博客
11-11 319
树，伟大的递归。
数据结构课程设计报告-二叉树的遍历.docx
03-07
11. 心得体会：通过本次课程设计，学生可以学到递归创建和非递归创建二叉树等有关二叉树的基本知识，并提高动手能力和学习数据结构的能力。 12. 数据结构的重要性：数据结构是计算机科学和信息技术的基础，学习数据...
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过...理解线索二叉树的原理和实现，对于深入学习数据结构和算法至关重要。
Python数据结构与算法之二叉树结构定义与遍历方法详解
12-25
本文实例讲述了Python数据结构与算法之二叉树结构定义与遍历方法。分享给大家供大家参考，具体如下： 先序遍历，中序遍历，后序遍历 ，区别在于三条核心语句的位置 层序遍历 采用队列的遍历操作第一次访问根，在...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
课程设计报告数据结构二叉树遍历演示_二叉树中序遍历怎么看
01-08
综上所述，二叉树遍历是数据结构学习中的核心内容，通过实际的演示和报告，学生可以深入理解遍历方法及其在实际问题中的应用。在设计过程中，应注重代码的可读性和可维护性，同时培养问题解决和分析能力。
数据结构实验报告 串 （C++版）
12-31
实验 串 1. 实验题目： 支持通配符？、*的模式匹配算法 2．问题描述： 1）功能要求：①模式串中支持通配符？和*，其中，？代表一个任意字符，*代表0个或多个任意字符。 ②模式串中可以多次出现通配符？和*。 ③ 输出模式串在主串中出现的位置。
二叉树学习的一些个人心得
晓梦林的博客
11-22 9262
目录前言二叉树的种类满二叉树完全二叉树二叉搜索树平衡二叉搜索树二叉树的存储方式二叉树的遍历方式二叉树的代码描述总结参考文献 前言 开启算法新征程，为了让我对二叉树有新层次的理解，加油学习吧。 二叉树的种类 二叉树的两种形式：满二叉树和完全二叉树 满二叉树 只有度为0和度为2的节点的树，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 如下图： 深度：k 节点个数：2^k-1 完全二叉树 除了最底层的节点没有安排满外，其余每层节点数都达到最大值，并且最下面一层节点都集中在该层最左的若干位置。
数据结构学习心得——二叉树的三种遍历算法
Xiaowei's Blog
09-29 4523
二叉树主要的遍历方式有四种，先序遍历，中序遍历，后序遍历和层次遍历（层次遍历放到下一篇博客单独讲）。 1、先序遍历 a.访问根结点 b.先序遍历左子树 c.后序遍历右子树2、中序遍历 a.先序遍历左子树 b.访问根结点 c.后序遍历右子树3、后序遍历 a.先序遍历左子树 b.后序遍历右子树 c.访问根结点看上很简单，代码实现也很简单，但是很多算法都是基于这几种遍历而衍生出来的，所
二叉树的建立与遍历【数据结构实验报告】
热门推荐
_
11-06 4万+
数据结构实验报告实验名称：实验四 二叉树的建立和遍历学号：***姓名：gnosed实验日期：2017.11.5 一、实验目的1、掌握树的先根构造2、了解树的遍历 二、实验具体内容1、实验题目1：（1）题目构造一棵二叉树，并进行遍历要求：1、二叉树的构造，可以输入树的先根序遍历序列，然后进行构造2、先使用递归的中根，先根，后根序对二叉树做遍历，然后对二叉树进行中根序非递归遍历提示：1、  在构造二叉...
《二叉树》学习心得
weixin_34130269的博客
05-03 2771
树的介绍 1. 树的定义 树是一种数据结构，它是由n（n&gt;=1）个有限节点组成一个具有层次关系的集合。 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：(01) 每个节点有零个或多个子节点；(02) 没有父节点的节点称为根节点；(03) 每一个非根节点有且只有一个父节点；(04) 除了根节点外，每个子节点可以分为多个不相交的子树。   2. 树...
算法设计之二叉树的遍历
lishinho的博客
03-18 796
最近发现面试很喜欢考二叉树的遍历，所以补一个。 树的节点结构： public class TreeNode{ public int value; public TreeNode left; public TreeNode right; public TreeNode(int data){ this.data = data; } } 一...
二叉树的存储方式和遍历方式
simplehap的博客
03-20 2万+
二叉树： 二叉树的每个节点至多有两个子树。如这个二叉树，其中1,2有两个子树，3只有左子树，5有右子树，4,6,7没有子树。 二叉树有两种存储方式： 第一种，数组表示。用数组存储方式就是用一组连续的存储单元存储二叉树的数据元素。                                      两颗树分别用数组表示为：
二叉树给我的人生感悟
阅读修身
06-16 1093
人生的意义到底是什么呢？ 我们活着到底是为了找寻什么呢？ 有的人说活着就是为了寻找一个目标，然后为之奋斗。但是这样是不是太过于单调呢？生命就像一个无限分支的二叉树，向下，直到生命终结。而咱们人生的选择只能算是其中的一个分支，如果人生就像是刚才所说那样，找一个目标然后奋斗一生，这样是不是太过于单调了呢？二叉树如下图所示（可以继续往下一直分叉）。 但是作为好奇心极其强烈的人类来说
二叉树的创建和文本显示
诗和远方，代码和你
06-22 3691
问题 J: 二叉树的创建和文本显示 时间限制: 1 Sec 内存限制: 128 MB 提交: 604 解决: 268 [提交][状态][讨论版] 题目描述 编一个程序，读入先序遍历字符串，根据此字符串建立一棵二叉树（以指针方式存储）。 例如如下的先序遍历字符串： A ST C # # D 10 # G # # F # # # 各结点数据（长度不超过3），用空格分开，其中“#”代表
掌握数据结构：深入理解树与二叉树及其遍历方法
二叉树的遍历方法是学习的重点，包括前序遍历、中序遍历和后序遍历，这些遍历方式有助于在树上进行有效的数据访问和操作。 接下来，线索二叉树的概念被引入，这是一种对二叉树进行额外标记的结构，便于在遍历时保持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值