白银挑战-二叉树的层次遍历经典问题

qq_53318302

已于 2023-08-09 16:09:39 修改

阅读量21

点赞数

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

于 2023-08-07 16:28:26 首次发布

本文链接：https://blog.csdn.net/qq_53318302/article/details/132044364

版权

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

6 篇文章 0 订阅

订阅专栏

0.二叉树节点的定义

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

1.基本的层次遍历

知识点补充： LinkedList类有很多方法要来模拟队列，以下是使用到的方法

入队 add(E e );将e插入队列末尾

出队删除队首 remove(); 取出队首元素，并且在队列中删除队首。队首为空报错

public List<Integer> singleLayerOrder(TreeNode root){
        if (root == null){
            //如果二叉树为空，返回空数组
            return new ArrayList<>();
        }
        //定义集合存放遍历的结果，存放的值是节点的val
        List<Integer> res = new ArrayList<>();
        //定义链表队列，存放二叉树节点
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        //循环遍历队列
        while (queue.size()>0){
            TreeNode t = queue.remove();
            res.add(t.val);
            if (t.leftNode != null){
                queue.add(t.leftNode);
            }
            if (t.rightNode != null){
                queue.add(t.rightNode);
            }
        }
        return res;
    }

1.1.二叉树的层次遍历

思路：在基本的层次遍历中新增变量temp，用来存储每一层的的节点，并定义一个变量size用来记录每一次的节点数量

  public List<List<Integer>> layerOrder(TreeNode root){
        if (root == null){
            return new ArrayList<>();
        }
        List<List<Integer>> res = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (queue.size()>0){
            List<Integer> temp = new ArrayList<>();
            int size = queue.size();
            for (int i =0;i<size;i++){
                TreeNode t = queue.remove();
                temp.add(t.val);
                if (t.leftNode != null){
                    queue.add(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.add(t.rightNode);
                }
            }
            res.add(temp);
        }
        return res;
    }

1.2层序遍历-自底向上

补充：

java.util.LinkedList.offer(E e) 将指定的元素添加为LinkedList的最后一个元素

判空 isEmpty(); 对象为空返回true,非空返回false

出队删除队首 poll() ; 取出队首元素，并且在队列中删除队首。队首为空返回null

指定位插入 add(int index, E e); 在index下标插入e元素

思路：就是1.1层序遍历（自上而下）的变形，把各层的节点元素存放进栈（或者遍历完每层元素把结果放在链表的头部），最后的遍历结果就是出栈的元素（或者说是链表元素）

public List<List<Integer>> layerByBottomToTop(TreeNode root){
        if (root == null){
            return new ArrayList<>();
        }
        //结果集 使用链表存储，方便自顶向下遍历每层后，把每层元素插入链表首部(模拟栈)
        List<List<Integer>> res = new LinkedList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while ( ! queue.isEmpty()){
            //临时变量temp，存储每层的元素
            List<Integer> temp = new ArrayList<>();
            int size = queue.size();
            for (int i =0;i<size;i++){
                //弹出 队列的元素
                TreeNode t = queue.poll();
                //把弹出来的元素 加入temp
                temp.add(t.val);
                //判断弹出来的结点是否存在左,右孩子
                if (t.leftNode != null){
                    queue.offer(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.offer(t.rightNode);
                }
            }
            //模拟栈的添加，每次添加都在链表首部
            res.add(0,temp);
        }
        return res;
    }

1.3锯齿遍历

补充： offerLast（）将元素链接到队列尾并返回true

Deque类：双向队列

思路：在层序遍历的基础上，维护一个变量 isOrderLeft 判断是从左往右遍历还是从右往左遍历（在出队列的时候添加到每层的结果集合中考虑的）

重点：遍历完每层元素后，要修改下一次遍历的方向（即维护变量 isOrderLeft）

public List<List<Integer>> zigzigOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<List<Integer>> res = new LinkedList<>();//结果集
        Queue<TreeNode> queue = new LinkedList<>();//队列
        boolean isLeftToRight = true;//每层遍历的顺序
        queue.offer(root);
        while (! queue.isEmpty()){
            //双向队列 用来存储每层的元素
            Deque<Integer> temp = new ArrayDeque<>();
            int size = queue.size();
            for (int i =0;i<size;i++){
                //队列 弹元素
                TreeNode t = queue.poll();
                //添加元素到temp(存储每层的元素)
                if (isLeftToRight){
                    //从左到右遍历
                    temp.addLast(t.val);
                }else {
                    //从右到左遍历
                    temp.addFirst(t.val);
                }
                //判断是否有左，右孩子
                if (t.leftNode != null){
                   queue.add(t.leftNode);
               }
               if (t.rightNode != null){
                   queue.add(t.rightNode);
                }
            }
            //把双向队列 准换 成集合
            res.add(new ArrayList<>(temp));
            isLeftToRight = !isLeftToRight;
        }
        return res;
    }

1.4N叉树的层序遍历（模糊）

思路：与二叉树的遍历类似，借助队列实现

N叉树节点的定义

public class NNode {
    int val;
    List<NNode> child;
}

N叉树的层序遍历

 public List<List<Integer>> nLevelOrder(NNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<List<Integer>> res = new ArrayList<>();
        Deque<NNode> queue = new ArrayDeque<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            //定义双向队列存放 弹出元素 的 孩子节点
            Deque<NNode> next = new ArrayDeque<>();
            //定义每层存放元素的结果集
            List<Integer> temp = new ArrayList<>();
            while (!queue.isEmpty()) {
                NNode cur = queue.pollFirst();
                temp.add(cur.val);
                //遍历当前弹出元素的孩子节点
                for (NNode curChild : cur.child) {
                    if (curChild != null) {
                        next.add(curChild);
                    }
                }
                queue = next;
                res.add(temp);
            }
        }
        return res;
    }

