二叉树的遍历（20）
二叉树的遍历：
一棵二叉树由三部分组成：根结点、左子树和右子树 。
本篇内容先用递归来遍历二叉树，后面再介绍用非递归的方式遍历二叉树。还有一个重要的概念就是递归归根结底也是栈的运算。
根据遍历算法访问根结点的次序，我们介绍三种遍历算法分别为前序遍历（DLR）、中序遍历（LDR）和后序遍历（LRD）。
前序遍历（DLR）递归算法为：
若二叉树为空则算法结束；否则：
（1）访问根结点；
（2）前序遍历根结点的左子树；
（3）前序遍历根结点的右子树。
前序遍历（DLR）递归算法为：
若二叉树为空则算法结束；否则：
（1）访问根结点；
（2）前序遍历根结点的左子树；
（3）前序遍历根结点的右子树。
中序遍历（LDR）递归算法为：
若二叉树为空则算法结束；否则：
（1）中序遍历根结点的左子树；
（2）访问根结点；
（3）中序遍历根结点的右子树。
后序遍历（LRD）递归算法为：
若二叉树为空则算法结束；否则：
（1）后序遍历根结点的左子树；
（2）后序遍历根结点的右子树；
（3）访问根结点。
除前序、中序和后序遍历算法外，二叉树还有层序遍历。层序遍历的要求是：按二叉树的层序次序（即从根结点层至叶结点层），同一层中按先左子树再右子树的次序遍历二叉树。
树节点：
packageorg.lixiyuan.erchashu;
public class BiTreeNode {
private BiTreeNode leftNode;
private BiTreeNode rightNode;
private Object data;
public BiTreeNode(Object data,BiTreeNode l,BiTreeNode r){
this.data=data;
this.leftNode=l;
this.rightNode=r;
}
public BiTreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(BiTreeNode leftNode) {
this.leftNode = leftNode;
}
public BiTreeNode getRightNode() {
return rightNode;
}
public void setRightNode(BiTreeNode rightNode) {
this.rightNode = rightNode;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
树：
packageorg.lixiyuan.erchashu;
public class BiTree {
public BiTreeNode root;
public BiTree(){
root=null;
}
public BiTree(Object data,BiTree left,BiTree right){
BiTreeNode l,r;
if(left!=null){
l=left.root;
}else{
l=null;
}
if(right!=null){
r=right.root;
}else{
r=null;
}
}
public static void printBiTree(BiTreeNode root,int eval){
if(root!=null){
printBiTree(root.getRightNode(),eval+1);
if(eval!=0){
for (int i = 0; i < 6*(eval-1); i++) {
System.out.print(" ");
}
System.out.print("-----");
}
System.out.println(root.getData());
printBiTree(root.getLeftNode(),eval+1);
}
}
public static BiTreeNode getTreeNode(Objectdata,BiTreeNode left,BiTreeNode right){
BiTreeNode b;
b=new BiTreeNode(data,left,right);
return b;
}
}
遍历算法：
packageorg.lixiyuan.erchashu;
importjava.util.LinkedList;
importjava.util.Queue;
public class BianLi {
/**
* 前序遍历 根左右
* @param node
*/
public static void qianxu(BiTreeNode root){
if(root!=null){
System.out.print(root.getData());
qianxu(root.getLeftNode());
qianxu(root.getRightNode());
}
}
public static void zhongxu(BiTreeNode root){
if(root!=null){
zhongxu(root.getLeftNode());
System.out.print(root.getData());
zhongxu(root.getRightNode());
}
}
public static void houxu(BiTreeNode root){
if(root!=null){
houxu(root.getLeftNode());
houxu(root.getRightNode());
System.out.print(root.getData());
}
}
/**
* 层次遍历
* @param root
*/
public static void cengci(BiTreeNode root){
Queue<BiTreeNode> queue = new LinkedList<BiTreeNode>();
if(root==null)
{
return ;
}
BiTreeNode curr;
queue.add(root);
while(!queue.isEmpty()){
curr=queue.remove();
System.out.println(curr.getData());
if(curr.getLeftNode()!=null){
queue.add(curr.getLeftNode());
}
if(curr.getRightNode()!=null){
queue.add(curr.getRightNode());
}
}
}
}
测试类：
packageorg.lixiyuan.erchashu;
public class Test {
public static BiTreeNode makeTree()
{
BiTreeNode b,c,d,e,f,g;
g = BiTree.getTreeNode(new Character('G'), null, null);
d = BiTree.getTreeNode(new Character('D'), null, g);
b = BiTree.getTreeNode(new Character('B'), d, null);
e = BiTree.getTreeNode(new Character('E'), null, null);
f = BiTree.getTreeNode(new Character('F'), null, null);
c= BiTree.getTreeNode(new Character('C'), e, f);
return BiTree.getTreeNode(new Character('A'), b, c);
}
public static void main(String[] args) {
BiTreeNode root;
BiTreeNode temp;
BianLi l=new BianLi();
root = Test.makeTree();
System.out.println("二叉树为：");
BiTree.printBiTree(root, 0);
System.out.println();
System.out.println("前序遍历");
l.qianxu(root);
System.out.println();
System.out.println("中续遍历");
l.zhongxu(root);
System.out.println();
System.out.println("后续遍历");
l.houxu(root);
System.out.println();
System.out.println("层次");
l.cengci(root);
}
}
输出结果：
二叉树为：
-----F
-----C
-----E
A
-----B
-----G
-----D
前序遍历
ABDGCEF
中续遍历
DGBAECF
后续遍历
GDBEFCA
层次
A
B
C
D
E
F
G