急！二叉树的存储结构，并完成：建立、查找、计算结点数、求高度、三种遍历方式

Posted 2023-02-27

不要和别人雷同！

public class BinaryTree<E> //二叉树类

protected BinaryNode<E> root; //根结点

public BinaryTree() //构造空二叉树

root=null;


public BinaryTree(BinaryNode<E> root) //构造指定根结点的二叉树

this.root=root;


public boolean isEmpty() //判断是否空二叉树

return this.root==null;


public BinaryNode<E> getRoot() //返回二叉树的根结点

return this.root;


//6.3.3 二叉树的遍历
public void preOrder() //先根次序遍历二叉树

System.out.print("\n先根序列： ");
preOrder(root);


private void preOrder(BinaryNode<E> p) //先根次序遍历以p结点为根的子二叉树

if(p!=null) //若二叉树不空

System.out.print(p.data+" "); //访问当前结点
preOrder(p.left); //按先根次序遍历当前结点的左子树
preOrder(p.right); //按先根次序遍历当前结点的右子树



public void inOrder() //中根次序遍历二叉树

System.out.print("\n中根序列： ");
inOrder(root);


private void inOrder(BinaryNode<E> p) //中根次序遍历以p结点为根的子二叉树

if (p!=null)

inOrder(p.left); //中根次序遍历左子树
System.out.print(p.data+" ");
inOrder(p.right); //中根次序遍历右子树



public void postOrder() //后根次序遍历二叉树

System.out.print("\n后根序列： ");
postOrder(root);


private void postOrder(BinaryNode<E> p) //后根次序遍历以p结点为根的子二叉树

if (p!=null)

postOrder(p.left);
postOrder(p.right);
System.out.print(p.data+" ");



//【例6.1】 构造并遍历二叉树。

//3. 基于遍历的操作
public int count() //求一棵二叉树中所有结点个数

return count(root);

public int count(BinaryNode<E> p) //求以p结点为根的子树的结点个数

if (p!=null)
return 1+count(p.left)+count(p.right);
else
return 0;


public int depth() //求二叉树的深度

return depth(root);

public int depth(BinaryNode<E> p) //求以p结点为根的子树的深度，后根次序遍历

if (p!=null)

int ld = depth(p.left); //求左子树的深度
int rd = depth(p.right);
return (ld>=rd) ? ld+1 : rd+1;

return 0;


public BinaryNode<E> search(E value) //查找值为value的结点

return search(root, value);

public BinaryNode<E> search(BinaryNode<E> p, E value) //在以p为根的子树中查找值为value的结点
//先根次序遍历，返回查找到结点，若未找到返回null
BinaryNode<E> find=null; //记载找到结点
if (p!=null && value!=null)

if (p.data.equals(value))
find = p; //查找成功
else

find = search(p.left, value); //在左子树中查找
if (find==null)
find=search(p.right, value); //若左子树中未找到，则继续在右子树中查找


return find; //返回找到结点


public BinaryNode<E> getParent(BinaryNode<E> node) //返回指定结点node的父母结点
//若空树、未找到或node为根，返回null
if (root==null || node==null || node==root)
return null;
return getParent(root, node);

public BinaryNode<E> getParent(BinaryNode<E> p, BinaryNode<E> node)
//在以p为根的子树中查找并返回node结点的父母结点
BinaryNode<E> find=null; //记载找到结点
if (p!=null)

if (p.left==node || p.right==node)
find = p; //查找成功
else

find = getParent(p.left, node); //在左子树中查找
if (find==null)
find = getParent(p.right, node); //若左子树中未找到，则继续在右子树中查找


return find; //返回找到的父母结点


//6.3.4 构造二叉树
// 1、以先根、中根次序遍历序列建立二叉树
public BinaryTree(String prestr,String instr) //1、以先根、中根次序遍历序列建立二叉树

root=create(prestr,instr);
//root=create2(prestr,instr);


public BinaryNode create(String prestr, String instr)

BinaryNode<String> p=null;
int k,n;
String first,presub,insub;
n=prestr.length();
if(n>0)

