二叉树的存储与实现

数据结构（⼆⼗四）⼆叉树的链式存储结构（⼆叉链表） ⼀、⼆叉树每个结点最多有两个孩⼦，所以为它设计⼀个数据域和两个指针域，称这样的链表叫做⼆叉链表。

⼆、结点结构包括：lchild左孩⼦指针域、data数据域和rchild右孩⼦指针域。

三、⼆叉链表的C语⾔代码实现：#include "string.h"#include "stdio.h"#include "stdlib.h"#include "io.h"#include "math.h"#include "time.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 100 /* 存储空间初始分配量 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 *//* ⽤于构造⼆叉树********************************** */int index=1;typedef char String[24]; /* 0号单元存放串的长度 */String str;Status StrAssign(String T,char *chars){int i;if(strlen(chars)>MAXSIZE)return ERROR;else{T[0]=strlen(chars);for(i=1;i<=T[0];i++)T[i]=*(chars+i-1);return OK;}}/* ************************************************ */typedef char TElemType;TElemType Nil=''; /* 字符型以空格符为空 */Status visit(TElemType e){printf("%c ",e);return OK;}typedef struct BiTNode /* 结点结构 */{TElemType data; /* 结点数据 */struct BiTNode *lchild,*rchild; /* 左右孩⼦指针 */}BiTNode,*BiTree;/* 构造空⼆叉树T */Status InitBiTree(BiTree *T){*T=NULL;return OK;}/* 初始条件: ⼆叉树T存在。

数据结构实验报告二叉树数据结构实验报告：二叉树引言：数据结构是计算机科学中的重要基础，它为我们提供了存储和组织数据的方式。

二叉树作为一种常见的数据结构，广泛应用于各个领域。

本次实验旨在通过实践，深入理解二叉树的概念、性质和操作。

一、二叉树的定义与性质1.1 定义二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。

二叉树可以为空树，也可以是由根节点和左右子树组成的非空树。

1.2 基本性质（1）每个节点最多有两个子节点；（2）左子树和右子树是有顺序的，不能颠倒；（3）二叉树的子树仍然是二叉树。

二、二叉树的遍历2.1 前序遍历前序遍历是指首先访问根节点，然后按照先左后右的顺序遍历左右子树。

在实际应用中，前序遍历常用于复制一颗二叉树或创建二叉树的副本。

2.2 中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。

中序遍历的结果是一个有序序列，因此在二叉搜索树中特别有用。

2.3 后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。

后序遍历常用于计算二叉树的表达式或释放二叉树的内存。

三、二叉树的实现与应用3.1 二叉树的存储结构二叉树的存储可以使用链式存储或顺序存储。

链式存储使用节点指针连接各个节点，而顺序存储则使用数组来表示二叉树。

3.2 二叉树的应用（1）二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树上的节点都小于根节点，右子树上的节点都大于根节点。

二叉搜索树常用于实现查找、插入和删除等操作。

（2）堆：堆是一种特殊的二叉树，它满足堆序性质。

堆常用于实现优先队列，如操作系统中的进程调度。

（3）哈夫曼树：哈夫曼树是一种带权路径最短的二叉树，常用于数据压缩和编码。

四、实验结果与总结通过本次实验，我成功实现了二叉树的基本操作，包括创建二叉树、遍历二叉树和查找节点等。

在实践中，我进一步理解了二叉树的定义、性质和应用。

二叉树作为一种重要的数据结构，在计算机科学中有着广泛的应用，对于提高算法效率和解决实际问题具有重要意义。

二叉树的储存结构的实现及应用二叉树是一种常见的数据结构，它在计算机科学和算法设计中广泛应用。

二叉树的储存结构有多种实现方式，包括顺序储存结构和链式储存结构。

本文将从这两种储存结构的实现和应用角度进行详细介绍，以便读者更好地理解二叉树的储存结构及其在实际应用中的作用。

一、顺序储存结构的实现及应用顺序储存结构是将二叉树的节点按照从上到下、从左到右的顺序依次存储在一维数组中。

通常采用数组来实现顺序储存结构，数组的下标和节点的位置之间存在一定的对应关系，通过数学计算可以快速找到节点的父节点、左孩子和右孩子。

顺序储存结构的实现相对简单，利用数组的特性可以迅速随机访问节点，适用于完全二叉树。

1.1 实现过程在采用顺序储存结构的实现中，需要首先确定二叉树的深度，然后根据深度确定数组的长度。

通过数学计算可以得到节点间的位置关系，初始化数组并按照规定的顺序将二叉树节点逐一填入数组中。

在访问二叉树节点时，可以通过计算得到节点的父节点和子节点的位置，从而实现随机访问。

1.2 应用场景顺序储存结构适用于完全二叉树的储存和遍历，常见的应用场景包括二叉堆和哈夫曼树。

二叉堆是一种特殊的二叉树，顺序储存结构可以方便地实现它的插入、删除和调整操作，因此在堆排序、优先队列等算法中得到广泛应用。

哈夫曼树则是数据压缩领域的重要应用，通过顺序储存结构可以有效地构建和处理哈夫曼树，实现压缩编码和解码操作。

二、链式储存结构的实现及应用链式储存结构是通过指针将二叉树的节点连接起来，形成一个类似链表的结构。

每个节点包含数据域和指针域，指针域指向节点的左右孩子节点。

链式储存结构的实现相对灵活，适用于任意形态的二叉树，但需要额外的指针空间来存储节点的地址信息。

2.1 实现过程在链式储存结构的实现中，每个节点需要定义为一个包含数据域和指针域的结构体或类。

通过指针来连接各个节点，形成一个二叉树的结构。

在树的遍历和操作中，可以通过指针的操作来实现节点的访问和处理，具有较高的灵活性和可扩展性。

数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构，它由节点和边构成，每个节点最多有两个子节点。

