优先队列（Priority Queue）最大堆最小堆

建议读者先去下载《啊哈算法》看大概在P182页的堆，什么是最小堆？

ps：如果想进来学习什么是堆的童鞋们，你们不需要再继续往下面阅读啦，对你们有意义的是第一行哦~随后我将此本算法书会长传到csdn上哦~

而已经学习过数据结构，对堆已经有了初步认识的童鞋，可以仔细读读一下内容哦，以下主要是堆的应用。以及为什么要用堆~

最小堆就是所有的父节点都要比子节点要小，反之所有的父节点都要比子节点大的完全二叉树是最大堆

回顾看了看后，真的时候恍然大悟，最后就把最重要的捞出来把

像这样支持插入和寻找最大值和最小值元素的数据结构称之为优先队列。

如果使用普通队列来实现这两个功能，那么寻找最大元素或者最小元素都要枚举整个队列，这样的时间复杂度比较高。如果是已经排序好的数组，那么插入一个元素需要移动很多元素，时间复杂度依旧很高，而堆就是一种优先队列的实现，可以很好的解决这两个问题。

堆还经常用来寻找第k大或第k小的元素，比如现在要找第k大的元素，现在只需要建立一个个数为k的最小堆，堆顶元素就是第k大的元素。例如现在有10个数，要找第3大的元素，那么就先建立一个数目为3个的最小堆，然后拿第4个元素和堆顶元素比较，如果比他小这个数就丢弃，如果比他大，就将第4个元素替换原来的堆顶，然后重新调整堆，后面的5-10个元素一次这样重复，遍历完成后，堆顶元素就是第k大的元素。

相反的，寻找第k小的元素，建立数目为k的最大堆，比堆顶大的元素丢弃，小的替换后重新向下调整堆

那么，求k个最大元素和k个最小元素，则遍历完成后，最小堆和最大堆中的元素就是k个最大元素和最小元素。

还要记录的一点就是向下调整和向上调整。

向下调整是从堆顶开始，将最小的元素放在父节点上，直至当前节点是叶子节点为止。

向下调整主要是用于删除堆顶元素，在堆顶上重新添加一个新的元素或者删除堆顶元素时候用到（删除堆顶元素是，将最后一个元素放在堆顶元素，再使用向下调整，保证最小堆或者最大堆），还用于创建一个最大或最小堆

向上调整用于在末尾增加一个元素时候用到。

还有使用堆排序的时间复杂度是NO（logN），例如从小到大排列，有两种方法，一种就是用最小堆，每次去堆顶元素，

还有一种就是更好的方法就是使用最大堆，因为从小到大排序，大的在后面，小的在前面。那么每次将堆顶元素放在和最后一个元素替换，即时heap[0]和heap[n]替换。然后n--，在从heap[0]向下调整堆。

下面贴下代码吧（这个代码中，我是将数组从1开始的，heap[0]可以忽略掉，就是执行过后将0忽略，只是个占位的而已，不是数据。。）

import sun.plugin.javascript.navig.Array;

import java.util.Arrays;

//建立最小堆（数组从1开始）
public class Test3 {

    public static void main(String[] args){
        Test3 t = new Test3();
        int heap[]={0,45,35,67,33,87,8,4,2,5,12};
        String str = Arrays.toString(heap);
        System.out.println(str);
        t.swap(heap,2,3);
        for(int i=heap.length-1/2; i>=1; i--){
            t.sift_down(heap,i);
        }
        String str2 = Arrays.toString(heap);
        System.out.println(str2);

        //测试向上调整，添加一个数据时
        int heap2[]={0,2,5,4,33,12,8,35,45,67,87,1};
        t.sift_up(heap2,heap2.length-1);
        String str3 = Arrays.toString(heap2);
        System.out.println(str3);
    }

    public int delete_min(int[] heap){
        int t = heap[1];
        //将最后一个元素赋值给堆顶
        heap[1]=heap[heap.length-1];
        //将heap的长度减1 n--
        //因为heap的不是全局变量
        sift_down(heap,1);
        return t;
    }

    //向上调整（添加元素）
    public void sift_up(int[] heap, int i){
      int n = heap.length-1;
      int flag = 0;
      if(i == 1)return ;//如果时候对顶就直接返回

      while(i != 1 && flag==0){
          if(heap[i] < heap[i/2]){
              swap(heap,i,i/2);

          }else{
              flag=1;
          }
          i=i/2;
      }
    }
    //向下调整（删除堆顶元素，添加一个元素需要用到向下调整）
    public void sift_down(int[] heap,int i){
        int temp,flag=0;//flag标记是否继续向下调整
        int n = heap.length-1;
        while(i*2 <= n && flag == 0){
            temp = i;
            if(heap[i*2] < heap[i]){
                temp = i*2;
            }
            if(i*2+1 <= n){
                if(heap[i*2+1] < heap[temp]){
                    temp = i*2+1;
                }
            }
            if(temp != i){//如果当前节点不是最小节点
                swap(heap,temp,i);
                i = temp;//更变当前节点，继续向下调整
            }
            else{
                flag = 1;
            }

        }
    }

    public void swap(int[] heap,int a,int b){
        int t = heap[a];
        heap[a] = heap[b];
        heap[b] = t;
    }
}

优先队列（Priority Queue）最大堆最小堆

猜你喜欢