二叉树的前中后序遍历，递归与非递归方式

package algorithm;

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

public class BinarySearchTree {
    private TreeNode root;

    /**
     * search a node which value equals number
     *
     * @param number number
     * @return node
     */
    public TreeNode search(int number) {
        if (root == null) {
            System.out.printf(Locale.ENGLISH, "Debug[Search]:root node is null%n");
            return null;
        }
        TreeNode cur = root;
        TreeNode pre = null;
        while (cur != null) {
            if (number == cur.getVal()) {
                System.out.printf(Locale.ENGLISH, "Debug[Search]:found node:%s%n", cur);
                return cur;
            }
            pre = cur;
            System.out.printf(Locale.ENGLISH, "Debug[Search]:pre become %s%n", pre);
            if (number < cur.getVal()) {
                cur = cur.getLeft();
                System.out.printf(Locale.ENGLISH, "Debug[Search]:cur move to Left %s%n", cur);
            } else {
                cur = cur.getRight();
                System.out.printf(Locale.ENGLISH, "Debug[Search]:cur move to Right %s%n", cur);
            }
        }
        if (number < pre.getVal()) {
            System.out.printf(Locale.ENGLISH, "Debug[Search]:found node:%s of Left of %s%n", pre.getLeft(), pre);
            return pre.getLeft();
        } else {
            System.out.printf(Locale.ENGLISH, "Debug[Search]:found node:%s of Right of %s%n", pre.getRight(), pre);
            return pre.getRight();
        }
    }

    /**
     * create and insert a node which value equals number
     *
     * @param number number
     */
    public void insert(int number) {
        System.out.printf(Locale.ENGLISH, "Debug[insert]:[********************* start insert %s *********************]%n", number);
        if (root == null) {
            root = new TreeNode(number);
            System.out.printf(Locale.ENGLISH, "Debug[insert]:%s became root node！%n", number);
            return;
        }
        TreeNode cur = root;
        TreeNode pre = null;
        while (cur != null) {
            if (number == cur.getVal()) {
                System.out.printf(Locale.ENGLISH, "Debug[insert]:%s is already exist！%n", number);
                return;
            }
            pre = cur;
            System.out.printf(Locale.ENGLISH, "Debug[insert]:pre become %s%n", pre);
            if (number < cur.getVal()) {
                cur = cur.getLeft();
                System.out.printf(Locale.ENGLISH, "Debug[insert]:cur:%s move to Left become %s%n", pre, cur);
            } else {
                cur = cur.getRight();
                System.out.printf(Locale.ENGLISH, "Debug[insert]:cur:%s move to Right become %s%n", pre, cur);
            }
        }
        TreeNode node = new TreeNode(number);
        if (number < pre.getVal()) {
            System.out.printf(Locale.ENGLISH, "Debug[insert]:insert node:%s to Left of %s%n", node, pre);
            pre.setLeft(node);
        } else {
            System.out.printf(Locale.ENGLISH, "Debug[insert]:insert node:%s to Right of %s%n", node, pre);
            pre.setRight(node);
        }
    }

    /**
     * delete a node which value equals number
     *
     * @param number number
     */
    public void delete(int number) {
        if (root == null) {
            System.out.printf(Locale.ENGLISH, "can't delete element from a empty tree!\n");
            return;
        }
        TreeNode cur = root;
        TreeNode parent = null;
        while (cur != null) {
            if (number == cur.getVal()) {
                System.out.printf(Locale.ENGLISH, "found node to delete:%s\n", cur);
                break;
            }
            parent = cur;
            if (number < cur.getVal()) {
                cur = cur.getLeft();
            } else {
                cur = cur.getRight();
            }
        }
        if (cur == null) {
            System.out.printf(Locale.ENGLISH, "node not found which val = %s\n", number);
            return;
        }
        if (parent == null) {
            System.out.printf(Locale.ENGLISH, "delete the root node: %s\n", root);
            root = null;
            return;
        }
        if (cur.getLeft() == null || cur.getRight() == null) {
            TreeNode child = cur.getLeft() != null ? cur.getLeft() : cur.getRight();
            if (parent.getLeft() == cur) {
                parent.setLeft(child);
            } else {
                parent.setRight(child);
            }
        } else {
            TreeNode next = cur.getRight();
            TreeNode pre = cur;
            while (next.getLeft() != null) {
                pre = next;
                next = next.getLeft();
            }
            cur.setVal(next.getVal());
            pre.setLeft(next.getRight());
        }
    }

    /**
     * 二叉递归树遍历
     *
     * @param node  root
     * @param order order
     * @return result
     */
    public static List<Integer> travelBinaryTreeRecursion(TreeNode node, String order) {
        List<Integer> res = new ArrayList<>();
        if (node == null) {
            System.out.println("node is null");
            return res;
        }
        if ("pre".equals(order)) {
            res.add(node.getVal());
            System.out.printf(Locale.ENGLISH, "add %s%n", node.getVal());
        }
        System.out.println("visit left of " + node);
        List<Integer> leftRes = travelBinaryTreeRecursion(node.getLeft(), order);
        if ("mid".equals(order)) {
            res.add(node.getVal());
            System.out.printf(Locale.ENGLISH, "add %s%n", node.getVal());
        }
        System.out.println("visit right of " + node);
        List<Integer> rightRes = travelBinaryTreeRecursion(node.getRight(), order);
        if ("post".equals(order)) {
            res.add(node.getVal());
            System.out.printf(Locale.ENGLISH, "add %s%n", node.getVal());
        }
        switch (order) {
            case "pre":
                res.addAll(leftRes);
                res.addAll(rightRes);
                return res;
            case "mid":
                leftRes.addAll(res);
                leftRes.addAll(rightRes);
                return leftRes;
            case "post":
                leftRes.addAll(rightRes);
                leftRes.addAll(res);
                return leftRes;
        }
        return res;
    }

    /**
     * 二叉树非递归遍历
     *
     * @param node  root
     * @param order order
     * @return result
     */
    public static List<Integer> travelBinaryTreeUnRecursion(TreeNode node, String order) {
        List<Integer> res = new ArrayList<>();
        if (node == null) {
            System.out.println("node is null");
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = node;
        while (!stack.isEmpty() || cur != null) {
            // 依次访问左子树直到访问到叶子结点的左孩子(null)，非空节点入栈
            // 入栈前保存节点值（前序）
            while (cur != null) {
                if (order.equals("pre")) {
                    res.add(cur.getVal());
                }
                stack.push(cur);
                cur = cur.getLeft();
            }
            // 节点出栈，指针移到右子树进入下一轮循环（访问右节点的左子树）
            // 出栈后保存节点值（中序）
            if (!stack.isEmpty()) {
                cur = stack.pop();
                if (order.equals("mid")) {
                    res.add(cur.getVal());
                }
                cur = cur.getRight();
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] nums = new int[]{21, 32, 54, 3, 13, 33, 12, 13, 27};
        /**
         *          21
         *        /   \
         *       3    32
         *       \   / \
         *       13 27 54
         *       /     /
         *      12    33
         *
         */
        BinarySearchTree tree = new BinarySearchTree();
        for (int num : nums) {
            tree.insert(num);
        }
        List<Integer> res = travelBinaryTreeUnRecursion(tree.root, "pre");
        System.out.println(res);
        res = travelBinaryTreeUnRecursion(tree.root, "mid");
        System.out.println(res);
        tree.delete(3);
        res = travelBinaryTreeUnRecursion(tree.root, "mid");
        System.out.println(res);
    }
}