在本次实验中，我们将对二叉树的基本结构和基本操作进行实现和测试，并深入了解它的特性和应用。

实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作，包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构：我们将首先学习二叉树的定义，并实现二叉树的存储结构，包括节点的定义和节点指针的表示方法。

2. 二叉树的创建和初始化：我们将实现二叉树的创建和初始化操作，以便后续操作和测试使用。

3. 二叉树的遍历：我们将实现二叉树的前序、中序和后序遍历算法，并测试其正确性和效率。

4. 二叉树的查找：我们将实现二叉树的查找操作，包括查找节点和查找最大值、最小值等。

5. 二叉树的应用：我们将探讨二叉树在实际应用中的使用场景，如哈夫曼编码、二叉搜索树等。

二叉树的定义和存储结构二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。

节点被表示为一个由数据和指向其左右子节点的指针组成的结构。

二叉树可以分为三类：满二叉树、完全二叉树和非完全二叉树。

二叉树可以用链式存储结构或顺序存储结构表示。

- 链式存储结构：采用节点定义和指针表示法，通过将节点起来形成一个树状结构来表示二叉树。

- 顺序存储结构：采用数组存储节点信息，通过计算节点在数组中的位置来进行访问和操作。

二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。

我们可以通过手动输入或读取外部文件中的数据来创建二叉树。

对于链式存储结构，我们需要自定义节点和指针，并通过节点的方式来构建二叉树。

对于顺序存储结构，我们需要定义数组和索引，通过索引计算来定位节点的位置。

一般来说，初始化一个二叉树可以使用以下步骤：1. 创建树根节点，并赋初值。

2. 创建子节点，并到父节点。

3. 重复步骤2，直到创建完整个二叉树。

实现二叉链表存储结构下二叉树的先序遍历的非递归算法要实现二叉链表存储结构下二叉树的先序遍历的非递归算法，可以使用栈来辅助存储节点。

首先，创建一个空栈，并将树的根节点压入栈中。

然后，循环执行以下步骤，直到栈为空：1. 弹出栈顶的节点，并访问该节点。

2. 若该节点存在右子节点，则将右子节点压入栈中。

3. 若该节点存在左子节点，则将左子节点压入栈中。

注：先将右子节点压入栈中，再将左子节点压入栈中的原因是，出栈操作时会先访问左子节点。

下面是使用Python语言实现的例子：```pythonclass TreeNode:def __init__(self, value):self.val = valueself.left = Noneself.right = Nonedef preorderTraversal(root):if root is None:return []stack = []result = []node = rootwhile stack or node:while node:result.append(node.val)stack.append(node)node = node.leftnode = stack.pop()node = node.rightreturn result```这里的树节点类为`TreeNode`，其中包含节点的值属性`val`，以及左子节点和右子节点属性`left`和`right`。

`preorderTraversal`函数为非递归的先序遍历实现，输入参数为二叉树的根节点。

函数中使用了一个栈`stack`来存储节点，以及一个列表`result`来存储遍历结果。

在函数中，先判断根节点是否为None。

如果是，则直接返回空列表。

然后，创建一个空栈和结果列表。

接下来，用一个`while`循环来执行上述的遍历过程。

循环的条件是栈`stack`不为空或者当前节点`node`不为None。

实验六：二叉树及其应用一、实验目的树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。

二、问题描述首先，掌握二叉树的各种存储结构和熟悉对二叉树的基本操作。

其次，以二叉树表示算术表达式的基础上，设计一个十进制的四则运算的计算器。

如算术表达式：a+b*(c-d)-e/f三、实验要求如果利用完全二叉树的性质和二叉链表结构建立一棵二叉树，分别计算统计叶子结点的个数。

求二叉树的深度。

十进制的四则运算的计算器可以接收用户来自键盘的输入。

由输入的表达式字符串动态生成算术表达式所对应的二叉树。

自动完成求值运算和输出结果。

四、实验环境PC微机DOS操作系统或Windows 操作系统Turbo C 程序集成环境或Visual C++ 程序集成环境五、实验步骤1、根据二叉树的各种存储结构建立二叉树；2、设计求叶子结点个数算法和树的深度算法；3、根据表达式建立相应的二叉树，生成表达式树的模块；4、根据表达式树，求出表达式值，生成求值模块；5、程序运行效果，测试数据分析算法。

六、测试数据1、输入数据：2.2*（3.1+1.20）-7.5/3正确结果：6.962、输入数据：(1+2)*3+(5+6*7);正确输出：56七、表达式求值由于表达式求值算法较为复杂，所以单独列出来加以分析：1、主要思路：由于操作数是任意的实数，所以必须将原始的中缀表达式中的操作数、操作符以及括号分解出来，并以字符串的形式保存；然后再将其转换为后缀表达式的顺序，后缀表达式可以很容易地利用堆栈计算出表达式的值。

例如有如下的中缀表达式：a+b-c转换成后缀表达式为：ab+c-然后分别按从左到右放入栈中，如果碰到操作符就从栈中弹出两个操作数进行运算，最后再将运算结果放入栈中，依次进行直到表达式结束。

如上述的后缀表达式先将a 和b 放入栈中，然后碰到操作符“+”，则从栈中弹出a 和b 进行a+b 的运算，并将其结果d（假设为d）放入栈中，然后再将c 放入栈中，最后是操作符“-”，所以再弹出d和c 进行d-c 运算，并将其结果再次放入栈中，此时表达式结束，则栈中的元素值就是该表达式最后的运算结果。

设计以先序遍历的顺序建立二叉树的二叉链表存储结构的算法一、算法简介二叉树是一种重要的树形结构，它的建立方式有多种，其中一种是按照先序遍历的顺序建立二叉树。

这种方式需要将先序遍历序列和二叉树的存储结构相结合，采用二叉链表存储结构。

具体流程是按照先序遍历序列的顺序依次创建二叉树的各个节点，同时使用二叉链表结构保存每个节点的数据和指针信息。