queue = next; 把孩子节点集合重新赋值给队列，继续遍历孩子节点......

2.处理每层元素的题目

2.1树的每一层中找最大值

补充·：Integer.MIN_VALUE（值为-231的常量，它表示int类型能够表示的最小值）

 public List<Integer> getLayerMax(TreeNode root){
        if (root== null){
            return new ArrayList<>();
        }
        List<Integer> res= new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (queue.size()>0){
            int size = queue.size();
            int MAX_NUM = Integer.MIN_VALUE;
            for (int i =0;i< size;i++){
                TreeNode t = queue.remove();
                MAX_NUM = Integer.max(MAX_NUM,t.val);
                if (t.leftNode != null){
                   queue.add(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.add(t.rightNode);
                }
            }
            res.add(MAX_NUM);
        }
        return res;
    }

2.2树的每一层求平均值

思路：在基本的树的层序遍历中，维护一个变量sum，记录每层的元素总和

保留一个小数点，存储时使用Double类型

public List<Double> getLayerAverage(TreeNode root){
        if (root == null){
            return new ArrayList<>();
        }
        List<Double> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (! queue.isEmpty()){
            //size表示每层元素的个数
            int size = queue.size();
            //定义变量 sum 存储每层的元素和
            double sum =0;
            for (int i =0;i<size;i++){
                TreeNode t = queue.remove();
                sum += t.val;
                if (t.leftNode != null){
                    queue.add(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.add(t.rightNode);
                }
            }
            res.add(sum/size);
        }
        return res;
    }

2.3树的每一层中找最小值

------------------------------------------------2.1同理-----------------------------------------------------------------------

2.4二叉树的右视图

题意：返回的是二叉树每层的最后一个元素的集合

 /**
     * 求每层的最后一个元素
     * @param root
     * @return 返回 每层的最后一个元素 的集合
     */
    public List<Integer> getRightSideView(TreeNode root){
        if (root == null){
            return new ArrayList<>();
        }
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (! queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode t = queue.remove();
                if (t.leftNode != null){
                    queue.add(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.add(t.rightNode);
                }
                //找出每层的最后一个元素
                if (i == size -1){
                    res.add(t.val);
                }
            }
        }
        return res;
    }

2.5二叉树的左视图

题意：返回的是二叉树每层的首个元素的集合

/**
     * 求每层的第一个元素
     * @param root
     * @return 返回 每层的第一个元素 的集合
     */
    public List<Integer> getLeftSideView(TreeNode root){
        if (root == null){
            return new ArrayList<>();
        }
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (! queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode t = queue.remove();
                if (t.leftNode != null){
                    queue.add(t.leftNode);
                }
                if (t.rightNode != null){
                    queue.add(t.rightNode);
                }
                //找出每层的第一个元素
                if (i == 0){
                    res.add(t.val);
                }
            }
        }
        return res;
    }

2.6最底层最左边

思路：正常从左向右遍历每层的元素，最后输出的一定是最底层最右边的叶子节点，那么，我们可以改变遍历的方向（从右向左遍历），则最后一个输出元素一定是最底层最左边的元素

public int findBottomLeftValue(TreeNode root){
        if (root.rightNode==null && root.leftNode==null){
            return root.val;
        }
        TreeNode temp =new TreeNode(-100);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (! queue.isEmpty()){
                temp = queue.remove();
                if (temp.rightNode != null){
                    queue.add(temp.rightNode);
                }
                if (temp.leftNode != null){
                    queue.add(temp.leftNode);
                }
            }
        return temp.val;
    }