二叉树的四种遍历方法

144. 二叉树的前序遍历

前序遍历，其方式便是中左右，先输出根节点，然后左子树，右子树，比如[1,2,3,4,5,6,7],其前序遍历就是[1，2，4，5，3，6，7]。所以可以用栈或者队列来进行模拟子树结点进出过程，亦可以递归来遍历。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();//用列表存放结点值
        if(root == null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node =stack.pop();
            res.add(node.val);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        } 
        return res;
    }
}

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }

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

94. 二叉树的中序遍历

中序遍历的顺序是左中右，还是例[1,2,3,4,5,6,7],那么其中序遍历之后就是，[4,2,5,1,6,3,7],从左子树的最左边，到其父亲节点，到其兄弟结点，然后到根节点，再到右子树继续从左到右，一样，还是栈或队列，或者递归做法。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null){
            return res;
        }
        TreeNode cur =root;
        Stack<TreeNode> stack = new Stack<>();
        while(!stack.isEmpty()||cur!=null){
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;  //遍历到左子树的最后一个子节点
            }
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.right!=null){//依次往前回溯，并判断右子树是否存在
                cur=node.right;
            }
        }
    return res;      
    }
}

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

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

145. 二叉树的后序遍历

后序遍历就是左右中，先遍历左子树，再遍历右子树，最后输出根节点例[1,2,3,4,5,6,7]，后序遍历之后就是[4,5,2,6,7,3,1],同样，用栈或队列，也有一种递归。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        TreeNode cur = root;
        LinkedList<TreeNode> stack = new LinkedList<>();
        while(!stack.isEmpty()||root!=null){
            while(root!=null){
                stack.addLast(root);
                if(root.left!=null){
                    root = root.left;
                }
                else{
                    root=root.right;
                }
            }
            root = stack.removeLast();
            res.add(root.val);
            if(!stack.isEmpty()&&stack.getLast().left==root){
                root=stack.getLast().right;//如果最后一个结点的左结点等于上一个删除
            }else{ //的结点，那就转到当前结点的右孩子，然后回到上面进行添加右结点
                root = null;//即没有右结点，接着忘父节点走，
            }
        }
    return res;
    }
}

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }

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

102. 二叉树的层序遍历

层序遍历，就是按照数的每一次来划分，例如[1,2,3,4,5,6,7],那么他的输出便是一个按层分序的二维数组

[ [1],[2,3],[4,5,6,7] ] 。这一题的思想并不是太复杂，用队列来进行结点出入，先进先出，根节点进入，然后其左右结点进入，输出第一个结点，然后根节点的孩子结点的左右结点一次进入，再输出第二层，依次类推，遍完成了。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        if(root== null){
            return lists;
        }
        queue.add(root);
        while(queue.size()>0){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size>0){
                TreeNode node = queue.remove();//弹出当前父亲节点
                if(node.left!=null){//添加左右孩子结点
                    queue.add(node.left);
                }if(node.right!=null){
                    queue.add(node.right);
                }
                list.add(node.val);  
                size--;
            }
            lists.add(list);
        }
        return lists;
    }
}