Dijkstra算法

具体算法，算法导论中已经有非常清楚的介绍了，实现时使用最小堆是我在Haffman编码[2]中实现过的，直接拿来使用。

使用最小堆的一个方法中需要调整从起始点到某个节点的路径长度，开始考虑的一个策略是使用一个外部数组表示节点到Heap中index的映射，当Heap节点交换时，也要更新数组，保持映射的一致性。

后来看了写其他人的实现，还有另一种方法，就是不更新节点的weight，而是将新的节点weight直接push到最小堆中，因为新push的weight比较小，一定会先pop出来。

还有一个问题就是，在push是否要检查是否该节点已经访问过了，仔细想想这个检查是没有必要的，因为假设路径权重都是正值，那么如果pop出来的是以前访问过的节点，那么就存在一个回路了，也就是说不可能存在这种情况，这是Dijkstra算法保证的，采用这种方法无法判断Heap是否为空，但我们知道当所有节点都pop出来后，应该就可以结束了。

还有一点需要注意的时，更新vertex的weight之前和当前节点的weight进行比较，如果小于当前节点的weight才进行更新。

具体的代码实现如下：

#include <stdio.h>
#include <vector>
#include <string>
template<typename T, typename Compare = std::less<T>  >
class MinHeap {
 public:
  MinHeap() : size_(0) {}
  MinHeap(Compare compare) : compare_(compare), size_(0) {}
  T Pop() {
    T value;
    if (size_ > 0) {
      value = data_[0];
      Swap(data_[0], data_[size_ - 1]);
      size_--;
      if (size_ > 0) {
        Heapfy(0);
      }
      data_.pop_back();
    }
    return value;
  }
  void Push(const T& value) {
    data_.push_back(value);
    size_++;
    size_t index = size_ - 1;
    size_t parent;
    while(index > 0) {
      parent = Parent(index);
      if (compare_(data_[index], data_[parent])) {
        Swap(data_[index], data_[parent]);
        index = parent;
      } else {
        break;
      }
    }
  }
  size_t Size() {
    return size_;
  }
 private:
  void Swap(T& left, T& right) {
    T tmp = left;
    left = right;
    right = tmp;
  }
  size_t Parent(size_t child) {
    if (child != 0) {
      return (child - 1) / 2;
    } else {
      return 0;
    }
  }
  size_t LeftChild(size_t parent) {
    return (parent + 1) * 2 - 1;
  }
  size_t RightChild(size_t parent) {
    return (parent + 1) * 2;
  }
  void Heapfy(size_t index) {
    size_t min = index;
    size_t left = LeftChild(index);
    size_t right = RightChild(index);
    if ((left < size_) && compare_(data_[left],data_[index])) {
      min = left;
    }
    if ((right < size_) && compare_(data_[right],data_[min])) {
      min = right;
    }
    if (min != index) {
      Swap(data_[index], data_[min]);
      Heapfy(min);
    }
  }
  Compare compare_;
  size_t size_;
  std::vector<T> data_;
};
class Vertex {
 public:
  void Set(char name, int weight, int index) {
    name_ = name;
    weight_ = weight;
    index_ = index;
  }
  bool operator<(const Vertex& right) const {
    return weight_ < right.weight_;
  }
  char name_;
  int weight_;
  int index_;
};
int main(int argc, char** argv) {
  const int kVertexSize = 5;
  int ** adj = new int*[kVertexSize];
  for (int i = 0; i < kVertexSize; ++i) {
    adj[i] = new int[kVertexSize];
    for (int j = 0; j < kVertexSize; ++j) {
      adj[i][j] = -1;
    }
  }
  adj[0][1] = 10;
  adj[0][3] = 5;
  adj[1][2] = 1;
  adj[1][3] = 2;
  adj[2][4] = 4;
  adj[3][1] = 3;
  adj[3][2] = 9;
  adj[3][4] = 2;
  adj[4][0] = 7;
  adj[4][2] = 6;
  Vertex vertex[kVertexSize];
  const int kMaxInt = 0x7FFFFFFF;
  vertex[0].Set('s', 0, 0);
  vertex[1].Set('t', kMaxInt, 1);
  vertex[2].Set('x', kMaxInt, 2);
  vertex[3].Set('y', kMaxInt, 3);
  vertex[4].Set('z', kMaxInt, 4);  
  MinHeap<Vertex> path_length_queue;
  for (int i = 0; i < kVertexSize; ++i) {
    path_length_queue.Push(vertex[i]);
  }
  for (int i = 0; i < kVertexSize; ++i) {
    Vertex current = path_length_queue.Pop();
    printf("%c ", current.name_);
    for (int j = 0; j < kVertexSize; ++j) {
      if (adj[current.index_][j] > 0 &&
          vertex[j].weight_ > vertex[current.index_].weight_ + adj[current.index_][j]) {
        vertex[j].weight_ = vertex[current.index_].weight_ + adj[current.index_][j];
        path_length_queue.Push(vertex[j]);
      }
    }
  }
  printf("\n");
}  

参考文献

[1]算法导论 第24章 P366

[2]http://blog.csdn.net/bertzhang/article/details/7222004

[3]http://www.codeproject.com/Articles/24816/A-Fast-Priority-Queue-Implementation-of-the-Dijkst

[4]http://renaud.waldura.com/doc/java/dijkstra/