校招算法笔面试 | 把二叉树打印成多行

原创于 2025-04-09 16:03:05 发布 · 830 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #面试 #职场和发展 #算法力扣 #算法力扣面试

题目## 题目

题目链接

题目主要信息：

将一棵n个节点的二叉树按照从上到下按层的方式打印，每层按照从左到右的顺序输出。

举一反三：

学习完本题的思路你可以解决如下题目：

JZ77. 按之字形顺序打印二叉树

JZ32. 从上往下打印二叉树

方法一：非递归层次遍历（推荐使用）

知识点：队列

队列是一种仅支持在表尾进行插入操作、在表头进行删除操作的线性表，插入端称为队尾，删除端称为队首，因整体类似排队的队伍而得名。它满足先进先出的性质，元素入队即将新元素加在队列的尾，元素出队即将队首元素取出，它后一个作为新的队首。

思路：

题目要求将二叉树按行打印，即按层打印，其中每层分开。不难想到，要使用层次遍历，但是难点在于如何每层分开存储，从哪里知晓分开的时机？在层次遍历的时候，我们通常会借助队列（queue），事实上，队列中的值大有玄机，让我们一起来看看：

当根节点进入队列时，队列长度为1，第一层节点数也为1
若是根节点有两个子节点，push进队列后，队列长度为2，第二层节点数也为2；若是根节点一个子节点，push进队列后，队列长度为为1，第二层节点数也为1.
由此，我们可知，每层的节点数等于进入该层时队列长度，因为刚进入该层时，这一层每个节点都会push进队列，而上一层的节点都出去了。

综上，反过来，每次只要在队列长度内循环，必定是一层，一层访问完毕再更新队列长度即可。

//遍历一层
int n = temp.size();
for(int i = 0; i < n; i++){
    p = temp.poll();
    row.add(p.val);
    //若是左右孩子存在，则存入左右孩子作为下一个层次
    if(p.left != null)
        temp.offer(p.left);
    if(p.right != null)
        temp.offer(p.right);
}

具体做法：

step 1：如果树为空，则返回空数组，没有任何打印结果。
step 2：使用队列辅助层次遍历，优先加入二叉树的根节点。
step 3：从根节点开始，每次进入一层的时候，记录队列的长度即本层的节点数，然后访问相应节点数全在同一个数组中，子节点加入队列中继续排队。
step 4：每次访问完一层将数组加入二维数组中再进入下一层。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    //层次遍历
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        TreeNode head = pRoot;
        ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
        if(head == null)
            //如果是空，则直接返回空数组
            return res; 
        //队列存储，进行层次遍历
        Queue<TreeNode> temp = new LinkedList<TreeNode>(); 
        temp.offer(head);
        TreeNode p;
        while(!temp.isEmpty()){
            //记录二叉树的某一行
            ArrayList<Integer> row = new ArrayList<Integer>();
            int n = temp.size();
            //因先进入的是根节点，故每层节点多少，队列大小就是多少
            for(int i = 0; i < n; i++){
                p = temp.poll();
                row.add(p.val);
                //若是左右孩子存在，则存入左右孩子作为下一个层次
                if(p.left != null)
                    temp.offer(p.left);
                if(p.right != null)
                    temp.offer(p.right);
            }
            res.add(row);
        }
        return res;
    }
    
}

C++实现代码：

class Solution {
public:
    //层次遍历
    vector<vector<int> > Print(TreeNode* pRoot) {
        TreeNode* head = pRoot;
        vector<vector<int> > res;
        if(head == NULL)
            //如果是空，则直接返回空数组
            return res; 
        //队列存储，进行层次遍历
        queue<TreeNode*> temp; 
        temp.push(head);
        TreeNode* p;
        while(!temp.empty()){
            //记录二叉树的某一行
            vector<int> row;  
            int n = temp.size();
            //因先进入的是根节点，故每层节点多少，队列大小就是多少
            for(int i = 0; i < n; i++){
                p = temp.front();
                temp.pop();
                row.push_back(p->val);
                //若是左右孩子存在，则存入左右孩子作为下一个层次
                if(p->left)
                    temp.push(p->left);
                if(p->right)
                    temp.push(p->right);
            }
            res.push_back(row);
        }
        return res;
    }
};

Python实现代码

