从零学算法103

103 .给你二叉树的根节点 root ,返回其节点值的 锯齿形层序遍历 。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。

示例 1:

输入:root = [3,9,20,null,null,15,7]

输出:[[3],[20,9],[15,7]]

示例 2:

输入:root = [1]

输出:[[1]]

示例 3:

输入:root = []

输出:[]

  • 我的原始人解法:层序遍历,每次处理一遍从左到右的和从右到左的遍历,可以直接略过不看
java 复制代码
  public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
      List<List<Integer>> res = new ArrayList<>();
      if(root==null)return res;
      Stack<TreeNode> stack = new Stack<>();
      stack.push(root);
      while(!stack.isEmpty()){
          List<Integer> temp = new ArrayList<>();
          Stack<TreeNode> tempStack = new Stack<>();
          // 从左到右遍历节点
          // stack 从左到右存节点,下面的遍历取的时候就相当于从右到左遍历
          for(int i=stack.size();i>0;i--){
              TreeNode node = stack.pop();
              temp.add(node.val);
              if(node.left != null)tempStack.push(node.left);
              if(node.right != null)tempStack.push(node.right);
          }
          stack=tempStack;
          tempStack = new Stack<>();
          res.add(temp);
          temp = new ArrayList<>();
          // 从右到左遍历节点,因为上面是用 stack 从左到右存的
          // stack 从右到左存节点,下一轮的遍历取的时候就相当于从左到右遍历
          for(int i=stack.size();i>0;i--){
              TreeNode node = stack.pop();
              temp.add(node.val);
              if(node.right != null)tempStack.push(node.right);
              if(node.left != null)tempStack.push(node.left);
          }
          stack=tempStack;
          // 如果到这已经遍历完了就不用加了
          if(temp.size()>0)res.add(temp);
      }
      return res;
  }
  • 他人解法1:层序遍历,用一个变量记录是从左到右还是从右到左存放当前层的值,这样每次遍历都从左到右放节点即可,具体看代码
java 复制代码
  public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
      List<List<Integer>> res = new ArrayList<>();
      if(root==null)return res;
      boolean leftToRight = true;
      Queue<TreeNode> queue = new LinkedList<>();
      queue.add(root);
      while(!queue.isEmpty()){
          List<Integer> temp = new ArrayList<>();
          for(int i=queue.size();i>0;i--){
              TreeNode node = queue.poll();
              // 从左到右正常放
              if(leftToRight)temp.add(node.val);
              // 遍历节点的顺序为从左到右,每次把值放首位
              // 这样就相当于从右到左存放了这层的结点的值
              else temp.add(0,node.val);
              if(node.left != null)queue.add(node.left);
              if(node.right != null)queue.add(node.right);
          }
          res.add(temp);
          // 记得下层换顺序了
          leftToRight = !leftToRight;
      }
      return res;
  }
  • 他人解法2:dfs,其实也可以看做上面 bfs 的递归版本,不过主要难在入参中的当前遍历层 level 可能想不到, level 不仅可以代替 leftToRight 判断存放节点值的顺序,还能根据 level 把节点值存放到对应层的 list,调用递归就相当于节点入队且遍历到了下一层, 具体如下
java 复制代码
  List<List<Integer>> res = new ArrayList<>();
  public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
      if(root==null)return res;
      dfs(root, 0);
      return res;
  }
  public void dfs(TreeNode root, int level){
      if(root==null)return;
      // 如果当前层还没 list 就先建一个
      if(res.size() <= level){
          List<Integer> levelRes = new ArrayList<>();
          res.add(levelRes);
      }
  	// 第几层的值就存到第几层的 list
      List<Integer> levelRes = res.get(level);
      // 判断存放值的顺序来存放
      if(level%2==0)levelRes.add(root.val);
      else levelRes.add(0, root.val);
  	// 处理下一层
      dfs(root.left, level+1);
      dfs(root.right, level+1);
  }
相关推荐
Python×CATIA工业智造10 分钟前
详细页智能解析算法:洞悉海量页面数据的核心技术
爬虫·算法·pycharm
无聊的小坏坏1 小时前
力扣 239 题:滑动窗口最大值的两种高效解法
c++·算法·leetcode
黎明smaly1 小时前
【排序】插入排序
c语言·开发语言·数据结构·c++·算法·排序算法
YuTaoShao1 小时前
【LeetCode 热题 100】206. 反转链表——(解法一)值翻转
算法·leetcode·链表
YuTaoShao1 小时前
【LeetCode 热题 100】142. 环形链表 II——快慢指针
java·算法·leetcode·链表
CCF_NOI.2 小时前
(普及−)B3629 吃冰棍——二分/模拟
数据结构·c++·算法
运器1232 小时前
【一起来学AI大模型】支持向量机(SVM):核心算法深度解析
大数据·人工智能·算法·机器学习·支持向量机·ai·ai编程
Zedthm2 小时前
LeetCode1004. 最大连续1的个数 III
java·算法·leetcode
神的孩子都在歌唱3 小时前
3423. 循环数组中相邻元素的最大差值 — day97
java·数据结构·算法
YuTaoShao3 小时前
【LeetCode 热题 100】73. 矩阵置零——(解法一)空间复杂度 O(M + N)
算法·leetcode·矩阵