数据结构——堆

堆是是用完全二叉树实现的一种数据结构，能够以O(1)的时间复杂度查找出当前集合中最小或者最大的那个元素。

jdk中有堆这个数据结构，叫PriorityQueue（优先级队列）

堆的一些基本操作：

1.插入一个数

2.求集合当中的最小值

3.删除最小值

4.删除任意一个元素

5.修改任意一个元素

我们这里使用数组再存储堆。第一个元素（根节点）的下标是1，左孩子节点的下标是2*父节点下标，右孩子节点的下标是2*父节点下标+1（参考完全二叉树的定义）。之所以要将第一个元素的下标设为1，是因为如果下标设为零了，根节点的左孩子的下标计算出来也是0就冲突了。

父节点大于所有的孩子。

堆的两个核心操作：down和up。down就是往下调整，up就是网上调整。

down：假设当前是一个小根堆，当前节点大于孩子，那么就将当前节点和孩子中较小的那一个进行交换。因为根节点一定是是严格大于所有孩子节点的，所以必须与孩子中较小的那一个进行交换。如果与较大的进行交换就会出现交换之后根节点比孩子大的情况。

up：若当前节点大于父节点，交换当前节点与父节点。

1.插入操作：再堆的最后插入x，再进行up操作。heap[++size] = x;up(size)

2.求当前集合中的最小值：heap（1）；

3.删除最小值：将最后一个元素覆盖根节点，size--再对根节点进行down操作（删除最后一个的原因是堆是一个完全二叉树，需要去维护这个性质）heap[1] = heap[size];size--;down(1)

4.删除任意一个元素：heap[k] = heap[size];size--;up(k);down(k);

5.修改任意一个元素：heap[k] = x;down(k);up(k);

实战例题：活动 - AcWing系统讲解常用算法与数据结构，给出相应代码模板，并会布置、讲解相应的基础算法题目。https://www.acwing.com/problem/content/description/840/参考题解：

import java.util.*;
import java.io.*;

public class Main{
    static int N = 100010;
    
    static int[] h = new int[N];
    static int size = 0;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
        String[] strings = br.readLine().split(" ");
        int n = Integer.parseInt(strings[0]),m = Integer.parseInt(strings[1]);
        strings = br.readLine().split(" ");
        for(int i = 0;i<strings.length;i++) {
            h[i + 1] = Integer.parseInt(strings[i]);
        }
        size = n;
        for(int i = n/2;i>0;i--) {
            down(i);
        }
        
        for(int i = 0;i<m;i++) {
            pw.print(h[1] + " ");
            h[1] = h[size];
            size--;
            down(1);
        }
        pw.flush();
    }
    
    public static void down(int i) {
        int t = i;
        if (i * 2 <= size && h[i * 2] < h[i]) {
            t = i * 2;
        }
        if (i * 2 + 1 <= size && h[i * 2 + 1] < h[t]) {
            t = i * 2 + 1;
        }
        if (t != i) {
            int temp =h[i];
            h[i] = h[t];
            h[t] = temp;
            down(t);
        }
    }
}

例题2：模拟堆活动 - AcWing 系统讲解常用算法与数据结构，给出相应代码模板，并会布置、讲解相应的基础算法题目。https://www.acwing.com/problem/content/841/参考代码：

import java.util.*;
import java.io.*;

public class Main {
    static int N = 100010;

    //h数组：堆数组，用来模拟堆
    //ph数组：point to heap 第i个插入的元素在堆中的下标
    //hp数组：heap to point 堆中的第i个元素是第几个插入的
    static int[] h = new int[N],ph = new int[N],hp = new int[N];
    static int size = 0;

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(br.readLine());
        int m = 0;
        for(int i = 0;i<n;i++) {
            String[] strings = br.readLine().split(" ");
            if (strings[0].equals("I")) {
                h[++size] = Integer.parseInt(strings[1]);
                ph[++m] = size;
                hp[size] = m;
                up(size);
            } else if (strings[0].equals("PM")) {
                pw.println(h[1]);
            } else if (strings[0].equals("DM")) {
                headswap(size,1);
                size--;
                down(1);
            } else if (strings[0].equals("D")) {
                int k = Integer.parseInt(strings[1]);
                k = ph[k];
                headswap(size,k);
                size--;
                down(k);
                up(k);
            } else {
                int k = Integer.parseInt(strings[1]);
                int x = Integer.parseInt(strings[2]);
                k = ph[k];
                h[k] = x;
                up(k);
                down(k);
            }
        }
        pw.flush();
    }

    public static void swap(int i,int j,int[] arr) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void headswap(int i,int j) {
        swap(hp[i],hp[j],ph);
        swap(i,j,hp);
        swap(i,j,h);
    }

    public static void down(int i) {
        int t = i;
        if (i * 2 <= size && h[i * 2] < h[i]) {
            t = i * 2;
        }
        if (i * 2 + 1 <= size && h[i * 2 + 1] < h[t]) {
            t = i * 2 + 1;
        }
        if (t != i) {
            headswap(t,i);
            down(t);
        }
    }

    public static void up(int i) {
        while (i/2 != 0 && h[i] < h[i/2]) {
            headswap(i,i/2);
            i = i/2;
        }
    }
}