算法导论第三版-第6章堆排序操作完整代码（建堆、插入、删除、排序等）

// heap_sort.cpp : 定义控制台应用程序的入口点。
//
#include<iostream>
#include<algorithm>
using namespace std;

#define N 1000
#define PARENT(i) (i)>>1
#define LEFT(i) (i)<<1;
#define RIGHT(i) ((i)<<1)+1

class Heap
{
public:
//成员变量
int A[N + 1];
int length;
int heap_size;
//构造与析构
Heap() {}
Heap(int size) :length(size), heap_size(size) {}
~Heap() {}
//功能函数
void Max_Heapify(int i);
void Build_Max_Heap();
void HeapSort(int A[]);
//优先队列函数
void Heap_Increase_Key(int i,int key);
void Max_Heap_Insert(int key);
int Heap_Maximum();
int Heap_Extract_Max();
void Heap_Delete(int i);
//辅助函数
void Print();
void Print1();

};
//使以i结点为根结点的子树成为堆，调用条件是确定i的左右子树已经是堆，时间是O(lgn)
//递归方法
void Heap::Max_Heapify(int i)
{
int l = LEFT(i);
int r = RIGHT(i);
int largest;
//选择i、i的左、i的右三个结点中值最大的结点
if (l<heap_size&&A[l]>A[i])
largest = l;
else largest = i;
if (r<heap_size&&A[r]>A[largest])
largest = r;
//如果根结点值最大，已经满足堆的条件，函数停止
//否则
if (largest != i)
{
//根结点与值最大的结点交换
swap(A[i],A[largest]);
//交换可能破坏子树的堆，重新调整子树
Max_Heapify(largest);
}

}

//建堆，时间复杂度O(nlgn)
void Heap::Build_Max_Heap()
{
heap_size = length;
//从中间开始依次向前调整每个结点，使得符合堆的性质
for (int i = length / 2; i >= 0; i--)
Max_Heapify(i);
}

//堆排序，时间复杂度O(nlgn)
void Heap::HeapSort(int A[])
{
//建立一个最大堆
Build_Max_Heap();
//每次将前i个元素构成最大堆
for (int i = length - 1; i >= 1; i--)
{
//将前i个元素中的最大值存入到A[i]中
swap(A[0],A[i]);
//堆的大小减一
heap_size--;
//只有堆顶的性质可能会被破坏
Max_Heapify(0);

}
}

//将元素i的关键字增加到key，要求key>=A[i]
void Heap::Heap_Increase_Key(int i, int key)
{
if (key < A[i])
{
cout << "new key is smaller than current key" << endl;
exit(0);
}
A[i] = key;
//跟父结点比较，若A[PARENT(i)]<A[i],则交换
//若运行到某个结点时A[PARENT(i)]>A[i],就跳出循环
while (A[PARENT(i)]>0 && A[PARENT(i)] < A[i])
{
swap(A[PARENT(i)],A[i]);
i = PARENT(i);
}
}

//将key插入到集合A中
void Heap::Max_Heap_Insert(int key)
{
if (heap_size == N)
{
cout << "heap is full" << endl;
exit(0);

}
heap_size++; length++;
A[heap_size - 1] = -0x7fffffff;
Heap_Increase_Key(heap_size - 1, key);
}

//返回A中最大关键字，时间O(1)
int Heap::Heap_Maximum()
{
return A[0];
}

//去掉并返回A中最大关键字，时间复杂度O(lgn)
int Heap::Heap_Extract_Max()
{
if (heap_size < 0)
{
cout << "heap underflow" << endl;
exit(0);
}
//取出最大值
int max = A[0];
//将最后一个元素补到最大值的位置
A[0] = A[heap_size - 1];
heap_size--;
//重新调整根结点
Max_Heapify(0);
//返回最大值
return max;
}

//删除堆中第i个元素
void Heap::Heap_Delete(int i)
{
if (i > heap_size)
{
cout << "there is no node i" << endl;
exit(0);
}
//把最后一个元素补到第i个元素的位置
int key = A[heap_size - 1];
heap_size--;
//如果新值比原来A[i]大，则向上调整
if (key > A[i])
Heap_Increase_Key(i,key);
else//否则，向下调整
{
A[i] = key;
Max_Heapify(i);
A[heap_size] = 0;
}
}
void Heap::Print()
{
int i;
for (i = 0; i < heap_size; i++)
{
if (i > 0)cout << ',';
else cout << "==>A={";
cout << A[i];
}
cout << '}' << endl;
}

void Heap::Print1()
{
int i;
cout << "==>A={";
for (i = 0; i < length; i++)
{
if (A[i] > 0)
{
cout << A[i] << " ";
}
}
cout << '}' << endl;
}
void main()
{
Heap a(13);
a.A[0] = 1; a.A[1] = 9; a.A[2] = 10; a.A[3] = 2; a.A[4] = 7;
a.A[5] = 5; a.A[6] = 6; a.A[7] = 4; a.A[8] = 13; a.A[9] = 3;
a.A[10] = 18; a.A[11] = 11; a.A[12] = 100;
a.Build_Max_Heap();
cout << "建立最大堆结果：" << endl;
a.Print();
a.Heap_Delete(2);
cout << "删除堆中A[2]结果：" << endl;
a.Print();
a.Heap_Extract_Max();
cout << "取出堆中最大值后结果：" << endl;
a.Print();
a.Heap_Increase_Key(8, 15);
cout << "将A[8]值增加到15后结果：" << endl;
a.Print();
a.Max_Heap_Insert(56);
cout << "将值56插入最大堆后的结果：" << endl;
a.Print();
a.HeapSort(a.A);
cout << "堆排序结果：" << endl;
a.Print1();
system("pause");
}