树的遍历方法Java实现

二叉树的先、中、后层次遍历，递归非递归，DFS、BFS

先序遍历

1. 递归

一般来说，递归遍历比非递归的好写，理解起来也比较简单，不过相比非递归的效率差一些

/*
*这题要求先序遍历二叉树，把遍历结果存储在 list 中，并返回
*/
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> preOrderList = new ArrayList<Integer>();
        preorderTraversal(root, preOrderList);
        return preOrderList;
    }
    public void preorderTraversal(TreeNode root, List<Integer> preOrderList) {
        if (root == null) {
            return ;
        }
        preOrderList.add(root.val);
        preorderTraversal(root.left, preOrderList);
        preorderTraversal(root.right, preOrderList);
        return ;
    }
}

2. 非递归（迭代）

主要思想是用栈来模拟递归的情况

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> preOrderList = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode node = root;
    while (!stack.isEmpty() || node != null) {
        while (node != null) { // 边访问当前，边压栈，指针指向左子树
            preOrderList.add(node.val);
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        node = node.right;
    }
    return preOrderList;
}

3. Morris 遍历

这是一种巧妙的方法，在线性时间内，只占用常数空间的内存来实现遍历，核心思想是利用树的大量空闲指针，实现空间开销的极限压缩

1. 新建临时节点，令该节点为 root；
2. 如果当前节点的左子节点为空，将当前节点加入答案，并遍历当前节点的右子节点；
3. 如果当前节点的左子节点不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点：
   · 如果前驱节点的右子节点为空，将前驱节点的右子节点设置为当前节点。然后将当前节点加入答案，并将前驱节点的右子节点更新为当前节点。当前节点更新为当前节点的左子节点。
   · 如果前驱节点的右子节点为当前节点，将它的右子节点重新设为空。当前节点更新为当前节点的右子节点。
4. 重复步骤 2 和步骤 3，直到遍历结束。

表示不会。。。。。。

中序遍历

1. 递归

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> inOrderList = new ArrayList<Integer>();
        inorderTraversal(root, inOrderList);
        return inOrderList;
    }
    public void inorderTraversal(TreeNode root, List<Integer> inOrderList) {
        if (root == null) {
            return ;
        }
        if (root.left != null) {
            inorderTraversal(root.left, inOrderList);
        }
        // 先左子树，再加入当前结点，最后右子树
        inOrderList.add(root.val);
        if (root.right != null) {
            inorderTraversal(root.right, inOrderList);
        }
        return ;
    }
}

2. 非递归（迭代）

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> inOrderList = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode node = root;
    while (node != null || !stack.isEmpty()) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        inOrderList.add(node.val);
        node = node.right;
    }
    return inOrderList;
}

后序遍历

1. 递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> postOrderList = new ArrayList<Integer>();
        postorderTraversal(root, postOrderList);
        return postOrderList;
    }
    public void postorderTraversal(TreeNode root, List<Integer> postOrderList) {
        if (root == null) {
            return ;
        }
        if (root.left != null) {
            postorderTraversal(root.left, postOrderList);
        }
        if (root.right != null) {
            postorderTraversal(root.right, postOrderList);
        }
        postOrderList.add(root.val);
        return ;
    }
}

2. 非递归（迭代）

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> postOrderList = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    // 用一个空间来记录之前访问的结点
    TreeNode prev = null;
    TreeNode node = root;
    while (!stack.isEmpty() || node != null) {
        // 一直遍历到最左下结点
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        // 右子树为空 || 右子树已经遍历完了
        if (node.right == null || node.right == prev) {
            postOrderList.add(node.val);
            prev = node;
            node = null;  // 接下来会继续弹栈
        } else {
            stack.push(node);
            node = node.right;
        }
    }
    return postOrderList;
}

层次遍历

广度优先搜索

思想：用队列存储树的结点，每访问到当前元素，就按左右的顺序将其子树入队。每遍历完一层，队列中的元素个数queue.suize()就是下一层的元素个数。

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