二叉树前、中、后序遍历

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class TraversalTree {
    public static class TreeNode {
        private TreeNode left;
        private TreeNode right;
        private Integer val;

        public TreeNode(Integer val) {
            this.val = val;
        }
    }

    //======================中序============================
    public static void InorderTraversalTree(TreeNode node) {
        if (node == null) return;
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || node != null) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                System.out.println(node.val);//左入栈，出栈时打印
                node = node.right;
            }
        }
    }

    public static void InorderTraversalTree_recursion(TreeNode node) {
        if (node == null) return;
        InorderTraversalTree_recursion(node.left);
        System.out.println(node.val);
        InorderTraversalTree_recursion(node.right);

    }

    //======================先序============================

    public static void preorderTraversalTree1(TreeNode node) {//先序非递归1
        if (node == null) return;
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || node != null) {
            if (node != null) {
                System.out.println(node.val);//左入栈，入栈时打印
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                node = node.right;
            }

        }

    }

    public static void preorderTraversalTree2(TreeNode node) {
        if (node == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        while (!stack.isEmpty()) {
            node = stack.pop();
            System.out.println(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }

        }

    }

    public static void preorderTraversalTree_recursion(TreeNode node) {
        if (node == null) return;
        System.out.println(node.val);
        InorderTraversalTree_recursion(node.left);
        InorderTraversalTree_recursion(node.right);
    }


    //======================后续==================================

    public List<Integer> postorderTraversal(TreeNode head) {
        Stack<TreeNode> stack = new Stack<>();
        LinkedList<Integer> output = new LinkedList<>();
        if (head == null) {
            return output;
        }

        stack.push(head);
        while (!stack.isEmpty()) {
            head = stack.pop();
            output.addFirst(head.val);//添加进头节点
            if (head.left != null) {
                stack.add(head.left);
            }
            if (head.right != null) {
                stack.add(head.right);
            }
        }
        return output;
    }

    private void postOrderTravel(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        postOrderTravel(treeNode.left);
        postOrderTravel(treeNode.right);
        System.out.println(treeNode.val);
    }

}