System.out.print("prestr="+prestr+"\t instr="+instr);
first=prestr.substring(0,1);
p=new BinaryNode<String>(first);
k=instr.indexOf(first);
System.out.println("\t first="+first+"\t k="+k);
presub=prestr.substring(1,k+1);
insub=instr.substring(0,k);
p.left=create(presub,insub);
presub=prestr.substring(k+1,n);
insub=instr.substring(k+1,n);
p.right=create(presub,insub);

return p;

public BinaryNode create2(String instr, String poststr) //以中根、后根次序遍历序列建立二叉树

BinaryNode<String> p=null;
int k,n;
String last,postsub,insub;
n=poststr.length();
if(n>0)

System.out.print("instr="+instr+"\t poststr="+poststr);
last=poststr.substring(poststr.length()-1,poststr.length());
p=new BinaryNode<String>(last);
k=instr.indexOf(last);
System.out.println("\t last="+last+"\t k="+k);
postsub=poststr.substring(0,k);
insub=instr.substring(0,k);
p.left=create2(insub,postsub);
postsub=poststr.substring(k,n-1);
insub=instr.substring(k+1,n);
p.right=create2(insub,postsub);

return p;


// 2、以标明空子树的先根序列构造一棵二叉树
public BinaryTree(E[] preorder) //2、以标明空子树的先根序列构造一棵二叉树

root=create(preorder);


private int i=0;
private BinaryNode<E> create(E[] preorder) //创建一棵子树，当前结点值是preorder[i]
//返回所创建子树的根结点
BinaryNode<E> p = null;
if (i<preorder.length)

E elem=preorder[i];
i++;
if (elem!=null)

p = new BinaryNode<E>(elem); //建立p结点
p.left = create(preorder); //建立p的左子树
p.right = create(preorder); //建立p的右子树


return p;

// 3、以广义表表示建立二叉树
public BinaryTree(String GenListStr)

System.out.println("GenListStr="+GenListStr);
if(GenListStr.length()>0)
root=create(GenListStr); //以GenListStr的全部元素建立一棵二叉树

public BinaryNode create(String GenListStr) //以GenListStr的部分元素（从i开始）建立一棵子树

BinaryNode p=null;
char ch=GenListStr.charAt(i);
if(ch>='A' && ch<='Z') //大写字母

p=new BinaryNode<String>(ch+""); //建立结点
i++; //跳过大写字母
ch=GenListStr.charAt(i);
if(ch=='(')

i++; //跳过(
p.left=create(GenListStr); //建立左子树
i++; //跳过#
p.right=create(GenListStr); //建立右子树
i++; //跳过）


if(ch=='#')
i++; //跳过#
return p; //ch非大写字母时，返回null


//【例6.2】 输出二叉树中指定结点的所有祖先结点。

//6.3.5 二叉树的插入和删除操作
public void insert(BinaryNode<E> p, E element, boolean leftChild) //插入元素element作为p结点的孩子
//若leftChild为true，插入结点作为左孩子，否则作为右孩子
if (p!=null)

BinaryNode<E> q = new BinaryNode<E>(element);
if (leftChild)

q.left = p.left; //p结点的原左孩子成为q结点的左孩子
p.left = q; //q结点作为p结点的左孩子

else

q.right = p.right; //p结点的原右孩子成为q结点的右孩子
p.right = q; //q结点作为p结点的右孩子



public void insert(BinaryNode<E> p, E element) //插入元素element作为p结点的左孩子

insert(p, element, true);


public void remove(BinaryNode<E> p, boolean leftChild) //删除p结点的左/右子树
//若leftChild为true，删除左子树，否则删除右子树
if (p!=null)

if (leftChild)
p.left = null;
else
p.right = null;


public void remove(BinaryNode<E> p) //删除p结点的左子树

remove(p, true);


//6.3.6 二叉树遍历的非递归算法
public void preOrderTraverse() //先根次序遍历二叉树的非递归算法

System.out.print("先根次序遍历（非递归）： ");
LinkedStack<BinaryNode<E>> stack = new LinkedStack<BinaryNode<E>>(); //创建一个空栈
BinaryNode<E> p = this.root;
while(p!=null || !stack.isEmpty()) //p非空或栈非空时
if(p!=null)

