leetCode之二叉树的前中后序遍历递归和非递归

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }


    /**
     * 前序便利递归
     * @param treeNode
     * @param result
     */
    public static void before(TreeNode treeNode, List<Integer> result) {
        if(treeNode == null) {
            return;
        }
        result.add(treeNode.val);
        before(treeNode.left, result);
        before(treeNode.right, result);
    }

    /**
     * 谦虚遍历非递归
     * @param treeNode
     * @param result
     */
    public static void beforeNoIte(TreeNode treeNode, List<Integer> result) {
        Stack<TreeNode> stack = new Stack<>();
        stack.push(treeNode);
        while (!stack.isEmpty()) {
            TreeNode tempNode = stack.pop();
            result.add(tempNode.val);
            if(tempNode.right != null) {
                stack.push(tempNode.right);
            }
            if(tempNode.left != null) {
                stack.push(tempNode.left);
            }
        }
    }

    /**
     * 后序遍历
     * @param treeNode
     * @param result
     */
    public static void after(TreeNode treeNode, List<Integer> result){
        if(treeNode == null) {
            return;
        }
        after(treeNode.left, result);
        after(treeNode.right, result);
        result.add(treeNode.val);
    }

    /**
     * 后序遍历非递归
     * @param treeNode
     * @param s2
     */
    public static void afterNoIte(TreeNode treeNode, List<Integer> s2){
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> result = new Stack<>();
        s1.push(treeNode);
        while (!s1.isEmpty()) {
            TreeNode temp = s1.pop();
            result.push(temp);
            if(temp.left != null) {
                s1.push(temp.left);
            }
            if(temp.right != null) {
                s1.push(temp.right);
            }
        }
        while (!result.isEmpty()) {
            s2.add(result.pop().val);
        }
    }

    /**
     * 中序遍历递归
     * @param treeNode
     * @param result
     */
    public static void middle(TreeNode treeNode, List<Integer> result) {
        if(treeNode == null) {
            return;
        }
        middle(treeNode.left, result);
        result.add(treeNode.val);
        middle(treeNode.right, result);
    }


    /**
     * 中序遍历非递归
     * @param treeNode
     * @param result
     */
    public static void middleNoIte(TreeNode treeNode, List<Integer> result) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode head = treeNode;
        while (head != null) {
            stack.push(head);
            head = head.left;
        }
        while (!stack.isEmpty()) {
            TreeNode temp = stack.pop();
            result.add(temp.val);
            if (temp.right != null) {
                TreeNode next = temp.right;
                while (next != null) {
                    stack.push(next);
                    next = next.left;
                }
            }
        }
    }

    public static void main(String[] args) {
        TreeNode t1 = new TreeNode(1, null, null);
        TreeNode t2 = new TreeNode(2, null, null);
        TreeNode t3 = new TreeNode(3, t1, t2);
        TreeNode t4 = new TreeNode(4, null, null);
        TreeNode t5 = new TreeNode(5, null, null);
        TreeNode t6 = new TreeNode(6, t4, t5);
        TreeNode root = new TreeNode(7, t3, t6);
        List<Integer> result = new ArrayList<>();
        middleNoIte(root, result);
        for (int num: result) {
            System.out.print(num);
        }
    }
}