二叉树的层序遍历(递归方式)

Posted 2021-04-09 力扣日记

给你一个二叉树，请你返回其按层序遍历得到的节点值(即逐层地，从左到右访问所有节点)

题解：

1.二叉树

2.层序遍历

3.可以参考前面的

示例：

二叉树：[3,9,20,null,null,15,7],

    3

   /

  9  20

    / 

   15   7

返回其层次遍历结果：

[ [3],

  [9,20],

  [15,7]]

解题思路：递归求解

• 从根节点开始搜索

• 用一个二维数组存储节点值，每深度加一则另起下一行记录

• 递归过程中传值，传深度

• 直到搜索完整个二叉树

C/C++题解：

/** * Definition for a binary tree node.

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 * };*/

class Solution {

public:

    vector<vector<int>> res;

    vector<vector<int>> levelOrder(TreeNode* root) {

        if(!root) return {}; //空树

        bfs(root, 0);//广度优先搜索

        return res;}

    void bfs(TreeNode *root, int depth) {

        if (!root) return ;

        if (depth >= res.size())

            res.push_back(vector<int> {});

        res[depth].push_back(root->val);//把一层上的节点存在同行数组中

        bfs(root->left, depth + 1);//搜索子节点深度增1，左子节点

        bfs(root->right, depth + 1);}};//搜索子节点深度增1，右子节点

Debug结果：

Java题解：

/*** Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode(int x) { val = x; }

 * } */

class Solution {

    List<List<Integer>> res = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {

        if(root==null) return new ArrayList<>();

        bfs(root, 0);//广度优先搜索

        return res;}

    public void bfs(TreeNode root, int depth) {

        if (res.size() == depth)

            res.add(new ArrayList<Integer>());

         res.get(depth).add(root.val);//把一层上的节点存在同行数组中

         if (root.left != null)//搜索子节点深度增1，左子节点

            bfs(root.left, depth + 1);

         if (root.right != null)//搜索子节点深度增1，右子节点

            bfs(root.right, depth + 1);}}

Debug结果：

Python题解：

# Definition for a binary tree node.

# class TreeNode(object):

#     def __init__(self, x):

#         self.val = x

#         self.left = None

#         self.right = None

class Solution(object):

    def levelOrder(self, root):

        """:type root: TreeNode:rtype: List[List[int]]"""

        if not root: return [] #空树

        res = []

        def bfs(root, depth):

            if not root: return 

            if depth >= len(res):

                res.append([]);

            res[depth].append(root.val) #把一层上的节点存在同行数组中

            bfs(root.left, depth + 1) #搜索子节点深度增1，左子节点

            bfs(root.right, depth + 1) #搜索子节点深度增1，右子节点

        bfs(root, 0) #广度优先搜索

        return res

Debug结果：

例题来自力扣网https://leetcode-cn.com/

欢迎评论后台留言交流~