优先队列

下面是数组实现的二叉堆，其中MAX_SIZE是数组的最大长度；ElementType是其中元素的类型；Priority(x: ElementType) 是一个函数，返回值是元素x的优先级，当然也可以用一个Priority数组来保存每个元素的优先级(在这个打字员问题中就应该用一个数组来保存每个元素的优先级，在这个问题中优先级就是从初始密码转换到该密码所需的操作的数目)。

type
 PriorityQueue = record
  contents: array [1..MAX_SIZE]of ElementType;
  last : integer;
 end;

{ 将一个优先队列变空 }
procedure MakeNull(var A: PriorityQueue);
begin
 A.last := 0;
end;

{ 向优先队列A中插入一个元素x }
procedure Insert(x: ElementType; var A: PriorityQueue);
var
 i: integer;
 temp:ElementType;
begin
 if A.last = MAX_SIZE then
  Error('Priority Queue is full.')
 else begin
  A.last := A.last + 1;
  A.contents[A.last] := x;
  i := A.last;
  while (i > 1) and ( Priority(A.contents[i]) < Priority(A.contents[i div 2]) do
  begin
   temp := A.contents[i];
   A.contents[i] := A.contents[i div 2];
   A.contents[i div 2] := temp;
   i := i div 2;
  end;  { end of while }
 end; { end of else }
end; { end of Insert }

{ 删除优先队列对头的那个优先级最小的元素，并将其值返回 }
function DeleteMin(var A: PriorityQueue): ElementType;
var
 minimun : ElementType;
 i : integer;
begin
 if A.last = 0 then
  Error('Priority Queue is empty. ')
 else begin
  minimun := A.contents[1];
  A.contents[1] := A.contents[A.last];
  A.last := A.last - 1;
  i := 1;
  while i < (A.last div 2) do
  begin
   if (Priority(A.contents[2*i]) < Priority(A.contents[2*i+1])) or (2*i = A.last)
    then j := 2*i
    else j := 2*i + 1;
   { j节点是i节点具有较高优先级的儿子，当i节点只有一个儿子的时候，j节点是i节点的唯一儿子 }

   if Priority(A.contents[i]) > Priority(A.contents[j]) then
   begin
    temp := A.contents[i];
    A.contents[i] := A.contents[j];
    A.contents[j] := temp;
    i := j;
   end
   else begin  { 不能再向下推了 }
    DeleteMin := minimum;
    exit;
   end;
  end; { end of while } 

  { 这时已经到达叶结点 }
  DeleteMin := minimum; 
  exit;
 end; { end of else }
end; { end of DeleteMin }
  

 优先队列插入和删除元素的复杂度都是O(lgn)，所以很快。

 

优先队列用C++描述如下

 
#define MAX_SIZE 100

typedef int ElementType;        // 定义元素的类型，这里假设是int类型

struct PriorityQueue {          // 定义优先队列
    ElementType contents[MAX_SIZE];
    int size;
};

int P[MAX_SIZE];

// 返回元素x的优先函数值，这个值越小说明优先级越高
int Priority(const ElementType& x)
{
    return P[x];    // 实际应用中通常用数组P来存储每个元素的优先级，
                    // 但是实际上也可以用其他方法（比如通过公式）计算出优先级
}

// 将一个优先队列变空
void MakeNull(PriorityQueue& Q)
{
    Q.size = 0;
}

// 向优先队列Q中插入一个元素x

void Insert(const ElementType& x, PriorityQueue& Q)
{
    int i;
    ElementType temp;

    if (Q.size == MAX_SIZE) {
        throw "Priority Queue is full.";
    } else {
        Q.contents[Q.size++] = x;
        i = Q.size - 1;     // 从最后一个元素开始
        while( ( i > 0 ) && ( Priority( Q.contents[i] ) < Priority( Q.contents[(i-1)/2] ) ) )
        {
            temp = Q.contents[i];
            Q.contents[i]       = Q.contents[(i-1)/2];
            Q.contents[(i-1)/2] = temp;
            i = (i-1) / 2;
        }

    }
}

// 删除优先队列对头的那个优先函数值最小的元素，并将其值返回
ElementType DeleteMin(PriorityQueue& Q)
{
    ElementType result;
    int i, j;

    if (Q.size == 0) {
        throw "PriorityQueue& Q";
    } else {
        result = Q.contents[0];
        Q.contents[0] = Q.contents[Q.size - 1];
        Q.size--;
        i = 0;
        while (2*i + 1 < Q.size) {
            // 节点i的左右儿子分别是2i+1和2i+2
            if( (2*i+1 == Q.size-1) ||
                ( Priority(Q.contents[2*i+1]) < Priority(Q.contents[2*i+2]) ) )
            {
                j = 2*i + 1;
            } else {
                j = 2*i + 2;
            }
            // j节点是i节点具有较小优先函数值的儿子，当i节点只有一个儿子的时候，j节点是i节点的唯一儿子

            if( Priority(Q.contents[i]) > Priority(Q.contents[j]) ) {
                temp = Q.contents[i];
                Q.contents[i] = Q.contents[j];
                Q.contents[j] = temp;
                i = j;
            } else {
                return result;
            }
        }

        return result;
    }

}