[Java算法分析与设计]二叉树的遍历

设计Node节点类：

package com.chen.arithmetic_test.BiTree_test;

/**
 * Created by ChenMP on 2017/7/13.
 */
public class BiTreeNode {
    private Object data;
    private BiTreeNode leftChild;
    private BiTreeNode rightChild;

    public BiTreeNode() {
    }

    public BiTreeNode(Object data) {
        this.data = data;
    }

    public BiTreeNode(Object data, BiTreeNode leftChild, BiTreeNode rightChild) {
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }

    public Object getData() {
        return data;
    }

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

    public BiTreeNode getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(BiTreeNode leftChild) {
        this.leftChild = leftChild;
    }

    public BiTreeNode getRightChild() {
        return rightChild;
    }

    public void setRightChild(BiTreeNode rightChild) {
        this.rightChild = rightChild;
    }
}

设计二叉树的遍历实现：

package com.chen.arithmetic_test.BiTree_test;

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by ChenMP on 2017/7/13.
 */
public class Traverse {

    //前序遍历
    public static void preOrder(BiTreeNode root) {
        if (root != null) {
            System.out.print("_" + root.getData()); //打印根节点
            if (root.getLeftChild() != null)
                preOrder(root.getLeftChild()); //左子节点递归
            if (root.getRightChild() != null)
                preOrder(root.getRightChild()); //右子节点递归
        }
    }

    //中序遍历
    public static void inOrder(BiTreeNode root) {
        if (root != null) {
            if (root.getLeftChild() != null)
                inOrder(root.getLeftChild()); //左子节点递归
            System.out.print("_" + root.getData()); //打印根节点
            if (root.getRightChild() != null)
                inOrder(root.getRightChild()); //右子节点递归
        }
    }

    //后序遍历
    public static void postOrder(BiTreeNode root) {
        if (root != null) {
            if (root.getLeftChild() != null)
                postOrder(root.getLeftChild()); //左子节点递归
            if (root.getRightChild() != null)
                inOrder(root.getRightChild()); //右子节点递归
            System.out.print("_" + root.getData()); //打印根节点
        }
    }

    //层序遍历
    public static void levOrder(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.print("_" + curr.getData());
            if (curr.getLeftChild() != null)
                queue.add(curr.getLeftChild());
            if (curr.getRightChild() != null)
                queue.add(curr.getRightChild());
        }

    }
}

设计测试类

package com.chen.arithmetic_test.BiTree_test;

/**
 * Created by ChenMP on 2017/7/13.
 */
public class Test {

    /**二叉树形
     *                      A
     *               B                 C
     *       D                   E            F
     *           G
     *        H     I
     */
    public static BiTreeNode makeTree() {
        BiTreeNode b,c,d,e,f,g,h,i;
        i = new BiTreeNode(new Character('I'), null, null);
        h = new BiTreeNode(new Character('H'), null, null);
        g = new BiTreeNode(new Character('G'), h, i);
        d = new BiTreeNode(new Character('D'), null, g);
        b = new BiTreeNode(new Character('B'), d, null);
        e = new BiTreeNode(new Character('E'), null, null);
        f = new BiTreeNode(new Character('F'), null, null);
        c = new BiTreeNode(new Character('C'), e, f);
        return new BiTreeNode(new Character('A'), b, c);
    }

    public static void main(String[] args) {
        BiTreeNode root = Test.makeTree();

        System.out.println("前序遍历：");
        Traverse.preOrder(root);
        System.out.println("\n中序遍历：");
        Traverse.inOrder(root);
        System.out.println("\n后序遍历：");
        Traverse.postOrder(root);
        System.out.println("\n层序遍历");
        Traverse.levOrder(root);
    }
}