7.7 栈 堆

src/main/java/binary_search/FindMedianSortedArrays.java

@@ -17,6 +17,7 @@ package binary_search;
 //二刷不会
 public class FindMedianSortedArrays {
 
+
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
         int length1 = nums1.length, length2 = nums2.length;
         int totalLength = length1 + length2;

src/main/java/heap/FindKthLargest.java

@@ -15,8 +15,10 @@ import java.util.PriorityQueue;
 
  * 链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/
  */
+//二刷不会  背一下堆的创建  快速选择
 public class FindKthLargest {
-    //完全填满堆再删除元素  最大堆
+
+    //完全填满堆再删除元素  最大堆 O(nlogn)
     public int findKthLargest1(int[] nums, int k) {
         PriorityQueue<Integer>maxheap=new PriorityQueue<>(Comparator.reverseOrder());
         for (int num : nums) {
@@ -28,6 +30,7 @@ public class FindKthLargest {
         return maxheap.peek();
     }
     //使用最小堆来存储前 k 个最大的元素。堆顶元素是 k 个最大元素中的最小值。这样，堆的大小始终保持为 k。当堆的大小大于 k 时，弹出堆顶元素。最终堆顶元素就是第 k 大的元素。不需要完全填满堆再删除元素：
+    // O(nlogk)
     public int findKthLargest2(int[] nums, int k) {
         // 使用最小堆
         PriorityQueue<Integer> minHeap = new PriorityQueue<>();
@@ -47,7 +50,7 @@ public class FindKthLargest {
         // 返回堆顶元素，即为第 k 大的元素
         return minHeap.peek();
     }
-    //快速选择
+    //快速选择 O(n)
     public int quickselect(int[] nums, int l, int r, int k) {
         // 当区间内只有一个元素时，直接返回该元素
         if (l >= r) {

src/main/java/heap/KSmallestPairs.java

@@ -19,17 +19,16 @@ import java.util.PriorityQueue;
  * 链接：https://leetcode.cn/problems/find-k-pairs-with-smallest-sums/
  */
 //有思路 但是超出时间限制，需要优化
+//二刷不会优化
 public class KSmallestPairs {
+
     /**
      * 可以把所有可能的组合看作一个虚拟的二维矩阵：
-     *
      * 行代表 nums1[i]
      * 列代表 nums2[j]
      * 每个点 (i,j) 对应的值是 nums1[i] + nums2[j]
      * 这个矩阵的特点是：从左到右、从上到下递增，因为两个数组都升序。
-     *
      * 我们不需要全部生成矩阵，而是只维护当前“最小的候选对”，类似 Dijkstra 算法或 BFS：
-     *
      * 初始时，把前 k 行的第一列（即 (nums1[i], nums2[0])）放入堆中。因为后面的列比前面的大，我们先选列头。
      * 每次弹出堆顶（最小的和），把它加入结果列表。
      * 如果该对还有下一列（即 (i, j+1) 存在），就把 (i, j+1) 加入堆，作为下一个候选。
@@ -45,26 +44,25 @@ public class KSmallestPairs {
         // 边界处理：任一数组为空 或 k==0，直接返回空结果
         if (nums1.length == 0 || nums2.length == 0 || k == 0) return res;
 
-        // 小顶堆，存储的是每对数的索引 [i, j]，按对应的和升序排列
+        // 小顶堆，存储的是每对数的索引 [i, j]，按对应的和 升序排列
         PriorityQueue<int[]> minHeap = new PriorityQueue<>(
                 (a, b) -> nums1[a[0]] + nums2[a[1]] - nums1[b[0]] - nums2[b[1]]
         );
 
-        // 初始化：将 nums1 的前 k 个元素与 nums2[0] 组成的数对放入堆中
+        // 初始：把每一行的第 0 列（最多 k 行）加入堆
-        // 因为只推进列，所以只需要每一行的第一个元素
         for (int i = 0; i < Math.min(nums1.length, k); i++) {
             minHeap.offer(new int[]{i, 0});  // i 表示 nums1 的索引，j=0 是固定的起点
         }
 
-        // 取出堆顶最小的数对，直到取满 k 个或者堆空为止
+        // 取最小的 k 对
         while (k-- > 0 && !minHeap.isEmpty()) {
-            int[] pos = minHeap.poll();  // 当前最小的数对在 nums1[pos[0]], nums2[pos[1]]
+            int[] idx = minHeap.poll();
-            int i = pos[0], j = pos[1];
+            int i = idx[0], j = idx[1];
 
             // 把数对值加入结果集
             res.add(List.of(nums1[i], nums2[j]));
 
-            // 如果当前数对还有下一列，就推进下一列（仍然在第 i 行）
+            // 推入同一行的下一列  若这一行所有可能的列都已被消费完了，就不再往堆里推新的 (i, j+1)
             if (j + 1 < nums2.length) {
                 minHeap.offer(new int[]{i, j + 1});
             }

src/main/java/heap/TopKFrequent.java

@@ -14,10 +14,46 @@ import java.util.PriorityQueue;
 
  * 链接：https://leetcode.cn/problems/top-k-frequent-elements/
  */
+// 二刷不会
 public class TopKFrequent {
+
     public int[] topKFrequent(int[] nums, int k) {
+        HashMap<Integer,Integer> map=new HashMap<>();
+        int cnt=0;
+        PriorityQueue<int[]> minHeap=new PriorityQueue<>(  //小根堆
+                (a,b) -> a[1]-b[1]
+        );
+        int[] temp;
+        int[] res=new int[k];
+        for (int i = 0; i < nums.length; i++) {
+            int cur=nums[i];
+            map.put(cur, map.getOrDefault(cur,0)+1);
+        }
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            if(cnt<k){
+                minHeap.add(new int[]{entry.getKey(),entry.getValue()});
+                cnt++;
+            }else {
+                temp=minHeap.peek();
+                if(entry.getValue()>temp[1]) {
+                    minHeap.poll();
+                    minHeap.add(new int[]{entry.getKey(),entry.getValue()});
+                }
+            }
+        }
+        cnt=0;
+        for (int[] ints : minHeap) {
+            res[cnt++]=ints[0];
+        }
+        return res;
+    }
+
+
+
+
+    public int[] topKFrequent2(int[] nums, int k) {
         HashMap<Integer,Integer>map=new HashMap<>();
-        PriorityQueue<int[]> minHeap = new PriorityQueue<>(
+        PriorityQueue<int[]> maxHeap = new PriorityQueue<>(    //大根堆
                 (a, b) -> b[1] - a[1]);
         int[] res=new int[k];
         int i=0;
@@ -28,11 +64,11 @@ public class TopKFrequent {
                 map.put(num,map.get(num)+1);
         }
         for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            minHeap.add(new int[]{entry.getKey(),entry.getValue()});
+            maxHeap.add(new int[]{entry.getKey(),entry.getValue()});
         }
-        while (!minHeap.isEmpty()) {
+        while (!maxHeap.isEmpty()) {
             if(i<k)
-                res[i++] = minHeap.poll()[0];
+                res[i++] = maxHeap.poll()[0];
             else break;
         }
         return res;

src/main/java/stack/DailyTemperatures.java

@@ -14,8 +14,28 @@ import java.util.Deque;
  * 链接：https://leetcode.cn/problems/daily-temperatures/
  */
 //第一次做没想到怎么利用栈
+//二刷会做
 public class DailyTemperatures {
     public int[] dailyTemperatures(int[] temperatures) {
+        int n = temperatures.length;
+        int[] ans = new int[n];                // 默认全 0，不用后面再填
+        Deque<Integer> stack = new ArrayDeque<>();
+
+        for (int i = 0; i < n; i++) {
+            // 只要栈不空，且当前温度更高，就把栈顶结算出来
+            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
+                int prev = stack.pop();
+                ans[prev] = i - prev;
+            }
+            stack.push(i);
+        }
+
+        // 剩下的索引对应的 ans 已经是 0 了（Java 数组默认值）
+        return ans;
+    }
+
+
+    public int[] dailyTemperatures1(int[] temperatures) {
         // 结果数组，初始化为全零
         int[] result = new int[temperatures.length];
 

src/main/java/stack/DecodeString.java

@@ -3,6 +3,7 @@ package stack;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.LinkedList;
+import java.util.Stack;
 
 /**
  * 题目： 394. 字符串解码 (decodeString)
@@ -18,8 +19,10 @@ import java.util.LinkedList;
  * 链接：https://leetcode.cn/problems/search-in-rotated-sorted-array/
  */
 //不会 有难度！
+//二刷不会
 public class DecodeString {
-    //s = "3[a]2[bc]"   "3[a2[c]]"
+
+//    s = "3[a]2[bc]"   "3[a2[c]]"
     public String decodeString(String s) {
         // 定义两个栈
         Deque<Integer> countStack = new LinkedList<>();

src/main/java/stack/IsValid.java

@@ -16,7 +16,10 @@ import java.util.HashMap;
  *
  * 链接：https://leetcode.cn/problems/valid-parentheses/
  */
+//二刷会做
 public class IsValid {
+
+
     public boolean isValid(String s) {
         // 如果长度为奇数，直接返回 false
         int sz = s.length();

src/main/java/stack/LargestRectangleArea.java

@@ -16,94 +16,151 @@ import java.util.Deque;
  * 链接：https://leetcode.cn/problems/largest-rectangle-in-histogram/
  */
 //初见不会
+//二刷不会
 public class LargestRectangleArea {
-    //暴力法 依次遍历柱形的高度，对于每一个高度分别向两边扩散，求出以当前高度为矩形的最大宽度多少。
-    public int largestRectangleArea1(int[] heights) {
-        int len = heights.length;
-        // 特判
-        if (len == 0) {
-            return 0;
-        }
 
-        int res = 0;
+//    public int largestRectangleArea(int[] heights) {
-        for (int i = 0; i < len; i++) {
+//        int len=heights.length;
+//        int[] leftIndex=new int[len],rightIndex=new int[len];
+//        leftIndex[0]=-1;
+//        rightIndex[len-1]=len;
+//        for (int i = 1; i < len; i++) {
+//            int cur=heights[i];
+//            int left=i-1;
+//            //向左找到第一个小于cur的index
+//            while (left>=0 && cur<=heights[left]){
+//                left=leftIndex[left];
+//            }
+//            leftIndex[i]=left;
+//        }
+//        for (int i = len-2; i >=0 ; i--) {
+//            int cur=heights[i];
+//            int right=i+1;
+//            while (right<len && cur<=heights[right])
+//                right=rightIndex[right];
+//            rightIndex[i]=right;
+//        }
+//        int max=Integer.MIN_VALUE;
+//        for (int i = 0; i < len; i++) {
+//            max=Math.max(max,(rightIndex[i]-leftIndex[i]-1)*heights[i]);
+//        }
+//        return max;
+//    }
 
-            // 找左边最后 1 个大于等于 heights[i] 的下标
+    /**
-            int left = i;
+     * 暴力法
-            int curHeight = heights[i];
+     * 对于每一个柱子 i，当做“最低高度”，向左扫描找到第一个高度比它小的位置 left，
-            while (left > 0 && heights[left - 1] >= curHeight) {
+     * 向右扫描找到第一个比它小的位置 right，那么以它为高的最大矩形宽度就是 right–left–1，面积就是 heights[i] * (right - left - 1)。
-                left--;
+     */
-            }
+//    public int largestRectangleArea1(int[] heights) {
-
+//        int len = heights.length;
-            // 找右边最后 1 个大于等于 heights[i] 的索引
+//        // 特判
-            int right = i;
+//        if (len == 0) {
-            while (right < len - 1 && heights[right + 1] >= curHeight) {
+//            return 0;
-                right++;
+//        }
-            }
+//
-
+//        int res = 0;
-            int width = right - left + 1;
+//        for (int i = 0; i < len; i++) {
-            res = Math.max(res, width * curHeight);
+//
-        }
+//            // 找左边最后 1 个大于等于 heights[i] 的下标
-        return res;
+//            int left = i;
-    }
+//            int curHeight = heights[i];
-    //动态规划 暴力解优化
+//            while (left > 0 && heights[left - 1] >= curHeight) {
-    public int largestRectangleArea2(int[] heights) {
+//                left--;
-        int size = heights.length;
+//            }
-        int[] minLeftIndex = new int[size];
+//
-        int[] minRightIndex = new int[size];
+//            // 找右边最后 1 个大于等于 heights[i] 的索引
-
+//            int right = i;
-        // 记录每个柱子左边第一个小于该柱子的下标
+//            while (right < len - 1 && heights[right + 1] >= curHeight) {
-        minLeftIndex[0] = -1; // 初始化，防止死循环
+//                right++;
-        for (int i = 1; i < size; i++) {
+//            }
-            int t = i - 1;
+//
-            // 不断向左寻找，直到找到第一个小于当前柱子的柱子
+//            int width = right - left + 1;
-            while (t >= 0 && heights[t] >= heights[i]) {
+//            res = Math.max(res, width * curHeight);
-                t = minLeftIndex[t]; // 更新为左边第一个小于当前柱子的下标
+//        }
-            }
+//        return res;
-            minLeftIndex[i] = t;
+//    }
-        }
+//
-
+//
-        // 记录每个柱子右边第一个小于该柱子的下标
+//    /**
-        minRightIndex[size - 1] = size; // 初始化，防止死循环
+//     * 动态规划 暴力解优化
-        for (int i = size - 2; i >= 0; i--) {
+//     * 预先为每根柱子 i 计算出：
-            int t = i + 1;
+//     * minLeftIndex[i]：右边第一个小于它的柱子的下标
-            // 不断向右寻找，直到找到第一个小于当前柱子的柱子
+//     * minRightIndex[i]：左边第一个小于它的柱子的下标
-            while (t < size && heights[t] >= heights[i]) {
+//     * 计算完后，对于每个 i，它能扩展的最大宽度就是 (minRightIndex[i] - minLeftIndex[i] - 1)，面积同理用高度乘宽度即可。
-                t = minRightIndex[t]; // 更新为右边第一个小于当前柱子的下标
+//
-            }
+//     */
-            minRightIndex[i] = t;
+//    public int largestRectangleArea2(int[] heights) {
-        }
+//        int size = heights.length;
-
+//        int[] minLeftIndex = new int[size];
-        // 计算最大矩形面积
+//        int[] minRightIndex = new int[size];
-        int result = 0;
+//
-        for (int i = 0; i < size; i++) {
+//        // 记录每个柱子左边第一个小于该柱子的下标
-            int width = minRightIndex[i] - minLeftIndex[i] - 1;
+//        minLeftIndex[0] = -1; // 初始化，防止死循环
-            int area = heights[i] * width;
+//        for (int i = 1; i < size; i++) {
-            result = Math.max(result, area);
+//            int t = i - 1;
-        }
+//            // 不断向左寻找，直到找到第一个小于当前柱子的柱子
-
+//            while (t >= 0 && heights[t] >= heights[i]) {
-        return result;
+//                t = minLeftIndex[t]; // 更新为左边第一个小于当前柱子的下标
-    }
+//            }
-    //单调栈
+//            minLeftIndex[i] = t;
+//        }
+//
+//        // 记录每个柱子右边第一个小于该柱子的下标
+//        minRightIndex[size - 1] = size; // 初始化，防止死循环
+//        for (int i = size - 2; i >= 0; i--) {
+//            int t = i + 1;
+//            // 不断向右寻找，直到找到第一个小于当前柱子的柱子
+//            while (t < size && heights[t] >= heights[i]) {
+//                t = minRightIndex[t]; // 更新为右边第一个小于当前柱子的下标
+//            }
+//            minRightIndex[i] = t;
+//        }
+//
+//        // 计算最大矩形面积
+//        int result = 0;
+//        for (int i = 0; i < size; i++) {
+//            int width = minRightIndex[i] - minLeftIndex[i] - 1;
+//            int area = heights[i] * width;
+//            result = Math.max(result, area);
+//        }
+//
+//        return result;
+//    }
+//
+    /**
+     * 单调栈解法思路：
+     * - 使用一个栈保存柱子的索引，栈内对应的高度单调递增。
+     * - 遍历每个柱子 i：
+     *     - 当当前柱子高度小于栈顶高度时，说明以栈顶柱子为高的矩形在 i 处结束：
+     *         pop 出栈顶 prev，计算宽度为 i - stack.peek() - 1，面积 = heights[prev] * width。
+     *     - 重复上述步骤，直到栈空或栈顶高度不超过当前高度。
+     *     - 将当前索引 i 压入栈中。
+     * - 遍历结束后，栈中仍有索引，依次弹出并计算：
+     *     宽度 = n - stack.peek() - 1。
+     * - 时间复杂度 O(n)，空间复杂度 O(n)。
+     */
     public int largestRectangleArea(int[] heights) {
-        Deque<Integer>stack=new ArrayDeque<>();
+        int n = heights.length;
-        int max=Integer.MIN_VALUE;
+        Deque<Integer> stack = new ArrayDeque<>();
+        // 先放一个哨兵，方便计算宽度
         stack.push(-1);
-        for (int i = 0; i < heights.length; i++) {
+        int maxArea = 0;
-            while(stack.size()>=2 && heights[i]<heights[stack.peek()]){
+        for (int i = 0; i < n; i++) {
-                int cur=stack.pop();
+            // 当前高度小于栈顶高度时，栈顶矩形结束
-                int width=i-stack.peek()-1;
+            while (stack.peek() != -1 && heights[i] < heights[stack.peek()]) {
-                if(max<width*heights[cur])
+                int prev = stack.pop(); // 栈顶索引
-                    max=width*heights[cur];
+                int width = i - stack.peek() - 1; // 计算以 heights[prev] 为高的宽度
+                maxArea = Math.max(maxArea, heights[prev] * width);
             }
             stack.push(i);
         }
-        while(stack.size()>=2){
+        // 处理剩余索引
-            int cur=stack.pop();
+        while (stack.peek() != -1) {
-            int width=heights.length-stack.peek()-1;
+            int prev = stack.pop();
-            if(max<width*heights[cur])
+            int width = n - stack.peek() - 1;
-                max=width*heights[cur];
+            maxArea = Math.max(maxArea, heights[prev] * width);
         }
-        return max;
+        return maxArea;
     }
 }

src/main/java/实现类功能/MinStack.java

@@ -1,4 +1,4 @@
-package stack;
+package 实现类功能;
 
 import java.util.Stack;
 
@@ -15,6 +15,7 @@ import java.util.Stack;
  *
  * 链接：https://leetcode.cn/problems/min-stack/description/
  */
+//二刷不会
 public class MinStack {
 
     private Stack<Integer> stack;      // 主栈