代码1：

四种遍历方式

package 第四章;
import java.util.LinkedList;
/** * @author 许湘扬 * @email 547139255@qq.com * @detail 先序创建 各种遍历 二叉树 */
/* * 先序创建、输出 二叉树 * 先序 二叉树 * * 创建参考自：http://www.cnblogs.com/llhthinker/p/4906631.html * 遍历参考自：http://blog.csdn.net/sjf0115/article/details/8645991 */

public class BinaryTree<T> {
    /* * 先序创建二叉树 * 返回：根节点 */
    public TreeNode<T>  creatBinaryPre(LinkedList<T> treeData)
    {
        TreeNode<T> root=null;
        T data=treeData.removeFirst();
        if (data!=null) 
        {
            root=new TreeNode<T>(data, null, null);
            root.left=creatBinaryPre(treeData);
            root.right=creatBinaryPre(treeData);
        }
        return root;
    }
    /* * 先序遍历二叉树（递归） */
    public void PrintBinaryTreePreRecur(TreeNode<T> root)
    {
        if (root!=null) 
        {
            System.out.print(root.data);
            PrintBinaryTreePreRecur(root.left);
            PrintBinaryTreePreRecur(root.right);
        }
    }
    /* * 中序遍历二叉树（递归） */
    public void PrintBinaryTreeMidRecur(TreeNode<T> root)
    {
        if (root!=null) 
        {
            PrintBinaryTreeMidRecur(root.left);
            System.out.print(root.data);
            PrintBinaryTreeMidRecur(root.right);
        }
    }
    /* * 后序遍历二叉树（递归） */
    public void PrintBinaryTreeBacRecur(TreeNode<T> root)
    {
        if (root!=null) 
        {
            PrintBinaryTreeBacRecur(root.left);
            PrintBinaryTreeBacRecur(root.right);
            System.out.print(root.data);
        }
    }
    /* * 先序遍历二叉树（非递归） * 思路：对于任意节点T，访问这个节点并压入栈中，然后访问节点的左子树， * 遍历完左子树后，取出栈顶的节点T，再先序遍历T的右子树 */
    public void PrintBinaryTreePreUnrecur(TreeNode<T> root)
    {
        TreeNode<T> p=root;//p为当前节点
        LinkedList<TreeNode> stack=new LinkedList<>();
        //栈不为空时，或者p不为空时循环
        while(p!=null || !stack.isEmpty())
        {
            //当前节点不为空。访问并压入栈中。并将当前节点赋值为左儿子
            if (p!=null) 
            {
                stack.push(p);
                System.out.print(p.data);
                p=p.left;
            }
            //当前节点为空：
            // 1、当p指向的左儿子时，此时栈顶元素必然是它的父节点
            // 2、当p指向的右儿子时，此时栈顶元素必然是它的爷爷节点
            //取出栈顶元素，赋值为right
            else
            {
                p=stack.pop();
                p=p.right;
            }
        }
    }
    /* * 中序遍历二叉树（非递归） * * 思路：先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T， * 出栈，访问T->data，再中序遍历T的右子树。 */
    public void PrintBinaryTreeMidUnrecur(TreeNode<T> root)
    {
        TreeNode<T> p=root;//p为当前节点
        LinkedList<TreeNode> stack=new LinkedList<>();

        //栈不为空时，或者p不为空时循环
        while(p!=null || !stack.isEmpty())
        {
            //当前节点不为空。压入栈中。并将当前节点赋值为左儿子
            if (p!=null) 
            {
                stack.push(p);
                p=p.left;
            }
            //当前节点为空：
            // 1、当p指向的左儿子时，此时栈顶元素必然是它的父节点
            // 2、当p指向的右儿子时，此时栈顶元素必然是它的爷爷节点
            //取出并访问栈顶元素，赋值为right
            else
            {
                p=stack.pop();
                System.out.print(p.data);
                p=p.right;
            }
        }
    }
    /* * 后序遍历二叉树（非递归） * */
    public void PrintBinaryTreeBacUnrecur(TreeNode<T> root)
    {
        class NodeFlag<T>
        {
            TreeNode<T> node;
            char tag;
            public NodeFlag(TreeNode<T> node, char tag) {
                super();
                this.node = node;
                this.tag = tag;
            }
        }
        LinkedList<NodeFlag<T>> stack=new LinkedList<>();
        TreeNode<T> p=root;
        NodeFlag<T> bt;
        //栈不空或者p不空时循环 
        while(p!=null || !stack.isEmpty())
        {
            //遍历左子树
            while(p!=null)
            {
                bt=new NodeFlag(p, 'L');
                stack.push(bt);
                p=p.left;
            }
            //左右子树访问完毕访问根节点 
            while(!stack.isEmpty() && stack.getFirst().tag=='R')
            {
                bt=stack.pop();
                System.out.print(bt.node.data);
            }
            //遍历右子树
            if (!stack.isEmpty()) 
            {
                bt=stack.peek();
                bt.tag='R';
                p=bt.node;
                p=p.right;
            }
        }
    }
    /* * 层次遍历二叉树（非递归） */
    public void PrintBinaryTreeLayerUnrecur(TreeNode<T> root)
    {
        LinkedList<TreeNode> queue=new LinkedList<>();
        TreeNode<T> p;
        queue.push(root);
        while(!queue.isEmpty())
        {
            p=queue.removeFirst();
            System.out.print(p.data);
            if (p.left!=null)
                queue.addLast(p.left);
            if (p.right!=null)
                queue.addLast(p.right);
        }
    }
}
 class TreeNode<T>
{
    public T data;
    public TreeNode<T> left;
    public TreeNode<T> right;
    public TreeNode(T data, TreeNode<T> left, TreeNode<T> right)
    {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

代码2

测试上面的四种遍历+先序创建树

package 第四章;

import java.util.LinkedList;
/* * 测试二叉树的 创建、遍历 * 二叉树结构如下 * A * B C * D E F G * H I J */
public class TestBinaryTree {
    public static void main(String[] args) 
    {
        BinaryTree<Character> binaryTree=new BinaryTree<>();

        //输入ABDH##I##E##CF#J##G##（#用null代替）
        LinkedList<Character> tree=new LinkedList<>();
        tree.add('A');tree.add('B');tree.add('D');
        tree.add('H');tree.add(null);tree.add(null);
        tree.add('I');tree.add(null);tree.add(null);
        tree.add('E');tree.add(null);tree.add(null);
        tree.add('C');tree.add('F');tree.add(null);
        tree.add('J');tree.add(null);tree.add(null);
        tree.add('G');tree.add(null);tree.add(null);

        TreeNode<Character> root=binaryTree.creatBinaryPre(tree);

        //先序遍历（递归）
        binaryTree.PrintBinaryTreePreRecur(root);System.out.println();
        //中序遍历（递归）
        binaryTree.PrintBinaryTreeMidRecur(root);System.out.println();
        //后序遍历（递归）
        binaryTree.PrintBinaryTreeBacRecur(root);System.out.println();


        //先序遍历（非递归）
        binaryTree.PrintBinaryTreePreUnrecur(root);System.out.println();
        //中序遍历（非递归）
        binaryTree.PrintBinaryTreeMidUnrecur(root);System.out.println();
        //后序遍历（非递归）
        binaryTree.PrintBinaryTreeBacUnrecur(root);System.out.println();
        //层次遍历（非递归）
        binaryTree.PrintBinaryTreeLayerUnrecur(root);System.out.println();


    }
}