System.out.print(p.data+" "); //访问结点
stack.push(p); //p结点入栈
p=p.left; //进入左子树

else //p为空且栈非空时

p=stack.pop(); //p指向出栈结点
p=p.right; //进入右子树

System.out.println();


public void inOrderTraverse() //中根次序遍历二叉树的非递归算法

System.out.print("中根次序遍历（非递归）： ");
LinkedStack<BinaryNode<E>> stack = new LinkedStack<BinaryNode<E>>(); //创建一个空栈
BinaryNode<E> p = this.root;
while(p!=null || !stack.isEmpty()) //p非空或栈非空时
if(p!=null)

stack.push(p); //p结点入栈
p=p.left; //进入左子树

else //p为空且栈非空时

p=stack.pop(); //p指向出栈结点
System.out.print(p.data+" "); //访问结点
p=p.right; //进入右子树

System.out.println();

//后根次序未写

//6.3.7 二叉树的层次遍历
public void levelOrder() //按层次遍历二叉树

LinkedQueue<BinaryNode<E>> que=new LinkedQueue<BinaryNode<E>>(); //创建一个空队列
BinaryNode<E> p=this.root;
System.out.print("层次遍历： ");
while(p!=null)

System.out.print(p.data+ " ");
if(p.left!=null)
que.enqueue(p.left); //p的左孩子结点入队
if(p.right!=null)
que.enqueue(p.right); //p的右孩子结点入队
p = que.dequeue(); //p指向出队结点

System.out.println();


//第6章习题
public void leaf() //遍历输出叶子结点

leaf(root);

private void leaf(BinaryNode<E> p) //先根次序遍历，输出叶子结点，3种遍历次序结果一样

if(p!=null)

if (p.isLeaf())
System.out.print(p.data+" ");
leaf(p.left);
leaf(p.right);



public int countLeaf() //求一棵二叉树中所有叶子结点个数

return countLeaf(root);

private int countLeaf(BinaryNode<E> p) //求以p结点为根的子树的叶子结点个数

if (p==null)
return 0;
if (p.isLeaf())
return 1;
return countLeaf(p.left)+countLeaf(p.right);


public BinaryTree(BinaryTree<E> bitree) //以已知的bitree构造二叉树

this.root = copy(bitree.root);


private BinaryNode<E> copy(BinaryNode<E> p) //复制以p根的子二叉树

BinaryNode<E> q = null;
if(p!=null)

q = new BinaryNode<E>(p.data);
q.left = copy(p.left); //复制左子树
q.right = copy(p.right); //复制右子树

return q; //返回建立子树的根结点


public boolean equals(Object obj) //比较两棵二叉树是否相等

if (obj == this)
return true;
if (obj instanceof BinaryTree)

BinaryTree<E> bitree = (BinaryTree)obj;
return equals(this.root, bitree.root);

return false;

private boolean equals(BinaryNode<E> p, BinaryNode<E> q) //判断以p和q结点为根的两棵子树是否相等
//递归方法
if(p==null && q==null)
return true;
if(p!=null && q!=null)
return (p.data.equals(q.data)) && equals(p.left, q.left) && equals(p.right, q.right);
return false;


public boolean replace(E old, E value) //将首次出现的值为old结点值替换为value

BinaryNode<E> find=search(old); //查找值为old的结点
if(find!=null)
find.data = value; //替换结点元素值
return find!=null;


public void replaceAll(E old, E value) //将值为old的结点全部替换为value

replaceAll(root, old, value);

private void replaceAll(BinaryNode<E> p, E old, E value) //在以p为根的子树中实现全部替换

if(p!=null)

if(p.data.equals(old))
p.data = value;
replaceAll(p.left, old, value);
replaceAll(p.right, old, value);



public static void main(String args[])

String[] preorder = "A","B","D",null,"G",null,null,null,"C","E",null,null,"F","H";
BinaryTree<String> bitree = new BinaryTree<String>(preorder);
preorder[0]="Z";
bitree.preOrder();
bitree.inOrder();
bitree.postOrder();
System.out.println("\n结点个数： "+bitree.count());
System.out.println("高度： "+bitree.depth());
System.out.print("叶子结点： ");
bitree.leaf();
System.out.println(" , 共"+bitree.countLeaf()+"个");

