二叉树的遍历

一、先序遍历

        <1>递归

        定义函数preorder(TreeNode root, List<Integer> res)作用是中序遍历根节点为root的二叉树，递归出口如果根节点为空就结束。

中序遍历可以分解成，先遍历根节点，再对左子树先序遍历，最后对右子树先序遍历：

        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);

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

        <2>迭代 

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return res;
    }

二、中序遍历

         <1>递归

        定义函数inorder(TreeNode root, List<Integer> res)作用是中序遍历根节点为root的二叉树，递归出口如果根节点为空就结束。

中序遍历可以分解成，先对左子树中序遍历，再遍历根节点，最后对右子树中序遍历：

        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);

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

         <2>迭代  

 public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }

三、后序遍历

        <1>递归 

定义函数postorder(TreeNode root, List<Integer> res)作用是后序遍历根节点为root的二叉树，递归出口如果根节点为空就结束。

后序遍历可以分解成，先对左子树后序遍历，再对右子树后序遍历，最后遍历跟节点：

        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);

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

         <2>迭代  

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }

四、层次遍历

        使用队列进行层次遍历

    
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> arr = new ArrayList<Integer>();
            int size = queue.size();
            for(int i = 0;i<size;i++){
                TreeNode t =  queue.poll();
                arr.add(t.val);
                if(t.left != null){
                    queue.offer(t.left);
                }
                if(t.right != null){
                    queue.offer(t.right);
                }
            }
            res.add(arr);
        }
        
        return res;
    }