算法通关村—原来如此简单

最新推荐文章于 2024-07-19 19:11:19 发布

叼着奶瓶逛酒吧

最新推荐文章于 2024-07-19 19:11:19 发布

阅读量96

点赞数

分类专栏：编程导航算法通关村文章标签：算法

本文链接：https://blog.csdn.net/weixin_44253799/article/details/132079023

版权

编程导航算法通关村专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.基本的层序遍历与变换

上面的二叉树应输出结果 [3, 9, 20, 15, 7]，方法上面已经图示了，这里看一下怎么代码实现。先访问根节点，然后将其左右子孩子放到队列里，接着继续出队，出来的元素都将其左右自孩子放到队列里，直到队列为空了就退出就行了：

代码实现

List<Integer> simpleLevelOrder(TreeNode root) {
    if (root == null) {
        return new ArrayList<Integer>();
    }
    List<Integer> res = new ArrayList<Integer>();
    LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
    //将根节点放入队列中，然后不断遍历队列
    queue.add(root);
    //有多少元素执行多少次
    while (queue.size() > 0) {
        //获取当前队列的长度，这个长度相当于 当前这一层的节点个数
        TreeNode t = queue.remove();
        res.add(t.val);
        if (t.left != null) {
            queue.add(t.left);
        }
        if (t.right != null) {
            queue.add(t.right);
        }
    }
    return res;
}

2.二叉树的层次遍历

LeetCode102 题目要求：给你一个二叉树，请你返回其按层序遍历得到的节点值。(即逐层地，从左到右访问所有节点)。

二叉树：[3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
返回其层序遍历结果：
 [
  [3],
  [9,20],
  [15,7]
]

思路:这题的变点是要把每层的元素分开遍历,加一个size在开始记录当层的size,当size为零时跳到下一层遍历

代码实现

 public List<List<Integer>> level102Order(TreeNode root) {
        if (root == null) {
            return new ArrayList<List<Integer>>();
        }
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            List<Integer> tmp = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode remove = queue.remove();
                tmp.add(remove.val);
                if (remove.left != null){
                    queue.add(remove.left);
                }
                if (remove.right != null){
                    queue.add(remove.right);
                }
            }
            res.add(tmp);
        }
        return res;
    }

3.层序遍历-自底向上

LeetCode 107.给定一个二叉树，返回其节点值自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）。例如给定的二叉树为：

    3
   / \
  9  20
    /  \
   15   7
      
  返回结果
  [
  [15,7],
  [9,20],
  [3]
]

看到这里,我第一个想到的是用栈的思想,在上面的代码基础上,每一次遍历把结果放到栈,然后输出栈的数据返回,代码如下

   public List<List<Integer>> level107Order(TreeNode root) {
        if (root == null) {
            return new ArrayList<List<Integer>>();
        }
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        Stack<List<Integer>> stack = new Stack<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> tmp = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode remove = queue.remove();
                tmp.add(remove.val);
                if (remove.left != null) {
                    queue.add(remove.left);
                }
                if (remove.right != null) {
                    queue.add(remove.right);
                }
            }
            stack.push(tmp);
        }
        while (!stack.isEmpty()) {
            res.add(stack.pop());
        }
        return res;
    }

但以上的做法的时间复杂度为O(2log2n),如果采用链表的方法可以进行优化.在遍历完一层节点之后，将存储该层节点值的列表添加到结果列表的头部。为了降低在结果列表的头部添加一层节点值的列表的时间复杂度，结果列表可以使用链表的结构，在链表头部添加一层节点值的列表的时间复杂度是 O(1)。在 Java 中，由于我们需要返回的 List 是一个接口，这里可以使用链表实现。

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
        if (root == null) {
            return levelOrder;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                TreeNode left = node.left, right = node.right;
                if (left != null) {
                    queue.offer(left);
                }
                if (right != null) {
                    queue.offer(right);
                }
            }
            levelOrder.add(0, level);//栈
        }
        return levelOrder;
    }

4.二叉树的锯齿形层序遍历