二、算法实现算法的实现主要包括初始化二叉树、创建节点、建立二叉树等步骤，下面对这些步骤进行详细描述。

1. 初始化二叉树初始化二叉树需要创建一个根节点，同时将根节点的左右指针指向NULL，表示二叉树为空。

2. 创建节点创建节点需要通过输入元素数据来创建，同时节点的左右指针也需要初始化为NULL。

3. 建立二叉树建立二叉树是按照先序遍历序列来实现的，具体流程如下：（1）读入当前节点的元素数据，创建节点，并将其作为当前节点。

（2）判断当前节点的元素数据是否为结束符号（这里结束符号可以指定），如果是，则返回NULL。

（3）递归创建当前节点的左子树，将左子树的根节点赋值给当前节点的左指针。

（4）递归创建当前节点的右子树，将右子树的根节点赋值给当前节点的右指针。

（5）返回当前节点。

三、算法优化虽然上述算法实现简单明了，但它有一个缺点，即无法处理空节点的情况，如果输入的先序遍历序列中存在空节点，那么该算法就无法建立正确的二叉树了。

因此，可以在输入的先序遍历序列中使用一个特殊的符号（如#）表示空节点，在建立节点时，如果遇到该符号，则将该节点的指针设置为NULL即可。

四、算法总结按照先序遍历的顺序建立二叉树是一种基于二叉链表存储结构的建树方式。

它通过递归的方式构建整个二叉树，同时为了处理空节点的情况，还需要对输入的先序遍历序列进行特殊处理。

该算法的效率较高，适用于对先序遍历序列已知的情况下建立二叉树。

