二叉树遍历

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

public class Main {

    public static void main(String[] args) {
        Tree tree = new Tree("G");
        tree.left = new Tree("D");
        tree.right = new Tree("M");
        tree.left.left = new Tree("A");
        tree.left.right = new Tree("F");
        tree.left.right.left = new Tree("E");
        tree.right.left = new Tree("H");
        tree.right.right = new Tree("Z");
//        前序中序后序
//        GDAFEMHZ
//        ADEFGHMZ
//        AEFDHZMG
//        递归
        qianxuDiGui(tree);
        System.out.println();
        zhongxuDiGui(tree);
        System.out.println();
        houxuDigui(tree);
        System.out.println();
        System.out.println("---------------");
//        非递归
        qianxu(tree);
        System.out.println();
        zhongxu(tree);
        System.out.println();
        houxu(tree);
        System.out.println();
        System.out.println("---------------");

//        层序
//        GDMAFHZE
        middleOrder(tree);
    }

    private static void qianxuDiGui(Tree node){
        if (node == null){
            return;
        }
        System.out.print(node.val);
        qianxuDiGui(node.left);
        qianxuDiGui(node.right);
    }

    private static void zhongxuDiGui(Tree node){
        if (node == null){
            return;
        }
        zhongxuDiGui(node.left);
        System.out.print(node.val);
        zhongxuDiGui(node.right);
    }

    private static void houxuDigui(Tree node){
        if (node == null){
            return;
        }
        houxuDigui(node.left);
        houxuDigui(node.right);
        System.out.print(node.val);
    }

    private static void qianxu(Tree tree) {
        Stack<Tree> stack = new Stack<>();
        Tree node = tree;
        while (node != null || stack.size() != 0) {
            if (node != null) {
                stack.push(node);
                System.out.print(node.val);
                node = node.left;
            } else {
                node = stack.pop().right;
            }
        }
    }

    private static void zhongxu(Tree node) {
        Stack<Tree> stack = new Stack<>();
        Tree tree = node;
        while (tree != null || stack.size() != 0) {
            if (tree != null) {
                stack.push(tree);
                tree = tree.left;
            } else {
                tree = stack.pop();
                System.out.print(tree.val);
                tree = tree.right;
            }
        }
    }

    private static void houxu(Tree node) {
        if (node == null) {
            return;
        }
        Stack<Tree> stack = new Stack<>();
        Stack<Boolean> stackFlag = new Stack<>();
        Tree tree = node;
        while (stack.size() != 0 || tree != null) {
            while (tree != null) {
                stack.push(tree);
                stackFlag.push(false);
                tree = tree.left;
            }
//            从右子树返回
            while (stack.size() != 0 && stackFlag.peek()){
                stackFlag.pop();
                System.out.print(stack.pop().val);
            }
//            从左子树返回
            if (stack.size() != 0 && !stackFlag.peek()){
                stackFlag.pop();
                stackFlag.push(true);
                tree=stack.peek().right;
            }
        }
    }

        private static void middleOrder(Tree tree){
        Queue<Tree> queue = new LinkedList<>();
        queue.offer(tree);
        while (queue.size() != 0){
            tree = queue.poll();
            if (tree.left != null){
                queue.offer(tree.left);
            }
            if (tree.right != null){
                queue.offer(tree.right);
            }
            System.out.print(tree.val);
        }
    }
}

class Tree {
    Tree left;
    Tree right;
    String val;

    public Tree(String val) {
        this.val = val;
    }
}