LeetCode103 题，要求是：给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
例如：给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
      
  返回结果
  [
  [3],
  [20,9],
  [15,7]
]

这个题也是102的变种，只是最后输出的要求有所变化，要求我们按层数的奇偶来决定每一层的输出顺序。如果当前层数是偶数，从左至右输出当前层的节点值，否则，从右至左输出当前层的节点值。这里只要采用以
我们依然可以沿用第 102 题的思想，为了满足题目要求的返回值为「先从左往右，再从右往左」交替输出的锯齿形，可以利用「双端队列」的数据结构来维护当前层节点值输出的顺序。双端队列是一个可以在队列任意一端插入元素的队列。在广度优先搜索遍历当前层节点拓展下一层节点的时候我们仍然从左往右按顺序拓展，但是对当前层节点的存储我们维护一个变量 isOrderLeft 记录是从左至右还是从右至左的：

如果从左至右，我们每次将被遍历到的元素插入至双端队列的末尾。
从右至左，我们每次将被遍历到的元素插入至双端队列的头部。

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<List<Integer>>();
        if (root == null) {
            return ans;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        boolean isOrderLeft = true;
        while (!queue.isEmpty()) {
            Deque<Integer> levelList = new LinkedList<Integer>();
            int size = queue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode curNode = queue.poll();
                if (isOrderLeft) {
                    levelList.offerLast(curNode.val);
                } else {
                    levelList.offerFirst(curNode.val);
                }
                if (curNode.left != null) {
                    queue.offer(curNode.left);
                }
                if (curNode.right != null) {
                    queue.offer(curNode.right);
                }
            }
            ans.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;
        }
        return ans;
    }

5.在每个树行中找最大值

LeetCode 515题目要求：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

     1
   /   \
  3     2
 /  \    \
5    3    9

这里其实就是在得到一层之后使用一个变量来记录当前得到的最大值

public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();
        
        if (root != null) {
            deque.addLast(root);
        }

        while (!deque.isEmpty()) {
            int size = deque.size();
            int levelMaxNum = Integer.MIN_VALUE;
            for (int i = 0; i < size; i++) {
                TreeNode node = deque.poll();
                levelMaxNum = Math.max(node.val,levelMaxNum);
                if (node.left != null) deque.addLast(node.left);
                if (node.right != null) deque.addLast(node.right);
            }
            res.add(levelMaxNum);
        }
        return res;
    }

6.在每个树行中找平均值

LeetCode 637 要求给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。示例

在这里插入图片描述

这个题和前面的几个一样，只不过是每层都先将元素保存下来，最后求平均就行了：

    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        if (root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            double sum = 0;
            for (int i = 0; i < size; i++) {
                TreeNode remove = queue.remove();
                sum += remove.val;
                if (remove.left != null) {
                    queue.add(remove.left);
                }
                if (remove.right != null) {
                    queue.add(remove.right);
                }
            }
            res.add(sum / size);
        }
        return res;
    }

7.二叉树的右视图

LeetCode 199题目要求是：给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。例如：

在这里插入图片描述

这个题目出现频率还挺高的，如果没有提前思考过，面试现场可能会想不到怎么做。其实也很简单那，利用 BFS 进行层次遍历，记录下每层的最后一个元素。

public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                if (i == size - 1) {  //将当前层的最后一个节点放入结果列表
                    res.add(node.val);
                }
            }
        }
        return res;
    }

叼着奶瓶逛酒吧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法通关村—原来如此简单

我们依然可以沿用第 102 题的思想，为了满足题目要求的返回值为「先从左往右，再从右往左」交替输出的锯齿形，可以利用「双端队列」的数据结构来维护当前层节点值输出的顺序。双端队列是一个可以在队列任意一端插入元素的队列。为了降低在结果列表的头部添加一层节点值的列表的时间复杂度，结果列表可以使用链表的结构，在链表头部添加一层节点值的列表的时间复杂度是 O(1)。LeetCode 199题目要求是：给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
复制链接

扫一扫