数据结构——二叉树基本操作源代码

合集下载

二叉树的建立与基本操作

二叉树的建立与基本操作

二叉树的建立与基本操作二叉树是一种特殊的树形结构,它由节点(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语言
二叉树是常见的数据结构,具有广泛的应用场景,例如搜索树、哈夫曼树等。

其中比较重要的一点就是对二叉树的遍历。

二叉树遍历有三种方式:先序遍历、中序遍历、后序遍历。

接下来,我将通过C语言来详细介绍这三种遍历方式。

一、先序遍历(Preorder Traversal)
先序遍历是指根节点->左子树->右子树的遍历方式。

C语言中的先序遍历算法如下:
```
void preorderTraversal(Node *node) {
if (node != NULL) {
printf("%d ", node->data); // 打印节点值
preorderTraversal(node->left); // 递归遍历左子树
preorderTraversal(node->right); // 递归遍历右子树
}
}
```
先序遍历的实现通过递归调用实现,当节点为空即遍历完成时返回。

总结:
以上三种遍历方式是二叉树遍历中最基本的方法,它们都是基于递归实现的。

通过学习这三种遍历方式,可以更好地理解二叉树的结构特点,提高数据结构算法的学习效果。

二叉树c语言实现完整代码

二叉树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语言-树和二叉树

数据结构-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

数据结构 -第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性质。

c语言二叉树代码

c语言二叉树代码

c语言二叉树代码以下是一个简单的C语言二叉树代码,包括二叉树的创建、插入、遍历、删除等操作:```#include<stdio.h>#include<stdlib.h>//定义二叉树节点类型typedef struct node{int data;struct node *left;struct node *right;}Node;//创建二叉树Node* create_tree(){int value;printf('请输入节点的值(-1表示结束):');scanf('%d', &value);if(value == -1){return NULL;}else{Node *p = (Node*)malloc(sizeof(Node));p->data = value;printf('请输入%d的左子节点:', value);p->left = create_tree();printf('请输入%d的右子节点:', value);p->right = create_tree();return p;}}//插入节点Node* insert_node(Node *root, int value){if(root == NULL){Node *p = (Node*)malloc(sizeof(Node));p->data = value;p->left = NULL;p->right = NULL;return p;}else if(value < root->data){root->left = insert_node(root->left, value);}else if(value > root->data){root->right = insert_node(root->right, value); }return root;}//先序遍历void preorder_traversal(Node *root){if(root != NULL){printf('%d ', root->data);preorder_traversal(root->left);preorder_traversal(root->right);}}//中序遍历void inorder_traversal(Node *root){if(root != NULL){inorder_traversal(root->left);printf('%d ', root->data);inorder_traversal(root->right);}}//后序遍历void postorder_traversal(Node *root){if(root != NULL){postorder_traversal(root->left);postorder_traversal(root->right);printf('%d ', root->data);}}//查找节点Node* search_node(Node *root, int value){ if(root == NULL){return NULL;}else if(root->data == value){return root;}else if(value < root->data){return search_node(root->left, value);}else{return search_node(root->right, value); }}//删除节点Node* delete_node(Node *root, int value){if(root == NULL){return NULL;}else if(value < root->data){root->left = delete_node(root->left, value); }else if(value > root->data){root->right = delete_node(root->right, value); }else{//情况一:被删除节点没有子节点if(root->left == NULL && root->right == NULL){ free(root);root = NULL;}//情况二:被删除节点只有一个子节点else if(root->left == NULL){Node *temp = root;root = root->right;free(temp);}else if(root->right == NULL){Node *temp = root;root = root->left;free(temp);}//情况三:被删除节点有两个子节点else{Node *temp = root->right;while(temp->left != NULL){temp = temp->left;}root->data = temp->data;root->right = delete_node(root->right, temp->data); }}return root;}//主函数int main(){Node *root = NULL;int choice, value;while(1){printf('请选择操作: ');printf('1.创建二叉树 ');printf('2.插入节点');printf('3.遍历二叉树 ');printf('4.查找节点');printf('5.删除节点');printf('6.退出程序');scanf('%d', &choice); switch(choice){case 1:root = create_tree(); break;case 2:printf('请输入要插入的节点值:');scanf('%d', &value);root = insert_node(root, value);break;case 3:printf('先序遍历:');preorder_traversal(root);printf('中序遍历:');inorder_traversal(root);printf('后序遍历:');postorder_traversal(root);printf('');break;case 4:printf('请输入要查找的节点值:');scanf('%d', &value);Node *result = search_node(root, value);if(result != NULL){printf('找到节点:%d', result->data);}else{printf('未找到节点:%d', value);}break;case 5:printf('请输入要删除的节点值:');scanf('%d', &value);root = delete_node(root, value); break;case 6:printf('程序已退出。

java实现二叉树的基本操作

java实现二叉树的基本操作

java实现二叉树的基本操作一、二叉树的定义树是计算机科学中的一种基本数据结构,表示以分层方式存储的数据集合。

树是由节点和边组成的,每个节点都有一个父节点和零个或多个子节点。

每个节点可以对应于一定数据,因此树也可以被视作提供快速查找的一种方式。

若树中每个节点最多只能有两个子节点,则被称为二叉树(Binary Tree)。

二叉树是一种递归定义的数据结构,它或者为空集,或者由一个根节点以及左右子树组成。

如果左子树非空,则左子树上所有节点的数值均小于或等于根节点的数值;如果右子树非空,则右子树上所有节点的数值均大于或等于根节点的数值;左右子树本身也分别是二叉树。

在计算机中实现二叉树,通常使用指针来表示节点之间的关系。

在Java中,定义一个二叉树节点类的代码如下:```public class BinaryTree {int key;BinaryTree left;BinaryTree right;public BinaryTree(int key) {this.key = key;}}```在这个类中,key字段表示该节点的数值;left和right字段分别表示这个节点的左右子节点。

1. 插入节点若要在二叉树中插入一个节点,首先需要遍历二叉树,找到一个位置使得插入新节点后,依然满足二叉树的定义。

插入节点的代码可以写成下面这个形式:```public void insert(int key) {BinaryTree node = new BinaryTree(key); if (root == null) {root = node;return;}BinaryTree temp = root;while (true) {if (key < temp.key) {if (temp.left == null) {temp.left = node;break;}temp = temp.left;} else {if (temp.right == null) {temp.right = node;break;}temp = temp.right;}}}```上面的代码首先创建了一个新的二叉树节点,然后判断二叉树根是否为空,若为空,则将这个节点作为根节点。

c++实现树(二叉树)的建立和遍历算法(一)(前序,中序,后序)

c++实现树(二叉树)的建立和遍历算法(一)(前序,中序,后序)

c++实现树(⼆叉树)的建⽴和遍历算法(⼀)(前序,中序,后序)最近学习树的概念,有关⼆叉树的实现算法记录下来。

不过学习之前要了解的预备知识:树的概念;⼆叉树的存储结构;⼆叉树的遍历⽅法。

⼆叉树的存储结构主要了解⼆叉链表结构,也就是⼀个数据域,两个指针域,(分别为指向左右孩⼦的指针),从下⾯程序1,⼆叉树的存储结构可以看出。

⼆叉树的遍历⽅法:主要有前序遍历,中序遍历,后序遍历,层序遍历。

(层序遍历下⼀篇再讲,本篇主要讲的递归法)下篇主要是,之后会有c++模板实现和。

如这样⼀个⼆叉树:它的前序遍历顺序为:ABDGHCEIF(规则是先是根结点,再前序遍历左⼦树,再前序遍历右⼦树)它的中序遍历顺序为:GDHBAEICF(规则是先中序遍历左⼦树,再是根结点,再是中序遍历右⼦树)它的后序遍历顺序为:GHDBIEFCA(规则是先后序遍历左⼦树,再是后序遍历右⼦树,再是根结点)如果不懂的话,可以参看有关数据结构的书籍。

1,⼆叉树的存储结构(⼆叉链表)//⼆叉树的⼆叉链表结构,也就是⼆叉树的存储结构,1个数据域,2个指针域(分别指向左右孩⼦)typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;2,⾸先要建⽴⼀个⼆叉树,建⽴⼆叉树必须要了解⼆叉树的遍历⽅法。

//⼆叉树的建⽴,按前序遍历的⽅式建⽴⼆叉树,当然也可以以中序或后序的⽅式建⽴⼆叉树void CreateBiTree(BiTree *T){ElemType ch;cin >> ch;if (ch == '#')*T = NULL; //保证是叶结点else{*T = (BiTree)malloc(sizeof(BiTNode));//if (!*T)//exit(OVERFLOW); //内存分配失败则退出。

实现二叉树的各种基本运算的算法代码

实现二叉树的各种基本运算的算法代码

实现二叉树的各种基本运算的算法代码(一)创建二叉树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;}}。

数据结构课程设计_二叉树操作

数据结构课程设计_二叉树操作

数据结构课程设计_⼆叉树操作数据结构课程设计题⽬:⼆叉树的操作学⽣姓名:学号:系部名称:计算机科学与技术系专业班级:指导教师:课程设计任务书第⼀章程序要求1)完成⼆叉树的基本操作。

2)建⽴以⼆叉链表为存储结构的⼆叉树;3)实现⼆叉树的先序、中序和后序遍历;4)求⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。

第⼆章算法分析建⽴以⼆叉链表为存储结构的⼆叉树,在次⼆叉树上进⾏操作;1先序遍历⼆叉树的操作定义为:若⼆叉树唯恐则为空操作;否则(1)访问根节点;(2)先序遍历做字数和;(3)先序遍历有⼦树;2中序遍历⼆叉树的操作定义为:若⼆叉树为空,则空操作;否则(1)中序遍历做⼦树;(2)访问根节点;(3)中序遍历有⼦树;3后续遍历⼆叉树的操作定义为:若⼆叉树为空则为空操作;否则(1)后序遍历左⼦树;(2)后序遍历右⼦树;(3)访问根节点;⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。

第三章⼆叉树的基本操作和算法实现⼆叉树是⼀种重要的⾮线性数据结构,是另⼀种树形结构,它的特点是每个节点之多有两棵⼦树(即⼆叉树中不存在度⼤于2的结点),并且⼆叉树的结点有左右之分,其次序不能随便颠倒。

1.1⼆叉树创建⼆叉树的很多操作都是基于遍历实现的。

⼆叉树的遍历是采⽤某种策略使得采⽤树形结构组织的若⼲年借点对应于⼀个线性序列。

⼆叉树的遍历策略有四种:先序遍历中续遍历后续遍历和层次遍历。

基本要求1 从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。

2 输出⼆叉树。

3 对⼆叉树进⾏遍历(先序,中序,后序和层次遍历)4 将⼆叉树的遍历打印出来。

⼀.问题描述⼆叉树的很多操作都是基于遍历实现的。

⼆叉树的遍历是采⽤某种策略使得采⽤树型结构组织的若⼲结点对应于⼀个线性序列。

⼆叉树的遍历策略有四种:先序遍历、中序遍历、后序遍历和层次遍历。

⼆.基本要求1.从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。

2.输出⼆叉树。

数据结构实验三——二叉树基本操作及运算实验报告

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。

问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。

算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。

输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。

计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。

测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。

二叉树的建立、输出、结点、高度、叶结点的输出

二叉树的建立、输出、结点、高度、叶结点的输出

7 二叉树的操作【实验简介】二叉树是树形结构的一种重要类型。

通过本次实验,熟悉二叉树结点的结构,掌握二叉树的基本操作以及具体实现,学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

【实验内容】编写程序,实现对二叉树的以下操作:1.建立二叉树。

2.按任一种遍历次序输出二叉树中的所有结点。

3.求二叉树的深度。

4.求二叉树中的所有节点数。

5.求二叉树中的所有叶子节点数。

6.清除二叉树,使之编程一只空树。

【主要代码】#include<iostream>using namespace std;template <class T>struct BinTreeNode //二叉树结点类定义{ T data; //数据域BinTreeNode<T> *leftChild, *rightChild; //左子女、右子女链域BinTreeNode () //构造函数{ leftChild=NULL;rightChild=NULL; }BinTreeNode (T x,BinTreeNode<T> *left=NULL,BinTreeNode<T>*right=NULL){ data=x; leftChild=left;rightChild=right; }};template <class T>class BinaryTree{ //二叉树类定义public:BinaryTree() {root=NULL;} //构造函数BinaryTree (T value) //构造函数{RefValue=value;root=NULL;}~BinaryTree(){destroy(root);} //析构函数bool IsEmpty(){ return root==NULL;} //判二叉树空否int Height(){ return Height(root);} //求树高度int Size() { return Size(root); } //求结点数BinTreeNode<T> *getRoot() { return root; }BinTreeNode<T> *LeftChild (BinTreeNode<T> *cur) //返回左子女{ return (cur!=NULL)?cur->leftChild:NULL; }BinTreeNode<T> *RightChild (BinTreeNode<T> *cur) //返回右子女{ return (cur!=NULL)?cur->rightChild:NULL; }void Output (BinTreeNode<T> * subtree); //输出结点void BinaryTreeCount(BinTreeNode<T>* BT,int& m1,int& m2); //输出结点数和叶结点数void SetRefValue(T& M){RefValue=M;} //设置数据输入停止标志void Setroot(BinTreeNode<T>* N){root=N;} //设置根节点void CreateBinTree (BinTreeNode<T> *& subTree);protected:BinTreeNode<T> *root; //二叉树的根指针T RefValue; //数据输入停止标志//void CreateBinTree (istream& in, BinTreeNode<T> *& subTree); //从文件读入建树void destroy (BinTreeNode<T> *& subTree); //删除int Height (BinTreeNode<T> *subTree)const; //返回树高度int Size(BinTreeNode<T> *subTree)const; //返回结点数BinTreeNode<T> *Parent (BinTreeNode<T> * subTree, BinTreeNode<T> *cur); //返回父结点friend ostream& operator<<(ostream& out,BinaryTree<T>& Tree);};template<class T>void BinaryTree<T>::destroy (BinTreeNode<T> *& subTree)//私有函数: 删除根为subTree的子树{ if (subTree!=NULL){ destroy (subTree->leftChild); //删除左子树destroy (subTree->rightChild); //删除右子树delete subTree; //删除根结点}};template <class T>void BinaryTree<T>::CreateBinTree(BinTreeNode<T> *& subTree){ T item;cin>>item; //读入根结点的值if(item!=RefValue){ subTree=new BinTreeNode<T>(item); //建立根结点if (subTree==NULL){cerr << "存储分配错!" << endl; exit (1);}CreateBinTree (subTree->leftChild); //递归建立左子CreateBinTree (subTree->rightChild);//递归建立右子树}else {subTree=NULL;} //封闭指向空子树的指针};template <class T>int BinaryTree<T>::Height(BinTreeNode<T> *subTree)const{ //私有函数:利用二叉树后序遍历算法计算二叉树的高度或深度;if (subTree==NULL) return 0; //空树高度为0;else{int i=Height(subTree->leftChild);int j=Height(subTree->rightChild);return (i<j)?j+1:i+1;}};template <class T>void BinaryTree<T>::BinaryTreeCount(BinTreeNode<T>* BT,int& m1,int& m2)//分别统计出二叉树中所有结点数和叶子结点数{if(BT!=NULL){ m1++; //统计所有结点if(BT->leftChild==NULL&&BT->rightChild==NULL)m2++; //统计叶子结点数BinaryTreeCount(BT->leftChild,m1,m2);BinaryTreeCount(BT->rightChild,m1,m2);}else return;return;};template <class T>void BinaryTree<T>::Output (BinTreeNode<T> *subtree){//私有函数:利用二叉树后序遍历算法输出二叉树的结点if (subtree!=NULL){cout<<subtree->data<<'\t'; //输出根节点Output(subtree->leftChild); //遍历Output(subtree->rightChild);}return;};void main(){BinaryTree<int> a;int m=0,n=0,p=0;BinTreeNode<int> *b;b=a.getRoot();a.SetRefValue(p); //设置结束标志cout<<"请输入要建立的二叉树的整型数,输入0结束,0应比数字多1:";a.CreateBinTree(b); //创建二叉树cout<<"二叉树的所有结点为:";a.Output(b);cout<<'\n'; //输出所有结点a.Setroot(b);cout<<"二叉树的高度为:";cout<<a.Height()<<'\n'; //输出二叉树高度a.BinaryTreeCount(b,m,n); //输出结点数和叶子结点数cout<<"二叉树结点数为:"<<m<<'\n'; //结点和叶结点个数输出cout<<"二叉树叶结点数为:"<<n<<'\n';a.~BinaryTree(); //删除二叉树exit(1); //退出}总黄酮生物总黄酮是指黄酮类化合物,是一大类天然产物,广泛存在于植物界,是许多中草药的有效成分。

数据结构课程设计-二叉树

数据结构课程设计-二叉树

《数据结构》课程设计说明书二叉平衡树算法实现班级组别:二指导老师:完成时间:2019.6.19 组长:学号:05 组员1:学号:33 组员2:学号:组员3:学号:成绩:目录目录一、课题设计任务 (2)二、任务分析 (2)1. 数据逻辑结构(算法描述) (2)2. 关键算法思想 (3)三、概要设计(总体设计) (3)四、详细设计 (4)1. 数据存储结构 (4)2. 各模块流程图及算法 (5)3. 算法效率分析 (9)五、测试 (10)1. 删除 (10)2. 查找 (10)3. 遍历 (10)六、课程设计心得 (10)七、参考文献 (11)八、附录 (11)一、课题设计任务针对给定的序列建立存储结构,实现各种遍历;实现树的生成,实现数据的查找、插入、删除,输出各种遍历。

二、任务分析1.数据逻辑结构(算法描述)//中序--递归void InorderTra(PNode root) {if (root) {InorderTra(root->leftChild); //中序遍历左子树printf("%d\t", root->keyValue); //访问根节点InorderTra(root->rightChild); //中序遍历右子数}}//前序--递归void PreOrderTra(PNode root) {if (root != NULL) {printf("%d\t", root->keyValue); //访问根节点PreOrderTra(root->leftChild); //前序遍历左子树PreOrderTra(root->rightChild); //前序遍历右子数}}//后序--递归void PostOrderTra(PNode root) {if (root) {PostOrderTra(root->leftChild); //后序遍历左子树PostOrderTra(root->rightChild); //后序遍历右子树printf("%d\t", root->keyValue); //访问根节点}}//求树的最大深度int getDeep(PNode root) {if (!root) {return 0;}int leftDeep = getDeep(root->leftChild) + 1;int rightDeep = getDeep(root->rightChild) + 1;return leftDeep > rightDeep ? leftDeep : rightDeep;}//从根节点开始打印出所有层void printByLevel(PNode root, int deep) {for (int i = 0; i < deep; i++) {LevelOrderTra(root, i);}printf("\n");}2.关键算法思想树的生成过程保持左右平衡,插入删除过程中保证树的平衡。

数据结构详细教案——树与二叉树

数据结构详细教案——树与二叉树

数据结构教案第六章树与二叉树目录6.1树的定义和基本术语 (1)6.2二叉树 (2)6.2.1 二叉树的定义 (2)6.2.2 二叉树的性质 (4)6.2.3 二叉树的存储结构 (5)6.3树和森林 (6)6.4二叉树的先|中|后序遍历算法 (7)6.5先|后|中序遍历的应用扩展 (9)6.5.1 基于先序遍历的二叉树(二叉链)的创建 (9)6.5.2 统计二叉树中叶子结点的数目 (9)6.5.3 求二叉树的高度 (10)6.5.4 释放二叉树的所有结点空间 (11)6.5.5 删除并释放二叉树中以元素值为x的结点作为根的各子树 (12)6.5.6 求位于二叉树先序序列中第k个位置的结点的值 (12)6.5.7 线索二叉树 (13)6.5.8 树和森林的遍历 (14)6.6二叉树的层次遍历 (16)6.7判断一棵二叉树是否为完全二叉树 (16)6.8哈夫曼树及其应用 (18)6.8.1 最优二叉树(哈夫曼树) (18)6.8.2 哈夫曼编码 (19)6.9遍历二叉树的非递归算法 (19)6.9.1 先序非递归算法 (19)6.9.2 中序非递归算法 (20)6.9.3 后序非递归算法 (21)第6章二叉树和树6.1 树的定义和基本术语1、树的递归定义1)结点数n=0时,是空树2)结点数n>0时有且仅有一个根结点、m个互不相交的有限结点集——m棵子树2、基本术语结点:叶子(终端结点)、根、内部结点(非终端结点、分支结点);树的规模:结点的度、树的度、结点的层次、树的高度(深度)结点间的关系:双亲(1)—孩子(m),祖先—子孙,兄弟,堂兄弟兄弟间是否存在次序:无序树、有序树去掉根结点非空树森林引入一个根结点3、树的抽象数据类型定义树特有的操作:查找:双亲、最左的孩子、右兄弟结点的度不定,给出这两种操作可以查找到一个结点的全部孩子插入、删除:孩子遍历:存在一对多的关系,给出一种有规律的方法遍历(有且仅访问一次)树中的结点ADT Tree{数据对象:D={a i | a i∈ElemSet, i=1,2,…,n, n≥0}数据关系:若D为空集,则称为空树;若D仅含一个数据元素,则R为空集,否则R={H},H是如下二元关系:(1) 在D中存在唯一的称为根的数据元素root,它在关系H下无前驱;(2) 若D-{root}≠Ф,则存在D-{root}的一个划分D1, D2, …, D m (m>0)(D i 表示构成第i棵子树的结点集),对任意j≠k (1≤j, k≤m) 有D j∩D k=Ф,且对任意的i (1≤i≤m),唯一存在数据元素x i∈D i, 有<root,x i>∈H(H表示结点之间的父子关系);(3) 对应于D-{root}的划分,H-{<root, x1>,…, <root, x m>}有唯一的一个划分H1, H2, …, H m(m>0)(H i表示第i棵子树中的父子关系),对任意j≠k(1≤j,k≤m)有H j∩H k=Ф,且对任意i(1≤i≤m),H i是D i上的二元关系,(D i, {H i})是一棵符合本定义的树,称为根root的子树。

二叉树的完整代码实现

二叉树的完整代码实现

⼆叉树的完整代码实现1 #include<stdio.h>2 #include<stdlib.h>3 #include<malloc.h>45 typedef struct Node//结构体6 {7char data;8struct Node *LChild;9struct Node *RChild;10 } BinNode,*BinTree;1112 BinTree CreateTree(BinTree T)13 {14char ch;15 scanf("%c",&ch);16if(ch=='#')17return NULL;18else19 {20 T=(BinTree)malloc(sizeof(BinNode));21 T->data=ch;22 T->LChild=CreateTree(T->LChild);/*创建左⼦树*/23 T->RChild=CreateTree(T->RChild);/*创建右⼦树*/24return T;25 }26 }2728void PreOrder(BinTree root)//先序遍历29 {30if (root != NULL)31 {32 printf("%c", root->data);33 PreOrder(root->LChild);34 PreOrder(root->RChild);35 }36 }3738void InOrder(BinTree root)//中序遍历39 {40if (root != NULL)41 {42 InOrder(root->LChild);43 printf("%c", root->data);44 InOrder(root->RChild);45 }46 }4748void PostOrder(BinTree root)//后序遍历49 {50if (root != NULL)51 {52 PostOrder(root->LChild);53 PostOrder(root->RChild);54 printf("%c", root->data);55 }56 }57/*求⼆叉树结点总数*/58int Count(BinTree T)59 {60if(T==NULL)61return0; /*空⼆叉树结点数为0*/62else/*左右⼦树结点总数加1*/63return Count(T->LChild)+Count(T->RChild)+1;64 }65//叶⼦数66int LeafCount(BinTree T){67if(T == NULL){68return0;69 }70else if ((T->LChild==NULL) && (T->RChild==NULL)){71return1;72 }73else{74return LeafCount(T->LChild)+LeafCount(T->RChild);75 }76 }77int main()78 {7980 BinTree bt;81 printf("⼀、请按先序的⽅式输⼊⼆叉树的结点元素(注:输⼊#表⽰节点为空)如:ABC##DE#G##F###\n");82 bt=CreateTree(bt);83 printf("⼆、前序遍历⼆叉树:\n");84 PreOrder(bt);85 printf("\n");86 printf("三、中序遍历⼆叉树:\n");87 InOrder(bt);88 printf("\n");89 printf("四、后序遍历⼆叉树:\n");90 PostOrder(bt);91 printf("\n");92 printf("五、⼆叉树结点数: %d\n",Count(bt));93 printf("六、叶⼦节点的个数:%d \n",LeafCount(bt));94 system("pause");95 }。

二叉树的顺序存储结构代码

二叉树的顺序存储结构代码

二叉树的顺序存储结构代码介绍二叉树是一种常用的数据结构,它由节点组成,每个节点最多有两个子节点。

在计算机中,我们通常使用顺序存储结构来表示二叉树。

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

本文将详细介绍二叉树的顺序存储结构代码,包括初始化、插入节点、删除节点以及遍历等操作。

二叉树的顺序存储结构代码实现初始化二叉树首先,我们需要定义一个数组来存储二叉树的节点。

假设数组的大小为n,则二叉树的最大节点数量为n-1。

# 初始化二叉树,将数组中所有元素置为空def init_binary_tree(n):binary_tree = [None] * nreturn binary_tree插入节点在二叉树的顺序存储结构中,节点的插入操作需要保持二叉树的特性,即左子节点小于父节点,右子节点大于父节点。

插入节点的算法如下:1.找到待插入位置的父节点索引parent_index。

2.如果待插入节点小于父节点,将其插入到父节点的左子节点位置,即数组索引2*parent_index+1处。

3.如果待插入节点大于父节点,将其插入到父节点的右子节点位置,即数组索引2*parent_index+2处。

# 插入节点def insert_node(binary_tree, node):index = 0 # 当前节点的索引值,初始值为根节点的索引值while binary_tree[index] is not None:if node < binary_tree[index]:index = 2 * index + 1 # 插入到左子节点else:index = 2 * index + 2 # 插入到右子节点binary_tree[index] = node删除节点删除节点需要保持二叉树的特性,即在删除节点后,仍然满足左子节点小于父节点,右子节点大于父节点的条件。

删除节点的算法如下:1.找到待删除节点的索引delete_index。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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) //若二叉树不为空。

相关文档
最新文档