实验4 表达式二叉树类型的实现源代码及每步注解：文件expression.h/*头文件以及存储结构*/#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<string.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW 0typedef int Status;/*二叉树结点类型*/typedef enum{INT,CHAR}ElemTag;/*INT为整型数据num，CHAR为字符型数据c*/ typedef struct TElemType{ElemTag tag;/*{INT,CHAR}指示是整型还是字符型*/union{int num;/*tag=INT时，为整型*/char c;/*tag=CHAR时，为字符型*/};} TElemType;/*二叉树的二叉链表存储表示 */typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild; /* 左右孩子指针 */}BiTNode,*BiTree;typedef BiTree SElemType;/*栈SqStack的元素*/typedef char SElemType1; /*栈SqStack1的元素*//*栈的顺序存储表示 */#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */#define STACKINCREMENT 2 /* 存储空间分配增量 *//*两个顺序栈*/typedef struct SqStack{SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */SElemType *top; /* 栈顶指针 */int stacksize; /* 当前已分配的存储空间，以元素为单位 */}SqStack; /* 顺序栈 */typedef struct SqStack1{SElemType1 *base; /* 在栈构造之前和销毁之后，base的值为NULL */SElemType1 *top; /* 栈顶指针 */int stacksize; /* 当前已分配的存储空间，以元素为单位 */}SqStack1; /* 顺序栈 *//*顺序栈的基本操作*/Status InitStack(SqStack *S){ /* 构造一个空栈S */(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!(*S).base)exit(OVERFLOW); /* 存储分配失败 */(*S).top=(*S).base;(*S).stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */if(S.top==S.base) return TRUE;else return FALSE;}Status Push(SqStack *S,SElemType e){ /* 插入元素e为新的栈顶元素 */if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */{(*S).base=(SElemType*)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));if(!(*S).base) exit(OVERFLOW); /* 存储分配失败 */(*S).top=(*S).base+(*S).stacksize;(*S).stacksize+=STACKINCREMENT;}*((*S).top)++=e;return OK;}Status Pop(SqStack *S,SElemType *e){ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ if((*S).top==(*S).base) return ERROR;*e=*--(*S).top;return OK;}Status GetTop(SqStack S,SElemType *e)if(S.top>S.base){*e=*(S.top-1);return OK;}elsereturn ERROR;}/*顺序栈的基本操作*/Status InitStack1(SqStack1 *S){ /* 构造一个空栈S */(*S).base=(SElemType1 *)malloc(STACK_INIT_SIZE*sizeof(SElemType1));if(!(*S).base)exit(OVERFLOW); /* 存储分配失败 */(*S).top=(*S).base;(*S).stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty1(SqStack1 S){ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */if(S.top==S.base) return TRUE;else return FALSE;}Status Push1(SqStack1 *S,SElemType1 e){ /* 插入元素e为新的栈顶元素 */if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */{(*S).base=(SElemType1*)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType1));if(!(*S).base) exit(OVERFLOW); /* 存储分配失败 */(*S).top=(*S).base+(*S).stacksize;(*S).stacksize+=STACKINCREMENT;}*((*S).top)++=e;return OK;}Status Pop1(SqStack1 *S,SElemType1 *e){ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ if((*S).top==(*S).base) return ERROR;*e=*--(*S).top;return OK;}Status GetTop1(SqStack1 S,SElemType1 *e)if(S.top>S.base){*e=*(S.top-1);return OK;}elsereturn ERROR;}文件expression.cpp#include"expression.h"/*全局变量*/int save_number[31];/*在按原表达式输入形式中，输入的常量保存到数组save_number中，常量最多为30个，0单元不用*/char Expr_String[30];/*存放表达式的字符串*//*以字符序列的形式输入语法正确的前缀表达式，保存到字符串string*//*参数flag=0表示输出的提示信息是"请输入正确的前缀表示式："*//*flag=1表示输出的提示信息为"请以表达式的原书写形式输入正确表示式："*/Status Input_Expr(char *string,int flag){if(flag==0)printf("\n请输入正确的前缀表示式：");else printf("\n请以表达式的原书写形式输入正确表示式：");flushall();/*清理缓冲区*/gets(string);/*从键盘输入一串字符串作为表达式*/if(strlen(string)==1)/*输入的表达式字符串长度为1*/if(string[0]=='+'||string[0]=='-'||string[0]=='*'||string[0]=='/'||string[0 ]=='^')/*输入的表达式只有一个运算符*/{ printf("\n表达式只有一个字符，为运算符，错误！");return ERROR;} elseif((string[0]>='0'&&string[0]<'9')||(string[0]>='a'&&string[0]<='z')||(string[0 ]>='A'&&string[0]<='Z'))/*输入的表达式只有一个数字或字符*/{ printf("\n表达式只有一个字符！");return OK;}else {printf("\n输入的字符不是运算符也不是变量常量，错误！");return ERROR;}return OK;}/*判断字符string[i]，如果是'0'-'9'常量之间，二叉树结点存为整型；否则，存为字符型*/void judge_value(BiTree *E,char *string,int i){if(string[i]>='0'&&string[i]<='9')/*为常量*/{(*E)->data.tag=INT;(*E)->data.num=string[i]-48;}else if(string[i]>=1&&string[i]<=20)/*为常量，常量存于数组save_number中*/{(*E)->data.tag=INT;(*E)->data.num=save_number[string[i]];} else/*为变量*/{(*E)->data.tag=CHAR;(*E)->data.c=string[i];}}/*以正确的前缀表示式并构造表达式E*/Status ReadExpr(BiTree *E,char *exprstring){SqStack S;int i,len;/*len为表达式的长度*/BiTree p,q;(*E)=(BiTree)malloc(sizeof(BiTNode));/*申请二叉树的根结点的空间*/(*E)->lchild=NULL;(*E)->rchild=NULL;len=strlen(exprstring);/*len赋值为表达式的长度*/if(len==1)/*表达式长度为1时，二叉树只有根结点*/judge_value(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/ else{judge_value(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/InitStack(&S);/*初始化栈*/q=(*E);Push(&S,q);/*入栈*/Push(&S,q);/*入栈，根结点入栈两次是为判断先序输入的表达式是不是正确的表达式*/for(i=1;i<len&&!StackEmpty(S);i++){p=(BiTree)malloc(sizeof(BiTNode));judge_value(&p,exprstring,i);/*将exprstring[i]存入二叉树的结点中*/p->lchild=NULL;p->rchild=NULL;if(exprstring[i]=='+'||exprstring[i]=='-'||exprstring[i]=='*'||exprstring[i ]=='/'||exprstring[i]=='^'){/*为运算符，运算符入栈，左孩子不空，向左孩子走，否则，如果右孩子不空，向右孩子走*/if(!q->lchild) {q->lchild=p;Push(&S,p);q=p;}else {q->rchild=p;Push(&S,p);q=p;}}else/*不是运算符，运算符出栈*/{if(!q->lchild) {q->lchild=p;Pop(&S,&q);}else {q->rchild=p;Pop(&S,&q);}}}if(StackEmpty(S)&&i>=len) return OK;/*栈空且i>=len，说明输入的表达式是正确的*/else /*输入的表达式是错误的*/{printf("\n输入的表达式有误！");return ERROR;}}}/*如果两个字符是运算符，比较两个运算符的优先级，c1比c2优先，返回OK，否则返回ERROR*/Status Pri_Compare(char c1,char c2){if((c1=='^'||c1=='*'||c1=='-'||c1=='+'||c1=='/')&&(c2=='^'||c2=='*'||c2=='-'||c2=='+'||c2=='/')){/*c1和c2为运算符*/if(c1=='^')/*c1为指数运算符，则当c2不为'^'时，c1比c2优先*/{if(c2!='^') return OK;else return ERROR;}else if(c1=='*'||c1=='/')/*c1为乘法或除法运算符，则当c2为'+'或'-'，c1比c2优先*/{if(c2=='^'||c2=='*'||c2=='/') return ERROR;else return OK;}else return ERROR;/*其余，c1不比c2优先*/}else return ERROR;/*c1和c2不是运算符*/}/*用带括弧的中缀表达式输入表达式*/void WriteExpr(BiTree E){if(E)/*树不为空*/{ /*先递归左子树*/if(E->lchild&&E->lchild->data.tag==CHAR)/*E的左孩子不为空，且左孩子为字符*/{if(Pri_Compare(E->data.c,E->lchild->data.c))/*E->data.c比E->lchild->data.c优先*/{printf("(");WriteExpr(E->lchild);printf(")");}/*带括弧输出左子树*/else WriteExpr(E->lchild);/*否则，不带括弧输出左子树*/}else WriteExpr(E->lchild);/*否则，输出左子树*//*访问输出根结点的值*/if(E->data.tag==INT){printf("%d",E->data.num);}else printf("%c",E->data.c);/*后递归右子树*/if(E->rchild&&E->rchild->data.tag==CHAR)/*E的右孩子不为空，且右孩子为字符*/{if(Pri_Compare(E->data.c,E->rchild->data.c))/*E->data.c比E->rchild->data.c优先*/{printf("(");WriteExpr(E->rchild);printf(")");}/*带括弧输出右子树*/else WriteExpr(E->rchild);/*否则，不带括弧输出右子树*/}else WriteExpr(E->rchild);/*否则，输出右子树*/}}/*实现对表达式中的所有变量V的赋值(V=c)，参数flag为表示是否赋值过的标志*/ void Assign(BiTree *E,char V,int c,int *flag){if(*E){if((*E)->data.tag==CHAR&&(*E)->data.c==V)/*如果找到要赋值的变量，赋值*/{(*E)->data.tag=INT;(*E)->data.num=c;*flag=1;}Assign(&((*E)->lchild),V,c,flag);/*递归左子树*/Assign(&((*E)->rchild),V,c,flag);/*递归左子树*/}}/*指数运算函数，底数为x，指数为exp*/long power(int x,int exp){long result;int i;for(i=1,result=1;i<=exp;i++)result*=x;return result;}/*运算符运算求值，参数opr1,opr2为常量，opr为运算符，根据不同的运算符，实现不同的运算，返回运算结果*/long Operate(int opr1,char opr,int opr2){long result;switch(opr){case '+':/*加法*/result=opr1+opr2;return result;break;case '-':/*减法*/result=opr1-opr2;return result;break;case '*':/*乘法*/result=opr1*opr2;return result;break;case '/':/*除法，除法是在整型类型上的除法*/result=opr1/opr2;return result;break;case '^':/*指数运算*/result=power(opr1,opr2);return result;break;default:break;}}/*检查表达式是否还存在没有赋值的变量，以便求算数表达式的值*/Status Check(BiTree E){if(E&&E->data.tag==CHAR)/*树不为空*/{if(E->data.c!='*'&&E->data.c!='^'&&E->data.c!='-'&&E->data.c!='+'&&E->data. c!='/'){printf("\n表达式中仍存在变量没有赋值！没法求出表达式的值！");return ERROR;}/*存在变量，提示信息，后返回ERROR*/if(Check(E->lchild))/*递归左子树*/Check(E->rchild);/*递归右子树*/}}/*对算术表达式求值*/long Value(BiTree E){if(E)/*树不为空*/{if(!E->lchild&&!E->rchild&&E->data.tag==INT) return (E->data.num);/*结点的左孩子和右孩子为空，为叶子结点，返回结点的值*/return Operate(Value(E->lchild),E->data.c,Value(E->rchild));/*运算求值，后根遍历的次序对表达式求值，其中参数递归调用了Value()函数求左子树的值和右子树的值*/}}/*构造一个新的复合表达式*/void CompoundExpr(char P,BiTree *E1,BiTree E2){BiTree E;E=(BiTree)malloc(sizeof(BiTNode));/*申请一个结点存放运算符P*/E->data.tag=CHAR;E->data.c=P;/*申请到的结点值为P*/E->lchild=(*E1);/*结点的左孩子为E1*/E->rchild=E2;/*结点的右孩子为E2*/(*E1)=E;/*(*E1)为根结点*/printf("\n表达式E复合成功！其表达式变为：\n");WriteExpr(E);/*输出复合好的表达式*/}/*以表达式的原书写形式输入，表达式的原书写形式字符串string变为字符串pre_expr*//*后调用reversal_string()函数反转得到前缀表达式pre_expr*/Status Read_Inorder_Expr(char *string,char *pre_expr){int i,j,len,char_number=1;/*len表示字符串string的长度，char_number是记录数组save_number[]的个数*/int number;/*保存大于9的常量*/char c,c1;SqStack1 S;/*栈定义*/InitStack1(&S);/*初始栈*/Push1(&S,'#');/*先将字符'#'入栈，用来表示作为栈的最底一个元素*/len=strlen(string);/*len为字符串string的长度*/c=string[len-1];/*从字符串的最后一个字符开始向前扫描*/i=len-1;while(!StackEmpty1(S)&&i>=0)/*栈不为空且i大于等于0*/{if(c=='(')/*字符为'('*/{Pop1(&S,&c);/*出栈，赋值给c*/while(c!=')')/*假如c不为')',出栈*/{*pre_expr++=c;if(!StackEmpty1(S)&&GetTop1(S,&c1)&&c1!='#') Pop1(&S,&c);else {printf("\n输入的表达式有误!");return ERROR;}}}else if(c==')')/*字符为')'，入栈*/{Push1(&S,c);}else if(c>='0'&&c<='9')/*字符为'0'-'9'之间，循环扫描string前一个字符，后确定常量的大小*/{number=c-48;/*number为第一个常量字符的ASCII码-48*/for(c1=string[i-1],j=1;(c1>='0'&&c1<='9')&&i>=0;j++,i--)/*循环扫描string前一个字符，求出常量后赋给number*/{number=(c1-48)*power(10,j)+number;/*number为扫描到的常量*/c1=string[i-2];}save_number[char_number]=number;/*将number存入到数组save_number中，下标为char_number*/*pre_expr++=char_number++;}else if((c>='a'&&c<='z')||(c>='A'&&c<='Z'))/*字符为'a'-'z'或'A'-'Z'之间的变量*/{/*string下一个字符不能为常量或变量，否则，出错*/if((string[i-1]>='0'&&string[i-1]<='9')||(string[i-1]>='A'&&string[i-1]<='Z ')||(string[i-1]>='a'&&string[i-1]<='z')){printf("\n输入的表达式有误！");return ERROR;}else *pre_expr++=c;}else if(c=='*'||c=='/')/*字符为运算符'*'或'/'*/{while(GetTop1(S,&c1)&&(c1=='^'))/*将c与栈顶的字符c1比较优先级*/{Pop1(&S,&c1);*pre_expr++=c1;}/*如果c1比c优先，出栈*/Push1(&S,c);/*入栈字符c*/}else if(c=='+'||c=='-')/*字符为运算符'+'或'-'*/{while(GetTop1(S,&c1)&&(c1=='^'||c1=='*'||c1=='/'))/*将c与栈顶的字符c1比较优先级*/{Pop1(&S,&c1);*pre_expr++=c1;}/*如果c1比c优先，出栈*/Push1(&S,c);/*入栈运算符c*/}else if(c=='^')/*字符为运算符'^'*/{Push1(&S,c);/*入栈运算符'^'*/}else {printf("\n输入的表达式有误！");return ERROR;}/*其他字符，错误，返回ERROR*/i--;/*下一个字符*/if(i>=0) c=string[i];/*i不小于0，c=string[i]循环下一个字符*/else /*否则，将清空栈*/while(!StackEmpty1(S)&&GetTop1(S,&c1)&&c1!='#'){Pop1(&S,&c);*pre_expr++=c;}}Pop1(&S,&c);/*将'#'出栈*/*pre_expr='\0';/*字符串结束符*/if(i<0&&StackEmpty1(S))return OK;else return ERROR;}/*将字符串exprstring反转过来*/void reversal_string(char *exprstring){int len,i,j;char temp;len=strlen(exprstring);/*len为exprstring的长度*/for(i=0,j=len-1;i<j;i++,j--)/*字符串前后两个字符对换*/{temp=exprstring[i];exprstring[i]=exprstring[j];exprstring[j]=temp;}}/*常数合并操作函数，合并表达式E中所有常数运算*/void MergeConst(BiTree *E){long result;if((*E)->lchild&&(*E)->rchild)/*左右孩子不为空*/{if((*E)->lchild->data.tag==INT&&(*E)->rchild->data.tag==INT)/*假如左右孩子为常量，合并*/{result=Operate((*E)->lchild->data.num,(*E)->data.c,(*E)->rchild->data.num); /*常数合并运算，调用Operate()函数求值*/(*E)->data.tag=INT;(*E)->data.num=result;/*修改之前的运算符为常量*/free((*E)->lchild);/*释放左孩子*/free((*E)->rchild);/*释放右孩子*/(*E)->lchild=(*E)->rchild=NULL;/*左右孩子置空*/}else{MergeConst(&((*E)->lchild));/*递归左孩子*/MergeConst(&((*E)->rchild));/*递归右孩子*/}}}/*主菜单*/char menu(){char choice;printf("\n\t****************************************");printf("\n\t K网络工程121班");printf("\n\t 学号：240121525 姓名：王云峰");printf("\n\t****************************************");printf("\n\t***********表达式类型的实现*************");printf("\n\t 1 >>>输入正确的前缀表达式");printf("\n\t 2 >>>带括弧的中缀表示式输出");printf("\n\t 3 >>>对变量进行赋值");printf("\n\t 4 >>>对算数表达式求值");printf("\n\t 5 >>>构造一个新的复合表达式");printf("\n\t 6 >>>以表达式的原书写形式输入");printf("\n\t 7 >>>合并表达式中所有常数运算");printf("\n\t 0 >>>退出");printf("\n\t****************************************");printf("\n\t请输入你的选择>>>>>");choice=getche();return choice;}/*主函数*/void main(){BiTree E,E1;/*两个表达式E和E1*/int flag=0;/*表达式E构造标志，为0表示未构造，为1表示已构造*/long result;/*保存算数表达式运算结果*/char V,P;int c;char string[30];while(1){ system("cls");switch(menu()){case '1':/*1 >>>输入正确的前缀表达式*/printf("\n\t*************************输入提示信息************************");printf("\n\t输入正确的前缀表达式的要求：");printf("\n\t\t【变量】 a-z或A-Z");printf("\n\t\t【常量】 0-9，不能超过9");printf("\n\t\t【运算符】 +,-,*,/,^(乘幂)");printf("\n\t请输入正确的前缀表达式，后按回车键存入缓冲区，否则可能会出错！");printf("\n\t*************************************************************") ;if(Input_Expr(Expr_String,0))if(ReadExpr(&E,Expr_String)){flag=1;printf("\n表达式构造成功！\n输入的带括弧的中缀表达式：");WriteExpr(E);}getch();break;case '2':/*2 >>>带括弧的中缀表示式输出*/printf("\n\t********************输出说明信息***********************************");printf("\n\t输出带括弧的中缀表达式：");printf("\n\t【1】如果表达式已经构造成功的，输出表达式；");printf("\n\t【2】如果表达式还未构造成功的，请返回主菜单选择构造表达式；");printf("\n\t【注】其中要注意的是，可能有一些表达式构造时没有办法判断为有误，");printf("\n\t 如果输出不是你想得到的，说明你之前输入的表达式有误，请重新构造！");printf("\n\t*************************************************************** *****");if(flag==1) {printf("\n带括弧的中缀表达式为：");WriteExpr(E);}else printf("\n表达式未构造成功！请构造成功的表达式！");getch();break;case '3':/*3 >>>对变量进行赋值*/printf("\n\t********************赋值操作说明信息***********************************");printf("\n\t赋值操作：实现对表达式中的某一个变量V的赋值，即使V=C，C为一整数");printf("\n\t 【1】根据输出的表达式，输入要赋值的变量V，只能输入一个字符，否则出错");printf("\n\t 【2】输入要将变量V赋值为的整数C，只能是整数，否则出错");printf("\n\t 【注】如果表达式未构造，请回到主菜单选择构造表达式");printf("\n\t*************************************************************** ********");if(flag==1){int Assign_flag=0;printf("\n表达式E为：");WriteExpr(E);flushall();/*清理缓冲区*/printf("\n请输入要赋值的值：");V=getchar();printf("请输入要将赋值为：");scanf("%d",&c);Assign(&E,V,c,&Assign_flag);if(Assign_flag) {printf("\n赋值成功！\n赋值后的表达式为：");WriteExpr(E);}else printf("\n表达式里没有%c这个变量！",V);}else printf("\n表达式未构造成功！请构造成功的表达式！");getch();break;case '4':/*4 >>>对算数表达式求值*/printf("\n\t********************算数表达式求值说明信息************************");printf("\n\t 【注】如果表达式还有变量未赋值，即表达式不是算数表达式");printf("\n\t 不能求出表达式的值，请回到主菜单选择赋值操作，后再求值");printf("\n\t*************************************************************** ***");if(flag==1){printf("\n算数表达式：");WriteExpr(E);if(Check(E)){result=Value(E);printf("\n求算数表达式的值:\t");WriteExpr(E);printf("=%ld",result);}}else printf("\n表达式未构造成功！请构造成功的表达式！");getch();break;case '5':/*5 >>>构造一个新的复合表达式*/printf("\n\t*****************构造新的复合表达式说明信息***************************");printf("\n\t 【1】构造一个新的表达式E1，采用表达式的原书写形式输入");printf("\n\t 【2】构造表达式E1成功后，输入要复合表达式E 和E1的操作运算符(+,-,*,/,^)");printf("\n\t 【注】如表达式E未构造，不能复合表达式；如构造表达式E1错误，复合失败");printf("\n\t*************************************************************** ********");if(flag==1){printf("\n表达式E1为：");WriteExpr(E);printf("\n请构造新的表达式E2:");flushall();/*清理缓冲区*/if(Input_Expr(string,1)){if(Read_Inorder_Expr(string,Expr_String)){reversal_string(Expr_String);if(ReadExpr(&E1,Expr_String)){flag=1;printf("\n表达式E1构造成功！");WriteExpr(E1);printf("\n请输入要构造新的复合表达式的操作运算符>>>");P=getchar();while(P!='*'&&P!='/'&&P!='+'&&P!='-'&&P!='^'){flushall();/*清理缓冲区*/printf("\n输入的操作运算符有误！请重新输入>>>");P=getchar();}CompoundExpr(P,&E,E1);}else printf("\n复合新的表达式失败！请按任意键返回主菜单！");}}}else printf("\n表达式未构造成功！请构造成功的表达式！");getch();break;case '6':/*6 >>>以表达式的原书写形式输入*/printf("\n\t*************以表达式的原书写形式输入说明信息************************");printf("\n\t输入正确的原书写形式表达式");printf("\n\t 【变量】 a-z或A-Z");printf("\n\t 【常量】大于等于0的正整数");printf("\n\t 【运算符】 +,-,*,/,^(乘幂)");printf("\n\t 【括弧】左括弧 ( ,右括弧 ) ");printf("\n\t 【注】表示式中常量最多只能是30个，超过30个，出错！");printf("\n\t按原书写形式输入中，请按照正确的方式输入，否则可能会出错！");printf("\n\t*************************************************************** *******");if(Input_Expr(string,1))if(Read_Inorder_Expr(string,Expr_String)){reversal_string(Expr_String);if(ReadExpr(&E,Expr_String)){flag=1;printf("\n表达式构造成功！\n输入的带括弧的中缀表达式：");WriteExpr(E);}}getch();break;case '7':/*7 >>>合并表达式中所有常数运算*/printf("\n***************合并表达式中的所有常数运算*******************************");printf("\n 【注】合并表达式中的所有常数运算并不能一次性将常数都合并！");printf("\n例如：表达式'1+2*(3+3*4+9/3)'的常数合并，选择7进行合并，结果变为\n'1+2*(3+12+3)'，");printf("根据优先级先后合并的，如果要合并到最后，需多次选择7\n进行合并，又合并一次'1+2*(15+3)'，");printf("再次合并'1+2*18',再次合并'1+36'，\n再次合并'37'，后无法合并！");printf("\n***************************************************************** *******");if(flag==1){printf("\n原表达式为：");WriteExpr(E);MergeConst(&E);printf("\n合并表达式中所有的常数运算后的表达式：");WriteExpr(E);}else printf("\n表达式未构造成功！请构造成功的表达式！");getch();break;case '0':/*0 >>>退出*/printf("\n请按任意键退出！");getch();exit(0);default :printf("\n输入有误！请按任意键回到主菜单重新选择！");getch();break;}}}。

