优先队列 (堆实现)

共两部分 C 实现 & C++类的编写

-------------------------------------C实现------------------------------------------

1 通过堆的性质 编写优先队列

2 堆中的元素可根据实际需要 存储相应的值（可以是指针，结构体 或者 是一个对象），

   此处简单起见使用了整数

//保持最大堆性质 参数inode为内部结点 注意结点从1开始，数组从0开始
void MaxHeapify(int array[], int size, int inode)
{
    int largest= inode;                //父结点
    int left = inode*2;                //左子结点
    int right = inode*2+1;            //右子结点

    if (left <= size && array[left-1] > array[largest-1])
    {
        largest = left;
    }
    if (right <= size && array[right-1] > array[largest-1])
    {
        largest = right;
    }

    if (largest != inode)                    //父结点小于 左子结点 或者 右子结点
    {
        int temp = array[inode-1];            //子结点值与父结点值交换
        array[inode-1] = array[largest-1];
        array[largest-1] = temp;

        MaxHeapify(array, size, largest);    //再次验证被交换的值的子结点是否满足 最大堆性质
    }
}
//建立最大堆 使每一个父结点大于子结点
void BuildMaxHeap(int array[],int size)
{
    for(int i=size/2; i>0; --i)     //最多有 size/2 个内部结点
    {
        MaxHeapify(array, size, i);
    }
}
//堆排序
void HeapSort(int array[], int size)
{
    BuildMaxHeap(array, size);  //建立最大堆  结果是最大值 为根结点
    int temp = 0;
    int heapSize = size;
    for (int i=size; i>1; --i)
    {
        temp=array[0];                //交换 根结点的值 与 最后面末尾的结点的值 
        array[0]=array[i-1];        //此时违背了最大堆的性质
        array[i-1] = temp;

        --heapSize;                //保持最大堆的性质之前 先去掉已排好序的元素，即减小堆的大小
        MaxHeapify(array, heapSize, 1);
    }
};
//返回堆中最大的值
int HeapMax(int array[], int size)
{
    return array[0];
}
//去掉并返回堆中最大的值，同时去掉最大值之后仍然保持最大堆的性质
int HeapExtractMax(int array[], int size)
{
    if (size < 0)
    {
        return -1;
    }
    else if(size == 1)
    {
        return array[0];
    }
    
    int max = array[0];
    array[0] = array[size-1];
    --size;
    MaxHeapify(array, size, 1);

    return max;
}

//增加指定关键字的值（此处是通过下标指定关键字,从1开始） 
void HeapIncreaseKey(int array[], int size, int index, int key)
{
    if(key<array[index-1])  //指定增加的值必须大于原先的值
        return;
    array[index-1] = key;

    while(index>1 && array[index/2-1] < array[index-1])
    {
        int tmp = array[index-1];
        array[index-1] = array[index/2-1];
        array[index/2-1] = tmp;
        index = index/2;
    }
}
//删除指定关键字的值，保持最大堆得性质
void HeapDelete(int array[], int size, int index)
{
    array[index-1] = array[size-1];
    --size;
    MaxHeapify(array, size, index); //确保index下的结点满足最大堆性质

    while(index>1 && array[index/2-1] < array[index-1])  //确保index的父结点满足最大堆性质
    {
        int tmp = array[index-1];
        array[index-1] = array[index/2-1];
        array[index/2-1] = tmp;
        index = index/2;
    }

}
//实现最大堆的插入操作，即给堆中插入新值，并且保持最大堆的性质
void HeapInsert(int array[], int size, int key)
{
    size = size+1;            //确保数组足够大不溢出
    array[size-1] = 0;        //此处直接复用HeapIncreaseKey，确保函数的性质
    HeapIncreaseKey(array, size, size, key);
}

void main()
{
    //_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    int Array[12] = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};

    BuildMaxHeap(Array, 10);

    for (int i=0; i<10; ++i)
    {
        cout << Array[i] << " ";
    }
    cout << "

HeapMax：" << HeapMax(Array, 10) << endl;

    cout <<"
HeapExtractMax: " << HeapExtractMax(Array, 10) << endl<<endl;

    HeapIncreaseKey(Array, 9, 2, 20);
    for (int i=0; i<9; ++i)
    {
        cout << Array[i] << " ";
    }
    HeapInsert(Array, 9, 17);
    cout << endl;
    for (int i=0; i<10; ++i)
    {
        cout << Array[i] << " ";
    }
    HeapDelete(Array, 10, 1);
    cout << endl;
    for (int i=0; i<10; ++i)
    {
        cout << Array[i] << " ";
    }

    system("pause");
}

------------------------------------C++类的编写-----------------------------------

1 通过C实现可改写成 优先队列的类

2 改写类的时候，确保抽象接口的一致性

const int SIZE = 100;
class Queue
{
private:
    int queue[SIZE];
    int count;　　　　　　　　　　　　//当前队列里的个数
    void MaxHeapify(int inode); //向下确保堆的最大性质
    void MaxHeapify_check_parent(int inode); //    向上确保堆得最大性质
    void BuildMaxHeap();
public:
    void HeapSort();
    int HeapMax();
    int HeapExtractMax();
    void HeapIncreaseKey(int index, int key);
    void HeapDelete(int index);
    void MaxHeapInsert(int key);
    bool Empty();
};