java

一.遍历

设L、D、R分别表示遍历左子树、访问根结点和遍历右子树， 则对一棵二叉树的遍历有三种情况：DLR（称为先根次序遍历），LDR（称为中根次序遍历），LRD （称为后根次序遍历）。

1.先序遍历:首先访问根，再先序遍历左子树，最后先序遍历右子树。

2.中序遍历:首先中序遍历左子树，再访问根，最后中序遍历右子树。

3.后序便利:首先后序遍历左子树，再后序遍历右子树，最后访问根。

二.二叉树的字符串表达式

String  expression = "A(B(D(,G)),C(E,F))";与该广义表对应的二叉树为：

写代码前，我们通过观察二叉树和广义表，先得出一些结论：

• 每当遇到字母，将要创建节点
• 每当遇到“（”，表面要创建左孩子节点
• 每当遇到“，”，表明要创建又孩子节点
• 每当遇到“）”，表明要返回上一层节点
• 广义表中“（”的数量正好是二叉树的层数

三.代码

1.树的每个节点

public class Node {
    //节点的数据
    private char data;
    //节点的左子节点
    private Node lchild;
    //节点的右子节点
    private Node rchild;
    
    public Node() {
        super();
    }

    public Node(char data, Node lchild, Node rchild) {
        super();
        this.data = data;
        this.lchild = lchild;
        this.rchild = rchild;
    }

    public char getData() {
        return data;
    }

    public void setData(char data) {
        this.data = data;
    }

    public Node getLchild() {
        return lchild;
    }

    public void setLchild(Node lchild) {
        this.lchild = lchild;
    }

    public Node getRchild() {
        return rchild;
    }

    public void setRchild(Node rchild) {
        this.rchild = rchild;
    }
    
    public String toString(){
        return ""+getData();
    }
    
}

2.二叉树

/**
 * 二叉树，包含有创建二叉树，遍历二叉树的方法
 * @author phase1
 *
 */
public class BinaryTree {
    //二叉树的字符串表达式
    private String tree; 
    //树的节点表式
    private Node treeNode;
    //构造方法
    public BinaryTree(String tree){
        this.tree = tree;
    }
    public BinaryTree(Node treeNode){
        this.treeNode = treeNode;
    }
    public String getTree() {
        return tree;
    }
    public void setTree(String tree) {
        this.tree = tree;
    }
    public Node getTreeNode() {
        return treeNode;
    }
    public void setTreeNode(Node treeNode) {
        this.treeNode = treeNode;
    }
    
    /**
     * 根据二叉树的字符串表式创建二叉树的节点表示法
     * @return
     */
    public Node createTree(){
        //将树的字符串表示转换成char数组
        char[] data = tree.toCharArray();
        //根节点，有了根节点所有节点都能获取
        Node root = null;
        //用于存放每一层的根节点，值动态的
        List<Node> nodes = new LinkedList<Node>();
        int level = -1;
        //控制创建左右子节点（L,R）
        char child = 'N';
        //当前节点
        Node now = null;
        for(int i=0;i<data.length;i++){
            switch(data[i]){
            case '(':
                level++;
                //此时nodes.get(level)与now对应
                nodes.add(now);
                child = 'L';
                break;
            case ',':
                child = 'R';
                break;
            case ')':
                nodes.remove(level);
                level--;
                break;
            default:
                now = new Node(data[i], null, null);
                if(root == null){
                    root = now;
                }else{
                    switch(child){//此时nodes.get(leve)为now的父节点
                    case 'L':
                        nodes.get(level).setLchild(now);
                        break;
                    case 'R':
                        nodes.get(level).setRchild(now);
                    }
                }
            }
                
        }
        return root;
    }
    
    /**
     * 先序遍历
     * @param node
     */
    public String beforeOrder(Node node){
        StringBuilder nodes = new StringBuilder();
        if(node != null){
            //根节点
            nodes.append(node.getData());
            //先序遍历左子节点
            nodes.append(beforeOrder(node.getLchild()));
            //先序遍历右子节点
            nodes.append(beforeOrder(node.getRchild()));
        }
        return nodes.toString();
    }
    
    /**
     * 中序遍历
     * @param node
     */
    public String inOrder(Node node){
        StringBuilder nodes = new StringBuilder();
        if(node != null){
            //中序遍历左子节点
            nodes.append(inOrder(node.getLchild()));
            //根节点
            nodes.append(node.getData());
            //中序遍历右子节点
            nodes.append(inOrder(node.getRchild()));
        }
        return nodes.toString();
    }
    
    /**
     * 后序遍历
     * @param node
     */
    public String afterOrder(Node node){
        StringBuilder nodes = new StringBuilder();
        if(node != null){
            //后序遍历左子节点
            nodes.append(afterOrder(node.getLchild()));
            //后序遍历右子节点
            nodes.append(afterOrder(node.getRchild()));
            //根节点
            nodes.append((node.getData()));
        }
        return nodes.toString();
    }
    
    public static void main(String[] args) {
        String  expression = "A(B(D(,G)),C(E,F))";
        BinaryTree tree = new BinaryTree(expression);
        Node node = tree.createTree();
        System.out.println(tree.beforeOrder(node));//ABDGCEF
        System.out.println(tree.inOrder(node));　　//DGBAECF
        System.out.println(tree.afterOrder(node));//GDBEFCA
    }
}