二叉树遍历

广度遍历（层序遍历）

class TreeNode {
    private int value;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(int value) {
        this.value = value;
    }
}

public class LevelTraversal {
    /**
     *         1
     *    2         3
     *  4   5     6   7
     */
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(6);
        TreeNode node6 = new TreeNode(7);

        root.setLeft(node1);
        root.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        List<ArrayList<Integer>> result = levelPrint(root);
        for (ArrayList<Integer> arrayList : result) {
            System.out.println(arrayList);
        }
    }

    /**
     * 层序遍历
     */
    private static List<ArrayList<Integer>> levelPrint(TreeNode root) {
        if (root == null) {
            return null;
        }
        List<ArrayList<Integer>> res = new ArrayList<>();
        Queue<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while (!deque.isEmpty()) {
            ArrayList<Integer> list = new ArrayList<>();
            // 每次都需要记录层的节点数，**size是变的，所以需要提取出来**
            int size = deque.size();
            // 将当前层的所有节点出栈，并将下一层的所有节点从左到右依次入栈
            for (int i = 0; i < size; i++) {
                TreeNode pop = deque.poll();
                list.add(pop.getValue());
                if (pop.getLeft() != null) {
                    deque.add(pop.getLeft());
                }
                if (pop.getRight() != null) {
                    deque.add(pop.getRight());
                }
            }
            res.add(list);
        }
        return res;
    }

}

深度遍历 （前、中、后序遍历）

class TreeNode {
    private int value;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(int value) {
        this.value = value;
    }
}


public class DepthTraversal {
    /**
     *         1
     *    2         3
     *  4   5     6   7
     */
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(6);
        TreeNode node6 = new TreeNode(7);

        root.setLeft(node1);
        root.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);

        List<Integer> res = new ArrayList<>();
        frontPrint(res, root);
//        frontPrint2(res, root);
        System.out.println("前序遍历结果：" + JSON.toJSONString(res));

        List<Integer> res2 = new ArrayList<>();
        midPrint(res2, root);
//        midPrint2(res2, root);
        System.out.println("中序遍历结果：" + JSON.toJSONString(res2));

        List<Integer> res3 = new ArrayList<>();
        afterPrint(res3, root);
//        afterPrint2(res3, root);
        System.out.println("后序遍历结果：" + JSON.toJSONString(res3));
    }

    /**
     * 递归-前序遍历
     * 先将跟节点依次入栈，一直从左找。找完左边再找右边
     */
    static void frontPrint(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        res.add(root.getValue());
        frontPrint(res, root.getLeft());
        frontPrint(res, root.getRight());
    }

    /**
     * 循环-前序遍历
     */
    static void frontPrint2(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();

        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                res.add(root.getValue());
                stack.push(root);
                root = root.getLeft();
            }
            root = stack.pop();
            root = root.getRight();
        }
    }

    /**
     * 递归-中序遍历
     * 一直从左找，找到底之后根进栈，再找右边
     */
    static void midPrint(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        midPrint(res, root.getLeft());
        res.add(root.getValue());
        midPrint(res, root.getRight());
    }

    /**
     * 循环-中序遍历
     */
    static void midPrint2(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();

        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.getLeft();
            }
            root = stack.pop();
            res.add(root.getValue());
            root = root.getRight();
        }
    }

    /**
     * 递归-后序遍历
     * 先找左，找完左再找右，找完右再取根
     */
    static void afterPrint(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        afterPrint(res, root.getLeft());
        afterPrint(res, root.getRight());
        res.add(root.getValue());
    }

    /**
     * 循环-后序遍历
     * 左 中 右
     */
    static void afterPrint2(List<Integer> res, TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode prevNode = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.getLeft();
            }

            root = stack.pop();
            if (root.getRight() == null || root.getRight() == prevNode) {
                res.add(root.getValue());
                prevNode = root;
                root = null;
            } else {
                stack.push(root);
                root = root.getRight();
            }
        }
    }
}