二叉排序树（二叉链表结构存储）数据结构课程设计报告目录1需求分析 (1)1.1课程设计题目、任务及要求 (1)1.2课程设计思想 (1)2概要设计 (2)2.1 二叉排序树的定义 (2)2.2二叉链表的存储结构 (2)2.3建立二叉排序树 (2)2.4二叉排序树的生成过程 (3)2.5中序遍历二叉树 (3)2.6二叉排序树的查找 (3)2.7二叉排序树的插入 (4)2.8平均查找长度 (4)3详细设计和实现 (4)3.1主要功能模块设计 (4)3.2主程序设计 (5)4调试与操作说明 (12)4.1程序调试 (12)4.2程序操作说明 (13)总结 (16)致谢 (17)参考文献 (19)1需求分析1.1课程设计题目、任务及要求二叉排序树。

用二叉链表作存储结构(1)以(0)为输入结束标志,输入数列L，生成一棵二叉排序树T；(2)对二叉排序树T作中序遍历,输出结果；(3)计算二叉排序树T查找成功的平均查找长度,输出结果；(4)输入元素x,查找二叉排序树T:若存在含x的结点,则删除该结点,并作中序遍历(执行操作2)；否则输出信息“无x”；1.2课程设计思想建立二叉排序树采用边查找边插入的方式。

