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

之前一直用C写代码，现在尝试用C++写，因此可能有些内容用的不太规范，若发现，望指正，不胜感谢~

另外感觉别扭的一点是定义的优先队列，优先队列类中没有堆相关数据。。。。后面有待改正

相关代码：

#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;
}

运行结果截图：