二叉树的遍历

二叉树的遍历, 分为层次遍历, 前序遍历, 中序遍历, 后序遍历.  是二叉树中的基本操作, 前序、中序、后序遍历一般也分为递归实现与非递归实现. 本文来将这三种遍历都实现一遍.

下面这些代码都是在 leetcode 上通过的代码 

三种遍历的递归实现

基本上就是按照遍历时, 左子树、父结点、右子树的遍历顺序来处理这三句代码的位置关系.

前序遍历

class Solution {
    List<Integer> result = new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root != null) {
            result.add(root.val);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
        return result;
    }
}

中序遍历

class Solution {
    public List<Integer> result = new LinkedList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.left);
            result.add(root.val);
            inorderTraversal(root.right);
        }
        return result;
    }
}

后序遍历

class Solution {
    private List<Integer> result = new LinkedList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root != null) {
            if (root.left != null)  postorderTraversal(root.left);
            if (root.right != null) postorderTraversal(root.right);
            result.add(root.val);
        }
        return result;
    }
}

三种遍历的非递归实现

前序遍历

这里需要注意的是栈是先进后出, 而我们是先处理左子树, 再处理右子树, 所以先加入右子树.

class Solution {
    List<Integer> result = new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null)
            return result;
        Stack<TreeNode> nodes = new Stack<>();
        nodes.add(root);
        while(!nodes.isEmpty()) {
            TreeNode curr = nodes.pop();
            if (curr== null) continue;
            result.add(curr.val);
            if (curr.right != null)  nodes.add(curr.right);
            if (curr.left != null)  nodes.add(curr.left);
        }
        return result;
    }
}

中序遍历

中序遍历的过程是 left -> root -> right, 如何来完成中序遍历呢? 那么对于每一个结点, 首先需要考虑的就是其左子结点, 然后再将自身的结点加进去, 最后才是右子结点, 所以对于每一个结点, 需要用一个 while 循环一直到其最左下的叶子结点. 这里 while 的条件也比前序和后序的多一个判断. 因为前序和中序每次都直接从栈中取值, 而中序只有在处理完左边子结点后才会从栈里取值.

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        if (root == null)
            return result;
        Stack<TreeNode> nodes = new Stack<>();
        TreeNode curr = root;
        while(!nodes.isEmpty() || curr != null) {
            while(curr != null) {
                nodes.push(curr);
                curr = curr.left;
            }
            curr = nodes.pop();
            result.add(curr.val);
            curr = curr.right;
        }
        return result;
    }
}

后序遍历

如果用栈来实现非递归算法, 如何能先处理左右子结点, 然后再处理本结点呢?

这里的思路是这样的 : 前序遍历的过程为 root -> left -> right, 后序遍历的过程为 left -> right -> root, 那么我们可以将前序遍历的过程修改一下, 将前序遍历的过程改为 root ->right ->left, 那么将得到的结果反序就可以得到最后的结果.

 

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> nodes = new Stack<>();
        nodes.push(root);
        TreeNode curr = root;
        while(!nodes.isEmpty()) {
            curr = nodes.pop();
            if (curr == null)
                continue;
            result.add(curr.val);
            if (curr.left != null)  nodes.push(curr.left);
            if (curr.right != null) nodes.push(curr.right);
        }
        Collections.reverse(result);
        return result;
    }
}