数据结构——二叉树基本操作源代码
二叉树的建立与基本操作

二叉树的建立与基本操作二叉树是一种特殊的树形结构,它由节点(node)组成,每个节点最多有两个子节点。
二叉树的基本操作包括建立二叉树、遍历二叉树、查找二叉树节点、插入和删除节点等。
本文将详细介绍二叉树的建立和基本操作,并给出相应的代码示例。
一、建立二叉树建立二叉树有多种方法,包括使用数组、链表和前序、中序、后序遍历等。
下面以使用链表的方式来建立二叉树为例。
1.定义二叉树节点类首先,定义一个二叉树节点的类,包含节点值、左子节点和右子节点三个属性。
```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```2.建立二叉树使用递归的方法来建立二叉树,先构造根节点,然后递归地构造左子树和右子树。
```pythondef build_binary_tree(lst):if not lst: # 如果 lst 为空,则返回 Nonereturn Nonemid = len(lst) // 2 # 取 lst 的中间元素作为根节点的值root = Node(lst[mid])root.left = build_binary_tree(lst[:mid]) # 递归构造左子树root.right = build_binary_tree(lst[mid+1:]) # 递归构造右子树return root```下面是建立二叉树的示例代码:```pythonlst = [1, 2, 3, 4, 5, 6, 7]root = build_binary_tree(lst)```二、遍历二叉树遍历二叉树是指按照其中一规则访问二叉树的所有节点,常见的遍历方式有前序遍历、中序遍历和后序遍历。
1.前序遍历前序遍历是指先访问根节点,然后访问左子节点,最后访问右子节点。
```pythondef pre_order_traversal(root):if root:print(root.value) # 先访问根节点pre_order_traversal(root.left) # 递归访问左子树pre_order_traversal(root.right) # 递归访问右子树```2.中序遍历中序遍历是指先访问左子节点,然后访问根节点,最后访问右子节点。
数据结构上机实验源代码

数据结构上机实验源代码栈的应用十进制数转换为八进制数,逆序输出所输入的数实验代码://stack.h,头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码://queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的(1)理解线性表的链式存储结构。
数据结构实验报告——中序遍历二叉树

实验报告一,实验目的:·掌握二叉树的链式存储结构;·掌握构造二叉树的方法;·加深对二叉树的中序遍历的理解;二,实验方法:·用递归调用算法中序遍历二叉树。
三,实验步骤:·通过链式存储建立一颗二叉树。
·设计一个算法实现中序遍历二叉树。
四,具体实验步骤:#include<stdio.h>#include<stdlib.h>#define LEFT 0#define RIGHT 1#define TRUE 1#define FALSE 0typedef struct _BTNODE{char c;struct _BTNODE *lchild;struct _BTNODE *rchild;}BTNODE,*PBTNODE;void PrintBTree(PBTNODE p,int depth);void ConstructBTree(PBTNODE p);void InorderTraverse(PBTNODE p);void main(){PBTNODE p;p=(PBTNODE)calloc(1,sizeof(BTNODE));printf("Input the data:");ConstructBTree(p);PrintBTree(p,0);printf("Now InorderTraverse:");InorderTraverse(p);printf("\nPress any key to continue...");getchar();}void PrintBTree(PBTNODE p,int depth){int i;if(p==NULL){return;}else{for(i=0;i<depth;i++){printf("--");}printf(">");printf("%c\n",p->c);PrintBTree(p->lchild,depth+1);PrintBTree(p->rchild,depth+1);}}void ConstructBTree(PBTNODE p){int side;char c;side=LEFT;while(TRUE){scanf("%c",&c);if(c=='\n'){//printf("EOF\n");return;}// printf("%d\n",c);switch(c){case '|':break;case')':return;case',':side=RIGHT;break;case'(':if(side==LEFT){if(p->lchild==NULL){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->lchild);}else{if(p->rchild==NULL){p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->rchild);}break;default:if(side==LEFT){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->lchild->c=c;}else{p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->rchild->c=c;}}}}void InorderTraverse(PBTNODE p){if(p==NULL){return;}else{InorderTraverse(p->lchild);printf("[%c] ",p->c);InorderTraverse(p->rchild);}return;}五,实验过程:·输出:Input the date;·输入:1(2(3,4),5(6,7));·输出:Now InorderTraverse:【3】【2】【4】【1】【6】【5】【7】;六,上机实验体会:·体会到熟练掌握各种程序算法的重要性;·通过上机练习,充分理解了链式建立二叉树的算法;·形象的了解二叉树的结构,能够熟练的进行先序,中序,后序遍历二叉树。
二叉树的先序,中序,后序遍历c语言

