花式玩转二叉树层序遍历——实现二叉树Z字输出

题目介绍

这个题目是在做一个测试里面遇到的，大致描述如下：
现在有一棵二叉树，需要实现如图所示的交叉来回遍历：

即相较于普通的层序遍历，需要控制遍历结果的方向。

二叉树层序遍历——队列实现

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）
分析
借助队列存储的方式实现。队列这个数据结构是先入先出的。

具体步骤：
1、将根节点入队
2、出队首节点，将队首节点的左右非空孩子入队
3、重复2操作直到队列为空

Java完整代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();  
        if (root == null) {
            return res;
        }
        LinkedList<TreeNode> queue = new LinkedList<>(); // Java的队列由linkedList实现的
        queue.add(root);
        while (!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int current_queue_size = queue.size();
            for (int i = 0; i < current_queue_size; i++) {
                TreeNode top = queue.getFirst();
                list.add(top.val);
                if (top.left != null) {
                    queue.add(top.left);
                }
                if (top.right != null) {
                    queue.add(top.right);
                }
                queue.removeFirst();
            }
            res.add(list);
        }
        return  res;
    }
    
}

分析

参考上面的层序遍历

这个题目的实现本质上还是二叉树的层序遍历，只是其中一个变种，我们可以通过一个判断标志，来控制遍历的方向，具体如代码所示。

Java完整代码实现

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public static List<List<Integer>> z_print(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        boolean flag = true; // true表示从左向右打印
        while (!queue.isEmpty()) {
            int size = queue.size();
            ArrayList<Integer> tmp = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.getFirst();
                tmp.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }

            if (flag) {  // flag = true 从左向右
                res.add(tmp);
                flag = false;
            } else {  // 从右向左
                Collections.reverse(tmp);  // 对List实现逆序，也可以自己去实现
                res.add(tmp);
                flag = true;
            }
        }
        return res;
    }

总结

这是一道在一次测试中遇到的题目，主要还是得对基本的层序遍历进行掌握，然后再加以变化解答，需要理解并掌握基础的算法。

ps:计划每日更新一篇博客，今日2023-05-08，日更第二十二天。（9号补更）
昨日更新：
搜索、添加、删除均为O(logn)的数据结构——跳表