class Solution:
    def Print(self , pRoot: TreeNode) -> List[List[int]]:
        res = []
        if pRoot is None:
            #如果是空，则直接返回空数组
            return res
        #队列存储，进行层次遍历
        q = [pRoot]
        while q:
            #记录二叉树的某一行
            row = []  
            n = len(q)
            #因先进入的是根节点，故每层节点多少，队列大小就是多少
            for i in range(n):
                #取出队首
                node = q.pop(0)
                row.append(node.val)
                #若是左右孩子存在，则存入左右孩子作为下一个层次
                if node.left:
                    #加入队尾
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(row)
        return res

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为二叉树的节点数，每个节点访问一次
空间复杂度： $O (n)$ ，辅助队列的空间最大情况为 $n$

方法二：递归层次遍历

知识点：二叉树递归

递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。

而二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。

思路：

除了用队列非递归可以实现二叉树的层次遍历，我们也可以使用递归。但是递归前序遍历访问二叉树不是按照层次的顺序，但是因为“根左右”的次序，我们能保证每一层一定左边的元素先访问，后面再访问到同一层右边的元素。

要找到这个节点是第几层的，只是需要在函数中加入记录深度的变量，每往下一层深度加1，同时保存结果的数组正好对应每层一个数组，因此数字的大小正好是遍历的深度，由此可以实现递归。

//递归左右时节点深度记得加1
traverse(root.left, res, depth + 1); 
traverse(root.right, res, depth + 1);

具体做法：

step 1：记录输出的二维数组初始化为空，每到一层里面填出一个一维数组。
step 2：从根节点开始，深度为1开始进行递归，当前节点有值递归内容才继续进行，否则返回。
step 3：如果记录输出的二维数组长度小于当前层数，说明要新到了一层，我们新开辟一个一维数组加到最后。
step 4：因为“根左右”的顺序，同一层左边必定先访问，只需要根据层数在二维数组中找到相应的行号，添加在该行末尾就一定是层次遍历的次序。

Java实现代码：

import java.util.*;
public class Solution {
    private void traverse(TreeNode root, ArrayList<ArrayList<Integer> > res, int depth) {
        if(root != null){
            //数组长度小于当前层数，新开一层
            if(res.size() < depth)             
                res.add(new ArrayList<Integer>());  
            //数组从0开始计数因此减1，在节点当前层的数组中插入节点
            res.get(depth - 1).add(root.val); 
            //递归左右时节点深度记得加1
            traverse(root.left, res, depth + 1); 
            traverse(root.right, res, depth + 1);
        }
    }
    //层次遍历
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
        //树的层级从1开始递归计数
        traverse(pRoot, res, 1); 
        return res;
    }
    
}

C++实现代码：

class Solution {
public:
    void traverse(TreeNode* root, vector<vector<int>>& res, int depth) {
        if(root){
            //数组长度小于当前层数，新开一层
            if(res.size() < depth)             
                res.push_back(vector<int>{});  
            //数组从0开始计数因此减1，在节点当前层的数组中插入节点
            res[depth - 1].push_back(root->val); 
            //递归左右时节点深度记得加1
            traverse(root->left, res, depth + 1); 
            traverse(root->right, res, depth + 1);
        }
    }
    //层次遍历
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        //树的层级从1开始递归计数
        traverse(pRoot, res, 1); 
        return res;
    }
};

Python实现代码：

class Solution:
    def traverse(self, root: TreeNode, res: List[List[int]], depth: int):
        if root:
            #数组长度小于当前层数，新开一层
            if len(res) < depth:             
                res.append([])  
            #数组从0开始计数因此减1，在节点当前层的数组中插入节点
            res[depth - 1].append(root.val) 
            #递归左右时节点深度记得加1
            self.traverse(root.left, res, depth + 1); 
            self.traverse(root.right, res, depth + 1)
    #层次遍历
    def Print(self , pRoot: TreeNode) -> List[List[int]]:
        res = []
        #树的层级从1开始递归计数
        self.traverse(pRoot, res, 1) 
        return res

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为二叉树的节点数，每个节点访问一次
空间复杂度： $O (n)$ ，递归栈的最大深度为二叉树退化为链表时，深度为 $n$

题目链接

题目主要信息:

给定一个数组，其中代表每家拥有的钱数
小偷每次不能偷取数组中相邻位置的钱，只要不相邻的钱都可以偷
数组形成环形，第一家与最后一家相邻
求最多能偷到钱数

举一反三：

学习完本题的思路你可以解决如下题目：

方法：动态规划（推荐使用）

