数据结构算法-堆(Heap)和优先队列

news2024/11/14 15:03:37

堆的概念

堆（heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：

always greater than its child node/s and the key of the root node is the largest among all other nodes. This property is also called max heap property.
always smaller than the child node/s and the key of the root node is the smallest among all other nodes. This property is also called min heap property.

最大堆

最大堆是指在树中，存在一个结点而且该结点有儿子结点，该结点的data域值都不小于其儿子结点的data域值。

最小堆

最小堆是指在树中，存在一个结点而且该结点有儿子结点，该结点的data域值都不大于其儿子结点的data域值。

堆的操作

Heapify

Heapify is the process of creating a heap data structure from a binary tree. It is used to create a Min-Heap or a Max-Heap.

heapify是将heap调整为最大堆或最小堆的过程，我们以最大堆为例，演示调整过程。

找到最后一个非叶子节点

heapify是从当前最后一个非叶子结点开始，一直向下到0.

如何找到最后一个非叶子节点

一个数组（假设长度为n）构成的完全二叉树，index表示节点索引索引,

个人理解：叶节点的数量大致为其父节点的2倍（子节点最多两个子节点，假设为满完全二叉树)，最后一个节点约等于叶节点的第一个节点(约为n/2)-1: 大致为n/2-1

叶节点和（假设四层）约等于 (1,2,3)层之和

编号	层(k)	索引(index)	层和索引	n和索引
1	1	0	2^k-1-1
2	2	1,2	2^k-1-1, 2^k-1	节点2:(6/2)-1 =2
3	3	3,4,5,6	2^k-1-1	节点6（假设有): 15/2-1=6
4	4	7,8,9,10,11,12,13,14

设置当前的为最大元素

int largest = i;
int len = size;  // 数组实际长度
//3. 计算当前节点的左子节点，和右子节点
int left = 2 * i + 1;   //左子节点位置
int right = 2 * i + 2;  //右子节点位置
right = Math.min(right,elements.length-1);

当前节点与左子和右子比较，找到最大值

// 3.1比较左子节点
if (left<size && elements[left] > elements[largest]) {
    largest = left;
}
if (right<size && elements[right] > elements[largest]) {
    largest = right;
}

与当前节点交换最大值

//交换largset
int tmp = elements[largest];
elements[largest] = elements[i];
elements[i] = tmp;
//用户当前节点递归heapify
heapify(largest);

从最后一个非叶子结点开始

从最后一个非叶节点依次递减到0，循环执行以上步骤

for(int i = elements.length/2-1; i>=0;i++){
    heapify(i);
}

heapify完整代码

public void heapify(int curr) {
    //1.找到最后一个非叶节点
    int len = elements.length;
    System.out.println("curr: " + curr);
    //2. 设置当前节点为最大节点
    int largest = curr;

    //3. 计算当前节点的左子节点，和右子节点
    int left = 2 * curr + 1;
    int right = 2 * curr + 2;

    // 3.1比较左子节点
    if (left < size && elements[left] > elements[largest]) {
        largest = left;
    }
    if (right < size && elements[right] > elements[largest]) {
        largest = right;
    }

    //交换largset
    if (largest != curr) {
        int tmp = elements[largest];
        elements[largest] = elements[curr];
        elements[curr] = tmp;
       // 递归地heapify受影响的子树（以新的最大值节点为根）  
       // 这会确保子树也保持最大堆的性质 
        heapify(largest);
    }
}

在堆中添加数据

public void insert(int data) {
    if (size == 0) {
        elements[size++] = data;
    } else {
        elements[size++] = data;
        for (int i = size / 2 - 1; i >= 0; i--) {
            heapify(i);
        }
    }
}

添加第一个数: 1

添加第二个数: 9

第二个数9作为1的左子节点进行比较大于1，交换两个值，largest=1

添加第三个数: 5

5作为第三个数，与它的父节点9比较，小于父节点，所以不做交换。

添加第四个数: 4

第四个节点按照完全二叉树的定义从左向右添加,作为节点(值=1)的子节点。需要heapify(), 节点(值=4)与节点(值=1)进行交换。

删除堆中的元素

选取要删除的元素

int wantedDelIndex;
for(wantedDelIndex =0; wantedDelIndex < size;wantedDelIndex++){
    if(data == elements[wantedDelIndex]) break;
}

将当前元素与最后一个元素交换

/*
  将要删除的元素与最后一个叶节点元素交换
 */
int tmp = elements[wantedDelIndex];
elements[wantedDelIndex] = elements[size-1];
elements[size-1] = tmp;

删除最后一个叶节点

heapify

调用heapify()方法

力扣“前K个高频元素”

https://leetcode.cn/problems/top-k-frequent-elements/description/
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

使用Map存储每个元素的值和出现频率，再将Map中的Map.entry对象放入，注意： Map.entry对象已经实现了Comparator方法，即可以存入优先队列（优先队列的底层由最小堆完成）. 以下给出自己的参考实现。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(Map.Entry.comparingByValue());
        for (int t : nums) {
            map.merge(t, 1, Integer::sum);
        }
        queue.addAll(map.entrySet());
        int n = map.size();
        int[] a = new int[k];
        for (int i = 0; i < n - k; i++) {
            queue.poll();
        }
        for (int i = 0; i < k; i++) {
            a[i] = Objects.requireNonNull(queue.poll()).getKey();
        }
        return a;
    }
}