c++最大堆的实现

     在看一些开源组件的源码时，会发现很多的底层地方都会使用到最大堆（最小堆）的数据结构，如 在libevent中维护超时事件就用到了最小堆的结构，可见，这种数据结构的重要性。

     最大堆：根结点的键值是所有堆结点键值中最大者。

     最小堆：根结点的键值是所有堆结点键值中最小者。

     堆，最重要的一个过程就是重建的过程，当有新的数据加进来或者移除时，都会对堆进行一次重建，最大堆也是如此：

     1.当弹出堆顶元素时，会将末尾元素放到堆顶，依次向下与 下层子节点比较，若比子节点小，则交换，继续向下比较，直到调整好顺序。
     2. 当有新元素添加时，先将元素放到末尾，依次向上与父节点比较，若比父节点大，则交换，继续向上比较，直到调整好顺序

    本文用c++实现了一个最大堆的模板类：

/*************
@author xl
@date 2018/08/28
**/

#ifndef _MAXHEAP_H
#define _MAXHEAP_H

#include <stdio.h>
#include <iostream>
using namespace std;

// *最大堆的实现,二叉树用数组来表示
template<typename T>
class MaxHeap
{
public:
	MaxHeap(const T* arr, const int& size);
	~MaxHeap();
	
	void push(const T& val);
	int pop();
	
	void sift_down( int index);
	void sift_up( int index);
	void input();
	
private:
	T* heap;
	int m_size;
	int capacity;
};

template<typename T>
MaxHeap<T>::MaxHeap(const T* arr,const int& size)
{
	
	m_size = size;
	capacity = 2*m_size;
	heap =new T[capacity];
	for(int i=0;i< m_size;i++)
	{
		heap[i] = arr[i];
	}
	
	for(int i=m_size/2-1; i>=0; i--)
	{
		sift_down(i);
	}
}

template<typename T>
MaxHeap<T>::~MaxHeap()
{
	delete []heap;
	heap = NULL;
	m_size = 0;
}
//push元素到堆底，并向上重建堆
template<typename T>
void MaxHeap<T>::push(const T& val)
{
	if(m_size < capacity)
	{
		heap[m_size] = val;
		m_size++;
		sift_up(m_size-1);
	}
	else
		printf("capacity is full.\n");
}

//弹出堆顶元素，并向下重建堆
template<typename T>
int MaxHeap<T>::pop()
{
	if(m_size>0)
	{
		T res = heap[0];
		heap[0] = heap[m_size-1];
		m_size--;
		sift_down(0);
		return res;
	}
	else
		printf("size is empty.\n");
}

template<typename T>
void MaxHeap<T>::sift_down( int index)
{
	if(index < 0 && index >= m_size)
		printf("index is invalid.");
	else
	{
		T temp = heap[index];  //保存当前节点的值
		index = index*2 + 1;     //定位到子节点
		while(index < m_size)    //循环处理，保持根节点 > 所有子节点的逻辑
		{
			if(index + 1 < m_size && heap[index] < heap[index+1])
				index++;      //找到子节点的大值
			if(heap[index] > temp)
			{
				heap[(index-1)/2] = heap[index];    //将大值赋给父节点
				index = index*2 + 1;   //推到下一级子节点
			}
			else
			{
				break;
			}
		}
		heap[(index-1)/2] = temp;   //将原值(小值)赋给处理结束的地方,完成down操作
	}
}

template<typename T>
void MaxHeap<T>::sift_up( int index)
{
	if(index < 0 && index >= m_size)
		printf("index is invalid.");
	else
	{
		T temp = heap[index];
		while(index > 0 && temp > heap[(index-1)/2])
		{
			heap[index] = heap[(index-1)/2];   //将小值赋给子节点
			index = (index -1) / 2;     //推到上一级父节点
		}
		heap[index] = temp;     //将大值赋给父节点，完成up操作
	}
}

template<typename T>
void MaxHeap<T>::input()
{
	for(int i=0; i<m_size;i++)
	{
		if(i == m_size-1)
			cout<<heap[i]<<endl;
		else
			cout<<heap[i]<<" ";
		
	}
}


#endif

其中，最重要的过程就是，sift_up 和 sift_down 操作     都是对堆重建过程的操作，对于堆结构不太了解的人，可能会看的比较费劲，因此这里我注释的比较详细。

下面写了一个测试程序：

#include <iostream>
#include "MaxHeap.h"

using namespace std;

int main()
{
	
	int array[10] = {1,3,25,8,34,9,7,15,18,11};
	MaxHeap<int> max_heap(array,10);
	
	max_heap.input();
	max_heap.push(80);
	max_heap.input();
	max_heap.pop();
	max_heap.input();
	return 0;
}

结果如下：

over~