数据结构与算法实战 5.1堆（优先队列 二叉堆）

*****优先队列与集合****
**优先队列** priority_queue
优先队列：对元素进行优先级的区分，入队没有要求，出对的时候按照优先级出队
数组、链表、二叉树、二叉搜索树 都可以做成优先队列。
但是他们各有各的优缺点，如图所示：

更好的实现方案？如图

 

 

所示：

 

 

 

 

课程地址：
https://www.icourse163.org/learn/QDU-1206503801?tid=1464154451#/learn/content?type=detail&id=1242523902&cid=1265642403&replay=true
*******代码实现*******
*******注意 下面实现的是小顶堆******
//2020.12.27 代码可能有注释不够清楚的地方，请参考青岛大学周强老师的《数据结构实战》,下次复习时候我再更新代码。#include<stdlib.h>
#include<cstdio>
#include<cstdlib>//引入free函数 销毁malloc申请的内存空间

typedef int Elem;

/*写在最前面：我们所学的是二叉堆（用完全二叉树（数组）储存）
  但是我们还有二项堆、Fib堆，这两种堆就不是用完全二叉树实现的
  二叉堆只是prorityqueue这个结构实现的一种方式，而不是说优先队列等同于二叉堆
  priortiyqueue还能用二项堆、avl树、线段树还有二进制分组的vector实现 
*/ 
/*
堆的其他操作：
全部操作都首先要看这个堆是最大堆还是最小堆，细节上有些差异 
1.提高元素优先级:提高优先级 + percolateup(因为提高优先级之后，这个位置不合适了，向上过滤） 
2.降低元素优先级：降低优先级 + percolatedown(和提高优先级的的理由一致) 
3.删除元素（不是堆顶的元素）: 欲想让其灭亡，先让其膨胀，不是堆顶就提高它的优先级变成堆顶，那么我们的操作就变成了删除堆顶hh 
*/
struct heap{
    //暂时用int代替Elem 
    //动态分配空间 
    Elem *data;
    int capcity;
    int size;
};

typedef struct heap* Heap;

Heap initHeap(int max){
    Heap h;
    h = (Heap)malloc(sizeof(struct heap));
    //不够内存分配时候 
    if(h == 0) return NULL;
    h->data = (Elem*)malloc(sizeof(Elem)*(max+1));
    if(h->data == 0) return NULL;
    h->size = 0;
    return h;
//free自己写 
}

void printHeap(Heap h){
//为了方便查找，0号位置不放东西 
    for(int i = 1; i <= h->size; i ++){
        printf("%d ",h->data[i]);
    }    
    putchar('\n');
}

bool isEmpty(Heap h){
    return h->size == 0; 
}
bool isFull(Heap h){
    return h->capcity == h->size;
}

//建立小顶堆 
//从位置k开始向上过滤 
//向上渗透一直到堆顶为止，或者直至它的上一个元素不大于它为止 
void percolateUp(int k, Heap h){
    Elem x;
    x = h->data[k];
    //父子相比大小,最后如果到了树根，就没法再往上走了,不用再和父亲比了，父亲是0号位置
    //当然与0号位置相比可以采取“哨兵”的做法,我们这个程序不采用这样的写法 
    //另外,i是要继续用的，所以不能定义为for的局部变量 
    //循环判断条件解释:=1时为树根，小于父亲节点时候进行交换 
    int i;
    for(i = k; i > 1 && h->data[i] < h->data[i/2];i = i / 2){
        //将小于x的父亲节点数据copy到这个位置
        //我们不需要临时变量保存它，因为开头x就是临时变量 
        h->data[i] = h->data[i/2];
    }
    //出来循环有两种情况： i到了树根位置 or 父亲节点比x小
    //pps:我们当前的堆以最小堆为样例
    h->data[i] = x; 
}
//因为可能会失败，用boolean作为返回值
//插入的元素，插入的位置 
bool insertHeap(Elem x, Heap h){
    if(isFull(h)) return false;
    //size从0开始增长，可不就是++size的地方开始存放元素嘛 
    h->data[++h->size] = x;
    percolateUp(h->size, h);
    return true;
}

/*删除操作：堆顶元素为最大或者最小 所以删除显然是删除堆顶比较方便
  本测试程序中以最小堆为示例，删除最小的元素 
  考虑堆是空的时候，抛出异常 
*/
/*如果是删除堆顶这个位置，会导致堆顶空了一个位置，接着堆顶这个空位会与它的
  左儿子和右儿子进行交换，把这个空位给交换下去，导致一块地方给空了出来 
  最终会破坏掉整棵完全二叉树的结构
  （二叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最大个数，第k 层所有的结点都连续集中在最左边，这就是完全二叉树） 
   那么我们可以交换最后一个元素和堆顶元素的位置，这样删除的就是最后一个元素的位置
   和堆顶的值，交换之后向下渗透就完事 
*/
 
