2. 程式人生 > 其它 >堆（優先佇列）之習題分析

堆（優先佇列）之習題分析

阿新 • • 發佈：2021-01-07

技術標籤：演算法佇列資料結構演算法java堆疊

堆（優先佇列）之習題分析

一、堆以及優先佇列的概念

（一）、堆的概念

嚴格來講，堆有不同的種類，但是我們在演算法學習中，主要用的還是二叉堆，而二叉堆有最大堆和最小堆之分。

最大（最小）堆是一棵每一個節點的鍵值都不小於（大於）其孩子（如果存在）的鍵值的樹。大頂堆是一棵完全二叉樹，同時也是一棵最大樹。小頂堆是一棵完全完全二叉樹，同時也是一棵最小樹。

需要注意的問題是：堆中的任一子樹也還是堆，即大頂堆的子樹也都是大頂堆，小頂堆同樣。

img

圖一為大頂堆，圖二為小頂堆

（二）、優先佇列——PriorityQueue

1、優先佇列的概念

​ PriorityQueue類在Java1.5中引入。PriorityQueue是基於優先堆的一個無界佇列，這個優先佇列中的元素可以預設自然排序或者通過提供的Comparator（比較器）在佇列例項化的時排序。要求使用Java Comparable和Comparator介面給物件排序，並且在排序時會按照優先順序處理其中的元素。

2、優先佇列的資料結構

​ 優先佇列底層的資料結構其實是一顆二叉堆，優先佇列使用二叉堆的特點，可以使得插入的資料自動排序（升序或者是降序）

​ 二叉堆：

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-djYv4zYK-1609923407678)(https://pics3.baidu.com/feed/f2deb48f8c5494ee1523ac36af9877f899257e14.jpeg?token=43d94f8e2c6a6a839bde47f73f4dc955)]

​ 特點：

  • 二叉堆是一個完全二叉樹
  • 根節點總是大於左右子節點（大頂堆），或者是小於左右子節點（小頂堆）

3、優先佇列的原始碼分析

（1）、屬性
/**
 * 預設初始量
 */
private static final int DEFAULT_INITIAL_CAPACITY = 11;

/**
 * 維持一個佇列：因為基於二叉堆來實現優先佇列，queue[i]的子節點為queue[2*i+1]/queue[2*i+2]
 */
transient Object[] queue; 

/**
 * 優先佇列中元素個數
 */
private int size = 0;

/**
 * 比較器：用於降序或者是比較自定義的物件
 */
private final Comparator<? super E> comparator;

/**
 * 優先佇列的結構：被修改的次數
 */
transient int modCount = 0;
（2）、構造方法
/**
 * 建立一個 PriorityQueue，並根據其自然順序對元素進行排序
 */
public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}

/**
 * 使用指定的初始容量建立一個 PriorityQueue，並根據其自然順序對元素進行排序
 */
public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}

/**
 * 建立包含指定 collection 中元素的 PriorityQueue
 */
public PriorityQueue(Comparator<? super E> comparator) {
    this(DEFAULT_INITIAL_CAPACITY, comparator);
}

/**
 * 使用指定的初始容量建立一個 PriorityQueue，並根據指定的比較器對元素進行排序
 */
public PriorityQueue(int initialCapacity,
                     Comparator<? super E> comparator) {
    if (initialCapacity < 1)
        throw new IllegalArgumentException();
    this.queue = new Object[initialCapacity];
    this.comparator = comparator;
}

/**
 * 建立包含指定 collection 中元素的 PriorityQueue
 */
@SuppressWarnings("unchecked")
public PriorityQueue(Collection<? extends E> c) {
    if (c instanceof SortedSet<?>) {
        SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
        this.comparator = (Comparator<? super E>) ss.comparator();
        initElementsFromCollection(ss);
    }
    else if (c instanceof PriorityQueue<?>) {
        PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
        this.comparator = (Comparator<? super E>) pq.comparator();
        initFromPriorityQueue(pq);
    }
    else {
        this.comparator = null;
        initFromCollection(c);
    }
}

/**
 * 建立包含指定優先順序佇列元素的 PriorityQueue
 */
@SuppressWarnings("unchecked")
public PriorityQueue(PriorityQueue<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initFromPriorityQueue(c);
}

/**
 * 建立包含指定有序set元素的PriorityQueue
 */
