精华内容
下载资源
问答
  • 二叉树的基本运算概述 归纳起来,二叉树有以下基本运算: 创建二叉树CreateBTNode(*b, *str):根据二叉树括号表示法字符串str生成对应的二叉链存储结构b 销毁二叉链存储结构DestroyBT(*b):销毁二叉链b并释放空间 ...

    树和二叉树基本运算及其实现

    二叉树的基本运算概述

    归纳起来,二叉树有以下基本运算

    • 创建二叉树CreateBTNode(*b, *str):根据二叉树括号表示法字符串str生成对应的二叉链存储结构b
    • 销毁二叉链存储结构DestroyBT(*b):销毁二叉链b并释放空间
    • 查找节点FindNode(*b,x):在二叉树b中寻找data域值为x的节点,并返回指向该节点的指针
    • 找孩子节点LchildNode( p) 和RchildNode( p):分别求二叉树中节点*p的左孩子节点和右孩子节点
    • 求高度BTNodeDepth(*b):求二叉树b的高度。若二叉树为空,则其高度为0;否则,其高度等于左子树与右子树中的最大高度加1
    • 输出二叉树DispBTNode(*b):以括号表示法输出一棵二叉树

    二叉树的基本运算算法实现

    (1)创建二叉树CreateBTNode(* b,*str)

    在这里插入图片描述
    正确的二叉树括号表示串中只有4类字符:

    • 单个字符: 节点的值
    • (:表示一棵左子树的开始
    • ):表示一棵子树的结束
    • ,:表示一棵右子树的开始

    算法设计:
    在这里插入图片描述

    • 先构造根节点N,再构造左子树L,最后构造右子树R
    • 构造右子树R时,找不到N了,所有需要保存N
    • 而节点是按最近原则匹配的,所以使用一个保存N

    用ch扫描采用括号表示法表示二叉树的字符串:

    1. 若ch=‘(’:则将前面创建的节点作为双亲结点进栈,并置k=1,表示开始处理左孩子节点
    2. 若ch=‘)’:表示栈顶节点的左,右孩子节点处理完毕,退栈
    3. 若ch=‘,’:表示开始处理右孩子节点,置k=2
    4. 其他情况(节点值):
      创建p节点用于存放ch
      k=1时,将
      p节点作为栈顶节点的左孩子节点
      k=2时,将*p节点作为栈顶节点的右孩子节点

    在这里插入图片描述

    void CreateBTNode(BTNode *&b,char *str) {
    	//由str-二叉链b
    	BTNode *St[MaxSize],*p;
    	int top=-1,k,j=0;
    	char ch;
    	b = NULL; //建立的二叉链初始时为空
    	ch = str[j];
    	while(ch!='\0') { //str未扫描完时循环
    		switch(ch) {	
    			case'(':top++;St[top]=p;k=1; break; //可能有左孩子节点,进栈
    			case')':top--; break;
    			case',':k=2; break; //后面为右孩子节点
    			default: //遇到节点值
    				p=(BTNode *)malloc(sizeof(BTNode));
    				p->data=ch; p->lchild=p->rchild=NULL;
    				if (b==NULL) //p为二叉树的根节点
    					b=p;
    				else { //已建立二叉树根节点
    					switch(k) {
    						case 1:St[top]->lchild=p; break;
    						case 2:St[top]->rchild=p; break;
    					}
    				}
    		}
    			j++; ch=str[j]; //继续扫描str
    	}
    }
    

    (2)销毁二叉链DestroyBT(*b)

    在这里插入图片描述
    递归模型如下:
    在这里插入图片描述
    对应的递归算法如下:

    void DestroyBT(BTNode *&b) {
    	if(b==NULL)
    		return ;
    	else {
    		DestroyBT(b->lchild);
    		DestroyBT(b->rchild);
    		free(b); //剩下一个节点*b,直接释放
    	}
    }
    

    (4)查找节点FindNode(*b,x)

    在这里插入图片描述
    对应的递归算法如下:

    BTNode *FindNode(BTNode *b,ElemType x) {
    	BTNode *p;
    	if(b==NULL)
    		return NULL;
    	else if(b->data==x)
    		return b;
    	else {
    		p=FindNode(b->lchild,x);
    		if(p!=NULL) 
    			return p;
    		else
    			return FindNode(b->rchild,x);
    	}
    }
    

    (4)找孩子节点LchildNode§和RchildNode§

    直接返回*p节点的左孩子节点或右孩子节点的指针

    BTNode *LchildNode(BTNode *p) {
    	return p->lchild;
    }
    
    BTNode *RchildNode(BTNode *p) {
    	return p->rchild;
    }
    

    (5)求高度BTNodeDepth(*b)

    在这里插入图片描述
    对应的递归算法如下:

    int BTNodeDepth(BTNode *b) {
    	int lchilddep,rchilddep;
    	if(b==NULL)
    		return(0); //空树的高度为0
    	else {
    		lchilddep=BTNodeDepth(b->lchild); //求左子树的高度为lchilddep
    		rchilddep=BTNodeDepth(b->rchild); //求右子树的高度为rchilddep
    		return ((lchilddep>rchilddep) ? (lchilddep+1):(rchilddep+1));
    	}
    }
    

    (6)输出二叉树DispBTNode(*b)

    在这里插入图片描述
    根节点(左子树,右子树)——括号表示

    void DispBTNode(BTNode *b) {
    	if(b!=NULL) {
    		printf("%c",b->data);
    		if(b->lchild!=NULL || b->rchild!=NULL) {
    			printf("(");
    			DispBTNode(b->lchild); //递归处理左子树
    			if(b->rchild!=NULL)
    				printf(",");
    			DispBTNode(b->rchild); //递归处理右子树
    			printf(")");
    		}
    	}
    }
    
    展开全文
  • 问题描述:树和二叉树的基本运算实现 设计一个程序exp7-6.cpp,构造一棵哈夫曼树,输出对应的哈夫曼编码平均查找长度。并用表7.8所示的数据进行验证  表7.8 单词及出现的频度 单词 The ...

    问题描述:树和二叉树的基本运算实现

    设计一个程序exp7-6.cpp,构造一棵哈夫曼树,输出对应的哈夫曼编码和平均查找长度。并用表7.8所示的数据进行验证

                                                 表7.8 单词及出现的频度

    单词

    The

    of

    a

    to

    and

    in

    that

    he

    is

    at

    on

    for

    His

    are

    be

    出现频度

    1192

    677

    541

    518

    462

    450

    242

    195

    190

    181

    174

    157

    138

    124

    123

    实验要求结果:

    算法设计:哈弗曼树建立和哈弗曼编码的创建

    作者:何知令

    完成时间:2017年6月22日

    代码:

    /*
    问题描述:树和二叉树的基本运算实现
    作者:何知令
    完成时间:2017年6月22日
    */
    #include <stdio.h>
    #define N 30
    typedef struct
    {
        char data[5];
        double weight;
        int parent;
        int lchild;
        int rchild;
    } HTNode;
    typedef struct
    {
        char cd[N/2];
        int start;
    } HCode;
    void CreatHt(HTNode ht[],int n)
    {
        int i,k,lnode,rnode;
        double min1,min2;
        for(i=0; i<2*n-1; ++i)
            ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
        for(i=n; i<2*n-1; ++i)
        {
            min1=min2=32767;
            lnode=rnode=-1;
            for(k=0; k<=i-1; ++k)
            {
                if(ht[k].parent==-1)
                {
                    if(ht[k].weight<min1)
                    {
                        min2=min1;
                        rnode=lnode;
                        min1=ht[k].weight;
                        lnode=k;
                    }
                    else if(ht[k].weight<min2)
                    {
                        min2=ht[k].weight;
                        rnode=k;
                    }
                }
            }
            ht[i].weight=ht[lnode].weight+ht[rnode].weight;
            ht[i].lchild=lnode;
            ht[i].rchild=rnode;
            ht[lnode].parent=i;
            ht[rnode].parent=i;
        }
    }
    void CreatHCode(HTNode ht[],HCode hcd[],int n)
    {
        int i,f,c;
        HCode hc;
        for(i=0; i<n; ++i)
        {
            hc.start=n;
            c=i;
            f=ht[i].parent;
            while(f!=-1)
            {
                if(ht[f].lchild==c)
                    hc.cd[--hc.start]='0';
                else
                    hc.cd[--hc.start]='1';
                c=f;
                f=ht[f].parent;
            }
            hcd[i]=hc;
        }
    }
    void DispHCode(HTNode ht[],HCode hcd[],int n)
    {
        int i,k;
        double sum=0,m=0;
        int j;
        printf("输出哈夫曼编码:\n"); //输出哈夫曼编码
        for (i=0; i<n; i++)
        {
            j=0;
            printf("%s:\t",ht[i].data);
            for (k=hcd[i].start; k<=n; k++)
            {
                printf("%c",hcd[i].cd[k]);
                j++;
            }
            m+=ht[i].weight;
            sum+=ht[i].weight*j;
            printf("\n");
        }
       printf("平均长度%f",1.0*sum/m-1);
    }
    int main()
    {
        HTNode ht[N]= {{"the",1192},{"of",677},{"a",541},{"to",518},{"and",462},{"in",450},{"that",242},{"he",195},{"is",190},{"at",181},{"on",174,},{"for",157},{"His",138},{"are",124},{"be",123}};
        HCode hcd[N/2];
        CreatHt(ht,N/2);
        CreatHCode(ht,hcd,N/2);
        DispHCode(ht,hcd,N/2);
        return 0;
    }
    
    程序运行结果展示:

    知识点总结:哈弗曼树的建立和哈弗曼编码的实现

    学习心得:...

    展开全文
  • 编写一个程序btree.cpp,实现二叉树的基本运算,在此基础上,编写exp7-1.cpp,完成如下功能: 1、由二叉树创建对应的二叉链存储结构b,该二叉树的括号表示串为"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(...

    实验题目:
         实现二叉树各种基本运算的算法
    实验目的:
         领会二叉链存储结构和掌握二叉树中各种基本运算算法设计
      实验内容:
            编写一个程序btree.cpp,实现二叉树的基本运算,在此基础上,编写exp7-1.cpp,完成如下功能:
     1、由二叉树创建对应的二叉链存储结构b,该二叉树的括号表示串为 "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))"。
    2、输出二叉树b
    3、输出'H'结点的左、右孩子结点值
    4、输出二叉树b的高度
    5、释放二叉树b

    btree.cpp如下:

    //
    // Created by liushihao on 19-4-26.
    //
    #include "iostream"
    #define Maxsize 100
    using namespace std;
    typedef char ElemType;
    
    typedef struct node
    {
        ElemType data;
        struct node *lchild;
        struct node *rchild;
    }BTNode;
    
    
    
    void CreateBTree(BTNode * &b, char *str) //创造二叉树
    {
        BTNode *St[Maxsize], *p;
        int top=-1,k,j=0;
        char ch;
        b=NULL;
        ch=str[j];
        while(ch!='\0')
        {
            switch (ch)
            {
                case '(':top++;St[top]=p;k=1;break;
                case ')':top--;              break;
                case ',':k=2;                break;
                default:
                    p=(BTNode*)malloc(sizeof(BTNode));
                    p->data=ch;
                    p->lchild=p->rchild=NULL;
                    if(b==NULL)
                        b=p;
                    else
                    {
                        switch(k)
                        {
                            case 1:St[top]->lchild=p;break;
                            case 2:St[top]->rchild=p;break;
                        }
                    }
            }
            j++;
            ch=str[j];
        }
    }
    
    void DestroyBtree(BTNode *&b)  //销毁二叉树
    {
        if(b!=NULL)
        {
            DestroyBtree(b->lchild);
            DestroyBtree(b->rchild);
            free(b);
        }
    }
    
    BTNode *FindNode(BTNode *b,ElemType x)
    {
        BTNode *p;
        if(b==NULL)
        {
            return NULL;
        }
        else if(b->data==x)
        {
            return b;
        }
        else
        {
            p=FindNode(b->lchild, x);
            if(p!=NULL)
            {
                return p;
            }
            else
            {
                return FindNode(b->rchild, x);
            }
        }
    }
    
    BTNode *LchildNode(BTNode *p)
    {
        return p->lchild;
    }
    
    BTNode *RchildNode(BTNode *p)
    {
        return p->rchild;
    }
    
    int BTHeight(BTNode *b)
    {
        int lchildh,rchildh;
        if(b==NULL) return 0;
        else
        {
            lchildh=BTHeight(b->lchild);
            rchildh=BTHeight(b->rchild);
            return (lchildh>rchildh)? (lchildh+1):(rchildh+1);
        }
    }
    
    void DispBTree(BTNode *b)
    {
        if(b!=NULL)
        {
            cout<<b->data;
            if(b->lchild!=NULL || b->rchild!=NULL)
            {
                cout<<"(";
                DispBTree(b->lchild);
                if(b->rchild!= NULL) cout<<",";
                DispBTree(b->rchild);
                cout<<")";
            }
        }
    }

    exp7-1.cpp如下:

    #include "btree.h"
    int main()
    {
        BTNode *b;
        char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
        CreateBTree(b, str);
        cout<<"初始化二叉树为:"<<endl;
        DispBTree(b);
        cout<<endl;
        cout<<"H结点的左结点:"<<LchildNode(FindNode(b,'H'))->data<<"  右结点:"<<RchildNode(FindNode(b,'H'))->data<<endl;
        cout<<"二叉树的高度为:"<<endl;
        cout<<BTHeight(b)<<endl;
        DestroyBtree(b);
        return 0;
    }

     

    展开全文
  • 说明:禁止转载,对源码要求是禁止把这个东西原封不动或非常小量改动后用于课程设计(我很建议你自己动手实现,你会做比我更好),源码仅供学习参考,思路仅供参考,仍有不足,欢迎评论指出。 1.问题定义及需求...

    说明:禁止转载,对源码的要求是禁止把这个东西原封不动或非常小量改动后用于课程设计(我很建议你自己动手实现,你会做的比我更好),源码仅供学习参考,思路仅供参考,仍有不足,欢迎评论指出。

    1.问题定义及需求分析

    二叉树算术表达式求值,设计十进制整数四则运算计算器。

    1)采用二叉树等存储结构。

    2)给定表达式字符串,生成二叉树。

    3)对二叉树遍历求值并输出。

    2.概要设计

    通过宏定义预先定义可输入的最大长度maxsize。用一个结构体BtreeNode代表二叉树的节点。

    通过afaToBtree函数将输入的字符串转化成二叉树,然后通过cal函数将所生成的二叉树进行遍历,从而计算出最终结果。

    3.详细设计

        结构体的设计:

        因为二叉树的节点既有可能存放运算符,有有可能存放数字,因此在定义结构体时,除了左右孩子,又定义的存放数字的double型变量data和存放运算符的char型变量yunsuan。

    typedef struct BtreeNode{

         double data;//数字型节点

         char yunsuan;//运算符型节点

         struct BtreeNode *lchild;

              struct BtreeNode *rchild;

    }BtreeNode;

    生成二叉树的设计:创建函数afaToBtree,输入字符串,起点s和终点e。若改字符串全为数字组成,则计算出所对应的数字,将其存储在data中。若不全为数字,则寻找优先级最低的运算符,既括号外且最右侧的+-或*/符号(都有则取+-),将其作为根节点,将改节点左侧和右侧的内容作为左右孩子,重复调用函数,通过不断调用函数,生成叶子节点均为数字的二叉树。

    BtreeNode* afaToBtree(char *input,int s,int e)

    {

             int local_r=0,flag=0,i;

             int m_m_p=0,a_s_p=0,x=0,xishu;

             for(i=s;i<e;i++)

                      if(input[i]=='+'||input[i]=='-'||input[i]=='*'||input[i]=='/')

                              x++;//判断是否全为数字,如果是x取零

             if(!x)

             {

                      int y;

                      y=input[e-1]-'0';

                      for(i=e-2,xishu=1;i>=s;i--)

                              {

                                       xishu=10*xishu;

                                       y=y+xishu*(input[i]-'0');

                              }//将该字符串所代表的数字算出

                      BtreeNode* bn=(struct BtreeNode*)malloc(sizeof(struct BtreeNode));

                      bn->data=y;

                      bn->yunsuan=NULL;

                      bn->lchild=NULL;

                      bn->rchild=NULL;

                      return bn;//将该数字的值返回给节点的data

             }

             for(i=s;i<e;i++)

             {

                      if(input[i]=='(')

                              flag++;

                      else if(input[i]==')')

                              flag--;//判断该字符是否在括号内,在内flag为1,在外为0

                      if(!flag)

                      {

                              if(input[i]=='*'||input[i]=='/')

                                       m_m_p=i;//将括号外的最右侧的*或/号的位置记录下来

                              else if(input[i]=='+'||input[i]=='-')

                                       a_s_p=i;//将括号外的最右侧的+或-号的位置记录下来

                      }

             }

             if((m_m_p==0)&&(a_s_p==0))

                      afaToBtree(input,s+1,e-1);//去掉最外层的括号

             else

             {

                     if(a_s_p>0)

                             local_r=a_s_p;

                     else if(m_m_p>0)

                              local_r=m_m_p;//将记录下的+-或*/号记录下来,作为根节点

                     BtreeNode* b=(struct BtreeNode*)malloc(sizeof(struct BtreeNode));

                     b->yunsuan=input[local_r];

                      b->lchild=afaToBtree(input,s,local_r);

                      b->rchild=afaToBtree(input,local_r+1,e);//对该根节点的左侧和右侧分别再次操作

                      return b;

             }

    }

    遍历二叉树求值的设计:通过double型函数cal,输入二叉树的根节点,从该根节点出发,若为数字则直接返回给函数,若为运算符则判断为加减乘除,并对该节点两端的式子进行相应的运算,若两端仍为表达式则继续调用该函数,直至全为数字,并计算出结果。

    double cal(BtreeNode *root){

            switch(root->yunsuan){

                case '+':{

                    return cal(root->lchild)+cal(root->rchild);

                    break;

                }

                case '-':{

                    return cal(root->lchild)-cal(root->rchild);

                    break;

                }

                case '/':{

                    return cal(root->lchild)/cal(root->rchild);

                    break;

                }

                case '*':{

                    return cal(root->lchild)*cal(root->rchild);

                    break;

                }//通过对根节点的运算符的遍历,判断加减乘除并进行操作,最后将结果返回

            }

        return root->data;

    }

     

    4.调试分析:

        在测试中,发现了输出结果一直为0的问题,后发现将double型数据当作int型用%d输出了,将其改为%lf后恢复正常。后在测试中发现了计算结果与实际结果不符的问题,经验证,是根节点的右孩子的计算出现了问题。通过不断的排查,发现在红字体i=s处,写成了i=0,从而导致无论s是几,都会从i=0开始遍历,因此对左指数无影响,而对右子树有影响,因为s不再是0,从而导致计算结果错误。在改正该错误后,问题得到解决,计算结果正确。

    for(i=s;i<e;i++)

                      if(input[i]=='+'||input[i]=='-'||input[i]=='*'||input[i]=='/')

                              x++;//判断是否全为数字,如果是x取零

             if(!x)

             {

                      int y;

                      y=input[e-1]-'0';

                      for(i=e-2,xishu=1;i>=s;i--)

                              {

                                       xishu=10*xishu;

                                       y=y+xishu*(input[i]-'0');

                              }//将该字符串所代表的数字算出

    5.使用说明

        调整最大输入长度,可以通过修改宏定义来实现。如设置最大长度为100,则输入

    #define maxsize 100

        输入时可输入数字及+-*/符号,优先计算的可用()括起来,计算顺序与我们日常的计算顺序一致。如输入:12+(21-4)/3+(3+2)*14

    6.测试结果

    7.附录

    #include<stdio.h>

    #include<stdlib.h>

    #include<string.h>

    #define maxsize 100//可输入的最大长度

    typedef struct BtreeNode{

         double data;//数字型节点

         char yunsuan;//运算符型节点

         struct BtreeNode *lchild;

              struct BtreeNode *rchild;

    }BtreeNode;

    BtreeNode* afaToBtree(char *input,int s,int e)

    {

             int local_r=0,flag=0,i;

             int m_m_p=0,a_s_p=0,x=0,xishu;

             for(i=s;i<e;i++)

                      if(input[i]=='+'||input[i]=='-'||input[i]=='*'||input[i]=='/')

                              x++;//判断是否全为数字,如果是x取零

             if(!x)

             {

                      int y;

                      y=input[e-1]-'0';

                      for(i=e-2,xishu=1;i>=s;i--)

                              {

                                       xishu=10*xishu;

                                       y=y+xishu*(input[i]-'0');

                              }//将该字符串所代表的数字算出

                      BtreeNode* bn=(struct BtreeNode*)malloc(sizeof(struct BtreeNode));

                      bn->data=y;

                      bn->yunsuan=NULL;

                      bn->lchild=NULL;

                      bn->rchild=NULL;

                      return bn;//将该数字的值返回给节点的data

             }

             for(i=s;i<e;i++)

             {

                      if(input[i]=='(')

                              flag++;

                      else if(input[i]==')')

                              flag--;//判断该字符是否在括号内,在内flag为1,在外为0

                      if(!flag)

                      {

                              if(input[i]=='*'||input[i]=='/')

                                       m_m_p=i;//将括号外的最右侧的*或/号的位置记录下来

                              else if(input[i]=='+'||input[i]=='-')

                                       a_s_p=i;//将括号外的最右侧的+或-号的位置记录下来

                      }

             }

             if((m_m_p==0)&&(a_s_p==0))

                      afaToBtree(input,s+1,e-1);//去掉最外层的括号

             else

             {

                     if(a_s_p>0)

                             local_r=a_s_p;

                     else if(m_m_p>0)

                              local_r=m_m_p;//将记录下的+-或*/号记录下来,作为根节点

                     BtreeNode* b=(struct BtreeNode*)malloc(sizeof(struct BtreeNode));

                     b->yunsuan=input[local_r];

                      b->lchild=afaToBtree(input,s,local_r);

                      b->rchild=afaToBtree(input,local_r+1,e);//对该根节点的左侧和右侧分别再次操作

                      return b;

             }

    }

    double cal(BtreeNode *root){

            switch(root->yunsuan){

                case '+':{

                    return cal(root->lchild)+cal(root->rchild);

                    break;

                }

                case '-':{

                    return cal(root->lchild)-cal(root->rchild);

                    break;

                }

                case '/':{

                    return cal(root->lchild)/cal(root->rchild);

                    break;

                }

                case '*':{

                    return cal(root->lchild)*cal(root->rchild);

                    break;

                }//通过对根节点的运算符的遍历,判断加减乘除并进行操作,最后将结果返回

            }

        return root->data;

    }

     

    int main()

    {

             char input[maxsize-1];//保存输入的字符串

             int s=0,e;

             double result;

             printf("请输入需计算的表达式:");

             scanf("%s",&input);//读入结果

             e=strlen(input);//计算字符串的长度

             result=cal(afaToBtree(input,s,e));//生成二叉树并计算出结果

             printf("计算结果为%lf\n",result);//输出最终结果

    }

    展开全文
  • C++ 二叉树的基本运算实现二叉树的定义二叉树的性质性质1:非空二叉树上的叶子结点数等于双分支结点数加1 二叉树的定义 二叉树是一个有限的结点的集合,这个集合或者为空,或者由一个根节点两棵互不相交的称为...
  • 实验内容 1、假设二叉树中的每个结点值为单个字符,...3、编写一个程序,实现二叉树的基本运算,并在此基础上完成以下功能: (1)由图7.33所示的二叉树创建对应的二叉链存储结构b,该二叉树的括号表示串为“A(B(...
  • 实现二叉树各种基本运算的算法

    千次阅读 2019-01-23 17:57:01
    /** * 实验题目: * 实现二叉树各种基本运算的算法 ... 设计程序,实现二叉树的基本运算,在此基础上,完成如下功能: * 1、由二叉树创建对应的二叉链存储结构b,该二叉树的括号表示串为 * "A(B(D,E(H(J,K(L,M(,...
  • 二叉树实现家谱相关运算

    千次阅读 2019-07-30 08:52:38
    * 用二叉树实现家谱相关运算 * 实验内容 * 编写程序,采用一棵二叉树表示一个家谱关系。要求程序具有如下功能: * 1、文件操作功能: * 记录输入,记录输出,清除全部文件记录将家谱记录存盘。 * 2、家谱操作...
  • 二叉树实现复杂运算

    2014-03-23 18:59:57
       二叉树  树是一种重要非线性数据结构,...树结构在客观世界中广泛存在,如人类社会族谱各种社会组织机构都可用树形象表示。树在计算机领域中也得到广泛应用,如在编译源程序如下时,可用树表示源源...
  • 在此以前序遍历来实现查找运算的递归算法。 bitree search(bitree bt,elemtype x)//利用前序遍历实现二叉树bt中查找元素为x结点,并返回结点地址 { if(bt!=NULL)//如果二叉树bt非空 { if(b
  • 实验题目设计一个程序exp7-6.cpp,构造一棵哈夫曼树,输出对应哈夫曼编码平均查找长度。并用表7.8所示数据进行验证。实验目的掌握哈夫曼树构造过程哈夫曼编码产生方法;灵活运用二叉树这种数据结构解决...
  • 多看代码,才能学习到二叉树的基本知识应用。 二叉树的基本运算 所谓的基本运算主要包括:括号表示法的树与二叉链存储结构的树互相转换,树节点查找,求树高度。 1. 树节点查找: 最基本的操作了: class ...
  • 二叉树的基本运算

    千次阅读 2016-12-16 20:33:31
    二叉树的基本运算 一、实验目的 1、使学生熟练掌握二叉树的逻辑结构存储结构。 2、熟练掌握二叉树的各种遍历算法。 二、实验内容 题目一:二叉树的基本操作实现 (必做题) [问题描述] 建立一棵二叉树,试编程实现...
  • 数据结构二叉树实现二叉树的遍历先中后序,二叉树的基本运算,计算结点数,实现二叉树的复制,求二叉树的最大值最小值,求二叉树中所有根结点到叶子结点的路径,判断两颗二叉树的相似性...
  • 实验名称:树和二叉树的基本运算实现 指导教师: 王莹洁  专业班级: 计163-1  姓 名: 曹欣宇  学 号: 201658503125  一、实验题目 设计一个程序exp7-6.cpp,构造一棵哈夫曼树,输出对
  • 18724 二叉树的遍历运算 时间限制:1000MS 代码长度限制:10KB 题型: 编程题 语言: 不限定 Description 二叉树的三种遍历都可以通过递归实现。 如果我们知道一棵二叉树的先序中序序列,可以用递归的方法求后序遍历...
  • 设计一个程序exp7-6.cpp,构造一棵哈夫曼树,输出对应哈夫曼编码平均查找长度。并用表7.8所示数据进行验证。 表7.8 单词及出现频度 单词 The of a to and in ...
  • 18724 二叉树的遍历运算 Description 二叉树的三种遍历都可以通过递归实现。 如果我们知道一棵二叉树的先序中序序列,可以用递归的方法求后序遍历序列。 输入格式 两行,第一行一个字符串,表示树的先序遍历,第二...
  • 二叉树采用二叉链表作为存储结构,实现二叉树的如下基本操作: (1)按先序序列构造一颗二叉链表表示的二叉树T; (2)对这颗二叉树进行先序层次遍历序列,分别输出结点的遍历序列; (3)求二叉树的深度。 #...
  • 利用二叉树计算四则运算表达式

    千次阅读 2012-03-19 15:53:47
    先做个简单实现,没有括号,所有数字都是个位数 主要思路如下: 例如有这样一个四则运算...+号作为二叉树的根,左右两部分分别作为二叉树根的左右子树 再依次递归的分下去。 最终将其转化为下面这样的一棵树:
  • Java中实现二叉树的递归迭代遍历二叉树递归遍历前序遍历,中序遍历,后序遍历迭代遍历前序遍历,中序遍历,后序遍历层序遍历(使用队列)平衡二叉树完全二叉树 二叉树 所谓遍历(Traversal)是指沿着某条搜索路线,...
  • 一。什么是二叉树遍历: ... 遍历是二叉树上最重要的运算之一,是二叉树上进行其它运算之基础。 二。三种遍历顺序:  ① NLR:前序遍历(Preorder Traversal 亦称(先序遍历))  访问根结点操作发生在遍

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 477
精华内容 190
关键字:

二叉树的实现和运算