堆的基本操作

　　我们期望的数据结构能支持插入操作，并能方便地从中取出具有最小或最大关键码的记录，这样的数据结构即为优先级队列。在优先级队列的各种实现中，堆是最高效的一种数据结构。
　　最小堆：任一结点的关键码均小于或等于它的左右子女的关键码，位于堆顶的结点的关键码是整个元素集合的最小的，所以称它为最小堆。最大堆类似定义。

　　创建堆：采用从下向上逐步调整形成堆得方法来创建堆。为下面的分支结点调用下调算法siftDown，将以它们为根的子树调整为最小堆。从局部到整体，将最小堆逐步扩大，直到将整个树调整为最小堆。

　　插入一个元素：最小堆的插入算法调用了另一种堆得调整方法siftUp，实现自下而上的上滑调整。因为每次新结点总是插在已经建成的最小堆后面，这时必须遵守与sift相反的比较路径，从下向上，与父结点的关键码进行比较，对调。

　　删除一个元素：从最小堆删除具有最小关键码记录的操作时将最小堆的堆顶元素，即其完全二叉树的顺序表示的第0号元素删去，去把这个元素取走后，一般以堆得最后一个结点填补取走的堆顶元素，并将堆的实际元素个数减1.但是用最后一个元素取代堆顶元素将破坏堆，需要调用siftDown算法进行调整堆。

本文代码均以最小堆的实现为例。

#include<iostream>
#include<assert.h>
usingnamespace std;

constint maxheapsize=100;
staticint currentsize=0;

//从上到下调整堆
void siftDown(int* heap,int currentPos,int m)
{
int i=currentPos;
int j=currentPos*2+1;//i's leftChild
int temp=heap[i];
while(j<=m)
{
if(j<m&&heap[j]>heap[j+1]) j++;// j points to minChild
if(temp<=heap[j]) break;
else
{
heap[i]=heap[j];
i=j;
j=2*i+1;
}
}
heap[i]=temp;
}

//从下向上调整堆
void siftUp(int* heap, int start)
{
int i=start,j=(i-1)/2;
int temp=heap[i];

while(i>0)
{
if(heap[j]>temp)
{
heap[i]=heap[j];
i=j;
j=(i-1)/2;
}
elsebreak;
}
heap[i]=temp;
}

//构建堆
int* Heap(int*arr, int size)
{
int i;
currentsize=size;
int* heap =newint[maxheapsize];
assert(heap!=NULL);
for(i=0;i<currentsize;i++) heap[i]=arr[i];
int currentPos=(currentsize-2)/2;
while(currentPos>=0)
{
siftDown(heap,currentPos,currentsize-1);
currentPos--;
}
return heap;
}


//增加一个元素
void insert(int* heap,int value)
{
if(currentsize>=maxheapsize)
{
cout<<"Heap is full!"<<endl;
return ;
}
heap[currentsize]=value;
siftUp(heap,currentsize);
currentsize++;
}

//删除一个元素,并返回删除前的堆顶元素
int removemin(int* heap)
{
assert(currentsize>=0);
int removeValue=heap[0];
heap[0]=heap[currentsize-1];
currentsize--;
siftDown(heap,0,currentsize-1);
return removeValue;
}

int main()
{
constint size=10;
int arr[size]={2,1,3,0,8,1,6,9,7,10};
int* heap=Heap(arr,size);
//堆排序
for(int i=0;i<size;i++)
{
arr[i]=removemin(heap);
cout<<arr[i]<<endl;
}
delete []heap;
return0;

 

 

 

}

---

面试百度时，遇到的一个面试题：

如何建堆，以及建堆的复杂度是多少？证明之。

复杂度为O(n)，不要凭空想象，因为凭空想象第一感觉是n*logn的，但是显然是不准确的。

具体证明参考算法导论，第六章 77页。