二叉树的遍历（前、中、后、层次）（递归、非递归）

1、前序遍历

public class PreOrder {
    public ArrayList<TreeNode> list=new ArrayList<>();
    public void recursive(TreeNode root){
        if(root!=null){
            list.add(root);
            recursive(root.left);
            recursive(root.right);
        }
    }

    public void notRecursive(TreeNode root){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode node=root;
        while (node!=null||!stack.isEmpty()){
            if(node!=null){
                list.add(node);
                stack.push(node);
                node=node.left;
            }else{
                node=stack.pop();
                node=node.right;
            }
        }
    }
}

2、中序遍历

public class InOrder {
    public ArrayList<TreeNode> list=new ArrayList<>();
    public void recursive(TreeNode root){
        if(root!=null){
            recursive(root.left);
            list.add(root);
            recursive(root.right);
        }
    }

    public void notRecursive(TreeNode root){
        Stack<TreeNode> stack=new Stack<>();
        TreeNode node=root;
        while (node!=null||!stack.isEmpty()){
            if(node!=null){
                stack.push(node);
                node=node.left;
            }else{
                node=stack.pop();
                list.add(node);
                node=node.right;
            }
        }
    }
}

3、后序遍历

public class PostOrder1 {
    public ArrayList<TreeNode> list=new ArrayList<>();
    public void recursive(TreeNode root){
        if(root!=null){
            recursive(root.left);
            recursive(root.right);
            list.add(root);
        }
    }

    public void notRecursive(TreeNode root){
        Stack<TreeNode> stack=new Stack<>();
        Stack<TreeNode> out=new Stack<>();

        TreeNode node=root;
        while (node!=null||!stack.isEmpty()){
            if(node!=null){
                out.push(node);
                stack.push(node);
                node=node.right;
            }else{
                node=stack.pop();
                node=node.left;
            }
        }
        while (!out.isEmpty()){
            list.add(out.pop());
        }
    } 
}

4、层次遍历

    public void layerOrder(TreeNode root){
        Queue<TreeNode> queue=new LinkedList<>();
        if(root!=null){
            queue.offer(root);
        }
        while (!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node);
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
        }
    }

5、二叉树的深度

    public int getTreeDepthRecursive(TreeNode root){
        int depth=0;
        if(root!=null){
            int leftDepth=getTreeDepthRecursive(root.left);
            int rightDepth=getTreeDepthRecursive(root.right);
            depth=Math.max(leftDepth,rightDepth)+1;
        }
        return depth;
    }

    public int getTreeDepthNotRecursive(TreeNode root){
        Queue<TreeNode> queue=new LinkedList<>();
        if(root!=null){
            queue.offer(root);
        }
        int count=0,depth=0,layerCount=1;
        while (!queue.isEmpty()){
            count++;
            TreeNode node=queue.poll();
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
            if(count==layerCount){
                depth++;
                count=0;
                layerCount=queue.size();
            }
        }
        return depth;
    }

6、二叉树“之”字型遍历

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> result=new ArrayList<ArrayList<Integer>>();

        if(pRoot==null)
            return result;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(pRoot);
        int rowLength=1;
        int num=0;
        ArrayList<Integer> list=new ArrayList<>();
        boolean leftToRight =true;
        while (!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);
            num++;
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
            if(num==rowLength){
                num=0;
                rowLength=queue.size();
                if(!leftToRight){
                    Collections.reverse(list);
                    leftToRight =true;
                }else{
                    leftToRight =false;
                }
                result.add(new ArrayList<>(list));
                //list.removeAll(list); 这两种方法都可以
                list.clear();
            }
        }
        return result;
    }