To_review_100_0---堆的整理

    引入：

    一些按照重要性或优先级来组织的对象称为优先队列。

    在普通队列数据结构中查找具有最高优先级元素的时间代价为O(n)，因而普通队列不能有效地实现优先队列。

    在有序表或无序表中插入和删除的时间代价都是O(n)。

    可以考虑使用把记录按优先级组织的BST，其平均情况下插入和删除操作的总时间代价为O(nlogn)，平均时间代价为O(logn)。但是BST可能会变得不平衡，这将导致BST性能变得很差。（若是完全二叉树就很好）

    堆可以解决上述问题。

    关于堆：

    1. 它是一棵完全二叉树，常用数组来实现。

    2. 对中存储的数据是局部有序的，包括最大堆和最小堆（无论最小堆还是最大堆，任何一个结点与其兄弟结点之间都没有必然联系）

    堆元素父节点与子节点映射于数组的关系：

    1. 父节点下标为i，则左子节点为2i+1，右子节点为2i+2。

    2. 子节点小标为i，则父节点为i-1/2。

    2. 叶子节点下标大于等于数组长度/2。

    性能分析：

    1. 建堆 O(n)，远比建立BST的平均时间复杂度O(nlogn)和最差时间复杂度O(n*n)要好得多。

    2. 删除对优先级最高的元素O(logn)

    C++实现代码：

#include <iostream>

#include <string>

using namespace std;

// Heap class

template <class E> class heap{

private:

 E* Heap;    // Pointer to the heap array

 int maxsize;   // Maximum size of the heap

 int n;     // Number of elements now in the heap

 bool Prior(E x, E y){

  return x > y;

 }

 void swap(E* source, int x, int y){

  E temp = source[x];

  source[x] = source[y];

  source[y] = temp;

 }

 void Assert(bool test, string error){

  if (!test){

   cout << error << endl;

   exit(1);

  }

 }

 // Helper function to put element in its correct place

 void siftdown(int pos){

  while (!isLeaf(pos)){ // Stop if pos is a leaf

   int j = leftchild(pos);

   int rc = rightchild(pos);

   if ((rc < n) && Prior(Heap[rc], Heap[j]))

    j = rc;   // Set j to greater child's value

   if (Prior(Heap[pos], Heap[j]))  

    return;   //Done

   swap(Heap, pos, j);

   pos = j;   //Move down

  }

 }

public:

 heap(E* h, int num, int max) // Constructor

 {

  Heap = h;

  n = num;

  maxsize = max;

  buildHeap();

 }

 int size() const{

  return n;

 }

 bool isLeaf(int pos) const{

  return (pos >= n / 2) && (pos < n);

 }

 int leftchild(int pos) const{

  return pos * 2 + 1;

 }

 int rightchild(int pos) const{

  return pos * 2 + 2;

 }

 int parent(int pos) const{

  return (pos - 1) / 2;

 }

 void buildHeap(){     //从暂时的堆的最底层父节点开始往上层调整

  for (int i = n / 2 - 1; i >= 0; i--)

   siftdown(i);

 }

 // Insert "it" into the heap

 void insert(const E& it){

  Assert(n < maxsize, "Heap is full");

  int cur = n++;

  Heap[curr] = it;    // Start at end of heap

  // Now sift up until curr's parnt>curr

  while ((curr != 0) && (Prior(Heap[curr], Heap[parent(curr)]))){ //只跟踪插入元素进行追踪调整

   swap(Heap, curr, parent(curr));

   curr = parent(curr);

  }

 }

 // Remove first value

 E removefirst(){

  Assert(n > 0, "Heap is empty");

  swap(Heap, 0, --n);

  if (n != 0)

   siftdown(0);     // Siftdown new root val

  return Heap
;      // Return deleted value 

 }

 // Remove and return element at specified position

 E remove(int pos){

  Assert((pos >= 0) && (pos < n), "Bad position");

  if (pos == (n - 1))

   n--; // Last element, no work to do

  else{

   swap(Heap, pos, --n);  //Swap with last value

   while ((pos != 0) && (Prior(Heap[pos], Heap[parent(pos)]))){  // Push up large key

    swap(Heap, pos, parent(pos));

    pos = parent(pos);

   }

   if (n != 0)

    siftdown(pos);              // Push down small key

  }

  return Heap
;

 }

};

int main(){

 int source[7] = { 7, 4, 6, 1, 2, 3, 5 };

 heap<int> test(source, 7, 100);

 cout << test.removefirst() << endl;

 cout << test.removefirst() << endl;

 cout << test.removefirst() << endl;

 cout << test.removefirst() << endl;

 return 0;

}

   

    感觉别人写得好多了=_=，附上网址：http://blog.csdn.net/morewindows/article/details/6709644/