//由于向上想下过滤并不一定只是适用于最后一个位置/最开始的位置 (比如堆排序.)
//所以我们在参数里面考虑用int k来指明位置
void percolateDown(int k, Heap h){
    //向下渗透
    Elem x;
    x = h->data[k];
    /*****/
    printf("已经保存的临时变量为：%d,从x:%d开始过滤\n",h->data[k],h->data[k]);
    printf("当前h:");
    for(int i = 1; i <= h->size; i ++){
        printf("%d ",h->data[i]);
    }
    putchar('\n');
    /*****/
//用i获取位置
//循环终止条件：没有儿子当然要停下来啦，当你比下一步的儿子还小的时候当然也要停下来啦
//i需要用来查看停止位置即原先第k号元素应该放的新位置
//所以i必须是一个for外面的变量 
    int i,child;

//疑惑：i*2=h->size的时候，下面语句中child++也就是i*2+1不会越界？？？ 
//2021.7.25 听课不够认真。。。下面已经用child!=h->size限制了越界 不可能会发生越界的
    for(i = k; i*2 <= h->size; i = child){
//为什么在for里面不直接像percolateUp那样同理赋值成一个特定的儿子？
//因为我们在（小顶堆）向下过滤的时候，我们要找的是小儿子进行替换，而不是有儿子就进行替换
        //先看左儿子  在下标1 2 3 4...这样顺序的情况下，完全二叉树的i节点的左右儿子位置为i*2 i*2+1 父节点位置i/2 
        //需不需要写成移位加快速度？不论是i+i，还是i*2，现在编译器都会优化成i<<1 左移，所以i+i 和i*2都可以
        child = i * 2;
        //注意越界
        //判断条件解释：child不是最后一个，左儿子大于右儿子 
        /*****/
        printf("左儿子：%d，右儿子:%d\n",h->data[i*2],h->data[i*2+1]);
        /*****/
        //不能直接写h->data[child] < h->data[child + 1]，因为可能会越界
        //用child!=h->size就能判断child不是堆h的最后一个元素，只要不是最后一个元素，child++就不会越界
        //最大child = h->size - 1的时候，child++刚好是最后一个元素
        //pps:child 左儿子 child+1就是右儿子嘛 
        //这个判断语句帮忙找出左儿子和右儿子哪个比较小 
        if(child != h->size && h->data[child] > h->data[child+1]){
            //更小的是右儿子 
            //否则就是维持默认的最小是左儿子，上面child的缺省值为i*2（左儿子）
            child ++; 
        }
        /****/
        printf("当前比较小的是：%d\n",h->data[child]); 
        /****/ 
        //i位置的数据大于小儿子 因为这个是最小堆 所以小儿子要往上挪 
        if(h->data[i] > h->data[child]){
            /***/
            printf("i位置元素：%d大于小儿子，小儿往上挪",h->data[i]);
            /***/
            h->data[i] = h->data[child];
        }else{//只要没有发生交换 就已经可以停止了
            break;
        } 
        /****/
        printf("当前h:");
        printHeap(h);
        /****/
    }
//出来以后，i到了叶节点 要么i处于比小儿子还小的位置上 
    /***/
    printf("最终i的位置为：%d\n",i);
    printf("x为：%d",x);
    /***/
    h->data[i] = x;
}

//参数：返回删除的元素，指定堆
//C语言没有异常的机制，需要一个返回值来确认是否成功
//删除的堆可能会是空的，就会异常，所以不直接用返回值来作为删除掉的元素
int removeHeap(Elem *px, Heap h){
    if(isEmpty(h)) return 0;//堆是空的，返回0
    *px = h->data[1];//堆顶元素存到*px中
    h->data[1] = h->data[h->size];//用最后一个元素上去顶替1号位置的堆顶 
    h->size --;//删除了少了一个
    percolateDown(1,h);//把堆顶向下过滤 
    return 1;
}

//参数：指定列表？size?堆的最大容量
Heap buildHeap(Elem *a, int size, int max){
    Heap h;
    h = initHeap(max);
    //h为空 
    if(!h) return NULL;
    h->size = size;
    //不需要写h->capacity = max 因为initHeap里面已经有了
    for(int i = 1; i <= size; i ++){//谨记 为了找父节点和儿子节点方便 我们是不用0号位置的
    //a是从0开始的 堆是从1开始的！！！
        h->data[i] = a[i - 1];
        printf("a[%d]:%d\n",i-1,a[i - 1]);
        printf("h->data[%d]:%d\n",i,a[i - 1]);
    }
    //size / 2是最后一个节点的父亲，所以i=size/2就是找到最后一个有儿子的结点
    //ppps:找父亲 i/2 找左节点 i*2 找右节点i*2 + 1
    //放进去之后开始调整元素的顺序
    //从什么地方开始调？最后一个有儿子的元素向下过滤
    //不停地往上找父节点进行向下过滤,树根1号位置的数据可能也要调整，将所有的树调整为最小堆 
    //最后一个元素为h->data[size],那么它的父节点就是size/2 
    for(int i = size / 2; i > 0; i --){
        percolateDown(i, h); 
    }
    return h; 
}