@SuppressWarnings("unchecked")
public PriorityQueue(SortedSet<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initElementsFromCollection(c);
}
（3）、常用方法
/**
 * 插入一個元素
 */
public boolean add(E e) {
    return offer(e);
}

/**
 * 插入一個元素
 */
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;
    if (i == 0)
        queue[0] = e;
    else
        siftUp(i, e);
    return true;
}

/**
 * 查詢隊頂元素
 */
@SuppressWarnings("unchecked")
public E peek() {
    return (size == 0) ? null : (E) queue[0];
}

/**
 * 刪除一個元素，並返回刪除的元素
 */
@SuppressWarnings("unchecked")
public E poll() {
    if (size == 0)
        return null;
    int s = --size;
    modCount++;
    E result = (E) queue[0];
    E x = (E) queue[s];
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);
    return result;
}

/**
 * 查詢物件o的索引
 */
private int indexOf(Object o) {
    if (o != null) {
        for (int i = 0; i < size; i++)
            if (o.equals(queue[i]))
                return i;
    }
    return -1;
}

/**
 * 刪除一個元素
 */
public boolean remove(Object o) {
    int i = indexOf(o);
    if (i == -1)
        return false;
    else {
        removeAt(i);
        return true;
    }
}

/**
 * 判斷是否包含該元素
 */
public boolean contains(Object o) {
    return indexOf(o) != -1;
}

二、資料流的中位數

（一）、題目需求

​ 如何得到一個數據流中的中位數？

​ 如果從資料流中讀出奇數個數值，那麼中位數就是所有數值排序之後位於中間的數值。如果從資料流中讀出偶數個數值，那麼中位數就是所有數值排序之後中間兩個數的平均值。

例如，

[2,3,4] 的中位數是 3

[2,3] 的中位數是 (2 + 3) / 2 = 2.5

設計一個支援以下兩種操作的資料結構：

void addNum(int num) - 從資料流中新增一個整數到資料結構中。
double findMedian() - 返回目前所有元素的中位數。
示例 1：

輸入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
輸出：[null,null,null,1.50000,null,2.00000]

示例 2：

輸入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
輸出：[null,null,2.00000,null,2.50000]

限制：

最多會對 addNum、findMedian 進行 50000 次呼叫。

（二）、解法

PriorityQueue<Integer> maxHeap;
PriorityQueue<Integer> minHeap;

/**
 * initialize your data structure here.
 */
public MedianFinder() {
    maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    minHeap = new PriorityQueue<>();
}

public void addNum(int num) {
    if (maxHeap.size() != minHeap.size()) {
        minHeap.add(num);
        maxHeap.add(minHeap.poll());
    } else {
        maxHeap.add(num);
        minHeap.add(maxHeap.poll());
    }
}

public double findMedian() {
    if (maxHeap.size() != minHeap.size()) {
        return minHeap.peek();
    } else {
        return (minHeap.peek() + maxHeap.peek()) / 2.0;
    }
}

（三）、程式碼分析

1、定義大頂堆與小頂堆

大頂堆：儲存輸入資料流中排序後，前半段的元素。堆頂為前半段元素的最後一位元素

小頂堆：儲存輸入資料流中排序後，後半段的元素。堆頂為後半段元素的第一位元素

PriorityQueue<Integer> maxHeap;
PriorityQueue<Integer> minHeap;

2、初始化大頂堆與小頂堆

public MedianFinder() {
    maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    minHeap = new PriorityQueue<>();
}

3、進行元素新增操作，並判斷大頂堆與小頂堆的數量。

（1）、若大頂堆與小頂堆的數量不一致則先將其放入小頂堆中進行排序，小頂堆堆頂元素出佇列，同時小頂堆重新進行排序。出隊的元素進入大頂堆，同時大頂堆重新進行排序。

（2）、若大頂堆與小頂堆的數量一致則先將其放入大頂堆中進行排序，大頂堆堆頂元素出佇列，同時大頂堆重新進行排序。出隊的元素進入小頂堆，同時小頂堆重新進行排序。

public void addNum(int num) {
    if (maxHeap.size() != minHeap.size()) {
        minHeap.add(num);
        maxHeap.add(minHeap.poll());
    } else {
        maxHeap.add(num);
        minHeap.add(maxHeap.poll());
    }
}