知识点：动态规划

动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果。

思路：

这道题与BM78.打家劫舍(一)比较类似，区别在于这道题是环形，第一家和最后一家是相邻的，既然如此，在原先的方案中第一家和最后一家不能同时取到。

具体做法：

step 1：使用原先的方案是：用dp[i]表示长度为i的数组，最多能偷取到多少钱，只要每次转移状态逐渐累加就可以得到整个数组能偷取的钱。
step 2：（初始状态） 如果数组长度为1，只有一家人，肯定是把这家人偷了，收益最大，因此 $d p [1] = n u m s [0]$ 。
step 3：（状态转移） 每次对于一个人家，我们选择偷他或者不偷他，如果我们选择偷那么前一家必定不能偷，因此累加的上上级的最多收益，同理如果选择不偷他，那我们最多可以累加上一级的收益。因此转移方程为 $d p [i] = ma x (d p [i - 1], n u m s [i - 1] + d p [i - 2])$ 。这里的i在dp中为数组长度，在nums中为下标。
step 4：此时第一家与最后一家不能同时取到，那么我们可以分成两种情况讨论：
- 情况1：偷第一家的钱，不偷最后一家的钱。初始状态与状态转移不变，只是遍历的时候数组最后一位不去遍历。
- 情况2：偷最后一家的请，不偷第一家的钱。初始状态就设定了 $d p [1] = 0$ ，第一家就不要了，然后遍历的时候也会遍历到数组最后一位。
step 5：最后取两种情况的较大值即可。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int rob (int[] nums) {
        //dp[i]表示长度为i的数组，最多能偷取多少钱
        int[] dp = new int[nums.length + 1]; 
        //选择偷了第一家
        dp[1] = nums[0]; 
        //最后一家不能偷
        for(int i = 2; i < nums.length; i++) 
            //对于每家可以选择偷或者不偷
            dp[i] = Math.max(dp[i - 1], nums[i - 1] + dp[i - 2]); 
        int res = dp[nums.length - 1]; 
        //清除dp数组，第二次循环
        Arrays.fill(dp, 0); 
        //不偷第一家
        dp[1] = 0; 
        //可以偷最后一家
        for(int i = 2; i <= nums.length; i++) 
            //对于每家可以选择偷或者不偷
            dp[i] = Math.max(dp[i - 1], nums[i - 1] + dp[i - 2]); 
        //选择最大值
        return Math.max(res, dp[nums.length]); 
    }
}

C++实现代码：

class Solution {
public:
    int rob(vector<int>& nums) {
        //dp[i]表示长度为i的数组，最多能偷取多少钱
        vector<int> dp(nums.size() + 1, 0); 
        //选择偷了第一家
        dp[1] = nums[0]; 
        //最后一家不能偷
        for(int i = 2; i < nums.size(); i++) 
            //对于每家可以选择偷或者不偷
            dp[i] = max(dp[i - 1], nums[i - 1] + dp[i - 2]); 
        int res = dp[nums.size() - 1]; 
        //清除dp数组，第二次循环
        dp.clear(); 
        //不偷第一家
        dp[1] = 0; 
        //可以偷最后一家
        for(int i = 2; i <= nums.size(); i++) 
            //对于每家可以选择偷或者不偷
            dp[i] = max(dp[i - 1], nums[i - 1] + dp[i - 2]); 
        //选择最大值
        return max(res, dp[nums.size()]); 
    }
};

Python代码实现：

class Solution:
    def rob(self , nums: List[int]) -> int:
        #dp[i]表示长度为i的数组，最多能偷取多少钱
        dp1 = [0 for i in range(len(nums) + 1)] 
        #选择偷了第一家
        dp1[1] = nums[0] 
        #最后一家不能偷
        for i in range(2, len(nums)): 
            #对于每家可以选择偷或者不偷
            dp1[i] = max(dp1[i - 1], nums[i - 1] + dp1[i - 2]) 
        res = dp1[len(nums) - 1]; 
        #第二次循环
        dp2 = [0 for i in range(len(nums) + 1)] 
        #不偷第一家
        dp2[1] = 0 
        #可以偷最后一家
        for i in range(2, len(nums) + 1): 
            #对于每家可以选择偷或者不偷
            dp2[i] = max(dp2[i - 1], nums[i - 1] + dp2[i - 2]) 
            #选择最大值
        return max(res, dp2[len(nums)])

复杂度分析：