void destroy(Heap h){
    free(h);
}

int main(){
    /*调试堆的代码*/ 
    Heap h;
    h = initHeap(10);
    insertHeap(20,h);
    printHeap(h);
    insertHeap(10,h);
    printHeap(h);
    insertHeap(5,h);
    printHeap(h);
    insertHeap(15,h);
    insertHeap(30,h);
    insertHeap(18,h);
    printHeap(h);
    Elem x;
    removeHeap(&x,h); 
    printf("%d\n",x);
    printHeap(h); 

/*****基于一个列表创建堆*****
给出列表:90 20 70 10 30 40 15 25 35 45 11 80
创建最小堆
创建空堆O(logN)，然后放进去 O(N)
总体效率为O(N*logN)
实际上我们还可以简化为O(N)的效率
分析一下：上面慢在哪里？因为每个元素插入都是放在最后面，要往上走最多要O(logN)
        后来会越来越多元素，就越来越慢,我们就发现叶子点占据的操作时间非常多
        能不能让这些数量最多的点的操作用的时间更少？
        我们可以认为，叶子节点已经是一个堆，因为一个元素嘛，不论最大最小都是一个堆了，
        那么叶子节点的上一层，这些点作为树根的树要成为最小堆，最多只需要调节一次，
        直至最上面，树根，我们发现，只有这个调节时间是最长的，是logN,，而且它只会有一个
        最终我们发现，占一半数量的叶子节点是不需要调节的，1/4的点调一层，1/8的点调两层
        最后那个点要调logN层，总的时间为O（N）.
    //以下为根据列表创建堆的代码
    
    /*Elem a[6] = {10, 50, 60, 5, 30, 20};
    //创建capcity为50的堆，首先将上面的六个元素放进去初始化 
    Heap h;
    h = buildHeap(a, 6, 50);
    printHeap(h); 
    for(int i = 1; i <= 6; i ++){
        printf("%d ",h->data[i]);
    } */
    destroy(h);
    return 0;
}
***堆的其他操作：提高元素优先级 降低元素优先级 删除元素（不只是堆顶）
***大顶堆，只要加大这个数，就能提高它的优先级，小顶堆则相反
***如何提高元素优先级？ 提高优先级后 + percolateUp 就好了
***如何降低元素优先级？ 降低优先级后 + percolateDown 就好了
***实际中的应用：例如病人的病情加重，或者减弱...
***删除元素？我们之前只学过删除堆顶，那么如果我们要删除一个特定的元素，只要把这个元素弄膨胀
***让它变成堆顶，我们就能删除它了。

***下面来看一下其他的语言如何使用堆***
C++:
#include<iostream>
#include<queue>

using namespace std;

int main(){
    //默认为大顶堆
    //小顶堆要写成priorit_queue<int, vector<int>, greater<int>> q;
    priority_queue<int> q;//堆就是优先队列的一种形式
    q.push(111);
    q.push(222);
    q.push(333);
    q.push(11);
    q.push(22);
    cout << q.top() << endl;
    q.pop();
    cout << q.top() << endl;
    return 0;
}

JAVA:

import java.util.PriorityQueue;

public class Main{
    public static void main(String[] args){
        //默认为小顶堆
        PriorityQueue<Integer> q = new PriorityQueue<>();
        //大顶堆写法
        //补充知识点：因为JAVA的函数，必须依靠类存在，所以在下面我们采取一种叫匿名内部类的东西
        //注意，10虽然传入了大小，但是即使add多了，也会自动扩容，无影响
        //实现了comparator这个接口的话 必须要实现compare方法
        //写comparator比较麻烦，我们可以采取写lambda表达式的方法
        PriorityQueue<Integer> q1 = new PriorityQueue<>(10, 
        new Comparator<Integer>(){
            @override
            public int compare(Integer o1, Integer o2){
                return o2 - o1;
            }
        })

        //Lambda表达式作为参数写法
        PriorityQueue<Integer> q2 = new PriorityQueue<>(10, (a, b)->{return b - a;});
        //*****
        q.add(111);
        q.add(222);
        q.add(333);
        q.add(444);
        q.add(11);
        q.add(22);
        //java的弹出会返回弹出的元素 和C++有点不一样
        System.out.println(q.poll());
    }
}