二叉树的先序,中序,后序遍历c语言
二叉树是常见的数据结构,具有广泛的应用场景,例如搜索树、哈夫曼树等。
其中比较重要的一点就是对二叉树的遍历。
二叉树遍历有三种方式:先序遍历、中序遍历、后序遍历。
接下来,我将通过C语言来详细介绍这三种遍历方式。
一、先序遍历(Preorder Traversal)
先序遍历是指根节点->左子树->右子树的遍历方式。
C语言中的先序遍历算法如下:
```
void preorderTraversal(Node *node) {
if (node != NULL) {
printf("%d ", node->data); // 打印节点值
preorderTraversal(node->left); // 递归遍历左子树
preorderTraversal(node->right); // 递归遍历右子树
}
}
```
先序遍历的实现通过递归调用实现,当节点为空即遍历完成时返回。
总结:
以上三种遍历方式是二叉树遍历中最基本的方法,它们都是基于递归实现的。
通过学习这三种遍历方式,可以更好地理解二叉树的结构特点,提高数据结构算法的学习效果。
二叉树c语言实现完整代码

二叉树c语言实现完整代码二叉树是一种非常常见的数据结构,它由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在计算机科学中,二叉树被广泛应用于搜索、排序、编译器等领域。
本文将介绍如何使用C语言实现二叉树的完整代码。
我们需要定义二叉树的节点结构体。
每个节点包含三个成员变量:数据、左子节点和右子节点。
代码如下:```struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};```接下来,我们需要实现二叉树的基本操作,包括创建节点、插入节点、删除节点、查找节点等。
这些操作可以通过递归实现。
代码如下:```// 创建节点struct TreeNode* createNode(int val) {struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));node->val = val;node->left = NULL;node->right = NULL;return node;}// 插入节点struct TreeNode* insertNode(struct TreeNode* root, int val) {if (root == NULL) {return createNode(val);}if (val < root->val) {root->left = insertNode(root->left, val);} else {root->right = insertNode(root->right, val);}return root;}// 删除节点struct TreeNode* deleteNode(struct TreeNode* root, int val) {if (root == NULL) {return NULL;}if (val < root->val) {root->left = deleteNode(root->left, val);} else if (val > root->val) {root->right = deleteNode(root->right, val);} else {if (root->left == NULL) {struct TreeNode* temp = root->right;free(root);return temp;} else if (root->right == NULL) {struct TreeNode* temp = root->left;free(root);return temp;}struct TreeNode* temp = findMin(root->right); root->val = temp->val;root->right = deleteNode(root->right, temp->val); }return root;}// 查找节点struct TreeNode* searchNode(struct TreeNode* root, int val) {if (root == NULL || root->val == val) {return root;}if (val < root->val) {return searchNode(root->left, val);} else {return searchNode(root->right, val);}}// 查找最小节点struct TreeNode* findMin(struct TreeNode* root) {while (root->left != NULL) {root = root->left;}return root;}```我们需要实现二叉树的遍历操作,包括前序遍历、中序遍历和后序遍历。
数据结构-C语言-树和二叉树