BinaryTree<String> bitree2 = new BinaryTree<String>(bitree);
System.out.println("两棵二叉树相等? "+bitree.equals(bitree2));
System.out.println("第2棵二叉树替换(\"D\",\"F\")： "+bitree2.replace("D","F"));

System.out.println("两棵二叉树相等? "+bitree.equals(bitree2));
System.out.println("第2棵二叉树全部替换(\"F\",\"Y\") ");
bitree2.replaceAll("F","Y");
bitree2.preOrder();

BinaryNode<String> find = bitree.search("D"); //查找
bitree.insert(find, "Z");
System.out.println("插入Z作为 "+find.data+" 的左孩子\n");
bitree.levelOrder();
bitree.preOrderTraverse();
bitree.inOrderTraverse();

String[] preorder2 = "A","B",null,null,"C"; //标明空子树的先根序列
BinaryTree<String> bitree3 = new BinaryTree<String>(preorder2);
bitree3.preOrder();
bitree3.inOrder();
bitree3.postOrder();
/*
BinaryTree<String> bitree4 = new BinaryTree<String>(preorder2);
bitree4.root = bitree4.create(preorder2); //错，i越界，私有化可避免问题
bitree4.preOrder();
*/
String[] preorder3 = "D","B","A",null,null,"C",null,null,"E"; //二叉排序树
BinaryTree<String> bitree5 = new BinaryTree<String>(preorder3);
bitree5.inOrder();
System.out.println("\n二叉排序树? "+bitree5.isSorted());



//第8章习题
public boolean isSorted() //判断一棵二叉树是否为二叉排序树

return isSorted(this.root);

public boolean isSorted(BinaryNode<E> p)

boolean yes = true;
if (p!=null)

if (!(p.data instanceof Comparable))
return false;
Comparable cmpobj = (Comparable)p.data;
if ((p.left==null || p.left!=null && cmpobj.compareTo(p.left.data)>0) &&
(p.right==null || p.right!=null && cmpobj.compareTo(p.right.data)<0))

yes = isSorted(p.left);
if (yes)
yes = isSorted(p.right);

else
yes = false;

return yes;




/*
程序运行结果如下：
先根序列： A B D G C E F H
中根序列： D G B A E C H F
后根序列： G D B E H F C A
结点个数： 8
高度： 4
叶子结点： G E H , 共3个
两棵二叉树相等? true
第2棵二叉树替换("D","F")： true
两棵二叉树相等? false
第2棵二叉树全部替换("F","Y")

先根序列： A B Y G C E Y H
第1棵二叉树查找： D
层次遍历： A B C D E F Z G H
先根次序遍历（非递归）： A B D Z G C E F H
中根次序遍历（非递归）： Z D G B A E C H F

先根序列： A B D G C E F H
中根序列： D G B A E C H F
后根序列： G D B E H F C A

中根序列： A B C D E
二叉排序树? true

*/
这是二叉树的所有方法 及实现实例
还有就是需要建立节点类 你应该知道怎么建的吧 参考技术A /*
包括二叉树的创建和遍历
*/
//头文件
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
//预定义宏常量
#define OK 1
#define ERROR -1
#define ENDFLAG '#'
typedef char TelemType;
typedef int status;
//二叉树的存储结构
typedef struct BiTNode
TelemType data;
struct BiTNode *lchild,*rchild;
BiTNode,*BiTree;
//全局变量，表示叶子个数
int m=0;
//二叉树的创建
status CreateBiTree(BiTree *T)
// 先序创建
TelemType ch;
scanf("%c",&ch);
if(ch==ENDFLAG) *T=NULL;
else
if(!(*T=(BiTNode *)malloc(sizeof(BiTNode))))

printf("\nOut of space.");
getch();
exit(0);

(*T)->data=ch; //生成根结点
CreateBiTree(&((*T)->lchild));//左子树
CreateBiTree(&((*T)->rchild));//右子树

return OK;

//先序遍历
status PreOrderTraverse(BiTree T)

if(T)

