算法导论笔记(二) : 优先级队列

1 堆与优先级队列

堆排序是一个不错的原地排序算法.但是一个实现较好的快速排序会优于堆排序。

但是堆数据结构有一个非常重要的用处,就是作为高效的优先级队列.

与堆一样优先级队列也有两种：最大优先级队列和最小优先级队列.

2 优先级队列及其操作

优先级队列是一种用来维护由一组元素构成的集合S的数据结构.

这一组元素的每一个都有一个关键字Key.一个最大优先级队列支持以下操作:

(i) INSERT(S,x) : 把元素x插入到集合S.

(ii) MAXMUM(S) : 返回S中具有最大关键字的元素.

(iii) EXTRACT-MAX(S) : 去掉并返回S中具有最大关键字的元素.

(iv) INCREASE-KEY(S,x,k) : 将x元素的关键字增加到k,k不能小于x之前的关键字.

3 优先级队列的用途

(i) 分时计算机上的作业调度. (最大优先级队列).

(ii) 基于事件的驱动模拟器.(最小优先级队列).

4 完整代码

(i) 类的定义

#ifndef __HEAP_H__
#define __HEAP_H__

class Heap
{
protected:
  int* m_data;
  int m_heapSize;
  int m_memSize;
public:
  Heap();
  Heap(int heapSize);
  ~Heap();
  void ReAlloc(int size=0);
};

#endif

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "heap.h"

class Heapsort : public Heap
{
public:
  Heapsort(int heapSize);
  ~Heapsort();
  void Build_Max_Heap();
  void Create(int size);
  void Max_Heapify(int nodeIndex,int currentHeapSize);
  void Sort();
  bool Verify();
};

#endif

#ifndef __PRIORITYQUEUE_H__
#define __PRIORITYQUEUE_H__

#include "Heapsort.h"

class PriorityQueue : public Heapsort
{
public:
  PriorityQueue(int heapSize);
  ~PriorityQueue();
  void Insert(int key);
  int Maxmum();
  int Extract_Max();
  void Increase_key(int nodeIndex,int newKey);
};

#endif

(ii)类的实现

#include "heap.h"
#include <stdio.h>
#include <malloc.h>

Heap::Heap(int heapSize)
{
  m_data = (int*)malloc(sizeof(int) * heapSize);
  m_heapSize = heapSize;
  m_memSize = heapSize;
}

Heap::Heap()
{
  m_data = NULL;
  m_heapSize = 0;
}

Heap::~Heap()
{
  if(m_data)
  {
    free(m_data);
  }
}

void Heap::ReAlloc(int size)
{
  if(m_data)
  {
    free(m_data);
    if(size==0)
    {
      m_memSize *= 2;
    }
    else
    {
      m_memSize = size;
    }
    m_data = (int*)malloc(sizeof(int) * m_memSize);
  }
}

#include <stdio.h>
#include <malloc.h>
#include "PriorityQueue.h"

#define INF -0x7fffffff

PriorityQueue::PriorityQueue(int heapSize) : Heapsort(heapSize)
{
}

PriorityQueue::~PriorityQueue()
{
}

int PriorityQueue::Maxmum()
{
  return m_data[0];
}

int PriorityQueue::Extract_Max()
{
  int maxKey;
  if(m_heapSize < 1)
  {
    printf("heap underflow \n");
    return -1;
  }
  maxKey = m_data[0];
  m_data[0] = m_data[m_heapSize-1];
  m_heapSize--;
  Max_Heapify(0,m_heapSize);
  return maxKey;
}

void PriorityQueue::Insert(int key)
{
  m_heapSize++;
  if(m_heapSize>m_memSize)
  {
    ReAlloc();
  }
  m_data[m_heapSize-1] = INF;
  Increase_key(m_heapSize-1,key);
}

void PriorityQueue::Increase_key(int nodeIndex,int newKey)
{
  if(newKey<m_data[nodeIndex])
  {
    printf("error : new key is smaller than current key \n");
    return;
  }
  m_data[nodeIndex] = newKey;
  int tmpSwap;
  while(nodeIndex>0 && m_data[(nodeIndex-1)>>1] < m_data[nodeIndex])
  {
    tmpSwap = m_data[nodeIndex];
    m_data[nodeIndex] = m_data[(nodeIndex-1)>>1];
    m_data[(nodeIndex-1)>>1] = tmpSwap;
    nodeIndex = (nodeIndex-1)>>1;
  }
}