Java实现二叉树的遍历Word格式.docx
《Java实现二叉树的遍历Word格式.docx》由会员分享，可在线阅读，更多相关《Java实现二叉树的遍历Word格式.docx（84页珍藏版）》请在冰豆网上搜索。
tree.bintree;
2./**
3.
*
创建
非完全二叉树、完全二叉树、满二叉树
4.
*
5.
由于二叉树的节点增加没有什么规则，所以这里只是简单的使用了递一
6.
次性把整棵树创建出来，而没有设计出一个一个添加节点的方法与删除
7.
8.
@author
jzj
9.
@date
2009-12-23
10.
*/
11.public
class
BinTree
{//
Bin=Binary（二进位的,
二元的）
12.
13.
protected
Entry
root;
//根
14.
private
int
size;
//树的节点数
15.
16.
/**
17.
树的节点结构
18.
19.
20.
21.
static
{
22.
elem;
//数据域，这里我们作为编号
23.
left;
//左子树
24.
right;
//右子树
25.
26.
public
Entry（int
elem）
27.
this.elem
=
28.
}
29.
30.
String
toString（）
31.
return
"
number="
+
32.
33.
34.
35.
36.
根据给定的节点数创建一个完全二叉树或是满二叉树
37.
@param
nodeCount
要创建节点总数
38.
39.
void
createFullBiTree（int
nodeCount）
40.
root
recurCreateFullBiTree（1,
nodeCount）;
41.
42.
43.
44.
递归创建完全二叉树
45.
num
节点编号
46.
节点总数
47.
@return
TreeNode
返回创建的节点
48.
49.
recurCreateFullBiTree（int
num,
50.
size++;
51.
rootNode
new
Entry（num）;
//根节点
52.
//如果有左子树则创建左子树
53.
if
（num
2
<
54.
rootNode.left
recurCreateFullBiTree（num
2,
55.
//如果还可以创建右子树，则创建
56.
1
57.
rootNode.right
1,
58.
59.
60.
（Entry）
rootNode;
61.
62.
63.
64.
根据给定的数组创建一棵树，这个棵树可以是完全二叉树也可是普通二叉树
65.
数组中为0的表示不创建该位置上的节点
66.
nums
数组中指定了要创建的节点的编号，如果为0，表示不创建
67.
68.
createBinTree（int[]
nums）
69.
recurCreateBinTree（nums,
0）;
70.
71.
72.
73.
递归创建二叉树
74.
75.
index
需要使用数组中的哪个元素创建节点，如果为元素为0，则不创建
76.
返回创建的节点，最终会返回树的根节点
77.
78.
recurCreateBinTree（int[]
nums,
index）
79.
//指定索引上的编号不为零上才需创建节点
80.
（nums[index]
!
0）
81.
82.
Entry（nums[index]）;
83.
84.
（（index
1）
nums.length）
85.
（index
-
1）;
86.
87.
88.
2）;
89.
90.
91.
92.
93.
null;
94.
95.
96.
97.
size（）
98.
99.
100.
101.
//取树的最左边的节点
102.
getLast（）
103.
e
104.
while
（e.right
null）
105.
e.right;
106.
107.
e.elem;
108.
109.
110.
//测试
111.
main（String[]
args）
112.
113.
//创建一个满二叉树
114.
binTree
BinTree（）;
115.
binTree.createFullBiTree（15）;
116.
System.out.println（binTree.size（））;
//15
117.
System.out.println（binTree.getLast（））;
118.
119.
//创建一个完全二叉树
120.
121.
binTree.createFullBiTree（14）;
122.
//14
123.
//7
124.
125.
//创建一棵非完全二叉树
126.
127.
int[]
{
3,
4,
0,
5,
6,
7,
8
};
128.
binTree.createBinTree（nums）;
129.
//8
130.
131.
132.
133.}
packagetree.bintree;
/**
*创建非完全二叉树、完全二叉树、满二叉树
*
*由于二叉树的节点增加没有什么规则，所以这里只是简单的使用了递一
*次性把整棵树创建出来，而没有设计出一个一个添加节点的方法与删除
*
*@authorjzj
*@date2009-12-23
*/
publicclassBinTree{//Bin=Binary（二进位的,二元的）
protectedEntryroot;
//根
privateintsize;
//树的节点数
/**
*树的节点结构
*@authorjzj
protectedstaticclassEntry{
intelem;
//数据域，这里我们作为编号
Entryleft;
//左子树
Entryright;
//右子树
publicEntry（intelem）{
this.elem=elem;
}
publicStringtoString（）{
return"
number="
+elem;
}
*根据给定的节点数创建一个完全二叉树或是满二叉树
*@paramnodeCount要创建节点总数
*/
publicvoidcreateFullBiTree（intnodeCount）{
root=recurCreateFullBiTree（1,nodeCount）;
*递归创建完全二叉树
*@paramnum节点编号
*@paramnodeCount节点总数
*@returnTreeNode返回创建的节点
privateEntryrecurCreateFullBiTree（intnum,intnodeCount）{
size++;
EntryrootNode=newEntry（num）;
//根节点
//如果有左子树则创建左子树
if（num*2<
=nodeCount）{
rootNode.left=recurCreateFullBiTree（num*2,nodeCount）;
//如果还可以创建右子树，则创建
if（num*2+1<
rootNode.right=recurCreateFullBiTree（num*2+1,nodeCount）;
}
return（Entry）rootNode;
*根据给定的数组创建一棵树，这个棵树可以是完全二叉树也可是普通二叉树
*数组中为0的表示不创建该位置上的节点
*@paramnums数组中指定了要创建的节点的编号，如果为0，表示不创建
publicvoidcreateBinTree（int[]nums）{
root=recurCreateBinTree（nums,0）;
*递归创建二叉树
*@paramindex需要使用数组中的哪个元素创建节点，如果为元素为0，则不创建
*@returnTreeNode返回创建的节点，最终会返回树的根节点
privateEntryrecurCreateBinTree（int[]nums,intindex）{
//指定索引上的编号不为零上才需创建节点
if（nums[index]!
=0）{
size++;
EntryrootNode=newEntry（nums[index]）;
//如果有左子树则创建左子树
if（（index+1）*2<
=nums.length）{
rootNode.left=（Entry）recurCreateBinTree（nums,（index+1）*2-1）;
//如果还可以创建右子树，则创建
if（（index+1）*2+1<
rootNode.right=（Entry）recurCreateBinTree（nums,（index+1）*2）;
}
return（Entry）rootNode;
returnnull;
publicintsize（）{
returnsize;
//取树的最左边的节点
publicintgetLast（）{
Entrye=root;
while（e.right!
=null）{
e=e.right;
returne.elem;
//测试
publicstaticvoidmain（String[]args）{
//创建一个满二叉树
BinTreebinTree=newBinTree（）;
binTree.createFullBiTree（15）;
System.out.println（binTree.size（））;
//15
System.out.println（binTree.getLast（））;
//创建一个完全二叉树
binTree=newBinTree（）;
binTree.createFullBiTree（14）;
//14
//7
//创建一棵非完全二叉树
int[]nums=newint[]{1,2,3,4,0,0,5,0,6,0,0,0,0,7,8};
binTree.createBinTree（nums）;
//8
}
（二）利用二叉树本身特点进行递归遍历（属内部遍历）
由于二叉树所具有的递归性质，一棵非空的二叉树可以看作是由根节点、左子树和右子树3部分构成，因为若能依次遍历这3部分的信息，也就遍历了整个二叉树。
按照左子树的遍历在右子树的遍历之前进行的约定，根据访问根节点位置的不同，可以得到二叉的前序、中序、后序3种遍历方法。
2.
3./**
二叉树的三种
内部
遍历：
前序、中序、后序
但不管是哪种方式，左子树的遍历在右子树的遍历之前遍历是这有三种遍历方式都
必须遵循的约定
10.public
BinTreeInOrder
extends
11.
节点访问者，可根据需要重写visit方法
abstract
Visitor
visit（Object
ele）
System.out.print（ele
）;
preOrder（Visitor
v）
preOrder（v,
root）;
树的前序递归遍历
pre=prefix（前缀）
node
要遍历的节点
v,
node）
//如果传进来的节点不为空，则遍历，注，叶子节点的子节点为null
（node
v.visit（node.elem）;
//先遍历父节点
node.left）;
//再遍历左节点
node.right）;
//最后遍历右节点
inOrder（Visitor
inOrder（v,
树的中序递归遍历
in=infix（中缀）
//先遍历左节点
//再遍历父节点
pu
升级会员 