练习
一棵完全二叉树有5000个结点,可以计算出其
叶结点的个数是( 2500)。
二叉树的性质和存储结构
性质4: 具有n个结点的完全二叉树的深度必为[log2n]+1
k-1层 k层
2k−1−1<n≤2k−1 或 2k−1≤n<2k n k−1≤log2n<k,因为k是整数
所以k = log2n + 1
遍历二叉树和线索二叉树
遍历定义
指按某条搜索路线遍访每个结点且不重复(又称周游)。
遍历用途
它是树结构插入、删除、修改、查找和排序运算的前提, 是二叉树一切运算的基础和核心。
遍历规则 D
先左后右
L
R
DLR LDR LRD DRL RDL RLD
遍历规则
A BC DE
先序遍历:A B D E C 中序遍历:D B E A C 后序遍历:D E B C A
练习 具有3个结点的二叉树可能有几种不同形态?普通树呢?
5种/2种
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
(a + b *(c-d)-e/f)的二叉树
目 录 导 航 Contents
5.1 树和二叉树的定义 5.2 案例引入 5.3 树和二叉树的抽象数据类型定义 5.4 二叉树的性质和存储结构 5.5 遍历二叉树和线索二叉树 5.6 树和森林 5.7 哈夫曼树及其应用 5.8 案例分析与实现
二叉树的抽象数据类型定义
特殊形态的二叉树
只有最后一层叶子不满,且全部集中在左边
数据结构二叉树的基本操作代码

数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空,无法查找return NULL;else if (val == tree->data)//值和节点的值相等,返回该节点return tree;else if (val < tree->data)//值小于节点的值,查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值,查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空,就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空,就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历:';preOrder(tree);cout<<endl;cout<<'中序遍历:';inOrder(tree);cout<<endl;cout<<'后序遍历:';postOrder(tree);cout<<endl;cout<<'查找节点数据:4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了,节点的值是:'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值:'<<findMax(tree)->data<<endl; cout<<'查找树的最小值:'<<findMin(tree)->data<<endl; cout<<'删除节点:。
数据结构 -第12周查找第3讲-二叉排序树.pdf

