堆 on Coder_Studio

大顶堆+小顶堆-数据流中的中位数

Fri, 16 Jan 2026 20:41:32 +0000

求解代码

private PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,
            b)->(b - a)); //大顶堆存较小的一半
    private PriorityQueue<Integer> minHeap = new PriorityQueue<>((a, b)->(a - b));

    public void Insert(Integer num) {
        if (maxHeap.isEmpty() || num <= maxHeap.peek()) {
            maxHeap.add(num);
        } else {
            minHeap.add(num);
        }
        balance();
    }

    public Double GetMedian() {
        if (maxHeap.size() == minHeap.size()) {
            return (double)((maxHeap.peek() + minHeap.peek()) / 2.0);
        } else {
            return (double)(maxHeap.size() > minHeap.size() ? maxHeap.peek() :
                            minHeap.peek());
        }
    }

    private void balance() {
        if (Math.abs(maxHeap.size() - minHeap.size()) == 2) {
            if (maxHeap.size() > minHeap.size()) {
                minHeap.add(maxHeap.poll());
            } else {
                maxHeap.add(minHeap.poll());
            }
        }
    }

小贴士

1.Java的PriorityQueue默认是小顶堆，这里采用大顶堆maxHeap存储较小的一半，用小顶堆存储较大的一半。

2.(maxHeap.peek() + minHeap.peek()) / 2.0，除以2.0 触发浮点运算，不会丢失小数位

快排思想-寻找第K大

Fri, 16 Jan 2026 07:59:31 +0000

求解代码

private void swap(int[] arr,int i,int j){
        if(i!=j){
            arr[i]^=arr[j];
            arr[j]^=arr[i];
            arr[i]^=arr[j];
        }
    }
    public int findKth (int[] a, int n, int K) {
        K=n-K;

        int low = 0,high = n-1;

        while(low<=high){

            int i = low;

            for(int j=low+1;j<=high;j++){
                if(a[j]<a[low]){
                    swap(a,j,++i);
                }
            }
            swap(a, low, i);
            if(K==i){
                return a[i];
            }else if(K<i){
                high=i-1;
            }else{
                low=i+1;
            }        
        }
        return -1;

    }

小贴士

数组中第K大的数对应的就是数组下标为n-K的数

优先队列-最小的K个数

Fri, 16 Jan 2026 07:58:54 +0000

求解代码

public ArrayList<Integer> GetLeastNumbers_Solution (int[] input, int k) {
        ArrayList<Integer> ans = new ArrayList<>();
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b)->(b - a));

        if (input == null || k <= 0 || input.length == 0) {
            return ans;
        }
        for (int val : input) {
            if (pq.size() < k) {
                pq.add(val);
            } else {
                if (pq.peek() > val) {
                    pq.poll();
                    pq.add(val);
                }
            }
        }

        while (!pq.isEmpty()) {
            ans.add(pq.poll());
        }

        return ans;
    }

小贴士

这里解释一下为什么是 pq.size() < k？

pq.size() < k 意味着只要堆里的元素还没凑够 k 个，就无脑往堆里加元素，不用任何筛选；

当 pq.size() == k 时，堆就「满了」，此时会进入 else 分支，也就是【筛选替换阶段】，堆顶就是「当前筛选出的最小 k 个数的最大值」，这个值就是筛选门槛，所有后续遍历到的数字，都只用和这个「门槛」比较就行。

如果写成了pq.size() <= k，就变成了只要堆里的元素 ≤k 个，就继续往堆里加元素到size=k的时候，size<=k是 true，但是执行 add 之后，下一次循环的判断条件还是pq.size()<=k，此时 size=k，依然是 true，但堆的 size 不会再涨了，堆永远不会进入 else 筛选替换分支，从头到尾只会无脑入堆，else分支里的逻辑完全失效。

双堆法求数据流的中位数

Fri, 24 Oct 2025 20:34:55 +0000

代码逻辑

这道题的关键在于如何在动态添加元素的过程中,快速找到中位数。

我们可以用一个大顶堆(maxHeap)存储较小的一半元素，堆顶是这部分的最大值和一个小顶堆(minHeap)存储较大的一半元素,堆顶是这部分的最小值，这样的话，中位数就在两个堆的堆顶附近!

1.添加元素