4、計算中位數

（1）、若大頂堆與小頂堆的數量不一致，則資料流數量為奇數，中位數為小頂堆的堆頂元素。

（2）、若大頂堆與小頂堆的數量不一致，則資料流數量為偶數，中位數為小頂堆的堆頂元素加上大頂堆的堆頂元素之和/2。

public double findMedian() {
    if (maxHeap.size() != minHeap.size()) {
        return minHeap.peek();
    } else {
        return (minHeap.peek() + maxHeap.peek()) / 2.0;
    }
}

三、第K大元素

（一）、題目需求

在未排序的陣列中找到第 k 個最大的元素。請注意，你需要找的是陣列排序後的第 k 個最大的元素，而不是第 k 個不同的元素。

示例 1:

輸入: [3,2,1,5,6,4] 和 k = 2
輸出: 5

示例 2:

輸入: [3,2,3,1,2,4,5,5,6] 和 k = 4
輸出: 4

說明:

你可以假設 k 總是有效的，且 1 ≤ k ≤ 陣列的長度。

（二）、解法

1、快速佇列

public int findKthLargestQuickSort(int[] nums, int k) {
    if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
        return -1;
    }
    sort(nums, 0, nums.length - 1);
    return nums[nums.length - k];
}

private void sort(int[] arr, int start, int end) {
    if (start >= end) {
        return;
    }
    int left = start;
    int right = end;
    int pivot = arr[start];
    while (left <= right) {
        while (left <= right && arr[left] < pivot) {
            left++;
        }
        while (left <= right && arr[right] > pivot) {
            right--;
        }
        if (left <= right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    sort(arr, start, right);
    sort(arr, left, end);
}

2、快速佇列改進版

public int findKthLargestQuickSort(int[] nums, int k) {
    if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
        return -1;
    }
    return partition(nums, 0, nums.length - 1, nums.length - k);
}

private int partition(int[] arr, int start, int end, int k) {
    if (start >= end) {
        return arr[k];
    }
    int left = start;
    int right = end;
    int mid = start + (end - start) / 2;
    int pivot = arr[mid];
    while (left <= right) {
        while (left <= right && arr[left] < pivot) {
            left++;
        }
        while (left <= right && arr[right] > pivot) {
            right--;
        }
        if (left <= right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    if (k <= right) {
        partition(arr, start, right, k);
    }
    if (k >= left) {
        partition(arr, left, end, k);
    }
    return arr[k];
}

3、優先佇列

public int findKthLargest(int[] nums, int k) {
    if (nums == null || nums.length == 0 || k < 1 || k > nums.length) {
        return -1;
    }
    PriorityQueue<Integer> heap = new PriorityQueue<>();

    for (int num : nums) {
        heap.add(num);
        if (heap.size() > k) {
            heap.poll();
        }
    }
    return heap.peek();
}

（三）、程式碼分析

1、定義並初始化小頂堆優先佇列進行輔助

PriorityQueue<Integer> heap = new PriorityQueue<>();

2、逐個加入佇列中，並進行判斷當前佇列元素數量是否超過k

for (int num : nums) {
    heap.add(num);
    if (heap.size() > k) {
        heap.poll();
    }
}

3、返回第K個大的元素——堆頂元素

return heap.peek();

相關推薦

堆（優先佇列）之習題分析

技術標籤：演算法佇列資料結構演算法java堆疊 堆（優先佇列）之習題分析 一、堆以及優先佇列的概念（一）、堆的概念（二）、優先佇列——PriorityQueue1、優先佇列的概念2、優先佇列的資料結構3、優先佇列的原

資料結構-堆（優先佇列）習題

判斷題 1.任何最小堆的前序遍歷結果是有序的（從小到大）。 TF 2.任何最小堆中從根結點到任一葉結點路徑上的所有結點是有序的（從小到大）。

堆（優先佇列）

std：priority_queue priority_queue允許使用者為佇列中元素設定優先順序，放置元素的時候不是直接放到隊尾，而是放置到比它優先順序低的元素前面，標準庫預設使用<操作符來確定優先順序關係。

c++STL系列之priority_queue（優先佇列）

開頭總結： C++中STL的概念總結： 1、容器 2、迭代器 STL中所有的不同庫都是容器的概念體現，基本操作都是基於迭代器的操作。

ZOJ 2724 Windows Message Queue（優先佇列）

題目連結： ZOJ 2724 Describe: Message queue is the basic fundamental of windows system. For each process, the system maintains a message queue. If something happens to this process, such as mouse

CF446B DZY Loves Modification（優先佇列）

本來想對行列都維護線段樹，然後每次查詢兩棵的最大值，之後進行修改。但是要考慮很多問題，例如最大值相同的時候選哪個，這些細節操作起來十分複雜，我也不知道是否可行

CF1399E1 Weights Division (easy version) （優先佇列）

這種題目很容易就聯想到獨立算貢獻，某條邊的貢獻就是他的權值和底下葉子節點的數量相關。

LeetCode 5638. 吃蘋果的最大數目（優先佇列）

技術標籤：LeetCode 文章目錄 1. 題目2. 解題 1. 題目 有一棵特殊的蘋果樹，一連 n 天，每天都可以長出若干個蘋果。 在第 i 天，樹上會長出 apples[i] 個蘋果，這些蘋果將會在 days[i] 天后（也就是說，第

priority_queue（優先佇列）

技術標籤：C++ 標頭檔案：#include <queue> 宣告格式：priority_queue <> 基本操作：

LeetCode 5673. 移除石子的最大得分（優先佇列）

技術標籤：LeetCode 文章目錄 1. 題目2. 解題2.1 優先佇列2.2 腦筋急轉彎 1. 題目 你正在玩一個單人遊戲，面前放置著大小分別為 a​​​​​​、b 和 c​​​​​​ 的 三堆 石子。

C++ priority_queue（優先佇列）

priority_queue是C++的優先佇列，優先佇列是指具有在出隊時，最高優先順序的元素先出特徵的佇列。

leetcode786. 第 K 個最小的素數分數（優先佇列）

連結：https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/ 題目 給你一個按遞增順序排序的陣列 arr 和一個整數 k 。陣列 arr 由 1 和若干 素數 組成，且其中所有整數互不相同。

劍指offer——資料流中的中位數C++（堆-優先佇列）

技術標籤：劍指Offer#佇列演算法資料結構優先佇列堆劍指offer vector加sort不香嗎，時間複雜度O(nlogn)，實際執行比這個更快誒。雖香但滾。 因為是中位數，所以把左右分成兩塊，左邊是大頂堆，右邊是小頂堆。堆

leetcode215. 陣列中的第K個最大元素（優先佇列 堆 partition減治 快排優化）

連結：https://leetcode-cn.com/problems/kth-largest-element-in-an-array/ 題目： 給定整數陣列 nums 和整數 k，請返回陣列中第 k 個最大的元素。

1049--最後一塊石頭的重量（優先佇列，堆）

題目 有一堆石頭，每塊石頭的重量都是正整數。 每一回合，從中選出兩塊 最重的 石頭，然後將它們一起粉碎。假設石頭的重量分別為 x 和 y，且 x <= y。那麼粉碎的可能結果如下：

牛客每日一題 NC17315揹包 （二分，優先佇列）

https://ac.nowcoder.com/acm/problem/17315 題目描述 Applese有1個容量為v的揹包，有n個物品，每一個物品有一個價值ai，以及一個大小bi 然後他對此提出了自己的疑問，如果我不要裝的物品裝的價值最大，只是一定需要

Jzoj P5830 water （優先佇列BFS）

Description 有一塊矩形土地被劃分成 n*m 個正方形小塊。這些小塊高低不 平，每一小塊都有自己的高度。水流可以由任意一塊地流向周圍四個 方向的四塊地中，但是不能直接流入對角相連的小塊中。 一場大雨後，由於地勢

CSUST 4003-你真的會泡麵嗎？（優先佇列模擬）

題目連結：http://acm.csust.edu.cn/problem/4003 CSDN食用連結：https://blog.csdn.net/qq_43906000/article/details/107739654

Function （思維+優先佇列）

Function 解題思路： 因為 x 是正整數，所以每個 Fi 都必須先分配 xi=1。這時候還剩下 m-n 個 1 沒有分配，採用貪心原則。首先需要先知道對於每一次分配的1，產生的增量為：

uva136醜數（優先佇列法）

題目 醜數指不能被2，3，5整除的數。求生粗排列的第1500個醜數 預備知識： set物件的insert()不去重，count()可以統計出現次數