查找函数采用递归的方式进行查找。

如果查找成功则不应再插入原树，否则返回当前结点的上一个结点。

然后利用插入函数将该元素插入原树。

对二叉排序树进行中序遍历采用递归函数的方式。

在根结点不为空的情况下，先访问左子树，再访问根结点，最后访问右子树。

由于二叉排序树自身的性质，左子树小于根结点，而根结点小于右子树，所以中序遍历的结果是递增的。

计算二插排序树的平均查找长度时，仍采用类似中序遍历的递归方式，用s记录总查找长度，j记录每个结点的查找长度，s置初值为0，采用累加的方式最终得到总查找长度s。

平均查找长度就等于s/i(i为树中结点的总个数)。

删除结点函数，采用边查找边删除的方式。

如果没有查找到，则不对树做任何的修改；如果查找到结点，则分四种情况分别进行讨论：1、该结点左右子树均为空；2、该结点仅左子树为空；3、该结点仅右子树为空；4、该结点左右子树均不为空。

二叉树的顺序存储结构代码二叉树的顺序存储结构代码一、前言二叉树是一种重要的数据结构，常用于实现搜索、排序等算法。

在实际应用中，为了方便对二叉树进行操作，需要将其存储在计算机中。

本文介绍了二叉树的顺序存储结构代码。

