LeetCode 二叉樹的層次遍歷

時間 2019-11-07

原文原文鏈接

第102題java

給定一個二叉樹，返回其按層次遍歷的節點值。 （即逐層地，從左到右訪問全部節點）。

例如:
給定二叉樹: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其層次遍歷結果：

[
  [3],
  [9,20],
  [15,7]
]

來源：力扣（LeetCode）
連接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal

如何遍歷一棵樹

有兩種通用的遍歷樹的策略：node

深度優先搜索（DFS）

在這個策略中，咱們採用深度做爲優先級，以便從跟開始一直到達某個肯定的葉子，而後再返回根到達另外一個分支。git

深度優先搜索策略又能夠根據根節點、左孩子和右孩子的相對順序被細分爲先序遍歷，中序遍歷和後序遍歷。github

寬度優先搜索（BFS）

咱們按照高度順序一層一層的訪問整棵樹，高層次的節點將會比低層次的節點先被訪問到。算法

解題思路

方法 1：迭代+隊列

咱們將樹上頂點按照層次依次放入隊列結構中，隊列中元素知足 FIFO（先進先出）的原則。使用 Queue 接口中的 LinkedList實現。spring

算法實現以下：函數

初始化隊列只包含一個節點 root。
初始一個List變量result，用來作返回結果
當隊列非空的時候，循環開始：
計算當前層有多少個元素：等於隊列的長度
初始一個List變量subResult，用來存當前層的節點值
將這些元素從隊列中彈出，將他們的值加入subResult列表中
將他們的孩子節點做爲下一層壓入隊列中
進入下一層，將當前層subResult add到result中

/**
 * 廣搜+隊列
 */
class Solution102_1 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null)
            return new ArrayList<>();
        return BFS(root);
    }

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

方法 2：遞歸

首先確認樹非空，而後調用遞歸函數 DFS(node,result,level)，參數是當前節點、返回結果列表、節點的層次。spring-boot

算法實現以下：code

result列表的長度小於level，爲result add一個新列表
爲當前層的result列表add節點值，即result.get(level - 1).add(node.val)
若是有左孩子，調用DFS(node.left, result, level + 1)，進入遞歸
若是有右孩子，調用DFS(node.right, result, level + 1)，進入遞歸

/**
 * 深搜+遞歸
 */
class Solution102_2 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return new ArrayList<>();
        List<List<Integer>> result = new LinkedList<>();

        DFS(root, result, 1);
        return result;
    }

    void DFS(TreeNode node, List<List<Integer>> result, int level) {
        if (result.size() < level) {
            result.add(new LinkedList<>());
        }
        result.get(level - 1).add(node.val);
        if (node.left != null) {
            DFS(node.left, result, level + 1);
        }
        if (node.right != null) {
            DFS(node.right, result, level + 1);
        }
    }
}

完整代碼

public class Sub102 {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(9);
        root.right = new TreeNode(20);
        root.right.left = new TreeNode(15);
        root.right.right = new TreeNode(7);

        Solution102_2 solution = new Solution102_2();
        List<List<Integer>> list = solution.levelOrder(root);
        for (List<Integer> subList : list) {
            System.out.println(subList.toString());
        }
    }
}

/**
 * 廣搜+隊列
 */
class Solution102_1 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null)
            return new ArrayList<>();
        return BFS(root);
    }

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

/**
 * 深搜+遞歸
 */
class Solution102_2 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return new ArrayList<>();
        List<List<Integer>> result = new LinkedList<>();

        DFS(root, result, 1);
        return result;
    }

    void DFS(TreeNode node, List<List<Integer>> result, int level) {
        if (result.size() < level) {
            result.add(new LinkedList<>());
        }
        result.get(level - 1).add(node.val);
        if (node.left != null) {
            DFS(node.left, result, level + 1);
        }
        if (node.right != null) {
            DFS(node.right, result, level + 1);
        }
    }
}

資料

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。