優先佇列 (轉)

優先佇列 (轉)[@more@]

下面是陣列實現的二叉堆，其中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;
  }

}