a better implementation of heap inspired by golang/heap

Author: xtaci

Makefile

@@ -53,8 +53,6 @@ PROGRAMS = m_based_demo \
 random_demo \
 k-means_demo \
 kmp_demo \
-heap_sort_demo \
-kruskal_mst_demo \
 LRU_cache_demo \
 base64_demo\
 max_subarray_demo \
@@ -209,9 +207,6 @@ k-means_demo: $(SRCDIR)/k-means_demo.cpp
 kmp_demo : $(SRCDIR)/kmp_demo.cpp
 $(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
 
-heap_sort_demo: $(SRCDIR)/heap_sort_demo.cpp
-$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
-
 kruskal_mst_demo: $(SRCDIR)/kruskal_mst_demo.cpp
 $(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
 

README.md

@@ -44,7 +44,6 @@
  Radix sort
  Quick sort
  Merge sort
- Heap sort
  Double linked list
  Skip list
  Self-organized linked-list ops (move-to-front, move-ahead-one)

include/astar.h

@@ -93,7 +93,7 @@ namespace alg {
 // initialy containing the start node
 // encoding [x,y] to [x*ncol + y]
 // using binary heap ...
-m_openset.insert(0, x1*ncol+y1);
+m_openset.push(0, x1*ncol+y1);
 // record the starting point in openset_grid
 m_openset_grid(x1,y1) = true;
 
@@ -109,7 +109,8 @@ namespace alg {
 
 // the main A*algorithm
 while(!m_openset.is_empty()) {
-uint32_t value = m_openset.min_value();
+Heap<uint32_t>::elem e = m_openset.pop();
+uint32_t value = e.data;
 intcx = value/ncol;
 intcy = value%ncol;
 
@@ -136,8 +137,7 @@ namespace alg {
 return as;
 }
 
-// delete current positon from openset and move it into closed set.
-m_openset.delete_min();
+// move it into closed set.
 m_closedset(cx, cy) = true;
 m_openset_grid(cx, cy) = false;
 
@@ -168,7 +168,7 @@ namespace alg {
 g_score(nx,ny) = tentative;// update path cost for current position
 f_score(nx,ny) = tentative + estimate(nx,ny,x2,y2);// record path cost to this neighbour
 if (!m_openset_grid(nx,ny)) {// only insert the neighbour if it hasn't been add to the openset.
-m_openset.insert(f_score(nx,ny), nx*ncol+ny);
+m_openset.push(f_score(nx,ny), nx*ncol+ny);
 m_openset_grid(nx,ny) = true;
 }
 }

include/dijkstra.h

@@ -37,6 +37,7 @@ namespace alg {
 class Dijkstra {
 public:
 static const int UNDEFINED = -1;
+static const int LARGE_NUMBER = 999999;
 // run dijkstra algorithm, and return the previous table
 static HashTable<int32_t, int32_t> * run(const Graph & g, uint32_t src_id) {
 // a binary heap
@@ -51,43 +52,35 @@ namespace alg {
 // all vertices
 Graph::Adjacent * a;
 list_for_each_entry(a, &g.list(), a_node){
-dist[a->v.id] = INT_MAX; // set inital distance to each vertex as INT_MAX
+dist[a->v.id] = LARGE_NUMBER; // set inital distance to each vertex to a large number
 (*previous)[a->v.id] = UNDEFINED; // clear path to UNDEFINED
 visited[a->v.id] = false; // all vertices are not visited
+Q.push(LARGE_NUMBER, a->v.id);// push all vertices to heap
 }
 
 // source vertex, the first vertex in Heap-Q
-Q.insert(0, src_id);
 dist[src_id] = 0;
+// decrease-key the source vertex to 0
+Q.decrease_key(src_id,0);
 
 while(!Q.is_empty()) { // for every un-visited vertex, try relaxing the path
-int32_t id = Q.min_value();
-Q.delete_min();// remove u from Q
-if (visited[id]) {// jump visited vertex, it means a closer vertex has found
-// printf("visted:%d %d\n", id, dist[id]);
+Heap<uint32_t>::elem e = Q.pop();
+uint32_t id = e.data;
+if (visited[id]) {// ignore visited vertex
 continue;
 }
 
 Graph::Adjacent * u = g[id];// the vertex to process
 int dist_u = dist[id];// current known shortest distance to u
-visited[id] = true;// mark the vertex as visited.
+visited[id] = true;// mark the vertex as visited.
 
 Graph::Vertex * v;
 list_for_each_entry(v, &u->v_head, v_node){
 uint32_t alt = dist_u + v->weight;
-uint32_t dist_v = dist[v->id];
-if (alt < dist_v) {
-/*
- uint32_t tmp = dist[v->id];
- if (tmp != INT_MAX) {
- printf("old %d %d\n", v->id, tmp);
- printf("new %d %d\n", v->id, dist[v->id]);
- }
- */
-
+if (alt < dist[v->id]) {
 dist[v->id] = alt;
-(*previous)[v->id] = u->v.id;
-Q.insert(alt, v->id);
+(*previous)[v->id] = id;
+Q.decrease_key(v->id, alt);// decrease-key
 }
 }
 }

include/heap.h

@@ -8,8 +8,8 @@
  * Heap Data structure
  *
  * Heaps can be used as an array. For any key at array position I,
- I left child is at ( 2i ), right child is at ( 2i+1 ) and parent is 
- I at (int) (i / 2). Heap size is stored at index 0.
+ * left child is at ( 2i ), right child is at ( 2i+1 ) and parent is 
+ * at (int) (i / 2). Heap size is stored at index 0.
  *
  * Basic operations of a heap are:
  *
@@ -27,80 +27,58 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <limits.h>
-#include "hash_code.h"
-#include "hash_table.h"
+#include "generic.h"
 
 namespace alg { 
 /**
  * define binary heap structure.
  */
 template<typename T>
 class Heap {
-private:
+public:
 /**
  * define key-value pair of heap struct.
  */
-struct KV {
+struct elem {
 public:
-int32_t key;
-T value;
+int key;
+T data;
 };
-int32_t m_size;// current heap size.
-int32_t m_max;// max heap size.
-KV * m_kvs;// key value pairs.
-
-HashTable<T, int32_t> * m_idx; // key -> idx
 
+private:
+int m_size;// current heap size.
+int m_max;// max heap size.
+elem * m_heap;// key value pairs.
 public:
 Heap(int max) {
 m_size = 0;
 m_max = max+1;
-m_kvs = new KV[m_max];
-m_kvs[0].key = INT_MIN;
-m_idx = new HashTable<T, int32_t>(m_max);
+m_heap = new elem[m_max];
 };
 
 ~Heap() {
-delete [] m_kvs;
-delete m_idx;
+delete [] m_heap;
 };
 
 private:
 Heap(const Heap &);
 Heap& operator=(const Heap&);
 
 public:
-
-inline int min_key() const { return m_kvs[1].key; };
-inline const T & min_value() const { return m_kvs[1].value; };
-
 // for loop through the kvs
-inline uint32_t count() const { return m_size; };
-inline const T & operator[] (uint32_t idx) const { return m_kvs[idx+1].value; };
+inline int count() const { return m_size; };
 
 /**
  * insert a 'key'->'value' pair into the heap.
  */
-void insert(int key, const T & value) {
+void push(int key, const T & data) {
 // heap full, just return;
 if(m_size == m_max) return; 
-
+// put in the back, and try move upward the heap
+m_heap[m_size].key = key;
+m_heap[m_size].data= data;
+up(m_size);
 m_size++;
-m_kvs[m_size].key= key;
-m_kvs[m_size].value= value;
-(*m_idx)[value] = m_size;
-
-// Adjust its position
-int now = m_size;
-while(m_kvs[now/2].key > key) {
-m_kvs[now] = m_kvs[now/2];
-(*m_idx)[m_kvs[now/2].value] = now;
-now /= 2;
-}
-
-m_kvs[now].key= key;
-m_kvs[now].value= value;
-(*m_idx)[value]	= now;
 }
 
 /**
@@ -113,84 +91,94 @@ namespace alg {
  */
 inline void clear() { m_size = 0; }
 
+bool contains(const T & data) {
+for(int i=1;i<=m_size;i++) {
+if(m_heap[i].data== data) return true;
+}
+return false;
+}
+
 /**
- * contains test
+ * pop the min element
  */
-bool contains(const T & value) {
-for(int32_t i=1;i<=m_size;i++) {
-if(m_kvs[i].value == value) return true;
-}
+elem pop() {
+int n = m_size-1;
+swap(m_heap[0],m_heap[n]);
+down(0, n);
+m_size--;
+return m_heap[m_size];
+}
 
+/**
+ * remove the given data
+ */
+bool remove(T data) {
+for (int i=0;i<m_size;i++) {// loop finding 
+if (m_heap[i].data == data) {// found
+int n = m_size-1;
+if (n != i) {
+swap(m_heap[i], m_heap[n]);
+down(i, m_size); 
+up(i);
+}
+m_size--;
+return true;
+}
+}
 return false;
 }
 
 /**
- * delete the min element --> heap top.
+ * decrease key
+ * simpliy implemented as remove then push
  */
-void delete_min() {
-// heap[1] is the minimum key. So we remove heap[1].
-// Size of the heap is decreased. Now heap[1] has to be filled.
-// We put the last key in its place and see if it fits. If it
-// does not fit, take minimum key among both its children and
-// replaces parent with it. Again See if the last key fits 
-//in that place.
-int32_t lastKey;
-T lastValue;
-int32_t child,now;
-
-// empty heap, just return
-if (m_size == 0) return; 
-
-lastKey = m_kvs[m_size].key;
-lastValue = m_kvs[m_size].value;
-m_size--;
+void decrease_key(T data, int newkey) {
+if (remove(data)) {
+push(newkey, data);
+}
+}
 
-// now refers to the index at which we are now
-for(now = 1; now*2 <= m_size ;now = child) {
-// child is the index of the key which is minimum among 
-// both the children, Indexes of children are i*2 and i*2 + 1
-child = now*2;
-// child!=heapSize beacuse heap[heapSize+1] does not exist, 
-// which means it has only one child 
-if(child != m_size && m_kvs[child+1].key < m_kvs[child].key) {
-child++;// choose the minium one.
+void up(int j) {
+for (;;) {
+int i = (j-1)/2; // parent
+if (i==j || !less(j,i)) {// j not smaller than i
+break;
 }
-// To check if the last key fits or not it suffices to check 
-// if the last key is less than the minimum key among both the children
-if(lastKey > m_kvs[child].key) {
-m_kvs[now] = m_kvs[child];
-(*m_idx)[m_kvs[now].value] = now;// record index
+swap(m_heap[i], m_heap[j]);
+j=i;
+}
+}
+
+void down(int i, int n) {
+for(;;) {
+int j1 = 2*i+1;// left child
+if (j1 >=n || j1 < 0) { // j1 < 0 after int overflow
+break;
+}
+
+int j = j1;
+int j2 = j1+1; // left child
+if (j2 < n && !less(j1,j2)) {
+j = j2; // choose the minium one.
 }
-else { // It fits there
+
+if (!less(j,i)) {
 break;
 }
+swap(m_heap[i], m_heap[j]);
+i=j;
 }
-
-m_kvs[now].key	= lastKey;
-m_kvs[now].value= lastValue;
-(*m_idx)[lastValue]	= now;// record index
 }
 
-/**
- * so called DECREASE KEY operation.
- * step 1. find the value
- * step 2. decrease the key to the newkey
- */
-void decrease_key(T value, int32_t newkey) {
-int32_t index = (*m_idx)[value];
-if (index > m_size || index == 0) return; // value not found 
-if (newkey >= m_kvs[index].key) return; // violate DECREASE meanning.
-T oldvalue = m_kvs[index].value;
-
-int now = index;
-while(m_kvs[now/2].key > newkey) {
-m_kvs[now] = m_kvs[now/2];
-(*m_idx)[m_kvs[now].value] = now;// record index
-now /= 2;
+void print_heap() {
+for (int i=0;i<m_size;i++) {
+printf("key:%d value:%d ", m_heap[i].key, m_heap[i].data);
 }
+printf("\n");
+}
 
-m_kvs[now].key	= newkey;
-m_kvs[now].value = oldvalue;
+bool less(int i, int j) {
+return m_heap[i].key < m_heap[j].key;
 }
 };
 }