堆排序以及优先队列

算法导论中的堆排序。

主要的几个函数：

三个宏用来表示取父节点和左右子节点，算法导论讲的很详细实现很简单
#define PARENT(i)(i/2)
#define  LEFT(i)(2*i)
#define  RIGHT(i)(2*i+1)
class Numbersort
{
public:
Numbersort()
{
arry=NULL;
nmber=0;
}
~Numbersort()
{
if (arry!=NULL)
{
delete[]arry;
}
}

int copynumber(int *p,int n);//给arry赋值
void putout();///输出数组
void sortnumber();///顺序排序，检验排序的正确性，堆排序中不用
void max_heapify(int heap_size,int i);//对长度为heap_size的堆的节点进行最大堆排序，以维护当前节点以及子节点的最大堆性质
void build_max_heap();//调用max_heapify构建最大堆
void stack_sort();//对build_max_heap()构建好的最大堆进行排序
void increase_key(int i,int key);//将当前借点i的key增加key(不是增加到key)
void addnum(int newn);//增加newn到最大堆中

private:
int *arry;
int nmber;
int size_down;
};

函数int copynumber(int *p,int n)、void putout()和sortnumber()没啥好说的。

void Numbersort::max_heapify(int heap_size,int i)
{
int l=LEFT(i);
int r=RIGHT(i);
int largest=0;
//堆排序的顺序比在数组中的位置大1，所以排序的顺序都要减去1
if (l<=heap_size&&arry[l-1]>arry[i-1])
{
largest=l;

}
else
largest=i;
if (r<=heap_size&&arry[r-1]>arry[largest-1])
{
largest=r;
}
if (largest !=i)
{
int temp=arry[largest-1];
arry[largest-1]=arry[i-1];
arry[i-1]=temp;
max_heapify(heap_size,largest);//递归调用以保证父节点后的子节点是最大堆
}
}

void Numbersort::build_max_heap()
{
int heap_size=nmber;
int half_size=heap_size/2;//最大堆中的去掉叶节点的节点数
for (int i=half_size;i>0;i--)
{
max_heapify(nmber,i);//对每个父节点逐次调用最大堆

}
}

void Numbersort::stack_sort()
{

for (int i=size_down;i>1;i--)
{
int temp=arry[0];
int temp2=arry[i-1];
arry[i-1]=arry[0];
arry[0]=temp2;//将最大的arry[0]与还未排序的最后一个交换，则最后一个就排好了数
size_down--;//sizedown减1后，已经排序好的数就不再参与最大堆排序。
max_heapify(size_down,1);
putout();
}
}

addnum(int newn)将一个newn元素添加到末尾，然后

void Numbersort::addnum(int newn)
{
int *p=new int [++nmber];

for (int i=0;i<nmber-1;i++)
{
p[i]=arry[i];
}
if (arry!=NULL)
{
delete arry;
arry=new int[nmber];
for (int i=0;i<nmber-1;i++)
{
arry[i]=p[i];
}
delete p;
}
arry[nmber-1]=0;//将最后一个元素置为0，然后调用increase_key
increase_key(nmber,newn);
}

将最大堆的第i个元素增加key

void Numbersort::increase_key(int i,int key)
{

arry[i-1]+=key;
while(i>1&&arry[PARENT(i)-1]<arry[i-1])
{//如果父节点比子节点小，则交换数，再对父节点进行判断，递归父节点的父节点是否符合。
int temp=arry[PARENT(i)-1];
arry[PARENT(i)-1]=arry[i-1];
arry[i-1]=temp;
i=PARENT(i);
}
}

总结：算法很简单，但是实现的时候总是会出现一些小问题，解决的也很爽快，主要还是不够细心，没有在草稿纸上先画一下。

有时候感觉，算法都贴出来有点傻X，这么简单还贴。这是一种小小成就感在内心蒸腾~(-ิo-ิ)