printf("%c",T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);

return OK;
/*
//中序
status InOrderTraverse(BiTree T)

if(T)

InOrderTraverse(T->lchild);
printf("%c",T->data);
InOrderTraverse(T->rchild);

return OK;

//后序
status PostOrderTraverse(BiTree T)

if(T)

PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c",T->data);

return OK;


*/
/*
用队列 层次遍历
*/
//存储定义
typedef char QElemType;
//typedef int status;
typedef struct Queue

QElemType data;
struct Queue *next;
Queue;
//头指针和尾指针
typedef struct

Queue *front;
Queue *rear;
LinkQueue;
//初始化队列
status InitQueue(LinkQueue *q)

q->front=q->rear =NULL; //----无头结点
return OK;

/*判断队列是否为空*/
status QueueEmpty(LinkQueue *Q)

return (Q->front==NULL)&&(Q->rear==NULL);
/*实际上只须判断队头指针是否为空即可*/

//入队
void EnQueue(LinkQueue *q,QElemType e)

Queue *p;
p=(Queue *)malloc(sizeof(Queue));/*申请新结点*/
p->data=e;
p->next=NULL;
if(QueueEmpty(q))
q->front=q->rear=p;
else /*x插入非空队列的尾*/
q->rear->next=p; /*p链到原队尾结点后*/
q->rear=p;/*队尾指针指向新的尾*/


//出队
QElemType DeQueue(LinkQueue *q)


Queue *p;
QElemType e;
if(QueueEmpty(q))

printf("Queue underflow\n");/*下溢*/
exit(1) ;

p=q->front;/*指向对头结点*/
e=p->data;/*保存对头结点的数据*/
q->front=p->next;/*将对头结点从链上摘下*/
if(q->rear==p)/*原队中只有一个结点，删去后队列变空，此时队头指针已为空*/
q->rear=NULL;
free(p);/*释放被删队头结点*/
return e;/*返回原队头数据*/

/*层次遍历思想 递归
a.根结点入队列
b.原队左子树的左右孩子（非空）入队列
c.原队右子数的左右孩子（非空）入队列
*/
//层次遍历入队列
status Arrange(BiTree T,LinkQueue *Q)

if(T)

EnQueue(Q,T->data);
Arrange(T->lchild,Q);
Arrange(T->rchild,Q);

return OK;

//从队列中输出各元素
status ArrangementTraverse(BiTree T)

char e;
LinkQueue Q;
InitQueue(&Q);
if(T)

Arrange(T,&Q);//递归调用
while(!QueueEmpty(&Q))

e=DeQueue(&Q);
printf("%c",e);



return OK;

//求二叉树的叶结点个数
status NumberLeaves(BiTree T)
//先序遍历得到叶结点的数目
//m=0;
if(T)

if(T->lchild==NULL&&T->rchild==NULL) m++;
NumberLeaves(T->lchild);
NumberLeaves(T->rchild);

return OK;

int btnodeheight(BiTree b)

int lchildh,rchildh;
if (b==NULL) return(0);
else

lchildh=btnodeheight(b->lchild);
rchildh=btnodeheight(b->rchild);
return (lchildh>rchildh)? (lchildh+1):(rchildh+1);


/*
//一个比较函数
status Max(int m, int n)

if (m > n)
return m;
else
return n;

//获取二叉树的高度
status HighBitree(BiTree t)

if (t == NULL)
return 0;
else
return 1 + Max(HighBitree(t->lchild), HighBitree(t->rchild));

*/
//主函数
void main()

BiTree T;
printf("请创建二叉树：\n");
CreateBiTree(&T);
NumberLeaves(T);
printf("叶节点个数为：");
printf("%d",m);
printf("\n二叉树的高度为:");
printf("%d",btnodeheight(T));
// printf("%d",HighBitree(T));
printf("\n先序遍历:\n");
PreOrderTraverse(T);
/* printf("\n中序遍历:\n");
InOrderTraverse(T);
printf("\n后序遍历:\n");
PostOrderTraverse(T);*/

printf("\n层次遍历\n");
ArrangementTraverse(T);
printf("\n");
参考技术B 发给你了注意查收