以二叉树或树作为表的组织形式,称为树表,它是一类动态查找表,不仅适合于数据查找,也适合于表插入和删除操作。
常见的树表:二叉排序树平衡二叉树B-树B+树9.3.1 二叉排序树二叉排序树(简称BST)又称二叉查找(搜索)树,其定义为:二叉排序树或者是空树,或者是满足如下性质(BST性质)的二叉树:❶若它的左子树非空,则左子树上所有节点值(指关键字值)均小于根节点值;❷若它的右子树非空,则右子树上所有节点值均大于根节点值;❸左、右子树本身又各是一棵二叉排序树。
注意:二叉排序树中没有相同关键字的节点。
二叉树结构满足BST性质:节点值约束二叉排序树503080209010854035252388例如:是二叉排序树。
66不试一试二叉排序树的中序遍历序列有什么特点?二叉排序树的节点类型如下:typedef struct node{KeyType key;//关键字项InfoType data;//其他数据域struct node*lchild,*rchild;//左右孩子指针}BSTNode;二叉排序树可看做是一个有序表,所以在二叉排序树上进行查找,和二分查找类似,也是一个逐步缩小查找范围的过程。
1、二叉排序树上的查找Nk< bt->keybtk> bt->key 每一层只和一个节点进行关键字比较!∧∧p查找到p所指节点若k<p->data,并且p->lchild=NULL,查找失败。
若k>p->data,并且p->rchild=NULL,查找失败。
查找失败的情况加上外部节点一个外部节点对应某内部节点的一个NULL指针递归查找算法SearchBST()如下(在二叉排序树bt上查找关键字为k的记录,成功时返回该节点指针,否则返回NULL):BSTNode*SearchBST(BSTNode*bt,KeyType k){if(bt==NULL||bt->key==k)//递归出口return bt;if(k<bt->key)return SearchBST(bt->lchild,k);//在左子树中递归查找elsereturn SearchBST(bt->rchild,k);//在右子树中递归查找}在二叉排序树中插入一个关键字为k的新节点,要保证插入后仍满足BST性质。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构二叉树基本操作(1).// 对二叉树的基本操作的类模板封装//------------------------------------------------------------------------------------------------------------------------#include<iostream>using namespace std;//------------------------------------------------------------------------------------------------------------------------//定义二叉树的结点类型BTNode,其中包含数据域、左孩子,右孩子结点。
template <class T>struct BTNode{T data ; //数据域BTNode* lchild; //指向左子树的指针BTNode* rchild; //指向右子树的指针};//------------------------------------------------------------------------------------------------------------------------//CBinary的类模板template <class T>class BinaryTree{BTNode<T>* BT;public:BinaryTree(){BT=NULL;} // 构造函数,将根结点置空~BinaryTree(){clear(BT);} // 调用Clear()函数将二叉树销毁void ClearBiTree(){clear(BT);BT=NULL;}; // 销毁一棵二叉树void CreateBiTree(T end); // 创建一棵二叉树,end为空指针域标志bool IsEmpty(); // 判断二叉树是否为空int BiTreeDepth(); // 计算二叉树的深度bool RootValue(T &e); // 若二叉树不为空用e返回根结点的值,函数返回true,否则函数返回falseBTNode<T>*GetRoot(); // 二叉树不为空获取根结点指针,否则返回NULLbool Assign(T e,T value); // 找到二叉树中值为e的结点,并将其值修改为value。
T GetParent(T e); // 若二叉树不空且e是二叉树中的一个结点那么返回其双亲结点值T GetLeftChild(T e); // 获取左孩子结点值T GetRightChild(T e); // 获取右孩子结点值T GetLeftSibling(T e); // 获取左兄弟的结点值T rightsibling(BTNode<T>*p,T e);T GetRightSibling(T e); // 获取右孩子的结点值bool InsertChild(BTNode<T>* p,BTNode<T>* c,int RL);// 插入操作bool DeleteChild(BTNode<T>* p,int RL); //删除操作void PreTraBiTree(); // 递归算法:先序遍历二叉树void InTraBiTree(); // 递归算法:中序遍历二叉树void PostTraBiTree(); // 递归算法:后序遍历二叉树void PreTraBiTree_N(); // 非递归算法:先序遍历二叉树void InTraBiTree_N(); // 非递归算法:中序遍历二叉树void LevelTraBiTree(); // 利用队列层次遍历二叉树int LeafCount(); // 计算叶子结点的个数BTNode<T>* SearchNode(T e); // 寻找到结点值为e的结点,返回指向结点的指针void DisplayBTreeShape(BTNode<T>*bt,int level=1);};//二叉树的树形显示算法template <class T>void BinaryTree<T>::DisplayBTreeShape(BTNode<T>*bt,int level){if(bt)//空二叉树不显示{ DisplayBTreeShape(bt->rchild,level+1);//显示右子树cout<<endl; //显示新行for(int i=0;i<level-1;i++)cout<<" "; //确保在第level列显示节点cout<<bt->data; //显示节点DisplayBTreeShape(bt->lchild,level+1);//显示左子树}//if}//DisplayBTreetemplate <class T>static int clear(BTNode<T>*bt){ //销毁一棵二叉树if(bt)//根结点不空{clear(bt->lchild); //递归调用Clear()函数销毁左子树clear(bt->rchild); //递归调用Clear()函数销毁右子树cout<<"释放了指针"<<bt<<"所指向的空间。
"<<endl;delete bt; //释放当前访问的根结点}return 0;}template <class T>void BinaryTree<T>::CreateBiTree(T end){ //创建一棵二叉树:先序序列的顺序输入数据,end为结束的标志cout<<"请按先序序列的顺序输入二叉树,-1为空指针域标志:"<<endl;BTNode<T>*p;T x;cin>>x; //输入根结点的数据if(x==end) return ; //end 表示指针为空,说明树为空p=new BTNode<T>; //申请内存if(!p){cout<<"申请内存失败!"<<endl;exit(-1);//申请内存失败退出}p->data=x;p->lchild=NULL;p->rchild=NULL;BT=p; //根结点create(p,1,end);//创建根结点左子树,1为标志,表示左子树create(p,2,end);//创建根结点右子树,2为标志,表示右子树}template <class T>static int create(BTNode<T>*p,int k,T end){//静态函数,创建二叉树,k为创建左子树还是右子树的标志,end为空指针域的标志BTNode<T>*q;T x;cin>>x;if(x!=end){ //先序顺序输入数据q=new BTNode<T>;q->data=x;q->lchild=NULL;q->rchild=NULL;if(k==1) p->lchild=q; //q为左子树if(k==2) p->rchild=q; //p为右子树create(q,1,end); //递归创建左子树create(q,2,end); //递归创建右子树}return 0;}template <class T>bool BinaryTree<T>::IsEmpty(){//判断二叉树是否为空if(BT==NULL) return true;//树根结点为空,说明树为空return false;}template <class T>int BinaryTree<T>::BiTreeDepth(){//利用递归算法计算树的深度BTNode<T>*bt=BT;//树根结点int depth=0;//开始的时候数的深度初始化为0if(bt)//如果树不为空Depth(bt,1,depth);return depth;}template <class T>static int Depth(BTNode<T>* p,int level,int &depth){ //这个函数由BiTreeDepth()函数调用完成树的深度的计算//其中p是根结点,Level 是层,depth用来返回树的深度if(level>depth) depth=level;if(p->lchild) Depth(p->lchild,level+1,depth);//递归的遍历左子树,并且层数加1 if(p->rchild) Depth(p->rchild,level+1,depth);//递归的遍历右子树,并且层数加1return 0;}template <class T>bool BinaryTree<T>::RootValue(T &e){//若二叉树不为空用e返回根结点的值,函数返回true,否则函数返回false if(BT!=NULL) //判断二叉树是否为空{e=BT->data; //若不空,则将根结点的数据赋值给ereturn true;//操作成功,返回true}return false; //二叉树为空,返回false}template <class T>BTNode<T>*BinaryTree<T>::GetRoot(){//获取根信息return BT;//返回根结点的指针,若二叉树为空那么返回NULL}template <class T>bool BinaryTree<T>::Assign(T e,T value){//结点赋值if(SearchNode(e)!=NULL){(SearchNode(e))->data=value;return true;}return false;}template <class T>T BinaryTree<T>::GetParent(T e){//获取双亲信息BTNode<T>*Queue[200],*p;int rear,front;rear=front=0;if(BT){Queue[rear++]=BT;while(rear!=front){p=Queue[front++];if(p->lchild&&p->lchild->data==e||p->rchild&&p->rchild->data==e) return p->data;else{if(p->lchild) Queue[rear++]=p->lchild;if(p->rchild) Queue[rear++]=p->rchild;}}}return NULL;}template <class T>T BinaryTree<T>::GetRightChild(T e){//如果二叉树存在,e是二叉树中的一个结点,右子树存在那么返回右子树的结点值,否则返回0并提示右子树为空BTNode<T>*p=SearchNode(e);if(p->rchild) return p->rchild->data;//右子树不空,返回右子树根结点的值cout<<"结点"<<e<<"的右子树为空"<<endl;return 0;}template <class T>T BinaryTree<T>::GetLeftChild(T e){//如果二叉树存在,e是二叉树中的一个结点,左子树存在那么返回左子树的结点值,否则返回0并提示左子树为空BTNode<T>*p=SearchNode(e);if(p->lchild) return p->lchild->data;cout<<"结点"<<e<<"的左子树为空"<<endl;return 0;}template <class T>T BinaryTree<T>::GetLeftSibling(T e){//获取左兄弟信息if(BT!=NULL){return leftsibling(BT,e);}else{//二叉树为空cout<<"二叉树为空!"<<endl;return 0;}}template <class T>T leftsibling(BTNode<T>*p,T e){T q=0;if(p==NULL) return 0;else{if(p->rchild){if(p->rchild->data==e){if(p->lchild) return p->lchild->data;elsereturn NULL;}}q=leftsibling(p->lchild,e);if(q)return q;q=leftsibling(p->rchild,e);if(q)return q;}return 0;}//------------------------------------------------------------------------------------------------------------------------template <class T>T BinaryTree<T>::GetRightSibling(T e){//获取右兄弟信息if(BT!=NULL){return rightsibling(BT,e);}else{//二叉树为空cout<<"二叉树为空!"<<endl;return 0;}}template <class T>T BinaryTree<T>::rightsibling(BTNode<T>*p,T e){BTNode<T> *q=SearchNode(e);BTNode<T> *pp;if(q){pp=SearchNode(GetParent(e));if(pp){if(pp->rchild) return pp->rchild->data;else return 0;}else return 0;}return 0;}template <class T>bool BinaryTree<T>::InsertChild(BTNode<T>* p,BTNode<T>* c,int LR){//插入孩子if(p){if(LR==0){c->rchild=p->lchild;p->lchild=c;}else{c->rchild=p->rchild;p->rchild=c;}return true;}return false;//p为空}//------------------------------------------------------------------------------------------------------------------------template <class T>bool BinaryTree<T>::DeleteChild(BTNode<T>* p,int RL){//删除结点if(p){if(RL==0){clear(p->lchild);//释放p右子树的所有结点空间p->lchild=NULL;}else{clear(p->rchild);p->rchild=NULL;}return true;//删除成功}return false;//p为空}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::PreTraBiTree(){//先序遍历二叉树cout<<"----------------------------------------------"<<endl;cout<<"先序遍历二叉树:";BTNode<T>*p;p=BT; //根结点PreTraverse(p); //从根结点开始先序遍历二叉树cout<<endl;cout<<"----------------------------------------------"<<endl;}template <class T>static int PreTraverse(BTNode<T>*p){if(p!=NULL){cout<<p->data<<' '; //输出结点上的数据PreTraverse(p->lchild); //递归的调用前序遍历左子树PreTraverse(p->rchild); //递归的调用前序遍历右子树}return 0;}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::InTraBiTree(){//中序遍历二叉树cout<<"----------------------------------------------"<<endl;cout<<"中序遍历二叉树:";BTNode<T>*p;p=BT;//根结点InTraverse(p);//从根结点开始中序遍历二叉树cout<<endl;cout<<"----------------------------------------------"<<endl;}template <class T>static int InTraverse(BTNode<T>*p){if(p!=NULL){InTraverse(p->lchild); //递归的调用中序遍历左子树cout<<p->data<<' '; //输出结点上的数据InTraverse(p->rchild); //递归的调用中序遍历右子树}return 0;}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::PostTraBiTree(){//后序遍历二叉树cout<<"----------------------------------------------"<<endl;cout<<"后序遍历二叉树:";BTNode<T>*p;p=BT;//根结点PostTraverse(p);//从根结点开始遍历二叉树cout<<endl;cout<<"----------------------------------------------"<<endl;}template <class T>static int PostTraverse(BTNode<T>*p){if(p!=NULL){PostTraverse(p->lchild);//递归调用后序遍历左子树PostTraverse(p->rchild);//递归调用后序遍历右子树cout<<p->data<<' '; //输出结点上的数据}return 0;}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::PreTraBiTree_N(){//cout<<"----------------------------------------------"<<endl;cout<<"先序(非递归)遍历二叉树得:";BTNode<T> *Stack[200];//利用指针数组作为栈int top=0;BTNode<T>*p=BT;//将根结点的指针赋值给pwhile(p!=NULL||top!=0){while(p!=NULL){cout<<p->data<<" ";Stack[top++]=p->rchild;p=p->lchild;}if(top!=0){p=Stack[--top];}}cout<<"\n----------------------------------------------"<<endl;}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::InTraBiTree_N(){//非递归中序遍历二叉树cout<<"----------------------------------------------"<<endl;cout<<"中序(非递归)遍历二叉树得:";int top=0;BTNode<T> *Stack[200];BTNode<T> *p=BT;while(p||top){while(p){Stack[top++]=p;p=p->lchild;}if(top){p=Stack[--top];cout<<p->data<<' ';p=p->rchild;}}cout<<"\n----------------------------------------------"<<endl;}//------------------------------------------------------------------------------------------------------------------------template <class T>void BinaryTree<T>::LevelTraBiTree(){//利用队列Queue层次遍历二叉树BTNode<T> *Queue[100]; //利用一维数组作为队列,存放结点的指针BTNode<T> *b;int front,rear; //指向队列的头和尾下标front=rear=0; //队列初始为空cout<<"----------------------------------------------"<<endl;if(BT) //若二叉树不为空。