二叉树的遍历建立

数据结构中的树不再是线性的数据结构，而是一种层次的数据结构，在树中较为特殊与常用的是二叉树，所以大多数针对树的算法都是以二叉树为基础的。今天实现一下二叉树的几种算法。

二叉树比较重要的实现是树的遍历，树的遍历的方法主要有

1. 先序遍历（模拟程序运行，第一次遇到树节点时输出）
2. 中序遍历（模拟程序运行，除叶节点外第二次遇到树节点输出）
3. 后序遍历（模拟程序运行，除叶节点外第三次遇到树节点输出）
4. 层次遍历（从根节点开始，一层一层从左到右遍历）

另外二叉树的建立也是很有趣的，一棵二叉树，只有知道了先序和中序，或者知道中序和后序的顺序才能唯一确定一棵树，所以下面采用先序与中序建立一棵二叉树。

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

public class Tree {
    private TreeNode root = null;
    public Tree() {
        this.root = null;
    }

    public Tree(TreeNode rootNode) {
        this.root = rootNode;
    }
//  用先序遍历的结果与中序遍历的结果构造一棵树

/*preOrder是先序遍历的结果
 * midOrder是中序遍历的结果
 * preindex是先序遍历的起始位置
 * midindex是中序遍历的起始位置
 * count是树的节点总数
 */
    public Tree(String preOrder,String midOrder,int preindex,int midindex,int count){
        if (count>0) {
            char r = preOrder.charAt(preindex);
            root = new TreeNode(r);
            int i = 0;
//  找出根节点在中序遍历中的位置，在这之前的为左子树，之后为右子树
            for (; i < count; i++) {
                if (r == midOrder.charAt(i+midindex)) {
                    break;
                }
            }
//  设置左子树
            root.setLeftchild(new Tree(preOrder, midOrder, preindex+1, midindex, i).root);
//  设置右子树
            root.setRightchild(new Tree(preOrder, midOrder,preindex+i+1, midindex+i+1, count-i-1).root);
        }
    }

//  递归先序遍历二叉树
    public void pretraverse (TreeNode t) {
        if (t!=null){
//          （除叶节点外）第一次遇到树节点的时候打印
            System.out.print(t.getR());
            pretraverse(t.getLeftchild());
            pretraverse(t.getRightchild());
        }
    }
//  递归中序遍历二叉树
    public void midtraverse (TreeNode t){
        if (t!=null) {
//          （除叶节点外）第二次遇到树节点的时候打印
            midtraverse(t.getLeftchild());
            System.out.print(t.getR());
            midtraverse(t.getRightchild());
        }
    }
//  递归后序遍历二叉树
    public void lasttraverse (TreeNode t){
        if (t!=null) {
//          （除叶节点外）第三次遇到树节点的时候打印
            lasttraverse(t.getLeftchild());
            lasttraverse(t.getRightchild());
            System.out.print(t.getR());
        }
    }
//  非递归层次遍历二叉树
    public void leveltraverse (TreeNode t){
//      层次遍历需要一个队列
        Queue queue = new LinkedBlockingQueue();
//      将根节点加入队列
        queue.offer(t);
        while (queue.peek()!=null) {
//          输出队首节点，将队首节点的左右节点依次入队
            TreeNode temNode = (TreeNode) queue.poll();
            System.out.print(temNode.getR());
            if (temNode.getLeftchild()!=null) {
                queue.offer(temNode.getLeftchild());
            }
            if (temNode.getRightchild()!=null) {
                queue.offer(temNode.getRightchild());
            }
        }
    }
//  测试代码
    public  static void main (String [] args) {
        String preOrder = "ABDEGCFH";
        String midOrder = "DBGEAFHC";
        Tree t = new Tree(preOrder, midOrder, 0, 0, preOrder.length());
        System.out.println("后序遍历");
        t.lasttraverse(t.root);
        System.out.println("\n"+"层次遍历"); 
        t.leveltraverse(t.root);
    }
}

下面是树的节点代码。

public class TreeNode {
private TreeNode leftchild;
private TreeNode rightchild;
private Object element;
private char r; //为了测试

public TreeNode(Object element) {
    this.element = element;
}
public TreeNode(TreeNode leftchild,Object element) {
    this.element = element;
    this.leftchild = leftchild;
}
public TreeNode(Object element,TreeNode rightchild) {
    this.element = element;
    this.rightchild = rightchild;
}
public TreeNode(TreeNode leftchild,Object element,TreeNode rightchild) {
    this.element = element;
    this.leftchild = leftchild;
    this.rightchild = rightchild;
}
public TreeNode(char r) {
    // TODO Auto-generated constructor stub
    this.r = r;
}
public char getR() {
    return r;
}
public void setR(char r) {
    this.r = r;
}
public TreeNode getLeftchild() {
    return leftchild;
}
public void setLeftchild(TreeNode leftchild) {
    this.leftchild = leftchild;
}
public TreeNode getRightchild() {
    return rightchild;
}
public void setRightchild(TreeNode rightchild) {
    this.rightchild = rightchild;
}
public Object getElement() {
    return element;
}
public void setElement(Object element) {
    this.element = element;
}