添加新元素时，如果大顶堆为空,或新元素 ≤ 大顶堆堆顶 → 放入大顶堆，否则 → 放入小顶堆。如果两个堆的大小差为 2,就从元素多的堆中取出堆顶,放入另一个堆。

2.查找中位数

如果两个堆大小相等 → 中位数 = (大顶堆堆顶 + 小顶堆堆顶) / 2;

如果大小不等 → 中位数 = 元素多的那个堆的堆顶。

代码实现

class MedianFinder {
    private PriorityQueue<Integer> maxHeap;  // 大顶堆,存储较小的一半
    private PriorityQueue<Integer> minHeap;  // 小顶堆,存储较大的一半
    
    public MedianFinder() {
        // Java的PriorityQueue默认是小顶堆,需要自定义比较器实现大顶堆
        maxHeap = new PriorityQueue<>((a, b) -> b - a);
        minHeap = new PriorityQueue<>((a, b) -> a - b);
    }
    
    public void addNum(int num) {
        // 决定新元素放入哪个堆
        if (maxHeap.isEmpty() || maxHeap.peek() >= num) {
            maxHeap.add(num);
        } else {
            minHeap.add(num);
        }
        // 调整两个堆的平衡
        balance();
    }
    
    public double findMedian() {
        if (maxHeap.size() == minHeap.size()) {
            // 偶数个元素,返回两个堆顶的平均值
            return (double) (maxHeap.peek() + minHeap.peek()) / 2;
        } else {
            // 奇数个元素,返回元素多的那个堆的堆顶
            return maxHeap.size() > minHeap.size() ? maxHeap.peek() : minHeap.peek();
        }
    }
    
    private void balance() {
        // 如果两个堆的大小差为2,需要调整
        if (Math.abs(maxHeap.size() - minHeap.size()) == 2) {
            if (maxHeap.size() > minHeap.size()) {
                minHeap.add(maxHeap.poll());
            } else {
                maxHeap.add(minHeap.poll());
            }
        }
    }
}

两种方法解决「将数组和减半的最少操作次数」

Tue, 07 Oct 2025 23:39:44 +0000

解决这个问题的关键是：每次必须选择当前最大的元素减半。

如果要高效地 “每次获取最大元素”，大根堆无疑是最佳选择。

方法 1：用 PriorityQueue 实现

使用 Java 内置的PriorityQueue作为大根堆，直接存储double类型的元素。

public static int halveArray(int[] nums) {
    // 大根堆：通过比较器(b.compareTo(a))实现，确保堆顶是最大元素
    PriorityQueue<Double> heap = new PriorityQueue<>((a, b) -> b.compareTo(a));
    double sum = 0;
    
    // 计算数组总和，并将所有元素加入大根堆
    for (int num : nums) {
        heap.add((double) num);
        sum += num;
    }
    
    // 减少的总量至少为原总和的一半
    sum /= 2;
    int ans = 0;
    double minus = 0; // 累计减少的总量
    
    // 每次取最大元素减半，直到累计减少量≥目标
    while (minus < sum) {
        ans++; // 操作次数+1
        double cur = heap.poll() / 2; // 取出最大元素，减半
        minus += cur; 
        heap.add(cur); // 减半后的元素放回堆中
    }
    
    return ans;
}

方法 2：自定义大根堆（用整数避免浮点数精度问题）

使用自定义的大根堆，并且用long类型存储元素（通过左移 20 位放大元素），避开浮点数精度陷阱。

public int halveArray(int[] nums) {
		int n = nums.length;
		long[] heap = new long[n];
		long sum = 0;

		for (int i = n - 1; i >= 0; i--) {
			// 放大2^20倍（足够覆盖1e9的精度，避免浮点数）
			heap[i] = (long) nums[i] << 20;
			sum += heap[i];
			heapify(heap, n, i);
		}

		sum /= 2;
		int ans = 0;
		long minus = 0;

		while (minus < sum) {
			ans++;
			// 堆顶减半（整数操作，无精度问题）
			heap[0] >>= 1; // 右移1位 = 除以2，比/=2更快
			minus += heap[0];
			// 调整堆顶
			heapify(heap, n, 0);
		}

		return ans;
	}

	private void heapify(long[] heap, int size, int i) {
		// 暂存当前节点值，避免重复访问heap[i]
		long curVal = heap[i];
		// 左孩子索引
		int left = i * 2 + 1;

		while (left < size) {
			// 暂存左孩子值，减少数组访问
			long leftVal = heap[left];
			// 右孩子值：存在则取，不存在则设为极小值（不影响比较）
			long rightVal = (left + 1 < size) ? heap[left + 1] : Long.MIN_VALUE;

			//选左右孩子中更大的那个
			int largerChild = (rightVal > leftVal) ? left + 1 : left;
			long largerVal = (largerChild == left) ? leftVal : rightVal;

			//若当前节点值 >= 较大孩子值，堆结构已满足，退出
			if (curVal >= largerVal) {
				break;
			}

			//直接将较大孩子值覆盖到当前节点
			heap[i] = largerVal;
			// 更新当前节点索引，继续向下调整
			i = largerChild;
			left = i * 2 + 1;
		}

		//将暂存的当前节点值放到最终位置
		heap[i] = curVal;
	}

