数据结构——堆

堆(heap)

• 堆是计算机科学中一类特殊的数据结构的统称，堆通常可以看做是一颗完全二叉树的数组对象。
• 堆的分类： 根结点最大的堆叫做最大堆或大顶堆，反之叫做最小堆或小顶堆。常见的堆有二叉树堆，斐波那契堆等。

堆的特点

1. 每个节点最多可以有两个结点。
2. 除了根结点没有兄弟结点，最后一个左子结点可以没有兄弟节点，其他结点必须有兄弟结点。
3. 根结点的键值是所有堆结点键值中最大者(最小者）且每个结点的值都比其孩子结点的值大(小).

如下图A,B不是堆，C是最大堆。

堆的算法实现(以最大堆为例)
将下列数组构建为最大堆

1. 首先我们需要找到最后一个结点的父结点如图(a)，我们找到的结点是87，然后找到该结点的最大子结点与自己比较，若该子结点比自身大，则将两个结点交换。
   图(a)中，87比左子结点95小，所以交换，交换后如图(b)所示。
   
   2.我们移动到前一个父结点93，同理做第一步的比较操作，结果不需要交换
   3.继续移动结点到前一个父结点82，如图(d)所示，82小于其两个结点，但其右子结点大于左子结点，所以82与95交换，如图(e)所示，82交换后，其值小于左子结点，不符合最大堆的特点，故要继续向下调整，如图（f)所示
   构建堆

#define DEFAULT_CAPCITY 128 
typedef struct _Heap{ 
 int *arr; //存储堆元素的数组
 int size;//当前已存储的元素个数
 int capacity; //当前存储的容量 
}Heap;

/*将当前的节点和子节点调整成最大堆*/
 void adjustDown(Heap &heap, int index) 
 {
   int cur=heap.arr[index];//当前待调整的节点
   int parent,child; 
   /*判断否存在大于当前节点子节点，如果不存在 ，则堆本身是平衡的，不 需要调整；如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则要继续按照同样的步骤对这个子节点进行调整*/ 
   for(parent=index; (parent*2+1)<heap.size; parent=child)
   { 
      child=parent*2+1; //取两个子节点中的最大的节点 
      if(((child+1)<heap.size)&&(heap.arr[child]<heap.arr[child+1]))
        {
         child++; 
         }
   //判断最大的节点是否大于当前的父节点 
     if(cur>=heap.arr[child])
       {
          //不大于，则不需要调整，跳出循环
           break; 
       }else {
       //大于当前的父节点，进行交换，然后从子节点位置继续向下调整 
              heap.arr[parent]=heap.arr[child];
               heap.arr[child]=cur; 
               }
   }
 }



/* 从最后一个父节点(size/2-1 的位置)逐个往前调整所有父节点（直到根节 点）,确保每一个父节点都是一个最大堆，最后整体上形成一个最大堆 */ 
  void buildHeap(Heap &heap)
    { 
      int i;
      for(i=heap.size/2-1; i>=0; i--)
        { 
          adjustDown(heap, i); 
        } 
     }

将数字99插入到上面大顶堆中
1）原始堆如图：对应的数组：{95，,93，,87，,92，,86，,82}
2）将新进的元素插入到大顶堆的尾部，如下图b所示：对应的数组是：{95，,93，,87，,92，,86，,82，99}
3）此时最大堆已经被破坏，需要重新调整, 因加入的节点比父节点大，则新节点跟父节点调换即可,如图 c 所示；调整后，新节点如果比新的父节点小，则已经调整到位，如果比新的父节点大，则需要和父节点重新进 行交换，如图 d, 至此，最大堆调整完成。

/*将当前的节点和父节点调整成最大堆*/
 void adjustUp(Heap &heap, int index)
  { 
  	if(index<0 || index >= heap.size)
  		{//大于堆的最大值直接
  			 return return; 
  		}
  	while(index>0)
  	  { 
  		int temp = heap.arr[index];
  		int parent = (index - 1) / 2; 
  		if(parent >= 0)
  		  {   //如果索引没有出界就执行想要的操作
  			if(temp > heap.arr[parent])
  			{ 
  			  heap.arr[index] = heap.arr[parent]; 
  			  heap.arr[parent] = temp; index = parent; 
  			}else {
  			//如果已经比父亲小 直接结束循环
  			 break; 
  			 } 
  			}
  		else {
  		//越界结束循环 
  		break;
  		 } 
  	  } 
  }


/*最大堆尾部插入节点，同时保证最大堆的特性*/
 bool insert(Heap &heap, int value)
  {
   if (heap.size == heap.capacity)
    { fprintf(stderr, "栈空间耗尽！\n");
      return false;
    }
   int index = heap.size;
   heap.arr[heap.size++] = value;
   adjustUp(heap, index);
   return true; 
   }

堆顶元素出列
当插入节点的时候，我们将新的值插入数组的尾部。现在我们来做相反的事情：我们取出数组中的最后一个元 素，将它放到堆的顶部，然后再修复堆属性。

/*将当前的节点和子节点调整成最大堆*/ 
void adjustDown(Heap &heap, int index)
 { 
   int cur = heap.arr[index];//当前待调整的节点
   int parent, child; 
   /*判断否存在大于当前节点子节点，如果不存在 ，则堆本身是平衡的，不 需要调整；
   如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节 点，则要继续
   按照同样的步骤对这个子节点进行调整 */
   for (parent = index; (parent * 2 + 1)<heap.size; parent = child)
    { 
      child = parent * 2 + 1; //取两个子节点中的最大的节点
      if (((child + 1)<heap.size) && (heap.arr[child]<heap.arr[child + 1]))
       { child++; }
       //判断最大的节点是否大于当前的父节点 
      if (cur >= heap.arr[child]) 
        {//不大于，则不需要调整，跳出循环
         break; 
        }else
        {//大于当前的父节点，进行交换，然后从子节点位置继续向下调整
         heap.arr[parent] = heap.arr[child];
         heap.arr[child] = cur; 
         } 
     } 
  }



//删除最大结点并获得结点的值
bool popMax(Heap &heap,int &vaule)
 {
    if(heap.size<1)   return false;
    
    vaule=heap.arr[0];
    //进行b图中操作，将最后一个结点放到根结点
    heap.arr[0]=heap.arr[--heap.size];
    //从上往下将其变为最大堆
    addjustDown(heap,0);