Java实现二叉树遍历(递归，非递归)

public class BinaryTree {
    class TreeNode<T>{
        private T data;
        private TreeNode<T> leftNode;
        private TreeNode<T> rightNode;

        public TreeNode(T data, TreeNode<T> leftNode, TreeNode<T> rightNode){
            this.data = data;
            this.leftNode = leftNode;
            this.rightNode = rightNode;
        }
    }
    //新建二叉树
    public TreeNode<String> init(){
        TreeNode<String> K = new TreeNode<String>("K", null, null);  
        TreeNode<String> J = new TreeNode<String>("J", null, null); 
        TreeNode<String> I = new TreeNode<String>("I", null, null); 
        TreeNode<String> H = new TreeNode<String>("H", null, null);
        TreeNode<String> G = new TreeNode<String>("G", K, null);
        TreeNode<String> F = new TreeNode<String>("F", null, J);
        TreeNode<String> E = new TreeNode<String>("E", H, I);
        TreeNode<String> D = new TreeNode<String>("D",null,null);
        TreeNode<String> C = new TreeNode<String>("C",F,G);
        TreeNode<String> B = new TreeNode<String>("B",D,E);
        TreeNode<String> A = new TreeNode<String>("A",B,C);

        return A;
    }

    //先序遍历(递归)
    public void preorderTraverse(TreeNode<String> root){
        if(root == null)
            return;

        System.out.print(root.data + " ");      
        preorderTraverse(root.leftNode);
        preorderTraverse(root.rightNode);
    }

    //中序遍历(递归)
    public void inorderTraverse(TreeNode<String> root){
        if(root == null)
            return; 

        inorderTraverse(root.leftNode);
        System.out.print(root.data + " ");
        inorderTraverse(root.rightNode);
    }

    //后序遍历(递归)
    public void postorderTraverse(TreeNode<String> root){
        if(root == null)
            return; 

        preorderTraverse(root.leftNode);        
        preorderTraverse(root.rightNode);
        System.out.print(root.data + " ");
    }

    //先序遍历(非递归)
    public void preorderTraverse_stack(TreeNode<String> root){
        if(root == null)
            return;
        Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();      
        while(root != null || !stack.isEmpty()){
            while(root != null){
                System.out.print(root.data + " ");
                stack.push(root);
                root = root.leftNode;
            }

            root = stack.pop();
            root = root.rightNode;
        }
    }

    //中序遍历(非递归)
    public void inorderTraverse_stack(TreeNode<String> root){
        if(root == null)
            return;
        Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.leftNode;
            }

            root = stack.pop();
            System.out.print(root.data + " ");
            root = root.rightNode;
        }
    }

    //后续遍历(非递归)
    public void postOrderTraverse_stack(TreeNode<String> root){
        if(root == null)
            return;
        Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();
        Map<TreeNode<String>,Boolean> map = new HashMap<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode<String> temp = stack.pop();
            if(temp.leftNode != null && !map.containsKey(temp.leftNode)){
                temp = temp.leftNode;
                while(temp != null){
                    if(map.containsKey(temp))
                        break;
                    else
                        stack.push(temp);
                    temp =temp.leftNode;
                }

                continue;
            }

            if(temp.rightNode != null && !map.containsKey(temp.rightNode)){
                stack.push(temp.rightNode);
                continue;
            }

            TreeNode<String> t = stack.pop();
            map.put(t, true);
            System.out.println(t.data);
        }
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.leftNode;
            }

            root = stack.pop();

        }
    }
    //层序遍历
    public void levelTraverse(TreeNode<String> root){
        if(root == null)
            return;
        Queue<TreeNode<String>> queue = new LinkedList<TreeNode<String>>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode<String> temp = queue.poll();
            System.out.print(temp.data + " ");
            if(temp.leftNode!=null)
                queue.add(temp.leftNode);
            if(temp.rightNode != null)
                queue.add(temp.rightNode);
        }
    }
    public static void main(String[] args){
        BinaryTree binaryTree = new BinaryTree();
        TreeNode<String> root = binaryTree.init();
        System.out.println("先序遍历(递归)");
        binaryTree.preorderTraverse(root);
        System.out.println();
        System.out.println("先序遍历(非递归)");
        binaryTree.preorderTraverse_stack(root);    
        System.out.println();

        System.out.println("中序遍历(递归)");
        binaryTree.inorderTraverse(root);
        System.out.println();
        System.out.println("中序遍历(非递归)");
        binaryTree.inorderTraverse_stack(root);
        System.out.println();

        System.out.println("后序遍历(递归)");
        binaryTree.postorderTraverse(root);
        System.out.println();
        System.out.println("后序遍历(非递归)");
        binaryTree.postorderTraverse(root);
        System.out.println();
        System.out.println("层序遍历");
        binaryTree.levelTraverse(root);
    }
}