堆（Heap）

下标关系
已知双亲(parent)的下标，则：
左孩子(left)下标 = 2 parent + 1;
右孩子(right)下标 = 2 parent + 2;
已知孩子（不区分左右）(child)下标，则：
双亲(parent)下标 = (child - 1) / 2
堆（heap）
定义：

• 堆逻辑上是一棵完全二叉树
• 堆物理上是保存在数组中
• 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆， 或者最大堆
• 4反之，则是小堆，或 者小根堆，或者最小堆
• 堆的基本作用是，快速找集合中的最值。
  向下调整:时间复杂度：O(log(n))
  前提：左右子树必须已经是一个堆，才能调整。

  //向下调整成小堆
  public static void shiftDownSmall(int[]array,int size,int index){
  int left=2*index+1;
  while(leftarray[right]){
              min=right;
          }
          if(array[index]>array[min]){
              swap(array,index,min);
              index=min;
              left=2*index+1;
          }
          else{
              break;
          }
      }
  }
  }
  public static void swap(int array[],int i,int j){
  int t=array[i];
  arrat[i]=array[j];
  array[j]=t; 
  }
  //向下调整成大堆
  public static void shiftDownBig(int[]a,int i,int s){
  while(2*i+1a[m]){
        m++;
    }
    if(a[i]>=a[m]){
        break;
    }
    swap(a,i,m);
    i=m;
    } 
  }

向上调整

****//向上调整成小端
//直到index=0,执行循环
//找到index的双亲
//比较index和双亲的值，满足，调整结束，否则交换，然后让i=parent继续
pubic static void shiftUpSmall(int[]array,int size,int index){
    while (index!=0){
        int parent=(index-1)/2;
        if(array[parent]<=array[index]){
           break;
        }
        swap(array,parent，index);
        index=parent；
    }
}
```**

**建堆**

public static void creatHeapBig(int[]array,int size){
for(int i=(s-2)/2;i>=0;i++){
shiftDownBig(a,i,s);
}
}

**优先级队列**
* 出队列:将[0]位置和[size-1]位置交换，然后做一次向下调整。
* 入队列(O(logn)):做向上调整。
* 返回队首元素：即返回[0]下标。

public class MyPriorityQueue {
// 不做扩容考虑
private int[] array;
private int size;

MyPriorityQueue() {
array = new int[16];
size = 0;
}
//入队列
public void offer(int element) {
array[size++] = element;
Heap.shiftUpSmall(array, size - 1);
}
// 出队列O(log(n))
public int poll() {
int element = array[0];
array[0] = array[--size];
Heap.shiftDownSmall(array, 0, size);
return element;
}
//取队首元素
public int peek() {
// 不做错误处理
return array[0];
}

**TopK问题**：在海量数据中找前k大的数据
            找前K个大的，建K个大小的小堆；
            找前k个小的，建K个大小的大堆；
**堆排序**

public static void heapSort(int[] array){
creatHeapBig(array,array.length);
for(int i=0;i//无序[0,array.length-i)
//有序[array.length-i,array.length)
swap(array,i:0,j:array.length-i-1-1);
//无序[0,array.length-i-1)
//长度 array.length-i-1
shiftDownBig(array,i:0,s:array.length-i-1);
}
}