5.17 二轮 链表

src/main/java/tree/AverageOfLevels.java

@@ -0,0 +1,38 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * 题目： 637. 二叉树的层平均值 (averageOfLevels)
+ * 描述：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。
+ *
+ 示例 1：
+ 输入：root = [3,9,20,null,null,15,7]
+ 输出：[3.00000,14.50000,11.00000]
+ 解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
+ 因此返回 [3, 14.5, 11] 。
+
+ * 链接：https://leetcode.cn/problems/average-of-levels-in-binary-tree/
+ */
+public class AverageOfLevels {
+    public List<Double> averageOfLevels(TreeNode root) {
+        Queue<TreeNode>queue=new LinkedList<>();
+        List<Double>res=new ArrayList<>();
+        queue.offer(root);
+        while (!queue.isEmpty()){
+            int size=queue.size();
+            double sum=0.0;
+            for (int i = 0; i < size; i++) {
+                TreeNode cur=queue.poll();
+                sum+=cur.val;
+                if(cur.left!=null)queue.offer(cur.left);
+                if(cur.right!=null)queue.offer(cur.right);
+            }
+            res.add(sum/size);
+        }
+        return res;
+    }
+}

src/main/java/tree/BSTIterator.java

@@ -0,0 +1,52 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 题目： 173. 二叉搜索树迭代器 (BSTIterator)
+ * 描述：实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
+ * BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
+ * boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
+ * int next()将指针向右移动，然后返回指针处的数字。
+ * 注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
+ *
+ * 你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。
+ *
+ 示例 1：
+ 输入
+ ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
+ [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
+ 输出
+ [null, 3, 7, true, 9, true, 15, true, 20, false]
+
+ * 链接：https://leetcode.cn/problems/binary-search-tree-iterator/
+ */
+class BSTIterator {
+    private int idx;
+    private List<Integer> arr;
+
+    public BSTIterator(TreeNode root) {
+        idx = 0;
+        arr = new ArrayList<Integer>();
+        inorderTraversal(root, arr);
+    }
+
+    public int next() {
+        return arr.get(idx++);
+    }
+
+    public boolean hasNext() {
+        return idx < arr.size();
+    }
+
+    private void inorderTraversal(TreeNode root, List<Integer> arr) {
+        if (root == null) {
+            return;
+        }
+        inorderTraversal(root.left, arr);
+        arr.add(root.val);
+        inorderTraversal(root.right, arr);
+    }
+}
+

src/main/java/tree/CountNodes.java

@@ -0,0 +1,49 @@
+package tree;
+/**
+ * 题目： 222. 完全二叉树的节点个数 (countNodes)
+ * 描述：给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
+ * 完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（从第 0 层开始），则该层包含 1~ 2h 个节点。
+ *
+ 示例 1：
+ 输入：root = [1,2,3,4,5,6]
+ 输出：6
+
+ * 链接：https://leetcode.cn/problems/count-complete-tree-nodes/
+ */
+//没想出小于o(n)的方法
+public class CountNodes {
+    public int countNodes(TreeNode root) {
+        // 空树直接返回 0
+        if (root == null) {
+            return 0;
+        }
+
+        // 用两个指针分别遍历左子树最左侧和右子树最右侧，
+        // 目的是快速判断当前子树是否为满二叉树
+        TreeNode l = root, r = root;
+        int hl = 0, hr = 0;
+
+        // 计算左子树从根到最左叶节点的高度
+        while (l != null) {
+            l = l.left;
+            hl++;
+        }
+
+        // 计算右子树从根到最右叶节点的高度
+        while (r != null) {
+            r = r.right;
+            hr++;
+        }
+
+        // 如果左右高度相同，则说明这是一棵满二叉树
+        // 满二叉树节点数 = 2^h - 1
+        if (hl == hr) {
+            // 使用位运算更高效：1 << hl 相当于 2^hl
+            return (1 << hl) - 1;
+        }
+
+        // 否则，当前树不是满二叉树，
+        // 则根据「根 + 左子树节点数 + 右子树节点数」递归计算
+        return 1 + countNodes(root.left) + countNodes(root.right);
+    }
+}

src/main/java/tree/GetMinimumDifference.java

@@ -0,0 +1,35 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 题目： 530. 二叉搜索树的最小绝对差 (getMinimumDifference)
+ * 描述：给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
+ *
+ * 差值是一个正数，其数值等于两值之差的绝对值。
+ *
+ 示例 1：
+ 输入：root = [4,2,6,1,3]
+ 输出：1
+
+ * 链接：https://leetcode.cn/problems/minimum-absolute-difference-in-bst/
+ */
+public class GetMinimumDifference {
+    void dfs(TreeNode root, List<Integer>list){
+        if(root==null)return;
+        dfs(root.left,list);
+        list.add(root.val);
+        dfs(root.right,list);
+    }
+    public int getMinimumDifference(TreeNode root) {
+        List<Integer>list=new ArrayList<>();
+        dfs(root,list);
+        int min=Integer.MAX_VALUE;
+        for (int i = 0; i < list.size()-1; i++) {
+            int tp=list.get(i+1)-list.get(i);
+            if(tp<min)min=tp;
+        }
+        return min;
+    }
+}

src/main/java/tree/ZigzagLevelOrder.java

@@ -0,0 +1,48 @@
+package tree;
+
+import java.util.*;
+
+/**
+ * 题目： 103. 二叉树的锯齿形层序遍历 (zigzagLevelOrder)
+ * 描述：给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+ *
+ 示例 1：
+ 输入：root = [3,9,20,null,null,15,7]
+ 输出：[[3],[20,9],[15,7]]
+
+ * 链接：https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal/
+ */
+public class ZigzagLevelOrder {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> ans = new LinkedList<List<Integer>>();
+        if (root == null) {
+            return ans;
+        }
+
+        Queue<TreeNode> nodeQueue = new ArrayDeque<>();
+        nodeQueue.offer(root);
+        boolean isOrderLeft = true;
+
+        while (!nodeQueue.isEmpty()) {
+            Deque<Integer> levelList = new LinkedList<Integer>();
+            int size = nodeQueue.size();
+            for (int i = 0; i < size; ++i) {
+                TreeNode curNode = nodeQueue.poll();
+                if (isOrderLeft) {
+                    levelList.offerLast(curNode.val);
+                } else {
+                    levelList.offerFirst(curNode.val);
+                }
+                if (curNode.left != null) {
+                    nodeQueue.offer(curNode.left);
+                }
+                if (curNode.right != null) {
+                    nodeQueue.offer(curNode.right);
+                }
+            }
+            ans.add(new LinkedList<Integer>(levelList));
+            isOrderLeft = !isOrderLeft;
+        }
+        return ans;
+    }
+}