牛客题解 | 按之字形顺序打印二叉树-编程知识

牛客题解 | 按之字形顺序打印二叉树

news/2025/2/21 9:39:11/文章来源:https://www.cnblogs.com/wc529065/p/18728318

题目

题目链接

题目的主要信息：

给定一个二叉树，返回该二叉树的之字形层序遍
第一层从左向右，下一层从右向左，一直这样交替

举一反三：

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

JZ32. 从上往下打印二叉树

JZ78. 把二叉树打印成多行

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

知识点：队列

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

思路：

按照层次遍历按层打印二叉树的方式，每层分开打印，然后对于每一层利用flag标记，第一层为false，之后每到一层取反一次，如果该层的flag为true，则记录的数组整个反转即可。

//奇数行反转，偶数行不反转
if(flag) reverse(row.begin(), row.end());

但是难点在于如何每层分开存储，从哪里知晓分开的时机？在层次遍历的时候，我们通常会借助队列（queue），事实上，队列中的值大有玄机，让我们一起来看看：当根节点进入队列时，队列长度为1，第一层节点数也为1；若是根节点有两个子节点，push进队列后，队列长度为2，第二层节点数也为2；若是根节点一个子节点，push进队列后，队列长度为为1，第二层节点数也为1。由此，我们可知，每层的节点数等于进入该层时队列长度，因为刚进入该层时，这一层每个节点都会push进队列，而上一层的节点都出去了。

int n = temp.size();
for(int i = 0; i < n; i++){//访问一层
}

具体做法：

step 1：首先判断二叉树是否为空，空树没有打印结果。
step 2：建立辅助队列，根节点首先进入队列。不管层次怎么访问，根节点一定是第一个，那它肯定排在队伍的最前面，初始化flag变量。
step 3：每次进入一层，统计队列中元素的个数，更改flag变量的值。因为每当访问完一层，下一层作为这一层的子节点，一定都加入队列，而再下一层还没有加入，因此此时队列中的元素个数就是这一层的元素个数。
step 4：每次遍历这一层这么多的节点数，将其依次从队列中弹出，然后加入这一行的一维数组中，如果它们有子节点，依次加入队列排队等待访问。
step 5：访问完这一层的元素后，根据flag变量决定将这个一维数组直接加入二维数组中还是反转后再加入，然后再访问下一层。

图示：

alt

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)//如果是空，则直接返回空listreturn res; //队列存储，进行层次遍历Queue<TreeNode> temp = new LinkedList<TreeNode>(); temp.offer(head);TreeNode p;boolean flag = true;while(!temp.isEmpty()){//记录二叉树的某一行ArrayList<Integer> row = new ArrayList<Integer>();  int n = temp.size();//奇数行反转，偶数行不反转flag = !flag; //因先进入的是根节点，故每层节点多少，队列大小就是多少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);}//奇数行反转，偶数行不反转if(flag)  Collections.reverse(row);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)//如果是空，则直接返回空vectorreturn res;//队列存储，进行层次遍历 queue<TreeNode*> temp; temp.push(head);TreeNode* p;bool flag = true;while(!temp.empty()){//记录二叉树的某一行vector<int> row;  int n = temp.size();//奇数行反转，偶数行不反转flag = !flag; //因先进入的是根节点，故每层节点多少，队列大小就是多少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);}//奇数行反转，偶数行不反转if(flag) reverse(row.begin(), row.end());res.push_back(row);}return res;}
};

Python实现代码

import queueclass Solution:def Print(self , pRoot: TreeNode) -> List[List[int]]:head = pRootres = []if not head:# 如果是空，则直接返回空listreturn res # 队列存储，进行层次遍历temp = queue.Queue() temp.put(head)flag = Truewhile not temp.empty():# 记录二叉树的某一行row = [] # 奇数行反转，偶数行不反转flag = not flag n = temp.qsize()# 因先进入的是根节点，故每层节点多少，队列大小就是多少for i in range(n): p = temp.get()row.append(p.val)# 若是左右孩子存在，则存入左右孩子作为下一个层次if p.left:temp.put(p.left)if p.right:temp.put(p.right)# 奇数行反转，偶数行不反转if flag: row = row[::-1]res.append(row)return res

复杂度分析：

时间复杂度：\(O(n)\)，每个节点访问一次，因为reverse的时间复杂度为\(O(n)\)，按每层元素reverse也相当于\(O(n)\)
空间复杂度：\(O(n)\)，队列的空间最长为\(O(n)\)

方法二：双栈法（扩展思路）

知识点：栈

栈是一种仅支持在表尾进行插入和删除操作的线性表，这一端被称为栈顶，另一端被称为栈底。元素入栈指的是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；元素出栈指的是从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

思路：

方法一用到了反转函数，反转我们能想到什么？肯定是先进后出的栈！

我们可以利用两个栈遍历这棵二叉树，第一个栈s1从根节点开始记录第一层，然后依次遍历两个栈，遍历第一个栈时遇到的子节点依次加入第二个栈s2中，即是第二层：

//遍历奇数层
while(!s1.empty()){ TreeNode* node = s1.top();//记录奇数层temp.push_back(node->val); //奇数层的子节点加入偶数层if(node->left)  s2.push(node->left);if(node->right) s2.push(node->right);s1.pop();
}

而遍历第二个栈s2的时候因为是先进后出，因此就是逆序的，再将第二个栈s2的子节点依次加入第一个栈s1中：

while(!s2.empty()){ reeNode* node = s2.top();//记录偶数层temp.push_back(node->val);  //偶数层的子节点加入奇数层if(node->right)  s1.push(node->right);if(node->left) s1.push(node->left);s2.pop();
}

于是原本的逆序在第一个栈s1中又变回了正序，如果反复交替直到两个栈都空为止。