二、二叉树的顺序存储结构1. 定义二叉树的顺序存储结构是指将二叉树中所有节点按照层次遍历的顺序依次存储到一个数组中。

2. 实现方法（1）计算数组长度：由于一个深度为k的满二叉树共有2^k-1个节点，因此可以通过计算出给定深度k下最多可能存在的节点数来确定数组长度。

（2）按层次遍历顺序存储节点：从根节点开始，按照从左到右、从上到下的顺序依次将每个节点存入数组中。

如果某个节点为空，则在数组中用特定符号表示。

3. 代码实现以下是C++语言实现的二叉树顺序存储结构代码：```#include <iostream>#include <cmath>using namespace std;#define MAXSIZE 1000 // 数组最大长度#define EMPTY '#' // 空节点标记// 二叉树结点struct TreeNode {char value; // 结点值};// 二叉树顺序存储结构class SeqBinaryTree {private:TreeNode nodes[MAXSIZE]; // 存储结点的数组int depth; // 树的深度public:SeqBinaryTree(char *values, int len) { // values为层次遍历序列，len为序列长度depth = ceil(log2(len+1)); // 计算树的深度for (int i = 0; i < MAXSIZE; i++) { // 初始化数组nodes[i].value = EMPTY;}for (int i = 0; i < len; i++) { // 将节点按层次遍历顺序存入数组中nodes[i].value = values[i];}}void print() { // 输出二叉树中所有结点值for (int i = 0; i < pow(2,depth)-1; i++) {if (nodes[i].value != EMPTY) {cout << nodes[i].value << " ";}}}};// 测试代码int main() {char values[] = {'A','B','C','#','#','D','E'};SeqBinaryTree tree(values,7);tree.print(); // 输出结果：A B C # # D E}```三、总结本文介绍了二叉树的顺序存储结构代码实现方法，该方法可以方便地对二叉树进行操作。