完整代码 链接：https://pan.quark.cn/s/2ed207e367ac 提取码：3H47

ACM模式经典问题-线段重合

Tue, 07 Oct 2025 12:26:33 +0000

在处理区间问题时，我们经常会遇到需要找出“最多有多少个事件同时发生”的场景。

比如会议室的最大占用数、资源的最大并发访问量等等。

本文分析一道经典的线段重合问题。

代码逻辑

输入输出

public static void main(String[] args) throws IOException {
        // 输入
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        // 输出
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 多组输入：直到读取到文件末尾
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            // 读取线段总数n
            n = (int) in.nval;
            // 读取n条线段的开始和结束位置
            for (int i = 0; i < n; i++) {
                in.nextToken(); // 读取开始位置
                line[i][0] = (int) in.nval;
                in.nextToken(); // 读取结束位置
                line[i][1] = (int) in.nval;
            }
            // 计算最大重合数并输出
            out.println(compute());
        }

        // 关闭流
        out.flush();
        out.close();
        br.close();
    }

compute 方法

    public static int compute() {
        size = 0; // 每次计算前重置堆大小
        // 按线段的「开始位置」升序排序
        Arrays.sort(line, 0, n, (a, b) -> a[0] - b[0]);

        int ans = 0; // 记录最大重合数
        // 遍历每条线段，维护堆并计算重合数
        for (int i = 0; i < n; i++) {
            int curStart = line[i][0]; // 当前线段的开始位置
            int curEnd = line[i][1];   // 当前线段的结束位置

            // 移除堆中「已结束」的线段（堆顶是最早结束的，先判断它）
            // 堆不为空，且堆顶的结束位置 ≤ 当前线段开始位置 → 不重合，弹出
            while (size > 0 && heap[0] <= curStart) {
                pop();
            }

            // 把当前线段的结束位置加入堆（当前线段开始参与重合）
            add(curEnd);

            // 更新最大重合数（堆的大小就是当前重合数）
            ans = Math.max(ans, size);
        }
        return ans;
    }

小根堆的实现

// 新元素向上调整
    public static void add(int x) {
        // 新元素先放到堆的最后一位
        heap[size] = x;
        int i = size++; // i是新元素的初始索引

        // 向上调整：和父节点比较，比父节点小就交换
        // 父节点索引 = (i-1)/2（整数除法，自动向下取整）
        while (heap[i] < heap[(i - 1) / 2]) {
            swap(i, (i - 1) / 2);
            i = (i - 1) / 2; 比较
        }
    }

    // 堆顶（最小值）移除，向下调整
    public static void pop() {
        // 堆顶（索引0）和堆的最后一位元素交换
        swap(0, --size); // 交换后，size-1 → 堆顶元素被“移除”

        int i = 0; // 从堆顶开始向下调整
        int l = 1; // 左孩子索引 = 2*i + 1

        // 向下调整
        while (l < size) {
            // 选左右孩子中「更小」的那个（右孩子存在且更小才选右）
            int best = (l + 1 < size && heap[l + 1] < heap[l]) ? l + 1 : l;

            // 比较“最小孩子”和当前节点
            best = (heap[best] < heap[i]) ? best : i;
            if (best == i) {
                break;
            }

            // 交换当前节点和最优孩子，继续向下调整
            swap(i, best);
            i = best;       
            l = i * 2 + 1;  
        }
    }

完整代码

链接：https://pan.quark.cn/s/7ec0540d754b 提取码：iMn8