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

前序遍历

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;
            }
        }
    }
}

中序遍历

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;
            }
        }
    }
}

#后序遍历

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());
        }
    } 
}

层次遍历

    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);
            }
        }
    }

二叉树的深度

    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;
    }