实现二叉树的各种基本运算的算法代码（一）创建二叉树1. 二叉树的链表存储结构：//定义二叉树的链表存储结构typedef struct BiTNode{char data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;2.利用二叉树的链表存储结构，创建一棵二叉树//根据二叉树的链表存储结构，创建一棵二叉树BiTree CreateBiTree(BiTree T){char c;scanf(&c);if(c=='#')T=NULL;else{T=(BiTree)malloc(sizeof(BiTNode)); // 产生根节点 T->data=c; // 生成根结点T->lchild = CreateBiTree(T->lchild); // 构造左子树 T->rchild = CreateBiTree(T->rchild); // 构造右子树 }return T;}（二）二叉树的遍历1.先序遍历// 先序遍历：根左右void PreOrderTraverse(BiTree T){if(T==NULL)return;printf('%c',T->data); // 访问根结点PreOrderTraverse(T->lchild); // 遍历左子树PreOrderTraverse(T->rchild); // 遍历右子树}2.中序遍历// 中序遍历：左根右void InOrderTraverse(BiTree T){if(T==NULL)return;InOrderTraverse(T->lchild); // 遍历左子树 printf('%c',T->data); // 访问根结点InOrderTraverse(T->rchild); // 遍历右子树 }3.后序遍历// 后序遍历：左右根void PostOrderTraverse(BiTree T){if(T==NULL)return;PostOrderTraverse(T->lchild); // 遍历左子树 PostOrderTraverse(T->rchild); // 遍历右子树 printf('%c',T->data); // 访问根结点}（三）二叉树的其他基本运算1.计算二叉树的结点数// 计算二叉树的结点数int CountTreeNode(BiTree T){if(T==NULL)return 0; // 二叉树T为空时，结点数为0elsereturnCountTreeNode(T->lchild)+CountTreeNode(T->rchild)+1; }2.计算二叉树的深度// 计算二叉树的深度int TreeDepth(BiTree T){int depL, depR;if(T==NULL)return 0; // 二叉树T为空时，深度为0else{depL = TreeDepth(T->lchild); // 左子树深度depR = TreeDepth(T->rchild); // 右子树深度if(depL > depR)return depL+1;elsereturn depR+1;}}。

二叉树的定义、定义、存储二叉树的定义二叉树是每个节点最多有两个子树的树结构。

通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

二叉树常被用于实现二叉查找树和二叉堆。

二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

特殊二叉树1. 斜树所有结点都只有左子树的二叉树叫左斜树，所有结点都只有右子树的二叉树叫右斜树。

斜树的每一层都只有一个结点，结点的个数与斜树的深度相同。

2. 满二叉树在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子结点都在同一层上，这样的二叉树称为满二叉树。

（上图中所示的二叉树，就是一棵满二叉树）3. 完全二叉树对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中的编号为i的结点在二叉树中的位置完全相同，则这棵二叉树称为完全二叉树。

二叉树的性质性质1：在二叉树的第i层上至多有2i-1个结点（i≥1）。

（数学归纳法可证）性质2：深度为k的二叉树最多有2k-1个结点（k≥1）。

（由性质1，通过等比数列求和可证）性质3：一棵二叉树的叶子结点数为n0，度为2的结点数为n2，则n0 = n2 + 1。

证：结点总数n = n0 + n1 + n2。

设B为分支总数，因为除根节点外，其余结点都有一个分支进入，所以n = B + 1。

又因为分支是由度为1或2的结点射出，所以B = n1 + 2n2。

综上：n = n0 + n1 + n2 = B + 1 = n1 + 2n2 + 1，得出：n0 = n2 + 1。

性质4：具有n个结点的完全二叉树的深度为floor(log2n) + 1 。

性质5：如果对一棵有n个结点的完全二叉树（其深度为floor(log2n) + 1 ）的结点按层序编号，则对任一结点i（1≤i≤n）有：（1）如果i = 1，则结点i是二叉树的根，无双亲；如果i > 1，则其双亲PARENT(i)是结点 floor((i)/2)。