题目：二叉树的锯齿形层次遍历

最新推荐文章于 2020-12-22 10:20:16 发布

cumt_cx

最新推荐文章于 2020-12-22 10:20:16 发布

阅读量625

点赞数

CC 4.0 BY-SA版权

分类专栏： LintCode刷题（按照难易程度）文章标签： LintCode

本文链接：https://blog.youkuaiyun.com/cumt_cx/article/details/48093329

LintCode刷题（按照难易程度）专栏收录该内容

192 篇文章

订阅专栏

本文介绍了一种特殊的二叉树遍历方法——锯齿形层次遍历，并提供了一个具体的实现方案。该方法首先从根节点开始，第一层从左到右遍历，第二层则从右到左遍历，以此类推，每层的遍历方向交替进行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给出一棵二叉树，返回其节点值的锯齿形层次遍历（先从左往右，下一层再从右往左，层与层之间交替进行）

您在真实的面试中是否遇到过这个题？

Yes

样例

给出一棵二叉树 {3,9,20,#,#,15,7},
    3
   / \
9 20
    / \
   15   7

返回其锯齿形的层次遍历为：
[
[3],
[20,9],
[15,7]
]
标签 Expand

解题思路：

与之前的树的层次遍历类似用2个队列去分别保存该层和下一层的节点，遍历第一个队列时弹出后，将弹出的节点的左右节点放入第2个队列。锯齿形只需要将符合n%2==0翻转即可。

/**
* Definition of TreeNode:
* public class TreeNode {
*     public int val;
*     public TreeNode left, right;
*     public TreeNode(int val) {
*         this.val = val;
*         this.left = this.right = null;
*     }
* }
*/

public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: A list of lists of integer include
     *          the zigzag level order traversal of its nodes' values
     */
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
        // write your code here
         ArrayList<ArrayList<Integer>> res = new ArrayList<>();
          if(null==root) return res;
          Queue<TreeNode> fQ = new LinkedList<>();
          fQ.add(root);
          int countswap = 1;
          while(fQ!=null&&fQ.size()>0){
              Queue<TreeNode> sQ = new LinkedList<>();
             ArrayList<Integer> depthRoot = new ArrayList<>();
              while(fQ!=null&&fQ.size()>0){
                   TreeNode cur = fQ.poll();
                   depthRoot.add(cur.val);
                   if(cur.left!=null){
                        sQ.add(cur.left);
                   }
                   if(cur.right!=null){
                        sQ.add(cur.right);
                   }
              }
              if(countswap%2==0){
                   depthRoot = reverseT(depthRoot);
              }
             res.add(depthRoot);
              countswap++;
              fQ = sQ;
          }
          return res;
     }
     public <T> ArrayList<T> reverseT(ArrayList<T> res){
         ArrayList<T> reres = new ArrayList<>();
         for(int i=res.size()-1;i>=0;i--){
              T tmp = res.get(i);
              reres.add(tmp);
         }
         return reres;
    }
}