树递归，非递归的前中后序层次遍历

目录

说明

前中后序遍历

递归

合并写法

非递归

合并写法

前序

中序

后序

层次遍历

---

说明

1. 前中后序遍历无论递归或非递归都借助栈
2. 层次遍历借助队列
3. 非递归且无栈遍历方式后续整理更新：迭代实现遍历，遍历中会对树结构修改，迭代完成后恢复原树结构

前中后序遍历

递归

合并写法

    public int[][] threeOrders (TreeNode root) {
        List<Integer> preorder = new LinkedList<>();
        List<Integer> inorder = new LinkedList<>();
        List<Integer> postorder = new LinkedList<>();
        treeTraversal(root, preorder, inorder, postorder);

        int[][] res = new int[3][preorder.size()];

        for (int j = 0; j < preorder.size(); j++) {
            res[0][j] = preorder.get(j);
        }
        for (int j = 0; j < inorder.size(); j++) {
            res[1][j] = inorder.get(j);
        }
        for (int j = 0; j < postorder.size(); j++) {
            res[2][j] = postorder.get(j);
        }
        return res;
    }

    public void treeTraversal(TreeNode root, List<Integer> preorder, List<Integer> inorder, List<Integer> postorder) {
        if (root == null) return;
        preorder.add(root.val);
        treeTraversal(root.left, preorder, inorder, postorder);
        inorder.add(root.val);
        treeTraversal(root.right, preorder, inorder, postorder);
        postorder.add(root.val);
    }

非递归

合并写法

    public void treeTraversal(TreeNode root) {
        List<Integer> preorder = new LinkedList<>();
        List<Integer> inorder = new LinkedList<>();
        List<Integer> postorder = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        TreeNode tmp;
        TreeNode lastVisited = root;
        while(!stack.isEmpty() || p != null) {
            while(p != null) {
                preorder.add(p.val);
                stack.push(p);
                p = p.left;
            }

            if (!stack.isEmpty()) {
                tmp = stack.peek();
                if (tmp.right != lastVisited) inorder.add(tmp.val);

                if (tmp.right != null && tmp.right != lastVisited) {
                    p = tmp.right;
                } else {
                    lastVisited = tmp;
                    postorder.add(tmp.val);
                    stack.pop();
                    p = null;
                }
            }
        }
    }

前序

    private List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(!stack.isEmpty() || p != null) {
            while(p != null) {
                list.offerLast(p.val);
                stack.push(p);
                p = p.left;
            }

            if (!stack.isEmpty()) {
                p = stack.pop();
                p = p.right;
            }
        }
        return list;
    }

中序

    private List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(!stack.isEmpty() || p != null) {
            while(p != null) {
                stack.push(p);
                p = p.left;
            }

            if (!stack.isEmpty()) {
                TreeNode t = stack.pop();
                list.offerLast(t.val);
                p = t.right;
            }
        }
        return list;
    }

后序

    private  List<Integer> postorderTravesal(TreeNode root) {
        List<Integer> list =new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        TreeNode listVisited= root;
        while(!stack.isEmpty() || p != null) {
            while (p != null) {
                stack.push(p);
                p = p.left;
            }

            if (!stack.isEmpty()) {
                p = stack.peek();
                if (p.right != null && p.right != listVisited) {
                    p = p.right;
                } else {
                    listVisited = p;
                    list.add(p.val);
                    stack.pop();
                    p = null;
                }
            }
        }
        return list;
    }

层次遍历

    public List<Integer> treeBFS(TreeNode root) {
        List<Integer> list = new LinkedList<>();
        LinkedList<TreeNode> queue = new LinkedList() {{offerLast(root);}}, tmp;
        TreeNode p;
        while(!queue.isEmpty()) {
            tmp = new LinkedList<>();
            while((p = queue.pollFirst()) != null) {
                list.add(p.val);
                if (p.left != null) tmp.offerLast(p.left);
                if (p.right != null) tmp.offerLast(p.right);
            }
            queue = tmp;
        }
        return list;
    }

实现二叉树先序，中序和后序遍历_牛客题霸_牛客网 (nowcoder.com)