二叉树的层序遍历

OrienZ 3

已于 2023-11-28 21:41:17 修改

阅读量359

点赞数 8

分类专栏：数据结构与算法文章标签：数据结构算法

于 2023-11-28 19:45:52 首次发布

本文链接：https://blog.csdn.net/weixin_45765073/article/details/134675227

版权

数据结构与算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1. 二叉树基本的层序遍历

1.1 二叉树的层序遍历

/**
     * 使用队列来保存节点
     * 并且在出队列的时候将其左右节点保存到队列中
     * @param root
     * @return
     */
    public static List<Integer> simpleLevelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        Queue<TreeNode> queue = new LinkedList<>();
        List<Integer> list = new ArrayList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.remove();
            list.add(node.val);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        return list;
    }

1.2 层序遍历-自底而上

/**
     * 和自顶向下一致，不过每次都加入到数组的头部
     * @param root
     * @return
     */
    public static List<List<Integer>> levelOrderBottom(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<List<Integer>> linkedList = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while (size > 0) {
                TreeNode node = queue.remove();
                list.add(node.val);
                size--;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            //linkedList.addFirst(list);
            ans.add(0, list);
        }
        /*while (!linkedList.isEmpty()) {
            List<Integer> list = linkedList.removeFirst();
            ans.add(list);
        }*/
        return ans;

1.3 二叉树的锯齿形层序遍历

/**
     * 判据奇偶行
     * 奇数行，按顺序加入到列表中
     * 偶数行，都从0位置加入到列表中
     * 也可以使用队列的双端特性，根据奇偶从不同方向进队列
     * @param root
     * @return
     */
    public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<List<Integer>> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int level = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            level++;
            List<Integer> list = new ArrayList<>();
            while (size > 0) {
                TreeNode node = queue.remove();
                if (level % 2 == 0) {
                    list.add(0, node.val);
                } else {
                    list.add(node.val);
                }
                size--;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add(list);
        }
        return ans;
    }

1.4 N叉树的层序遍历

/**
     * 和二叉树的层序遍历类似
     * 使用队列
     * @param root
     * @return
     */
    public static List<List<Integer>> nLevelOrder(NTreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<List<Integer>> ans = new ArrayList<>();
        Queue<NTreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            while (size > 0) {
                NTreeNode node = queue.remove();
                size--;
                list.add(node.val);
                List<NTreeNode> children = node.children;
                for (NTreeNode child : children) {
                    if (child != null) {
                        queue.add(child);
                    }
                }
            }
            ans.add(list);
        }
        return ans;
    }
    
class NTreeNode {
    public int val;
    public List<NTreeNode> children;


    public NTreeNode(int val, List<NTreeNode> children) {
        this.val = val;
        this.children = children;
    }


    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }


    public static NTreeNode buildBinaryTree() {
        List<NTreeNode> list11 = new ArrayList<>();
        List<NTreeNode> list12 = new ArrayList<>();
        List<NTreeNode> list13 = new ArrayList<>();
        List<NTreeNode> list14 = new ArrayList<>();

        List<NTreeNode> list3 = new ArrayList<>();
        list3.add(new NTreeNode(5, list11));
        list3.add(new NTreeNode(6, list12));
        NTreeNode nTreeNode3 = new NTreeNode(3, list3);

        List<NTreeNode> list1 = new ArrayList<>();
        list1.add(nTreeNode3);
        list1.add(new NTreeNode(2, list13));
        list1.add(new NTreeNode(4, list14));

        NTreeNode nTreeNode = new NTreeNode(1, list1);
        return nTreeNode;

    }

}

2. 处理每层树元素的题目

2.1 每行中找最大值

/**
     * 遍历每层的时候找到最大值
     * @param root
     * @return
     */
    public static List<Integer> largestValues(TreeNode root) {
       if (root == null) {
           return new ArrayList<>();
       }
       List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            int max = Integer.MIN_VALUE;
            while (size > 0) {
                TreeNode node = queue.remove();
                size--;
                max = Math.max(max, node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add(max);
        }
        return ans;
    }

2.2 每行的平均值

public static List<Double> averageOfLevels(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<Double> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            int num = size;
            long sum = 0;
            while (size > 0) {
                TreeNode node = queue.remove();
                size--;
                sum += node.val;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add( (sum * 1.0) / (num * 1.0));
        }
        return ans;
    }

2.3 二叉树的右视图

/**
     * 找每行的最后一个元素
     * @param root
     * @return
     */
    public static List<Integer> rightSideView(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            int right = 0;
            while (size > 0) {
                TreeNode node = queue.remove();
                if (size == 1) {
                    right = node.val;
                }
                size--;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add(right);
        }
        return ans;
    }

    /**
     * 倒序找每行的最后一个元素，即为左视图
     * @param root
     * @return
     */
    public static List<Integer> leftSideView(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            int right = 0;
            while (size > 0) {
                TreeNode node = queue.remove();
                if (size == 1) {
                    right = node.val;
                }
                size--;
                if (node.right != null) {
                    queue.add(node.right);
                }
                if (node.left != null) {
                    queue.add(node.left);
                }

            }
            ans.add(right);
        }
        return ans;
    }

2.4 二叉树最底层的最左边元素

/**
     * 和上边类似
     * 倒序找最后一行行的最后一个元素
     * @param root
     * @return
     */
    public static int findBottomLeftValue(TreeNode root) {
        if (root == null) {
            return -1;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode node = new TreeNode(-1);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                node = queue.remove();
                size--;
                if (node.right != null) {
                    queue.add(node.right);
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
            }
        }
        return node.val;
    }