算法导论第六章堆排序相关代码

#include <iostream>
#include <vector>
using namespace std;

class Heap{
public:
vector<int> data;
int heapSize;
int length(){
return data.size() - 1;
};
Heap(vector<int> a,int heap_Size):data(a),heapSize(heap_Size) {}
};
void CoutHeap(Heap A);
void MaxHeapify(Heap &A,int i);
void Swap(int &a,int &b);
int Parent(int i);
int Left(int i);
int Right(int i);
void BuildMaxHeap(Heap &A);
void HeapSort(Heap &A);

class PriorityQueue{
public:
void Insert(Heap &A,int x);//把元素x插入到集合A中
int MaxNum(Heap A);//返回A中最大key的元素
int ExtarctMax(Heap &A);//去掉并返回A中最大key的元素
int IncreaseKey(Heap &A,int index ,int k);//将下标为index的元素的值增加到k
};

int main()
{
//这里有11个元素，其中第一个元素0，是为了使堆的序号从一开始计数
//由求结点i的孩子节点序号时从1编号，孩子结点下标分别为2*i和2*i+1
int num[] = {0,4,1,3,2,16,9,10,14,8,7};

vector<int> a;
for(int i=0 ; i<11 ; i++){//!!!!修改参数11
a.push_back(num[i]);
}
Heap A(a,0);//定义一个堆，堆中有效元素个数为0
CoutHeap(A);

//    A.heap_size = 10;
//    MaxHeapify(A,2);
BuildMaxHeap(A);
cout << A.heapSize << endl;
CoutHeap(A);

//    HeapSort(A);
//    CoutHeap(A);

PriorityQueue B;
cout <<"MaxNum(A):" << B.MaxNum(A) << endl;
cout <<"ExtarctMax(A):" << B.ExtarctMax(A) << endl;
CoutHeap(A);

B.Insert(A,5);
CoutHeap(A);
B.Insert(A,-1);
CoutHeap(A);
B.Insert(A,1000);
CoutHeap(A);

B.IncreaseKey(A,3,10);
CoutHeap(A);
B.IncreaseKey(A,3,1766);
CoutHeap(A);

return 0;
}
void CoutHeap(Heap A)
{
for(int i=1 ; i<=A.heapSize ; i++){
cout << A.data[i] << "\t";
}
cout << endl;
}

void PriorityQueue::Insert(Heap &A,int x)//把元素x插入到集合A中
{
if(A.heapSize == A.length()){
A.data.push_back(x);
A.heapSize = A.heapSize + 1;
}
else{
A.heapSize = A.heapSize + 1;
A.data[A.heapSize] = x;
}
int parent = Parent(A.heapSize);
while(parent!=0 && A.data[parent]>A.data[A.heapSize]){//!!!
MaxHeapify(A,parent);
parent = Parent(parent);
}
}
int PriorityQueue::MaxNum(Heap A)//返回A中最大key的元素
{
return A.data[1];
}
int PriorityQueue::ExtarctMax(Heap &A)//去掉并返回A中最大key的元素
{
Swap(A.data[1],A.data[A.heapSize]);
A.heapSize = A.heapSize - 1;//!!先改heapSize,后调用maxHeapify函数
MaxHeapify(A,1);

return A.data[A.heapSize + 1];
}
int PriorityQueue::IncreaseKey(Heap &A,int index ,int k)//将下标为index的元素的值增加到k
{
if(index > A.heapSize){
cout << "index is larger than heapsize" << endl;
return -1;
}
if(A.data[index] > k){
cout << "k is smaller than the former value" << endl;
return -1;
}
A.data[index] = k;
int parent = Parent(index);
//   while(parent != 0){
while(parent!=0 && A.data[parent]<A.data[index]){//!!!加上后半个约束可以减少检查的次数
MaxHeapify(A,parent);
parent = Parent(parent);
}
return 1;
}

//功能：堆排序函数
//输入：最大堆
//实现：每次交换堆顶元素和最后一个元素，即vector A中第一个和最后一个元素，
//交换后，最后一个元素是最大的，堆元素个数减一，然后调用最大堆化函数，
//使剩余元素满足最大堆定义
void HeapSort(Heap &A)
{
while(A.heapSize > 1){
Swap(A.data[1],A.data[A.heapSize]);
A.heapSize = A.heapSize - 1;
MaxHeapify(A,1);
}
}

//功能：创建堆
//输入：数组仅含数组A的数据
//实现时，从i=A.length/2开始到1每个结点分别调用一次最大堆化程序
void BuildMaxHeap(Heap &A)
{
A.heapSize = A.length();
for(int i=A.length()/2 ; i>=1 ; i--){
MaxHeapify(A,i);
}
}

//功能：用于维护最大堆的性质
//输入:数组A，下标i
//实现：假定LEFT(i)和RIGHT(i)都是二叉树的最大堆
//达到 以下标i为根结点的子树重新遵循最大堆的性质 的目的
void MaxHeapify(Heap &A,int i)
{
int l = Left(i);
int r = Right(i);
int largestIndex = i;
if(l<=A.heapSize && A.data[l]>A.data[largestIndex]){
largestIndex = l;
}
if(r<=A.heapSize && A.data[r]>A.data[largestIndex]){
largestIndex = r;
}
if(largestIndex != i){
Swap(A.data[i],A.data[largestIndex]);
MaxHeapify(A,largestIndex);
}
}
void Swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
int Parent(int i)
{
return i/2;
}
//返回堆中根为i的左孩子的下标
int Left(int i)
{
return 2*i;
}
//返回堆中根为i的右孩子的下标
int Right(int i)
{
return 2*i+1;
}