二叉树的前中后层序遍历的递归和非递归写法

前序遍历：

public class PreOder {
    static List<Integer> preOder1 = new ArrayList<>();
    static List<Integer> preOder2 = new ArrayList<>();
    private void recurrent(TreeNode node){//前序递归
        preOder1.add(node.val);
        if (node.left!=null) recurrent(node.left);
        if (node.right!=null) recurrent(node.right);
    }

    private List<Integer> unRecurrent(TreeNode node){//前序非递归
        Stack<TreeNode> stack = new Stack<>();
        while (node!=null || !stack.isEmpty()){
            while (node!=null){
                preOder2.add(node.val);
                stack.add(node.right);
                node = node.left;
            }
            if (!stack.isEmpty()) {
                node = stack.pop();
            }
        }

        return preOder2;
    }
}

中序遍历：

public class InOder {
    static List<Integer> inOder1 = new ArrayList<>();
    static List<Integer> inOder2 = new ArrayList<>();
    private void recurrent(TreeNode node){//前序递归
        if (node.left!=null) recurrent(node.left);
        inOder1.add(node.val);
        if (node.right!=null) recurrent(node.right);
    }

    private List<Integer> unRecurrent(TreeNode node){//前序非递归
        Stack<TreeNode> stack = new Stack<>();
        while (node!=null || !stack.isEmpty()){
            while (node!=null){
                stack.add(node);
                node = node.left;
            }
            if (!stack.isEmpty()) {
                node = stack.pop();
                inOder2.add(node.val);//先找到最左边的值
                node = node.right;//然后获得右边值，在获得中间值
            }
        }

        return inOder2;
    }

}

后序遍历

非递归需要用到两个栈；

public class PostOder {
    static List<Integer> postOder1 = new ArrayList<>();
    static List<Integer> postOder2 = new ArrayList<>();
    private void recurrent(TreeNode node){//后序递归遍历
        if (node.left!=null) recurrent(node.left);
        if (node.right!=null) recurrent(node.right);
        postOder1.add(node.val);
    }

    //双栈法,目的是在stack2从后序的反向输入；
    private List<Integer> unRecurrent(TreeNode node){//后序非递归
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.add(node);
        while (!stack1.isEmpty()) {
            TreeNode head = stack1.pop();
            stack2.push(head);
            if (node.left!=null) stack1.push(head.left);
            if (node.right!=null) stack1.push(head.right);
        }
        while (!stack2.isEmpty()){
            postOder2.add(stack2.pop().val);
        }

        return postOder2;
    }
}

层序遍历

分层进行输入；

public class LevelOder {//递归遍历
    List<List<Integer>> reses = new ArrayList<>();//里面嵌套的是LinkedList<>();
    List<List<Integer>> levelOder = new ArrayList<>();

    public List<List<Integer>> levelOrder_3(TreeNode root) {
        recurrent(root,0);
        return levelOder;
    }

    /* 递归层序遍历，输出半存在levelOder里面 */
    private void recurrent(TreeNode root,int level){
        if (root == null) return;
        if (levelOder.size()<level) levelOder.add(new ArrayList<Integer>());
        List<Integer> temp = levelOder.get(level);
        temp.add(root.val);//
        recurrent(root.left,level+1);
        recurrent(root.right,level+1);
    }

    /* 非递归层序遍历二叉树，输出int[]类型 */
    public int[] levelOrder_2(TreeNode root) {
        if (root == null) {
            return new int[0];
        }
        ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
        queue.add(root);
        for (int i = 0; i < queue.size(); i++) {//先把数据按顺序放在队列内
            TreeNode node = queue.get(i);
            if (node.left != null) {
                queue.add(node.left);//先入先出
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        int[] res = new int[queue.size()];
        for (int i = 0; i < queue.size(); i++) {
            res[i] = queue.get(i).val;
        }
        return res;
    }

    /* 层序遍历二叉树，一排往左一排往右 */
    public List<List<Integer>> levelOrder_1(TreeNode root) {
        recur(root, 0);
        return reses;
    }

    //递归函数,增加是那层的判断
    void recur(TreeNode root, int level) {
        if (root == null) return;
        if (reses.size() == level) reses.add(new LinkedList<Integer>());//强制向下转型
        LinkedList<Integer> res = (LinkedList<Integer>) reses.get(level);
        if ((level & 1) == 0) res.addLast(root.val);//若层数level为偶数层，将当前值放在前面<--
        else res.addFirst(root.val);//若level为奇数-->将当前值放在最后
        recur(root.left, level+1);//添加使用一样的方式
        recur(root.right, level+1);
    }
}