diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..8226360b
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,5 @@
+language: cpp
+compiler: 
+    - clang
+script:
+    - make
diff --git a/Makefile b/Makefile
index ed8cccc0..82f536a5 100644
--- a/Makefile
+++ b/Makefile
@@ -1,28 +1,29 @@
 .PHONY: all clean
-CC=gcc
-CPP=g++
+CC=clang
+CPP=clang++
 AR=ar
 RANLIB=ranlib
-CFLAGS= -g -Wall -Wno-unused-function -std=gnu++0x
+CFLAGS= -g -Wall -Wno-unused-function
+C11FLAGS= -g -Wall -Wno-unused-function -std=c++11
 SRCDIR = ./src
 INCLUDEDIR = -I./include -I.
 DEPS = 
 LIBS = -lm
-PROGRAMS =  m_based_demo \
+
+PROGRAMS = m_based_demo \
 			integer_demo \
-			insertion_sort_demo \
-			radix_sort_demo \
-			shuffle_demo \
-			quick_sort_demo \
-			merge_sort_demo \
-			random_select_demo \
-			hash_multi_demo \
-			hash_table_demo \
-			double_linked_list_demo \
-			stack_demo \
-			queue_demo \
-			priority_queue_demo \
-			prime_demo \
+       		insertion_sort_demo \
+					shell_sort_demo \
+       		radix_sort_demo \
+       		shuffle_demo \
+           	quick_sort_demo \
+           	merge_sort_demo \
+           	random_select_demo \
+           	hash_multi_demo \
+           	hash_table_demo \
+           	double_linked_list_demo \
+           	stack_demo \
+          	queue_demo \
 			universal_hash_demo \
 			perfect_hash_demo \
 			binary_search_tree_demo \
@@ -53,8 +54,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 \
@@ -69,13 +68,200 @@ PROGRAMS =  m_based_demo \
 			selection_sort_demo	\
 			8queue_demo \
 			palindrome_demo \
-			suffix_array_demo \
-			suffix_tree_demo
+			suffix_tree_demo \
+			avl_demo
 
 all: $(PROGRAMS)
 
-%: $(SRCDIR)/%.cpp $(DEPS)
-	$(CPP) $(CFLAGS) -o $@ $< $(INCLUDEDIR) $(LIBS)
+m_based_demo: $(SRCDIR)/m_based_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+integer_demo: $(SRCDIR)/integer_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+insertion_sort_demo: $(SRCDIR)/insertion_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+shell_sort_demo: $(SRCDIR)/shell_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+radix_sort_demo: $(SRCDIR)/radix_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+shuffle_demo: $(SRCDIR)/shuffle_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+quick_sort_demo: $(SRCDIR)/quick_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+merge_sort_demo: $(SRCDIR)/merge_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+random_select_demo: $(SRCDIR)/random_select_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+hash_multi_demo: $(SRCDIR)/hash_multi_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+hash_table_demo: $(SRCDIR)/hash_table_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+double_linked_list_demo: $(SRCDIR)/double_linked_list_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+stack_demo: $(SRCDIR)/stack_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+queue_demo: $(SRCDIR)/queue_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+priority_queue_demo: $(SRCDIR)/priority_queue_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+prime_demo: $(SRCDIR)/prime_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+universal_hash_demo: $(SRCDIR)/universal_hash_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+perfect_hash_demo: $(SRCDIR)/perfect_hash_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+binary_search_tree_demo: $(SRCDIR)/binary_search_tree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+rbtree_demo: $(SRCDIR)/rbtree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+heap_demo: $(SRCDIR)/heap_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+interval_tree_demo: $(SRCDIR)/interval_tree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+dos_tree_demo: $(SRCDIR)/dos_tree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+skiplist_demo: $(SRCDIR)/skiplist_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+lcs_demo: $(SRCDIR)/lcs_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+prim_mst_demo: $(SRCDIR)/prim_mst_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+directed_graph_demo: $(SRCDIR)/directed_graph_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+undirected_graph_demo: $(SRCDIR)/undirected_graph_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+dijkstra_demo: $(SRCDIR)/dijkstra_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+bellman_ford_demo: $(SRCDIR)/bellman_ford_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+graph_search_demo: $(SRCDIR)/graph_search_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+edmonds_karp_demo: $(SRCDIR)/edmonds_karp_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+astar_demo: $(SRCDIR)/astar_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+hash_string_demo: $(SRCDIR)/hash_string_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+bitset_demo: $(SRCDIR)/bitset_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+bloom_filter_demo: $(SRCDIR)/bloom_filter_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+sha1_demo: $(SRCDIR)/sha1_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+huffman_demo: $(SRCDIR)/huffman_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+word_seg_demo: $(SRCDIR)/word_seg_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+md5_demo: $(SRCDIR)/md5_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+trie_demo: $(SRCDIR)/trie_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+simhash_demo: $(SRCDIR)/simhash_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+imath_demo: $(SRCDIR)/imath_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+random_demo: $(SRCDIR)/random_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+k-means_demo: $(SRCDIR)/k-means_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+kmp_demo : $(SRCDIR)/kmp_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+kruskal_mst_demo: $(SRCDIR)/kruskal_mst_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+LRU_cache_demo: $(SRCDIR)/LRU_cache_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+base64_demo: $(SRCDIR)/base64_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+max_subarray_demo: $(SRCDIR)/max_subarray_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+disjoint-set_demo: $(SRCDIR)/disjoint-set_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+relabel_to_front_demo: $(SRCDIR)/relabel_to_front_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+btree_demo: $(SRCDIR)/btree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+sort_demo: $(SRCDIR)/sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+fib-heap_demo: $(SRCDIR)/fib-heap_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+scc_demo: $(SRCDIR)/scc_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+bubble_sort_demo: $(SRCDIR)/bubble_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+selection_sort_demo: $(SRCDIR)/selection_sort_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+8queue_demo: $(SRCDIR)/8queue_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+palindrome_demo: $(SRCDIR)/palindrome_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+suffix_tree_demo: $(SRCDIR)/suffix_tree_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+avl_demo: $(SRCDIR)/avl_demo.cpp
+	$(CPP) $(CFLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
+
+suffix_array_demo: $(SRCDIR)/suffix_array_demo.cpp
+	$(CPP) $(C11FLAGS) -o $@ $^ $(INCLUDEDIR) $(LIBS)
 
 clean:
-	rm -rf $(PROGRAMS) *.dSYM
+	rm -rf $(PROGRAMS) *.dSYM *.o
+
diff --git a/README.md b/README.md
index e907418f..b7fcffcb 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,11 @@
-###Algorithms & Data Structures in C++
+### Algorithms & Data Structures in C++
 
-####目标 ( goal ) :
+[![Build Status][1]][2]
+
+[1]: https://travis-ci.org/xtaci/algorithms.svg?branch=master
+[2]: https://travis-ci.org/xtaci/algorithms
+
+#### 目标 ( goal ) :
 
    1. 经典的算法实现      
       (classical algorithms implementations)      
@@ -9,7 +14,7 @@
    3. 正确，易于使用和改造, 一个头文件一个算法，并附带一个demo.       
       (correct! and ease of use, one .header file per algorithm)        
 
-####约定 ( Convention ):
+#### 约定 ( Convention ):
 
    1.  一个算法用一个.h文件表示放到include下. ( one .header file per algorithm. )
    2.  算法演示的demo程序放到src下.  ( one demo per algorithm.  )
@@ -21,81 +26,81 @@
    	eg:
    	![demograph](demo_graph.png)
 
-####已实现 ( Implemented ):
-
-    Array shuffle
-    Prime test(trial division)
-    Prime test(Miller-Rabin's method)
-    2D Array
-    Arbitary Integer
-    Linear congruential generator
-    Maximum subarray problem
-
-    Bit-Set
-    Queue
-    Stack
-    Binary Heap
-	Fibonacci Heap
-    Priority Queue (list based)
-
-	Bubble sort
-	Selection sort
-    Insertion sort
-    Radix sort
-    Quick sort
-    Merge sort
-    Heap sort
-    Double linked list
-    Skip list
-    Self-organized linked-list ops (move-to-front, move-ahead-one)
-    Largest common sequence
+#### 已实现 ( Implemented ):
 
-    Binary search tree
-    Dynamic order statistics
-    Red-black tree
-    Interval tree
-    Prefix Tree(Trie)
-    Suffix Tree
-    B-Tree
-	Suffix Array
+| Name | File |
+|------|------|
+|Array shuffle|https://github.com/xtaci/algorithms/blob/master/include/shuffle.h |
+|Prime test(trial division)|https://github.com/xtaci/algorithms/blob/master/include/prime.h|
+|Prime test(Miller-Rabin's method)|https://github.com/xtaci/algorithms/blob/master/include/prime.h|
+|2D Array|https://github.com/xtaci/algorithms/blob/master/include/2darray.h|
+|Arbitrary Integer|https://github.com/xtaci/algorithms/blob/master/include/integer.h|
+|Linear congruential generator|https://github.com/xtaci/algorithms/blob/master/include/random.h|
+|Maximum subarray problem|https://github.com/xtaci/algorithms/blob/master/include/max_subarray.h|
+|Bit-Set|https://github.com/xtaci/algorithms/blob/master/include/bitset.h|
+|Queue|https://github.com/xtaci/algorithms/blob/master/include/queue.h|
+|Stack|https://github.com/xtaci/algorithms/blob/master/include/stack.h|
+|Binary Heap|https://github.com/xtaci/algorithms/blob/master/include/heap.h|
+|Fibonacci Heap|https://github.com/xtaci/algorithms/blob/master/include/fib-heap.h|
+|Priority Queue (list based)|https://github.com/xtaci/algorithms/blob/master/include/priority_queue.h|
+|Bubble sort|https://github.com/xtaci/algorithms/blob/master/include/bubble_sort.h|
+|Selection sort|https://github.com/xtaci/algorithms/blob/master/include/selection_sort.h|
+|Insertion sort|https://github.com/xtaci/algorithms/blob/master/include/insertion_sort.h|
+|Shell sort|https://github.com/xtaci/algorithms/blob/master/include/shell_sort.h|
+|Radix sort|https://github.com/xtaci/algorithms/blob/master/include/radix_sort.h|
+|Quicksort|https://github.com/xtaci/algorithms/blob/master/include/quick_sort.h|
+|Merge sort|https://github.com/xtaci/algorithms/blob/master/include/merge_sort.h|
+|Double linked list|https://github.com/xtaci/algorithms/blob/master/include/double_linked_list.h|
+|Skip list|https://github.com/xtaci/algorithms/blob/master/include/skiplist.h|
+|Largest common sequence|https://github.com/xtaci/algorithms/blob/master/include/lcs.h|
+|Binary search tree|https://github.com/xtaci/algorithms/blob/master/include/binary_search_tree.h|
+|AVL tree|https://github.com/xtaci/algorithms/blob/master/include/avl.h|
+|Dynamic order statistics|https://github.com/xtaci/algorithms/blob/master/include/dos_tree.h|
+|Red-black tree|https://github.com/xtaci/algorithms/blob/master/include/rbtree.h|
+|Interval tree|https://github.com/xtaci/algorithms/blob/master/include/interval_tree.h|
+|Prefix Tree(Trie)|https://github.com/xtaci/algorithms/blob/master/include/trie.h|
+|Suffix Tree|https://github.com/xtaci/algorithms/blob/master/include/suffix_tree.h|
+|B-Tree|https://github.com/xtaci/algorithms/blob/master/include/btree.h|
+|Suffix Array|https://github.com/xtaci/algorithms/blob/master/include/suffix_array.h|
+|Hash by multiplication|https://github.com/xtaci/algorithms/blob/master/include/hash_multi.h|
+|Hash table|https://github.com/xtaci/algorithms/blob/master/include/hash_table.h|
+|Universal hash function|https://github.com/xtaci/algorithms/blob/master/include/universal_hash.h|
+|Perfect hash|https://github.com/xtaci/algorithms/blob/master/include/perfect_hash.h|
+|Java's string hash|https://github.com/xtaci/algorithms/blob/master/include/hash_string.h|
+|FNV-1a string hash|https://github.com/xtaci/algorithms/blob/master/include/hash_string.h|
+|SimHash|https://github.com/xtaci/algorithms/blob/master/include/simhash.h|
+|Bloom Filter|https://github.com/xtaci/algorithms/blob/master/include/bloom_filter.h|
+|SHA-1 Message Digest Algorithm|https://github.com/xtaci/algorithms/blob/master/include/sha1.h|
+|MD5|https://github.com/xtaci/algorithms/blob/master/include/md5.h|
+|Base64|https://github.com/xtaci/algorithms/blob/master/include/base64.h|
+|Strongly Connected Components(SCC)|https://github.com/xtaci/algorithms/blob/master/include/scc.h|
+|Prim's minimum spanning tree|https://github.com/xtaci/algorithms/blob/master/include/prim_mst.h|
+|Kruskal MST|https://github.com/xtaci/algorithms/blob/master/include/kruskal_mst.h|
+|Breadth First Search|https://github.com/xtaci/algorithms/blob/master/include/graph_search.h|
+|Depth First Search|https://github.com/xtaci/algorithms/blob/master/include/graph_search.h|
+|Dijkstra's algorithm|https://github.com/xtaci/algorithms/blob/master/include/dijkstra.h|
+|Bellman-Ford algorithm|https://github.com/xtaci/algorithms/blob/master/include/bellman_ford.h|
+|Edmonds-Karp Maximal Flow|https://github.com/xtaci/algorithms/blob/master/include/edmonds_karp.h|
+|Push–Relabel algorithm|https://github.com/xtaci/algorithms/blob/master/include/relabel_to_front.h|
+|Huffman Coding|https://github.com/xtaci/algorithms/blob/master/include/huffman.h|
+|Word segementation|https://github.com/xtaci/algorithms/blob/master/include/word_seg.h|
+|A\* algorithm|https://github.com/xtaci/algorithms/blob/master/include/astar.h|
+|K-Means|https://github.com/xtaci/algorithms/blob/master/include/k-means.h|
+|Knuth–Morris–Pratt algorithm|https://github.com/xtaci/algorithms/blob/master/include/kmp.h|
+|Disjoint-Set|https://github.com/xtaci/algorithms/blob/master/include/disjoint-set.h|
+|8-Queue Problem|https://github.com/xtaci/algorithms/blob/master/include/8queen.h|
+|Palindrome|https://github.com/xtaci/algorithms/blob/master/include/palindrome.h|
+|LCA using Binary Lifting|https://github.com/xtaci/algorithms/blob/master/include/LCA.h|
 
-    Hash by multiplication
-    Hash table
-    Universal hash function
-    Perfect hash
-    Java's string hash
-    FNV-1a string hash
-    SimHash
-    Bloom Filter
-    SHA-1 Message Digest Algorithm
-    MD5
-    Base64
-
-    Graph data structure
-	Strongly Connected Components(SCC)
-    Prim's minimum spanning tree
-    Kruskal MST
-    Directed/Undirected graph ops
-    Breadth First Search
-    Depth First Search
-    Dijkstra's algorithm
-    Bellman-Ford algorithm
-    Edmonds-Karp Maximal Flow
-    Push–Relabel algorithm
-
-    Huffman Coding
-    Word segementation(CHN/GB18030) using HMM and viterbi algorithm.
-    A* algorithm
-    K-Means
-    Knuth–Morris–Pratt algorithm
-    Disjoint-Set
-	8-Queue Problem
-	Palindrome
-
-####贡献者 ( Contributors ) :  
-    Samana :  for heavy work of MSVC compatability
+#### 贡献者 ( Contributors ) :  
+    Samana:  for heavy work of MSVC compatability
     wycg1984: for K-Means
     xmuliang: for HeapSort, Kruskal MST
     wyh267: for base64, LRU, bubble sort, selection sort
     ZhangYou0122: Push-Relabel algorithm, Suffix Tree           
-	UsingtcNower: Suffix Array        
+    UsingtcNower: Suffix Array
+    afernandez90: AVL trees
+
+#### 支持此项目 ( Donations ) :     
+![donate](donate_alg.png)          
+欢迎使用支付宝扫描上面的二维码，对该项目进行捐赠。捐赠款项将用于持续优化补全及完善。 
diff --git a/donate_alg.png b/donate_alg.png
new file mode 100644
index 00000000..04e73bb0
Binary files /dev/null and b/donate_alg.png differ
diff --git a/include/2darray.h b/include/2darray.h
index 1383e242..2a565810 100644
--- a/include/2darray.h
+++ b/include/2darray.h
@@ -10,8 +10,8 @@
  * Simulated by 1-dimension array.
  ******************************************************************************/
  
-#ifndef __2D_ARRAY_H__
-#define __2D_ARRAY_H__
+#ifndef ALGO_2D_ARRAY_H__
+#define ALGO_2D_ARRAY_H__
 #include <stdint.h>
 #include <stdlib.h>
 
diff --git a/include/8queen.h b/include/8queen.h
index 27062e3a..511ebe21 100644
--- a/include/8queen.h
+++ b/include/8queen.h
@@ -9,8 +9,8 @@
  * http://en.wikipedia.org/wiki/Eight_queens_puzzle
  ******************************************************************************/
 
-#ifndef __8QUEEN_H__
-#define __8QUEEN_H__
+#ifndef ALGO_8QUEEN_H__
+#define ALGO_8QUEEN_H__
 
 #include <stdio.h>
 #include <string.h>
@@ -84,4 +84,4 @@ namespace alg {
 	};
 }
 
-#endif //__8QUEEN_H__
+#endif //ALGO_8QUEEN_H__
diff --git a/include/LCA.h b/include/LCA.h
new file mode 100644
index 00000000..ef0eb098
--- /dev/null
+++ b/include/LCA.h
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ *
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _
+ * /--\ | (_| (_) |  |  |_ | | | | | _>
+ *         _|
+ *
+ * LCA Finding using Binary Lifting and Dynamic Programming
+ *
+ * Features:
+ * 1. Answers Query about LCA of two nodes in O(log N)
+ *          where N is the total number of nodes in a tree.
+ *
+ * https://en.wikipedia.org/wiki/Lowest_common_ancestor
+ * http://www.csegeek.com/csegeek/view/tutorials/algorithms/trees/tree_part12.php
+ ******************************************************************************/
+
+#ifndef LCA_H
+#define LCA_H
+#include <vector>
+
+class LCA
+{
+    public:
+        LCA(std::vector< std::pair<int,int> > edges);
+        int lcaQuery(int a, int b);
+
+    private:
+        int getMaxLog();
+        void initDP();
+        void dfs(int currentNode, int currentParent);
+        std::vector< std::vector<int> > adjList, binaryLiftDp;
+        std::vector<int> parent, nodeHeight;
+        std::vector<bool> visited;
+        int _numberOfNodes, _maxLog;
+};
+
+#endif // LCA_H
diff --git a/include/astar.h b/include/astar.h
index 78fa276f..a821488d 100644
--- a/include/astar.h
+++ b/include/astar.h
@@ -19,8 +19,8 @@
  *
  ******************************************************************************/
 
-#ifndef __ASTAR_H__
-#define __ASTAR_H__
+#ifndef ALGO_ASTAR_H__
+#define ALGO_ASTAR_H__
 
 #include <stdlib.h>
 #include <stdint.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;
 					int	cx = value/ncol;
 					int	cy = 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;
 								}
 							}
diff --git a/include/avl.h b/include/avl.h
new file mode 100644
index 00000000..697317ab
--- /dev/null
+++ b/include/avl.h
@@ -0,0 +1,243 @@
+/*******************************************************************************
+ * ALGORITHM IMPLEMENTAIONS
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
+ * /--\ | (_| (_) |  |  |_ | | | | | _> 
+ *         _|                      
+ *
+ * Adelson-Velskii and Landis' (AVL) tree
+ *
+ * Features, being N the number of elements in the tree:
+ * 1. Guaranteed search time is O(log(N)).
+ * 2. Dynamically updated/balanced tree structure O(N) storage.
+ * 3. Exportable to GraphViz format for easy visualization and verification
+ *
+ * http://en.wikipedia.org/wiki/AVL_tree
+ * 
+ * @author Alejandro Fernandez (alejandro.fernandez.suarez@gmail.com)
+ * @github afernandez90
+ *
+ ******************************************************************************/
+
+#ifndef ALGO_AVL_H__
+#define ALGO_AVL_H__
+
+#include <iostream>
+#include <cmath>
+#include <stack>
+#include <algorithm>
+#include <string>
+
+namespace alg {
+
+template <typename T>
+class AVL {
+
+    public:
+
+        AVL() : tree(0), numNodes(0) {}
+
+        T root () const           { return tree->value; }
+        unsigned height() const   { return Node::getHeight(tree); }
+        unsigned size() const     { return numNodes; }
+        bool isEmpty() const      { return numNodes == 0; }
+
+        bool contains(const T &x) const {
+            if (!isEmpty()) {
+                return tree->contains(x);
+            } else return false;
+        }
+
+        void insert(const T &x) {
+            if (isEmpty()) tree = new Node(x);
+            else tree = tree->insert(x);
+            numNodes++;
+        }
+
+        void erase(const T &x) {
+            if (!isEmpty()) {
+                bool found = false;
+                tree = tree->erase(x, found);
+                if (found) numNodes--;
+            }
+        }
+
+        void toGraphViz(std::ostream &stream, std::string name) const {
+            if (!isEmpty()) {
+                stream << "digraph " << name << " {" << std::endl;
+                tree->toGraphViz(stream);
+                stream << "}" << std::endl;
+            }
+        }
+
+    public:
+
+        struct Node {
+            Node *left, *right;
+            T value;
+            unsigned height;
+
+            Node(const T &x) : left(0), right(0), value(x), height(1) {}
+
+            bool contains(const T &x) const {
+                if (value == x) return true;
+                else if (x < value && left != 0) return left->contains(x);
+                else if (right != 0) return right->contains(x);
+                else return false;
+            }
+
+            Node *insert(const T &x) {
+                if (x <= value) {
+                    if (left == 0) left = new Node(x);
+                    else left = left->insert(x);
+                }
+                else {
+                    if (right == 0) right = new Node(x);
+                    else right = right->insert(x);
+                }
+
+                return update();
+            }
+
+            Node *erase(const T &x, bool &found) {
+                if (value == x) {
+                    found = true;
+                    if (left == 0 && right == 0) {
+                        delete this;
+                        return 0;
+                    } else if (left == 0) {
+                        Node *aux = right;
+                        *this = *right;
+                        delete aux;
+                    } else if (right == 0) {
+                        Node *aux = left;
+                        *this = *left;
+                        delete aux;
+                    } else {
+                        // Tracing path to rightmost leaf of the left subtree
+                        std::stack<Node*> trace;
+
+                        Node *current = left;
+                        while (current != 0) {
+                            trace.push(current);
+                            current = current->right;
+                        }
+
+                        current = trace.top();
+                        value = current->value;
+                        Node *lsubtree = current->left;
+                        delete current;
+                        trace.pop();
+
+                        if (trace.empty()) { left = lsubtree; }
+                        else {
+                            trace.top()->right = lsubtree;
+                            trace.pop();
+                            while (!trace.empty()) {
+                                current = trace.top();
+                                current->right = current->right->update();
+                                trace.pop();
+                            }
+                        }
+                    }
+                    return update();
+                }
+                else if (x < value) {
+                    if (left != 0) {
+                        left = left->erase(x, found);
+                        return update();
+                    } else return this;
+                }
+                else {
+                    if (right != 0) {
+                        right = right->erase(x, found);
+                        return update();
+                    } else return this;
+                }
+            }
+
+            Node *update() {
+                updateHeight();
+
+                if (getBF(this) >= 2) {
+                    if (getBF(left) <= -1) LR();
+                    return LL();
+                } else if (getBF(this) <= -2) {
+                    if (getBF(right) >= 1) RL();
+                    return RR();
+                } else return this;
+            }
+
+            void updateHeight() { height = std::max(getHeight(left), getHeight(right)) + 1; }
+
+            void LR() {
+                Node *lrcopy = left->right;
+                left->right = lrcopy->left;
+                lrcopy->left = left;
+                left = lrcopy;
+                left->left->updateHeight();
+                left->updateHeight();
+                updateHeight();
+            }
+
+            void RL() {
+                Node *rlcopy = right->left;
+                right->left = rlcopy->right;
+                rlcopy->right = right;
+                right = rlcopy;
+                right->right->updateHeight();
+                right->updateHeight();
+                updateHeight();
+            }
+
+            Node *LL() {
+                Node *lcopy = left;
+                left = left->right;
+                lcopy->right = this;
+                lcopy->left->updateHeight();
+                lcopy->right->updateHeight();
+                lcopy->updateHeight();
+                return lcopy;
+            }
+
+            Node *RR() {
+                Node *rcopy = right;
+                right = right->left;
+                rcopy->left = this;
+                rcopy->left->updateHeight();
+                rcopy->right->updateHeight();
+                rcopy->updateHeight();
+                return rcopy;
+            }
+
+            static int getBF(const Node *t) {
+                return getHeight(t->left) - getHeight(t->right);
+            }
+
+            static int getHeight(const Node *t) {
+                return t == 0 ? 0 : t->height;
+            }
+
+            void toGraphViz(std::ostream &stream) const {
+                stream << value << ";" << std::endl;
+                if (left != 0) {
+                    stream << left->value << ";" << std::endl;
+                    stream << value << "->" << left->value << ";" << std::endl;
+                    left->toGraphViz(stream);
+                }
+                if (right != 0) {
+                    stream << right->value << ";" << std::endl;
+                    stream << value << "->" << right->value << ";" << std::endl;
+                    right->toGraphViz(stream);
+                }
+            }
+        };
+
+        Node *tree;
+        unsigned numNodes;
+};
+
+}       // namespace alg
+
+#endif  // _ALG_AVL_HPP
+
diff --git a/include/bellman_ford.h b/include/bellman_ford.h
index 2d6df417..40771ae4 100644
--- a/include/bellman_ford.h
+++ b/include/bellman_ford.h
@@ -44,8 +44,8 @@
  * 
  ******************************************************************************/
 
-#ifndef __BELLMAN_FORD_H__
-#define __BELLMAN_FORD_H__
+#ifndef ALGO_BELLMAN_FORD_H__
+#define ALGO_BELLMAN_FORD_H__
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/include/binary_search_tree.h b/include/binary_search_tree.h
index 21ff297a..574914af 100644
--- a/include/binary_search_tree.h
+++ b/include/binary_search_tree.h
@@ -8,7 +8,7 @@
  * BINARY SEARCH TREE
  *
  * Features:
- * 1. Expected search time is O(nlogn).
+ * 1. Expected search time is O(log(n)), with worst case O(n).
  * 2. Data should be !!!SHUFFLED!!! first before tree creation.
  * 3. First initialize the value of the root (pointer to the 
  *    structure treeNode) with NULL. eg:
@@ -18,8 +18,8 @@
  *
  ******************************************************************************/
 
-#ifndef __BINARY_SEARCH_TREE_H__
-#define __BINARY_SEARCH_TREE_H__
+#ifndef ALGO_BINARY_SEARCH_TREE_H__
+#define ALGO_BINARY_SEARCH_TREE_H__
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -31,7 +31,7 @@ namespace alg {
 		class BST {
 			private:
 				/**
-				 * binary search tree definiton.
+				 * binary search tree definition.
 				 */
 				struct treeNode {
 					KeyT 	key;			// key
@@ -57,7 +57,7 @@ namespace alg {
 				BST():m_root(NULL){};
 
 				~BST() {
-					__destruct(m_root);
+					destruct_(m_root);
 				}
 
 				/**
@@ -159,10 +159,10 @@ namespace alg {
 				}
 
 			private:
-				void __destruct(treeNode *n) {
+				void destruct_(treeNode *n) {
 					if (n==NULL) return;
-					__destruct(n->left);
-					__destruct(n->right);
+					destruct_(n->left);
+					destruct_(n->right);
 					delete n;
 				}
 
diff --git a/include/bitset.h b/include/bitset.h
index 83171c12..9e7b9bbc 100644
--- a/include/bitset.h
+++ b/include/bitset.h
@@ -11,8 +11,8 @@
  *
  ******************************************************************************/
 
-#ifndef __BIT_SET_H__
-#define __BIT_SET_H__
+#ifndef ALGO_BIT_SET_H__
+#define ALGO_BIT_SET_H__
 
 #include <stdlib.h>
 #include <stdint.h>
diff --git a/include/bloom_filter.h b/include/bloom_filter.h
index 810badd5..08253593 100644
--- a/include/bloom_filter.h
+++ b/include/bloom_filter.h
@@ -18,8 +18,8 @@
  * 
  ******************************************************************************/
 
-#ifndef __BLOOM_FILTER_H__
-#define __BLOOM_FILTER_H__
+#ifndef ALGO_BLOOM_FILTER_H__
+#define ALGO_BLOOM_FILTER_H__
 
 #include <stdint.h>
 #include <stdbool.h>
diff --git a/include/btree.h b/include/btree.h
index bec96048..6e17050f 100644
--- a/include/btree.h
+++ b/include/btree.h
@@ -24,8 +24,8 @@
  * http://en.wikipedia.org/wiki/B-tree
  ******************************************************************************/
 
-#ifndef __BTREE_H__
-#define __BTREE_H__
+#ifndef ALGO_BTREE_H__
+#define ALGO_BTREE_H__
 
 #include <stdio.h>
 #include <assert.h>
diff --git a/include/dictionary.h b/include/dictionary.h
new file mode 100644
index 00000000..4c38a9cf
--- /dev/null
+++ b/include/dictionary.h
@@ -0,0 +1,562 @@
+/*******************************************************************************
+* DANIEL'S ALGORITHM IMPLEMENTAIONS
+*
+*  /\  |  _   _  ._ o _|_ |_  ._ _   _
+* /--\ | (_| (_) |  |  |_ | | | | | _>
+*         _|
+* 
+* .Net Dictionary Implementation (Cache friendly hash table)
+*
+******************************************************************************/
+
+#pragma once
+
+#include <cstdint>
+#include <cassert>
+#include <vector>
+#include "hash_code.h"
+#include "prime.h"
+
+namespace alg
+{
+
+template< typename TKey, typename TValue, typename THash = hash_code<TKey> >
+class Dictionary
+{
+public:
+	struct KeyValuePair
+	{
+		TKey Key;
+		TValue Value;
+	};
+
+private:
+	struct Entry : public KeyValuePair
+	{
+		int32_t HashCode;
+		int32_t Next;
+
+		Entry()
+			: HashCode(-1)
+			, Next(-1)
+		{
+		}
+
+		void Reset()
+		{
+			HashCode = -1;
+			Next = -1;
+			Key = TKey();
+			Value = TValue();
+		}
+	};
+
+private:
+	std::vector<int32_t> m_Buckets;
+	std::vector<Entry> m_Entries;
+	int32_t m_Count;
+	int32_t m_FreeList;
+	int32_t m_FreeCount;
+
+	friend class Iterator;
+public:
+
+	template<typename DictType, typename EntryType, typename TIter>
+	class IteratorBase
+	{
+	protected:
+		DictType* Dict;
+		int32_t Index;
+		EntryType* Current;
+
+		friend class Dictionary;
+
+		IteratorBase(DictType* dict)
+			: Dict(dict)
+			, Index(0)
+			, Current(nullptr)
+		{
+		}
+
+	public:
+		TIter& operator++()
+		{
+			while ((uint32_t) Index < (uint32_t) Dict->m_Count)
+			{
+				if (Dict->m_Entries[Index].HashCode >= 0)
+				{
+					Current = &Dict->m_Entries[Index];
+					Index++;
+					return *static_cast<TIter*>(this);
+				}
+				Index++;
+			}
+
+			Index = Dict->m_Count + 1;
+			Current = nullptr;
+			return *static_cast<TIter*>(this);
+		}
+
+		TIter operator++(int32_t)
+		{
+			TIter tmp = *static_cast<TIter*>(this);
+			++(*this);
+			return tmp;
+		}
+
+		bool operator == (const TIter& other) const
+		{
+			return Dict == other.Dict
+				&& Index == other.Index
+				&& Current == other.Current;
+		}
+
+		bool operator != (const TIter& other) const
+		{
+			return !(*this == other);
+		}
+	};
+
+	class Iterator : public IteratorBase<Dictionary, Entry, Iterator>
+	{
+		friend class Dictionary;
+	private:
+		Iterator(Dictionary* dict)
+			: IteratorBase<Dictionary, Entry, Iterator>(dict)
+		{
+		}
+	public:
+		KeyValuePair& operator*() const
+		{
+			return *Current;
+		}
+	};
+
+	class ConstIterator : public IteratorBase<const Dictionary, const Entry, ConstIterator>
+	{
+		friend class Dictionary;
+	private:
+		ConstIterator(const Dictionary* dict)
+			: IteratorBase<const Dictionary, const Entry, ConstIterator>(dict)
+		{
+		}
+	public:
+		const KeyValuePair& operator*() const
+		{
+			return *Current;
+		}
+	};
+
+public:
+	typedef Iterator iterator;
+	typedef ConstIterator const_iterator;
+
+public:
+	Dictionary(int32_t capacity = 0)
+		: m_Count(0)
+		, m_FreeList(-1)
+		, m_FreeCount(0)
+	{
+		_Init(capacity);
+	}
+
+	~Dictionary()
+	{
+		Clear();
+	}
+
+	int32_t Size() const
+	{
+		return m_Count - m_FreeCount;
+	}
+
+	TValue& operator[](const TKey& key)
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return m_Entries[i].Value;
+		}
+		throw MxKeyNotFoundException();
+	}
+	const TValue& operator[](const TKey& key) const
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return m_Entries[i].Value;
+		}
+		throw MxKeyNotFoundException();
+	}
+
+	bool TryGetValue(const TKey& key, TValue& outValue) const
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			outValue = m_Entries[i].Value;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	TValue TryGetValueOrDefault(const TKey& key, const TValue& defaultValue) const
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return m_Entries[i].Value;
+		}
+		else
+		{
+			return defaultValue;
+		}
+	}
+
+	const TValue& TryGetValueRefOrDefault(const TKey& key, const TValue& defaultValue) const
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return m_Entries[i].Value;
+		}
+		else
+		{
+			return defaultValue;
+		}
+	}
+
+	TValue* TryGetValuePtr(const TKey& key)
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return &m_Entries[i].Value;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+
+	const TValue* TryGetValuePtr(const TKey& key) const
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return &m_Entries[i].Value;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+
+	void AddOrUpdate(const TKey& key, const TValue& value)
+	{
+		_Insert(key, value, false);
+	}
+
+	bool ContainsKey(const TKey& key) const
+	{
+		int32_t i = _FindEntry(key);
+		return i >= 0;
+	}
+
+	bool Contains(const std::pair<TKey, TValue>& pair) const
+	{
+		int32_t i = _FindEntry(pair.first);
+		return i >= 0 && pair.second == m_Entries[i].Value;
+	}
+
+	bool Add(const TKey& key, const TValue& value)
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return false;
+		}
+
+		return _Insert(key, value, true);
+	}
+
+	bool Add(const TKey& key, TValue&& value)
+	{
+		int32_t i = _FindEntry(key);
+		if (i >= 0)
+		{
+			return false;
+		}
+
+		return _Insert(key, value, true);
+	}
+
+	bool Remove(const TKey& key)
+	{
+		int32_t hashCode = THash()(key) & 0x7FFFFFFF;
+		int32_t bucket = hashCode % m_Buckets.size();
+		int32_t last = -1;
+		for (int i = m_Buckets[bucket]; i >= 0; last = i, i = m_Entries[i].Next)
+		{
+			if (m_Entries[i].HashCode == hashCode && m_Entries[i].Key == key)
+			{
+				if (last < 0)
+				{
+					m_Buckets[bucket] = m_Entries[i].Next;
+				}
+				else
+				{
+					m_Entries[last].Next = m_Entries[i].Next;
+				}
+				m_Entries[i].HashCode = -1;
+				m_Entries[i].Next = m_FreeList;
+				m_Entries[i].Key = TKey();
+				m_Entries[i].Value = TValue();
+				m_FreeList = i;
+				m_FreeCount++;
+
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void Clear()
+	{
+		if (m_Count > 0)
+		{
+			memset(m_Buckets.data(), -1, m_Buckets.size() * sizeof(m_Buckets[0]));
+			for (auto& entry : m_Entries)
+			{
+				entry.Reset();
+			}
+			m_FreeList = -1;
+			m_FreeCount = 0;
+			m_Count = 0;
+		}
+	}
+
+	Iterator Begin()
+	{
+		return ++Iterator(this);
+	}
+
+	ConstIterator Begin() const
+	{
+		return CBegin();
+	}
+
+	ConstIterator CBegin() const
+	{
+		return ++ConstIterator(this);
+	}
+
+	Iterator End()
+	{
+		Iterator ret(this);
+		ret.Index = m_Count + 1;
+		ret.Current = nullptr;
+		return ret;
+	}
+
+	ConstIterator End() const
+	{
+		return CEnd();
+	}
+
+	ConstIterator CEnd() const
+	{
+		ConstIterator ret(this);
+		ret.Index = m_Count + 1;
+		ret.Current = nullptr;
+		return ret;
+	}
+
+	//STL style
+	iterator begin()
+	{
+		return Begin();
+	}
+
+	const_iterator begin() const
+	{
+		return CBegin();
+	}
+
+	const_iterator cbegin() const
+	{
+		return CBegin();
+	}
+
+	iterator end()
+	{
+		return End();
+	}
+
+	const_iterator end() const
+	{
+		return CEnd();
+	}
+
+	const_iterator cend() const
+	{
+		return CEnd();
+	}
+private:
+	int32_t _FindEntry(const TKey& key) const
+	{
+		if (m_Buckets.size() > 0)
+		{
+			int32_t hashCode = THash()(key) & 0x7FFFFFFF;
+			for (int32_t i = m_Buckets[hashCode % m_Buckets.size()]; i >= 0; i = m_Entries[i].Next)
+			{
+				if (m_Entries[i].HashCode == hashCode && m_Entries[i].Key == key)
+				{
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+
+	void _Init(int32_t capacity)
+	{
+		int32_t size = GetNextPrime(capacity);
+		m_Buckets.clear();
+		m_Buckets.resize(size, -1);
+		m_Entries.clear();
+		m_Entries.resize(size);
+		m_FreeList = -1;
+	}
+
+	template<typename TValueRef>
+	bool _Insert(const TKey& key, TValueRef value, bool add)
+	{
+		if (m_Buckets.size() == 0)
+		{
+			_Init(3);
+		}
+
+		int32_t hashCode = THash()(key) & 0x7FFFFFFF;
+		int32_t targetBucket = hashCode % m_Buckets.size();
+
+		for (int32_t i = m_Buckets[targetBucket]; i >= 0; i = m_Entries[i].Next)
+		{
+			if (m_Entries[i].HashCode == hashCode && m_Entries[i].Key == key)
+			{
+				if (add)
+				{
+					return false;
+				}
+				m_Entries[i].Value = value;
+				return true;
+			}
+		}
+
+		int32_t index;
+		if (m_FreeCount > 0)
+		{
+			index = m_FreeList;
+			m_FreeList = m_Entries[index].Next;
+			m_FreeCount--;
+		}
+		else
+		{
+			if (m_Count == m_Entries.size())
+			{
+				_Resize();
+				targetBucket = hashCode % m_Buckets.size();
+			}
+			index = m_Count;
+			m_Count++;
+		}
+
+		m_Entries[index].HashCode = hashCode;
+		m_Entries[index].Next = m_Buckets[targetBucket];
+		m_Entries[index].Key = key;
+		m_Entries[index].Value = value;
+
+		m_Buckets[targetBucket] = index;
+
+		return true;
+	}
+
+	void _Resize()
+	{
+		_Resize(GetNextPrime(m_Count * 2), false);
+	}
+
+	void _Resize(int32_t newSize, bool forceNewHashCodes)
+	{
+		assert(newSize >= m_Entries.size());
+
+		m_Buckets.resize(0);
+		m_Buckets.resize(newSize, -1);
+		m_Entries.resize(newSize);
+
+		if (forceNewHashCodes)
+		{
+			for (int32_t i = 0; i < m_Count; i++)
+			{
+				if (m_Entries[i].HashCode != -1)
+				{
+					m_Entries[i].HashCode = (THash()(m_Entries[i].Key) & 0x7FFFFFFF);
+				}
+			}
+		}
+		for (int32_t i = 0; i < m_Count; i++)
+		{
+			if (m_Entries[i].HashCode >= 0)
+			{
+				int32_t bucket = m_Entries[i].HashCode % newSize;
+				m_Entries[i].Next = m_Buckets[bucket];
+				m_Buckets[bucket] = i;
+			}
+		}
+	}
+
+
+	static int GetNextPrime(int n)
+	{
+		static const int c_PrimeArraySize = 72;
+		static const int c_Primes[c_PrimeArraySize] =
+		{
+			3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
+			1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
+			17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
+			187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
+			1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369
+		};
+		static const int c_HashPrime = 101;
+
+		if (n < 0)
+		{
+			return -1;
+		}
+
+		for (int i = 0; i < c_PrimeArraySize; i++)
+		{
+			int prime = c_Primes[i];
+			if (prime >= n)
+			{
+				return prime;
+			}
+		}
+
+		//outside of our predefined table. 
+		//compute the hard way. 
+		for (int i = (n | 1); i < INT32_MAX; i += 2)
+		{
+			if (is_prime(i) && ((i - 1) % c_HashPrime != 0))
+			{
+				return i;
+			}
+		}
+		return n;
+	}
+};
+
+}
\ No newline at end of file
diff --git a/include/dijkstra.h b/include/dijkstra.h
index c7b9c9c3..853376cc 100644
--- a/include/dijkstra.h
+++ b/include/dijkstra.h
@@ -19,8 +19,8 @@
  *
  ******************************************************************************/
 
-#ifndef __DIJKSTRA_H__
-#define __DIJKSTRA_H__
+#ifndef ALGO_DIJKSTRA_H__
+#define ALGO_DIJKSTRA_H__
 
 #include <stdio.h>
 #include <stdlib.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 initial 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 && !visited[v->id]) {
-							/*
-							   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
 						}
 					}
 				}
diff --git a/include/directed_graph.h b/include/directed_graph.h
index 0eb8e56e..9e46cfe0 100644
--- a/include/directed_graph.h
+++ b/include/directed_graph.h
@@ -14,8 +14,8 @@
  *
  ******************************************************************************/
 
-#ifndef __DIRECTED_GRAPH_H__
-#define __DIRECTED_GRAPH_H__
+#ifndef ALGO_DIRECTED_GRAPH_H__
+#define ALGO_DIRECTED_GRAPH_H__
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/include/disjoint-set.h b/include/disjoint-set.h
index c13a002e..be6bff7d 100644
--- a/include/disjoint-set.h
+++ b/include/disjoint-set.h
@@ -18,8 +18,8 @@
  * http://en.wikipedia.org/wiki/Disjoint-set_data_structure
  ******************************************************************************/
 
-#ifndef __DISJOINTSET_H__
-#define __DISJOINTSET_H__
+#ifndef ALGO_DISJOINTSET_H__
+#define ALGO_DISJOINTSET_H__
 
 namespace alg {
 	template<typename T>
diff --git a/include/dos_tree.h b/include/dos_tree.h
index 7440990f..42689457 100644
--- a/include/dos_tree.h
+++ b/include/dos_tree.h
@@ -16,8 +16,8 @@
  *
  ******************************************************************************/
 
-#ifndef __DOS_TREE_H__
-#define __DOS_TREE_H__
+#ifndef ALGO_DOS_TREE_H__
+#define ALGO_DOS_TREE_H__
 
 #include <stdlib.h>
 #include <assert.h>
diff --git a/include/double_linked_list.h b/include/double_linked_list.h
index 7b8a8637..678c66b8 100644
--- a/include/double_linked_list.h
+++ b/include/double_linked_list.h
@@ -16,8 +16,8 @@
  * http://en.wikipedia.org/wiki/Double_linked_list
  ******************************************************************************/
 
-#ifndef __DOUBLE_LINKED_LIST_H__
-#define __DOUBLE_LINKED_LIST_H__
+#ifndef ALGO_DOUBLE_LINKED_LIST_H__
+#define ALGO_DOUBLE_LINKED_LIST_H__
 
 struct list_head {
 	struct list_head *next, *prev;
@@ -39,7 +39,7 @@ struct list_head {
  * the prev/next entries already!
  */
 static inline void 
-__list_add(struct list_head *n,
+list_add_(struct list_head *n,
 			      struct list_head *prev,
 			      struct list_head *next)
 {
@@ -57,14 +57,14 @@ __list_add(struct list_head *n,
  * the prev/next entries already!
  */
 static inline void 
-__list_del(struct list_head *prev, struct list_head *next)
+list_del_(struct list_head *prev, struct list_head *next)
 {
 	next->prev = prev;
 	prev->next = next;
 }
 
 static inline void 
-__list_splice(struct list_head *list, struct list_head *head)
+list_splice_(struct list_head *list, struct list_head *head)
 {
 	struct list_head *first = list->next;
 	struct list_head *last = list->prev;
@@ -88,7 +88,7 @@ __list_splice(struct list_head *list, struct list_head *head)
 static inline void 
 list_add(struct list_head *n, struct list_head *head)
 {
-	__list_add(n, head, head->next);
+	list_add_(n, head, head->next);
 }
 
 /**
@@ -102,7 +102,7 @@ list_add(struct list_head *n, struct list_head *head)
 static inline void 
 list_add_tail(struct list_head *n, struct list_head *head)
 {
-	__list_add(n, head->prev, head);
+	list_add_(n, head->prev, head);
 }
 
 /**
@@ -113,7 +113,7 @@ list_add_tail(struct list_head *n, struct list_head *head)
 static inline void 
 list_del(struct list_head *entry)
 {
-	__list_del(entry->prev, entry->next);
+	list_del_(entry->prev, entry->next);
 	entry->next = NULL;
 	entry->prev = NULL;
 }
@@ -125,7 +125,7 @@ list_del(struct list_head *entry)
 static inline void 
 list_del_init(struct list_head *entry)
 {
-	__list_del(entry->prev, entry->next);
+	list_del_(entry->prev, entry->next);
 	INIT_LIST_HEAD(entry); 
 }
 
@@ -137,7 +137,7 @@ list_del_init(struct list_head *entry)
 static inline void 
 list_move(struct list_head *list, struct list_head *head)
 {
-        __list_del(list->prev, list->next);
+        list_del_(list->prev, list->next);
         list_add(list, head);
 }
 
@@ -149,7 +149,7 @@ list_move(struct list_head *list, struct list_head *head)
 static inline void 
 list_move_tail(struct list_head *list, struct list_head *head)
 {
-        __list_del(list->prev, list->next);
+        list_del_(list->prev, list->next);
         list_add_tail(list, head);
 }
 
@@ -172,7 +172,7 @@ static inline void
 list_splice(struct list_head *list, struct list_head *head)
 {
 	if (!list_empty(list))
-		__list_splice(list, head);
+		list_splice_(list, head);
 }
 
 /**
@@ -186,7 +186,7 @@ static inline void list_splice_init(struct list_head *list,
 				    struct list_head *head)
 {
 	if (!list_empty(list)) {
-		__list_splice(list, head);
+		list_splice_(list, head);
 		INIT_LIST_HEAD(list);
 	}
 }
diff --git a/include/edmonds_karp.h b/include/edmonds_karp.h
index 396c9fbc..295de725 100644
--- a/include/edmonds_karp.h
+++ b/include/edmonds_karp.h
@@ -21,8 +21,8 @@
  *
  ******************************************************************************/
 
-#ifndef __EDMONDS_KARP_H__
-#define __EDMONDS_KARP_H__
+#ifndef ALGO_EDMONDS_KARP_H__
+#define ALGO_EDMONDS_KARP_H__
 
 #include <stdlib.h>
 #include <stdint.h>
diff --git a/include/fenwick_tree.h b/include/fenwick_tree.h
new file mode 100644
index 00000000..4806536e
--- /dev/null
+++ b/include/fenwick_tree.h
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Fenwick Tree
+ *
+ * Data structure providing prefix sums and modify the table in O(log n) - n is the size o the table.
+ *
+ * In this algorithm we use two functions:
+ * - RSQ - This function calculates the range sum query in O(log n)
+ * - Update - This function adjusts the values in the given range in O(log n)
+ *
+ * https://en.wikipedia.org/wiki/Fenwick_tree
+ * 
+ * @author Gabriel Duarte (gabriellagoa10@yahoo.com.br)
+ * @github Gabriel123Duarte
+ *
+ ******************************************************************************/
+
+#ifndef ALGO_FENWICK_H__
+#define ALGO_FENWICK_H__
+
+#include <vector>
+
+#define LSONE(x) (x & (-x))
+
+class Fenwick
+{
+	private:
+		// Vector representing the table
+		std::vector<int> fen;
+	public:
+		Fenwick() {}
+
+		// We don't use the index 0, because it is the base case
+		Fenwick(int n)
+		{
+			fen.assign(n + 1, 0);
+		}
+
+		// Calculate the 
+		int rsq(int a)
+		{
+			int ans = 0;
+			for(; a; a -= LSONE(a))
+				ans += fen[a];
+			return ans;
+		}
+
+		// RSQ a..b
+		inline int rsq(int a, int b)
+		{
+			return rsq(b) - (a == 1 ? 0 : rsq(a - 1));
+		}
+
+		// Update the value of the k-th element by x
+		void update(int k, int x)
+		{
+			for(; k < (int)fen.size(); k += LSONE(k))
+				fen[k] += x;	
+		}
+};
+
+#endif
diff --git a/include/fib-heap.h b/include/fib-heap.h
index 68100b8b..44af130a 100644
--- a/include/fib-heap.h
+++ b/include/fib-heap.h
@@ -17,8 +17,8 @@
  * http://en.wikipedia.org/wiki/Fibonacci_heap
  ******************************************************************************/
 
-#ifndef __FIB_HEAP_H__
-#define __FIB_HEAP_H__
+#ifndef ALGO_FIB_HEAP_H__
+#define ALGO_FIB_HEAP_H__
 #include <math.h>
 #include <stdint.h>
 #include <unistd.h>
diff --git a/include/generic.h b/include/generic.h
index c55487c6..785e5078 100644
--- a/include/generic.h
+++ b/include/generic.h
@@ -9,8 +9,8 @@
  *
  ******************************************************************************/
 
-#ifndef __ALG_INC_H__
-#define __ALG_INC_H__
+#ifndef ALGO_ALG_INC_H__
+#define ALGO_ALG_INC_H__
 #include <stdio.h>
 #include <stdint.h>
 #include <assert.h>
@@ -24,7 +24,7 @@
 #define Min(a, b) ( (a < b) ? a : b )
 
 #define RANDOM_INIT()	srand(time(NULL))
-#define RANDOM(L, R)	(L + rand() % ((R) - (L))) // gen a random integer in [L, R]
+#define RANDOM(L, R)	(L + rand() % ((R) - (L) + 1)) // gen a random integer in [L, R]
 
 namespace alg {
 	/**
diff --git a/include/graph_defs.h b/include/graph_defs.h
index 8860c9b1..06e77be2 100644
--- a/include/graph_defs.h
+++ b/include/graph_defs.h
@@ -1,5 +1,5 @@
-#ifndef __GRAPH_DEFS_H__
-#define __GRAPH_DEFS_H__
+#ifndef ALGO_GRAPH_DEFS_H__
+#define ALGO_GRAPH_DEFS_H__
 
 #include "double_linked_list.h"
 
diff --git a/include/graph_search.h b/include/graph_search.h
index 438ea660..e0d18f4d 100644
--- a/include/graph_search.h
+++ b/include/graph_search.h
@@ -20,8 +20,8 @@
  *
  ******************************************************************************/
 
-#ifndef __BREADTH_FIRST_SEARCH_H__
-#define __BREADTH_FIRST_SEARCH_H__
+#ifndef ALGO_BREADTH_FIRST_SEARCH_H__
+#define ALGO_BREADTH_FIRST_SEARCH_H__
 
 #include <stdio.h>
 #include <stdint.h>
diff --git a/include/hash_code.h b/include/hash_code.h
index 89f22b2b..a310580c 100644
--- a/include/hash_code.h
+++ b/include/hash_code.h
@@ -1,5 +1,5 @@
-#ifndef __HASH_CODE_H__
-#define __HASH_CODE_H__
+#ifndef ALGO_HASH_CODE_H__
+#define ALGO_HASH_CODE_H__
 #include <string.h>
 #include "hash_string.h"
 namespace alg {
diff --git a/include/hash_multi.h b/include/hash_multi.h
index bc75cb37..ec22f65f 100644
--- a/include/hash_multi.h
+++ b/include/hash_multi.h
@@ -15,8 +15,8 @@
  *
  ******************************************************************************/
 
-#ifndef __HASH_MULTIPLICATION_H__
-#define __HASH_MULTIPLICATION_H__
+#ifndef ALGO_HASH_MULTIPLICATION_H__
+#define ALGO_HASH_MULTIPLICATION_H__
 
 #include <math.h>
 #include <string.h>
@@ -42,7 +42,7 @@ namespace alg {
 	}
 
 #ifdef _MSC_VER
-#define log2(x) (log(x) / log(2))
+#define log2(x) (log(x) / log(2.0))
 #endif
 
 	/**
@@ -50,7 +50,7 @@ namespace alg {
 	 */
 	static MultiHash * multi_hash_init(uint32_t size) {
 		// find prime larger than log2(size)
-		uint32_t r = ceil(log2(size));
+		uint32_t r = ceil(log2((double)size));
 		int i;
 		for (i = r; ;i++) {
 			if (is_prime(i)) {
diff --git a/include/hash_string.h b/include/hash_string.h
index 52d1b7cf..6eee926c 100644
--- a/include/hash_string.h
+++ b/include/hash_string.h
@@ -12,8 +12,8 @@
  *
  ******************************************************************************/
 
-#ifndef __STRING_HASH_H__
-#define __STRING_HASH_H__
+#ifndef ALGO_STRING_HASH_H__
+#define ALGO_STRING_HASH_H__
 
 #include <stdint.h>
 
diff --git a/include/hash_table.h b/include/hash_table.h
index 0fcdb713..72018610 100644
--- a/include/hash_table.h
+++ b/include/hash_table.h
@@ -14,8 +14,8 @@
  *
  ******************************************************************************/
 
-#ifndef __HASH_TABLE_H__
-#define __HASH_TABLE_H__
+#ifndef ALGO_HASH_TABLE_H__
+#define ALGO_HASH_TABLE_H__
 
 #include <stdint.h>
 #include <string.h>
@@ -36,7 +36,7 @@ namespace alg {
 			typedef _HashCode hash_code_fn;
 			private:
 				/**
-				 * definiton of Key-Value pair.
+				 * definition of Key-Value pair.
 				 */
 				struct HashKV {
 					key_type key;	// 32-bit key
diff --git a/include/heap.h b/include/heap.h
index 3462660a..d793cdab 100644
--- a/include/heap.h
+++ b/include/heap.h
@@ -7,28 +7,36 @@
  *
  * 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.
+ * In computer science, a heap is a specialized tree-based data structure that 
+ * satisfies the heap property: If A is a parent node of B then the key of node
+ * A is ordered with respect to the key of node B with the same ordering applying 
+ * across the heap. Heaps can be classified further as either a "max heap" or 
+ * a "min heap". In a max heap, the keys of parent nodes are always greater
+ * than or equal to those of the children and the highest key is in the root node.
+ * In a min heap, the keys of parent nodes are less than or equal to those of 
+ * the children and the lowest key is in the root node. Heaps are crucial in 
+ * several efficient graph algorithms such as Dijkstra's algorithm, and in 
+ * the sorting algorithm heapsort. A common implementation of a heap is the 
+ * binary heap, in which the tree is a complete binary tree (see figure).
  *
  * Basic operations of a heap are:
  *
- * 1. Insert – Insert an key.
- * 2. Delete minimum – Delete and return the smallest item in the heap.
+ * 1. Push – Insert an key.
+ * 2. Pop – Delete and return the smallest item in the heap.
+ * 3. Remove - Remove an element
  *
  * http://en.wikipedia.org/wiki/Binary_heap
  ******************************************************************************/
 
-#ifndef __HEAP_H__
-#define __HEAP_H__
+#ifndef ALGO_HEAP_H__
+#define ALGO_HEAP_H__
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <limits.h>
-#include "hash_code.h"
-#include "hash_table.h"
+#include "generic.h"
 
 namespace alg { 
 	/**
@@ -36,33 +44,29 @@ namespace alg {
 	 */
 	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_max = max;
+					m_heap = new elem[m_max];
 				};
 
 				~Heap() {
-					delete [] m_kvs;
-					delete m_idx;
+					delete [] m_heap;
 				};
 
 			private:
@@ -70,37 +74,20 @@ namespace alg {
 				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 +100,94 @@ namespace alg {
 				 */
 				inline void clear() { m_size = 0; }
 
+				bool contains(const T & data) {
+					for(int i=0;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(const 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(const 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; // right 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;
 				}
 		};
 }
diff --git a/include/heap_sort.h b/include/heap_sort.h
deleted file mode 100644
index 7c4d3455..00000000
--- a/include/heap_sort.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * DANIEL'S ALGORITHM IMPLEMENTAIONS
- *
- *  /\  |  _   _  ._ o _|_ |_  ._ _   _
- * /--\ | (_| (_) |  |  |_ | | | | | _>
- *         _|
- *
- * HEAPSORT
- *
- * Features:
- * 1. Although somewhat slower in practice on most machines than a well-implemented quicksort,
- it has the advantage of a more favorable worst-case O(n log n) runtime
- *
- * http://en.wikipedia.org/wiki/Heapsort
- *
- ******************************************************************************/
-
-#ifndef __HEAPSORT_H__
-#define __HEAPSORT_H__
-
-#include <heap.h>
-
-namespace alg {
-	/**
-	 * heap sort an array
-	 */
-	template<typename T>
-		static void heapsort(T *array,int number_of_elements) {
-			Heap<T> heap(number_of_elements);
-			int i;
-
-			// In order to build a heap structure from input array
-			for(i=0;i<number_of_elements;i++)
-			{
-				heap.insert(array[i],0);    //set key with the value of the array,value to 0(no use)
-			}
-
-			// Temporary array to store the minkey of each step,which is deleted from the heap
-			T tempArray[number_of_elements];
-			for(i=0;i<number_of_elements;i++)
-			{
-				tempArray[i]=heap.min_key();    //find the min key
-				heap.delete_min();
-			}
-
-			for(i=0;i<number_of_elements;i++)
-			{
-				array[i]=tempArray[i];      //copy back to the original array
-			}
-		}
-}
-
-#endif //
-
diff --git a/include/huffman.h b/include/huffman.h
index b47a4d12..50088b53 100644
--- a/include/huffman.h
+++ b/include/huffman.h
@@ -21,8 +21,8 @@
  *
  ******************************************************************************/
 
-#ifndef __HUFFMAN_CODING_H__
-#define __HUFFMAN_CODING_H__
+#ifndef ALGO_HUFFMAN_CODING_H__
+#define ALGO_HUFFMAN_CODING_H__
 
 #include <stdint.h>
 #include <stdlib.h>
diff --git a/include/imath.h b/include/imath.h
index 6a23ab52..b3fa2430 100644
--- a/include/imath.h
+++ b/include/imath.h
@@ -9,8 +9,8 @@
  *
  ******************************************************************************/
 
-#ifndef __IMATH_H__
-#define __IMATH_H__
+#ifndef ALGO_IMATH_H__
+#define ALGO_IMATH_H__
 
 #include <stdint.h>
 #include <string.h>
diff --git a/include/insertion_sort.h b/include/insertion_sort.h
index 42427e4b..eb9f58ef 100644
--- a/include/insertion_sort.h
+++ b/include/insertion_sort.h
@@ -13,8 +13,8 @@
  *
  ******************************************************************************/
 
-#ifndef __INSERTION_SORT_H__
-#define __INSERTION_SORT_H__
+#ifndef ALGO_INSERTION_SORT_H__
+#define ALGO_INSERTION_SORT_H__
 
 namespace alg {
 	/**
diff --git a/include/integer.h b/include/integer.h
index f177d5ad..1d5ff609 100644
--- a/include/integer.h
+++ b/include/integer.h
@@ -12,8 +12,8 @@
  *
  ******************************************************************************/
 
-#ifndef __INTEGER_H__
-#define __INTEGER_H__
+#ifndef ALGO_INTEGER_H__
+#define ALGO_INTEGER_H__
 
 #include <stdlib.h>  
 #include <stdint.h>
diff --git a/include/interval_tree.h b/include/interval_tree.h
index c4edca19..ec107364 100644
--- a/include/interval_tree.h
+++ b/include/interval_tree.h
@@ -16,8 +16,8 @@
  *
  ******************************************************************************/
 
-#ifndef __INTERVAL_TREE_H__
-#define __INTERVAL_TREE_H__
+#ifndef ALGO_INTERVAL_TREE_H__
+#define ALGO_INTERVAL_TREE_H__
 
 #include <stdlib.h>
 #include <assert.h>
diff --git a/include/k-means.h b/include/k-means.h
index 953430de..86fdef3c 100644
--- a/include/k-means.h
+++ b/include/k-means.h
@@ -12,8 +12,8 @@
  * 	https://github.com/wycg1984
  ******************************************************************************/
 
-#ifndef __KMEANS_H__
-#define __KMEANS_H__
+#ifndef ALGO_KMEANS_H__
+#define ALGO_KMEANS_H__
 #include <fstream>
 #include <stdlib.h>
 #include <math.h>
diff --git a/include/kmp.h b/include/kmp.h
index ada982a1..d75d207b 100644
--- a/include/kmp.h
+++ b/include/kmp.h
@@ -15,8 +15,8 @@
  *
  ******************************************************************************/
 
-#ifndef __KMP_H__
-#define __KMP_H__
+#ifndef ALGO_KMP_H__
+#define ALGO_KMP_H__
 #include <string.h>
 
 namespace alg {
diff --git a/include/kruskal_mst.h b/include/kruskal_mst.h
index e5305868..6db3458f 100644
--- a/include/kruskal_mst.h
+++ b/include/kruskal_mst.h
@@ -25,8 +25,8 @@
  * By Contibutor:xmuliang
  ******************************************************************************/
 
-#ifndef __KRUSKAL_MST_H__
-#define __KRUSKAL_MST_H__
+#ifndef ALGO_KRUSKAL_MST_H__
+#define ALGO_KRUSKAL_MST_H__
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -91,7 +91,7 @@ namespace alg {
 
 				Graph::Vertex * v;
 				list_for_each_entry(v, &a.v_head, v_node){
-					pa->heap.insert(v->weight, v);  // weight->vertex
+					pa->heap.push(v->weight, v);  // weight->vertex
 				}
 			}
 
diff --git a/include/lcs.h b/include/lcs.h
index a3c3e9d9..ce218022 100644
--- a/include/lcs.h
+++ b/include/lcs.h
@@ -11,8 +11,8 @@
  *
  ******************************************************************************/
 
-#ifndef __LCS_H__
-#define __LCS_H__
+#ifndef ALGO_LCS_H__
+#define ALGO_LCS_H__
 
 #include "generic.h"
 #include "2darray.h"
diff --git a/include/max_subarray.h b/include/max_subarray.h
index c791df3b..96b0d943 100644
--- a/include/max_subarray.h
+++ b/include/max_subarray.h
@@ -21,8 +21,8 @@
  * http://en.wikipedia.org/wiki/Maximum_subarray_problem
  ******************************************************************************/
 
-#ifndef	__MAX_SUBARRAY__
-#define	__MAX_SUBARRAY__
+#ifndef	MAX_SUBARRAY__
+#define	MAX_SUBARRAY__
 
 namespace alg {
 	/**
diff --git a/include/md5.h b/include/md5.h
index 5ff52525..284d8c70 100644
--- a/include/md5.h
+++ b/include/md5.h
@@ -23,8 +23,8 @@
  */
 
 
-#ifndef __MD5_H__
-#define __MD5_H__
+#ifndef ALGO_MD5_H__
+#define ALGO_MD5_H__
 #include <stdint.h>
 
 /* Data structure for MD5 (Message Digest) computation */
diff --git a/include/merge_sort.h b/include/merge_sort.h
index 8a45aece..b50d1976 100644
--- a/include/merge_sort.h
+++ b/include/merge_sort.h
@@ -13,8 +13,8 @@
  *       and right part.
  *           Example: Say the input is  -10 32 45 -78 91 1 0 -16 then the left part will be  
  *           -10 32 45 -78 and the right part will be  91 1 0 6.
- *   (2) Sort Each of them seperately. Note that here sort does not mean to sort it using some other
- *            method. We already wrote fucntion to sort it. Use the same.
+ *   (2) Sort Each of them separately. Note that here sort does not mean to sort it using some other
+ *            method. We already wrote function to sort it. Use the same.
  *   (3) Then merge the two sorted parts.
  *
  * ------------
@@ -32,15 +32,15 @@
  *
  ******************************************************************************/
 
-#ifndef __MERGE_SORT_H__
-#define __MERGE_SORT_H__
+#ifndef ALGO_MERGE_SORT_H__
+#define ALGO_MERGE_SORT_H__
 
 namespace alg {
 	/**
 	 * Merge functions merges the two sorted parts. Sorted parts will be from [left, mid] and [mid+1, right].
 	 */
 	template<typename T>
-		static void __merge(T *array, int left, int mid, int right) {
+		static void merge_(T *array, int left, int mid, int right) {
 			/*We need a Temporary array to store the new sorted part*/
 			T tempArray[right-left+1];
 			int pos=0,lpos = left,rpos = mid + 1;
@@ -75,7 +75,7 @@ namespace alg {
 				/* Sort the right part */
 				merge_sort(array,mid+1,right);
 				/* Merge the two sorted parts */
-				__merge(array,left,mid,right);
+				merge_(array,left,mid,right);
 			}
 		}
 
diff --git a/include/perfect_hash.h b/include/perfect_hash.h
index 52dd9801..55af66c1 100644
--- a/include/perfect_hash.h
+++ b/include/perfect_hash.h
@@ -10,8 +10,8 @@
  * http://en.wikipedia.org/wiki/Perfect_hash 
  *
  ******************************************************************************/
-#ifndef __PERFECT_HASH_H__
-#define __PERFECT_HASH_H__
+#ifndef ALGO_PERFECT_HASH_H__
+#define ALGO_PERFECT_HASH_H__
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
diff --git a/include/prim_mst.h b/include/prim_mst.h
index b3bf5069..be48ab58 100644
--- a/include/prim_mst.h
+++ b/include/prim_mst.h
@@ -22,18 +22,20 @@
  *
  ******************************************************************************/
 
-#ifndef __PRIM_MST_H__
-#define __PRIM_MST_H__
+#ifndef ALGO_PRIM_MST_H__
+#define ALGO_PRIM_MST_H__
 
 #include <stdio.h>
 #include <stdlib.h>
 #include "undirected_graph.h"
 #include "double_linked_list.h"
 #include "heap.h"
+#include "hash_table.h"
 
 namespace alg {
 	class Prim {
 		public:
+			static const int LARGE_NUMBER = 999999;
 			/**
 			 * Prim's Algorithm. 
 			 *
@@ -62,19 +64,16 @@ namespace alg {
 				// all vertices
 				Graph::Adjacent * a;
 				list_for_each_entry(a, &g.list(), a_node){
-					if (a->v.id != src_id) {
-						Q.insert(INT_MAX, a->v.id);
-						keys[a->v.id] = INT_MAX;
-					}
+					Q.push(LARGE_NUMBER, a->v.id);
+					keys[a->v.id] = LARGE_NUMBER;
 				}
-
-				Q.insert(0, src_id);
+			
+				Q.decrease_key(src_id, 0);
 				keys[src_id] = 0;
 
 				while (!Q.is_empty()) {
-					int32_t id = Q.min_value();
-					Q.delete_min();		// remove u from Q
-
+					Heap<uint32_t>::elem e = Q.pop();
+					uint32_t id = e.data;
 					Graph::Adjacent * u = g[id];	// the vertex to process
 					Graph::Vertex * v;
 					list_for_each_entry(v, &u->v_head, v_node) {
diff --git a/include/prime.h b/include/prime.h
index 8780dfd3..357f8b96 100644
--- a/include/prime.h
+++ b/include/prime.h
@@ -11,8 +11,8 @@
  * http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
  *
  ******************************************************************************/
-#ifndef __PRIME_H__
-#define __PRIME_H__
+#ifndef ALGO_PRIME_H__
+#define ALGO_PRIME_H__
 
 #include <stdlib.h>
 #include <math.h>
@@ -34,8 +34,8 @@ namespace alg {
 
 		if (n%2	== 0) return false;
 
-		unsigned sqrtn = sqrt(n);
-		for (unsigned int i = 2; i <= sqrtn; ++i) {
+		unsigned sqrtn = sqrt((double)n);
+		for (unsigned int i = 3; i <= sqrtn; i+=2) {
 			if (n % i == 0) {
 				return false;
 			}
diff --git a/include/priority_queue.h b/include/priority_queue.h
index 4a8dbe28..8795bc08 100644
--- a/include/priority_queue.h
+++ b/include/priority_queue.h
@@ -15,8 +15,8 @@
  *
  ******************************************************************************/
 
-#ifndef __PRIORITY_QUEUE_H__
-#define __PRIORITY_QUEUE_H__
+#ifndef ALGO_PRIORITY_QUEUE_H__
+#define ALGO_PRIORITY_QUEUE_H__
 
 #include <stdint.h>
 #include <stdbool.h>
@@ -75,12 +75,12 @@ namespace alg {
 					list_add(&n->node, &m_head);
 					m_count++;
 				} else {
-					// sequentially find the apropriate position
+					// sequentially find the appropriate position
 					PQNode * pos;
 					bool found = false;
 					list_for_each_entry(pos, &m_head, node) {
 						if (n->priority <= pos->priority) {
-							__list_add(&n->node, pos->node.prev, &pos->node);
+							list_add_(&n->node, pos->node.prev, &pos->node);
 							m_count++;
 							found = true;
 							break;
diff --git a/include/queue.h b/include/queue.h
index 1de7b292..55051228 100644
--- a/include/queue.h
+++ b/include/queue.h
@@ -13,8 +13,8 @@
  *
  ******************************************************************************/
 
-#ifndef __QUEUE_H__
-#define __QUEUE_H__
+#ifndef ALGO_QUEUE_H__
+#define ALGO_QUEUE_H__
 
 #include <stdbool.h>
 #include <stdint.h>
diff --git a/include/quick_sort.h b/include/quick_sort.h
index 35caf1dd..b3a74489 100644
--- a/include/quick_sort.h
+++ b/include/quick_sort.h
@@ -15,53 +15,35 @@
  *
  ******************************************************************************/
 
-#ifndef __QUICKSORT_H__
-#define __QUICKSORT_H__
+#ifndef ALGO_QUICKSORT_H__
+#define ALGO_QUICKSORT_H__
 
 #include <generic.h> 
-#include <cassert>
 
 namespace alg {
-
-	/**
-     * Return median of begin, middle, and end.
-	 * Order these and hide the pivot.
-     */
-	template<typename T>
-	static const T & __median3(T list[], int begin, int end) {
-		assert(begin + 2 <= end);
-		int middle = end - (end - begin) / 2;
-		if (list[middle] < list[begin])
-			swap(list[middle], list[begin]);
-		if (list[end] < list[begin])
-			swap(list[end], list[begin]);
-		if (list[end] < list[middle])
-			swap(list[end], list[middle]);
-	
-		//Place pivot at position [end - 1]
-		swap(list[middle], list[end - 1]);
-		return list[end - 1];
-	}
-	
 	/**
 	 * the quick-sort partition routine
 	 */
 	template<typename T>
-		static int __partition(T list[],int begin, int end) {
-			T pivot = __median3<T>(list, begin, end);
-
-			int i = begin;
-			int j = end - 1;
-
-			while(i < j) {
-				while(list[++i] < pivot) {}
-				while(pivot < list[--j]) {}
+		static int partition_(T list[],int begin, int end) {
+			int pivot_idx = RANDOM(begin,end);
+			T pivot = list[pivot_idx];
+			swap(list[begin], list[pivot_idx]);
+
+			int i = begin + 1;
+			int j = end;
+
+			while(i <= j) {
+				while((i <= end) && (list[i] <= pivot))
+					i++;
+				while((j >= begin) && (list[j] > pivot))
+					j--;
 				if(i < j)
 					swap(list[i],list[j]);
 			}
 
-			swap(list[i],list[end - 1]);
-			return i; // final pivot position
+			swap(list[begin],list[j]);
+			return j; // final pivot position
 		}
 
 	/**
@@ -69,13 +51,10 @@ namespace alg {
 	 */
 	template<typename T>
 		static void quicksort(T list[],int begin,int end) {
-			if( begin + 1 < end) {
-				int pivot_idx = __partition<T>(list, begin, end);
+			if( begin < end) {
+				int pivot_idx = partition_<T>(list, begin, end);
 				quicksort(list, begin, pivot_idx-1);
 				quicksort(list, pivot_idx+1, end);
-			} else if ( begin + 1 == end) {
-				if (list[begin + 1] > list[end])
-					swap(list[begin + 1], list[end]);
 			}
 		}
 }
diff --git a/include/radix_sort.h b/include/radix_sort.h
index 4272ce48..ec5e0733 100644
--- a/include/radix_sort.h
+++ b/include/radix_sort.h
@@ -15,8 +15,8 @@
  *
  ******************************************************************************/
 
-#ifndef __RADIX_SORT_H__
-#define __RADIX_SORT_H__
+#ifndef ALGO_RADIX_SORT_H__
+#define ALGO_RADIX_SORT_H__
 
 #include <stdint.h>
 #include <string.h>
@@ -29,7 +29,7 @@ namespace alg {
 	/**
 	 * couting sort
 	 */
-	static void __radix(int byte, const unsigned N, const uint32_t *source, uint32_t *dest) {
+	static void radix_(int byte, const unsigned N, const uint32_t *source, uint32_t *dest) {
 		unsigned count[256];
 		unsigned index[256];
 		memset(count, 0, sizeof (count));
@@ -51,10 +51,10 @@ namespace alg {
 	 */
 	static void radix_sort(uint32_t *source, const unsigned N) {
 		uint32_t * temp = new uint32_t[N];
-		__radix(0, N, source, temp);
-		__radix(1, N, temp, source);
-		__radix(2, N, source, temp);
-		__radix(3, N, temp, source);
+		radix_(0, N, source, temp);
+		radix_(1, N, temp, source);
+		radix_(2, N, source, temp);
+		radix_(3, N, temp, source);
 
 		delete [] temp;
 	}
diff --git a/include/random.h b/include/random.h
index 456ab698..1b2fd82e 100644
--- a/include/random.h
+++ b/include/random.h
@@ -11,8 +11,8 @@
  *
  ******************************************************************************/
 
-#ifndef __RANDOM_H__
-#define __RANDOM_H__
+#ifndef ALGO_RANDOM_H__
+#define ALGO_RANDOM_H__
 
 #include <stdio.h>
 #include <stdint.h>
diff --git a/include/random_select.h b/include/random_select.h
index 3577bdd9..8893008d 100644
--- a/include/random_select.h
+++ b/include/random_select.h
@@ -17,8 +17,8 @@
  *
  ******************************************************************************/
 
-#ifndef __RANDOM_SELECT_H__
-#define __RANDOM_SELECT_H__
+#ifndef ALGO_RANDOM_SELECT_H__
+#define ALGO_RANDOM_SELECT_H__
 
 #include <generic.h> 
 
@@ -27,7 +27,7 @@ namespace alg {
 	 * the random_select partition routine
 	 */
 	template<typename T>
-		static int __partition(T list[],int begin, int end) {
+		static int partition_(T list[],int begin, int end) {
 			int pivot_idx = RANDOM(begin,end);
 			T pivot = list[pivot_idx];
 			swap(list[begin],list[pivot_idx]);
@@ -56,7 +56,7 @@ namespace alg {
 			if(begin == end)
 				return begin;
 
-			int pivot_idx = __partition<T>(list, begin, end);
+			int pivot_idx = partition_<T>(list, begin, end);
 			int human_idx = pivot_idx - begin + 1;
 
 			if(k < human_idx)
diff --git a/include/rbtree.h b/include/rbtree.h
index c9b8a318..61c129bd 100644
--- a/include/rbtree.h
+++ b/include/rbtree.h
@@ -15,8 +15,8 @@
  * http://en.literateprograms.org/Red-black_tree_(C)
  ******************************************************************************/
 
-#ifndef __RBTREE_H__
-#define __RBTREE_H__
+#ifndef ALGO_RBTREE_H__
+#define ALGO_RBTREE_H__
 #include <stdio.h>
 #include <stdint.h>
 #include <stdexcept>
diff --git a/include/rbtree_defs.h b/include/rbtree_defs.h
index ab5ef4ea..a99a26b0 100644
--- a/include/rbtree_defs.h
+++ b/include/rbtree_defs.h
@@ -15,8 +15,8 @@
  * http://en.literateprograms.org/Red-black_tree_(C)
  ******************************************************************************/
 
-#ifndef __RBTREE_DEFS_H__
-#define __RBTREE_DEFS_H__
+#ifndef ALGO_RBTREE_DEFS_H__
+#define ALGO_RBTREE_DEFS_H__
 #include <stdio.h>
 #include <stdint.h>
 
diff --git a/include/relabel_to_front.h b/include/relabel_to_front.h
index c8a4d950..ef933e02 100644
--- a/include/relabel_to_front.h
+++ b/include/relabel_to_front.h
@@ -9,8 +9,8 @@
  *
  * */
 
-#ifndef __RELABEL_TO_FRONT_H__
-#define __RELABEL_TO_FRONT_H__
+#ifndef ALGO_RELABEL_TO_FRONT_H__
+#define ALGO_RELABEL_TO_FRONT_H__
 
 #include <stdlib.h>
 #include <stdint.h>
diff --git a/include/scc.h b/include/scc.h
index 23e34e0e..ef41af12 100644
--- a/include/scc.h
+++ b/include/scc.h
@@ -17,8 +17,8 @@
  * http://en.wikipedia.org/wiki/Strongly_connected_component
  ******************************************************************************/
 
-#ifndef __SCC_H__
-#define __SCC_H__
+#ifndef ALGO_SCC_H__
+#define ALGO_SCC_H__
 #include <stdio.h>
 #include <stdint.h>
 #include <limits.h>
@@ -39,7 +39,7 @@ namespace alg {
 		Heap<int32_t> Q(g.vertex_count()) ;
 		Graph::Adjacent * a;
 		list_for_each_entry(a, &g.list(), a_node) {
-			Q.insert(INT_MAX - a->f, a->v.id);	// descending order of a->f
+			Q.push(INT_MAX - a->f, a->v.id);	// descending order of a->f
 		}
 
 		// step 2. discover 
@@ -51,9 +51,9 @@ namespace alg {
 		// step 3. call DFS(GT), but in the main loop of DFS, consider the vertices
 		// in order of decreasing u.f (as computed in line 1)
 		while(!Q.is_empty()) {
-			int32_t key = Q.min_key();
-			int32_t id = Q.min_value();
-			Q.delete_min(); 
+			Heap<int32_t>::elem e = Q.pop();
+			int32_t key = e.key;
+			int32_t id = e.data;
 			if ((*GT)[id]->color == Graph::WHITE) {
 				printf("component:%d %d\n",id, INT_MAX - key);
 				_DFS_VISIT(*GT, (*GT)[id]);
diff --git a/include/selection_sort.h b/include/selection_sort.h
index a956ad9a..7b0f53e3 100644
--- a/include/selection_sort.h
+++ b/include/selection_sort.h
@@ -17,8 +17,8 @@
  * http://en.wikipedia.org/wiki/Selection_sort
  ******************************************************************************/
 
-#ifndef __SELECTION_SORT_H__
-#define __SELECTION_SORT_H__
+#ifndef ALGO_SELECTION_SORT_H__
+#define ALGO_SELECTION_SORT_H__
 
 #include <assert.h>
 #include <generic.h>
@@ -49,4 +49,4 @@ namespace alg {
 		}
 }
 
-#endif //__SELECTION_SORT_H__
+#endif //ALGO_SELECTION_SORT_H__
diff --git a/include/sha1.h b/include/sha1.h
index 3079e20c..da529b94 100644
--- a/include/sha1.h
+++ b/include/sha1.h
@@ -37,8 +37,8 @@
  * http://en.wikipedia.org/wiki/SHA-1
  */
 
-#ifndef __SHA1_H__
-#define __SHA1_H__
+#ifndef ALGO_SHA1_H__
+#define ALGO_SHA1_H__
 
 #include <stdbool.h>
 
diff --git a/include/shell_sort.h b/include/shell_sort.h
new file mode 100644
index 00000000..7d9285c2
--- /dev/null
+++ b/include/shell_sort.h
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * DANIEL'S ALGORITHM IMPLEMENTAIONS
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
+ * /--\ | (_| (_) |  |  |_ | | | | | _> 
+ *         _|                      
+ * 
+ * SHELL SORT 
+ *
+ * 1. sort array in O(n^(3/2)) time.
+ * 
+ * https://en.wikipedia.org/wiki/Shellsort
+ *
+ ******************************************************************************/
+
+#ifndef ALGO_SHELL_SORT_H__
+#define ALGO_SHELL_SORT_H__
+
+namespace alg {
+	/**
+	 * shell sort an array
+	 */
+	template<typename T>
+		static void shell_sort(T *array, int len) {
+			int h = 1;
+			while (h < len / 3) {
+				h = 3 * h + 1; // 1, 4, 13, 40, 121, ...
+			}
+			while (h >= 1) {
+				for (int i = h; i < len; i++) {
+					int cur = array[i];
+					int j = i - h;
+					while (j >= 0 && array[j] > cur) {
+						array[j + h] = array[j];
+						j = j - h;
+					}
+					array[j + h] = cur;
+				}
+				h = h / 3;
+			}
+		}
+}
+
+#endif //
diff --git a/include/shuffle.h b/include/shuffle.h
index fe8b97ab..0bdd69cd 100644
--- a/include/shuffle.h
+++ b/include/shuffle.h
@@ -14,8 +14,8 @@
  * 
  ******************************************************************************/
 
-#ifndef __SHUFFLE_H__
-#define __SHUFFLE_H__
+#ifndef ALGO_SHUFFLE_H__
+#define ALGO_SHUFFLE_H__
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/include/simhash.h b/include/simhash.h
index f68e9e58..650af6c2 100644
--- a/include/simhash.h
+++ b/include/simhash.h
@@ -12,8 +12,8 @@
  *
  ******************************************************************************/
 
-#ifndef __SIMHASH_H__
-#define __SIMHASH_H__
+#ifndef ALGO_SIMHASH_H__
+#define ALGO_SIMHASH_H__
 
 #include <string.h>
 #include <stdint.h>
diff --git a/include/skiplist.h b/include/skiplist.h
index 1c330ba7..7469511d 100644
--- a/include/skiplist.h
+++ b/include/skiplist.h
@@ -11,8 +11,8 @@
  *
  ******************************************************************************/
  
-#ifndef __SKIP_LIST_H__
-#define __SKIP_LIST_H__
+#ifndef ALGO_SKIP_LIST_H__
+#define ALGO_SKIP_LIST_H__
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
@@ -97,7 +97,7 @@ namespace alg {
 			if(x == NULL || x->key != key) {        
 				int lvl = random_level();	// random promotion
 
-				// for nodes higer than  current max level
+				// for nodes higher than  current max level
 				// make 'header node' as it's prev
 				if(lvl > m_level) {
 					for(int i = m_level + 1; i <= lvl; i++) {
diff --git a/include/sol.h b/include/sol.h
index 070ee4c5..c8064fc8 100644
--- a/include/sol.h
+++ b/include/sol.h
@@ -16,8 +16,8 @@
  *
  ******************************************************************************/
 
-#ifndef __SOL_H__
-#define __SOL_H__
+#ifndef ALGO_SOL_H__
+#define ALGO_SOL_H__
 #include "double_linked_list.h"
 
 namespace alg {
@@ -26,8 +26,8 @@ namespace alg {
 	 */
 	static inline void list_mtf(struct list_head *entry, struct list_head *head) {
 		if (entry->prev == head) return;
-		__list_del(entry->prev, entry->next);
-		__list_add(entry, head, head->next);
+		list_del_(entry->prev, entry->next);
+		list_add_(entry, head, head->next);
 	}
 
 
@@ -38,8 +38,8 @@ namespace alg {
 		// if the entry in the 1st position
 		if (entry->prev == head) return;
 		struct list_head * prev = entry->prev;
-		__list_del(entry->prev, entry->next);
-		__list_add(entry, prev->prev, prev);
+		list_del_(entry->prev, entry->next);
+		list_add_(entry, prev->prev, prev);
 	}
 }
 #endif //
diff --git a/include/stack.h b/include/stack.h
index acc75414..21ab1159 100644
--- a/include/stack.h
+++ b/include/stack.h
@@ -14,8 +14,8 @@
  *
  ******************************************************************************/
 
-#ifndef __STACK_H__
-#define __STACK_H__
+#ifndef ALGO_STACK_H__
+#define ALGO_STACK_H__
 
 #include <stdint.h>
 #include <stdbool.h>
diff --git a/include/suffix_array.h b/include/suffix_array.h
index 92fd67e9..8c7e11fb 100644
--- a/include/suffix_array.h
+++ b/include/suffix_array.h
@@ -20,13 +20,14 @@
  * AUTHOR: nowerzt@gmail.com
  ******************************************************************************/
 
-#ifndef __SUFFIX_ARRAY_H__
-#define __SUFFIX_ARRAY_H__
+#ifndef ALGO_SUFFIX_ARRAY_H__
+#define ALGO_SUFFIX_ARRAY_H__
 
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <math.h>
+#include <functional>
 
 using namespace std;
 
@@ -69,7 +70,7 @@ namespace alg {
 		for(size_t k=0;k<bucket.size();k++) bucket[k].resize(N+N);
 
 		for(L=1,K=0;(L>>1)<N;L<<=1,K++) {
-			sort(suffix.begin(), suffix.end(), bind(&SuffixArray::less_than, *this, placeholders::_1, placeholders::_2));
+			sort(suffix.begin(), suffix.end(), std::bind(&SuffixArray::less_than, *this, placeholders::_1, placeholders::_2));
 			update_bucket();
 		}
 	}
@@ -99,4 +100,4 @@ namespace alg {
 	}
 }
 
-#endif // __SUFFIX_ARRAY_H__
+#endif // ALGO_SUFFIX_ARRAY_H__
diff --git a/include/suffix_tree.h b/include/suffix_tree.h
index bc6eb8a8..7fd684e6 100644
--- a/include/suffix_tree.h
+++ b/include/suffix_tree.h
@@ -1,21 +1,3 @@
-/*******************************************************************************
- * ALGORITHM IMPLEMENTAIONS
- *
- *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
- * /--\ | (_| (_) |  |  |_ | | | | | _> 
- *         _|                      
- *
- * SUFFIX TREE
- *
- * In computer science, a suffix tree (also called PAT tree or, in an earlier 
- * form, position tree) is a compressed trie containing all the suffixes of the 
- * given text as their keys and positions in the text as their values. Suffix 
- * trees allow particularly fast implementations of many important string 
- * operations.
- *
- * http://en.wikipedia.org/wiki/Suffix_tree
- ******************************************************************************/
-
 #include <string>
 //#include <tr1/unordered_map>
 #include <limits>
@@ -35,280 +17,300 @@ using std::ostream;
 //typedef tr1::unordered_map map;
 
 // TODO: upgrade it to process trace. Rule: char-->elem  string-->elem_list
-class SuffixTree {
-	public:
-		// active point is initialized as (root, None, 0), remainder initialized as 1
-		SuffixTree(string str):test_str(str), root(test_str), active_point(&root, 0, 0), remainder(0), pos(0), ls() {}
-		int construct(void);
-
-		// return -1 if no such sub exist, return the beginning postion of this substring in thr original string if it exist
-		int search(string sub);
-
-		// return the length of the longest prefix of sub which can be matched in suffix tree
-		template <class Iterator>
-			Iterator inc_search(Iterator sub) {
-				typedef typename Iterator::value_type T;	// extract real type
-
-				Iterator result = sub;
-				Node* node = &root;
-				Edge* edge = NULL;
-				int pos = 0;	// the iter's pos at edge
-				int edge_len = -1;
-				bool flag = true;
-
-				while (flag) {
-					if (edge == NULL) {
-						edge = node->find_edge(*result);	
-						if (edge == NULL) {
-							flag = false;
-						}
-						else {
-							result++;
-							pos = 1; // the second element of the edge
-							edge_len = edge->length();
-						}
-					}
-					else {
-						if (pos >= edge_len) {
-							node = edge->endpoint;
-							edge = NULL;
-							edge_len = 0;
-						}
-						else {
-							if (*result == (*edge)[pos]) {
-								result++;
-								pos++;
-							}
-							else
-								flag = false;
-						}
-					}
+class SuffixTree
+{
+public:
+	// active point is initialized as (root, None, 0), remainder initialized as 1
+	SuffixTree(string str):test_str(str), root(test_str), active_point(&root, 0, 0), remainder(0), pos(0), active_e(0), ls() {}
+	int construct(void);
+
+	// return -1 if no such sub exist, return the beginning position of this substring in thr original string if it exist
+	int search(string sub);
+
+	// return the length of the longest prefix of sub which can be matched in suffix tree
+	template <class Iterator>
+	Iterator inc_search(Iterator sub)
+	{
+		Iterator result = sub;
+		Node* node = &root;
+		Edge* edge = NULL;
+		int pos = 0;	// the iter's pos at edge
+		int edge_len = -1;
+		bool flag = true;
+
+
+		while (flag) {
+			if (edge == NULL) {
+				edge = node->find_edge(*result);	
+				if (edge == NULL) {
+					flag = false;
+				}
+				else {
+					result++;
+					pos = 1; // the second element of the edge
+					edge_len = edge->length();
 				}
-
-				return result;
-			}
-
-		int print_tree(void);
-	private:
-		string test_str;
-
-		struct Node;
-		typedef struct Node Node;
-
-		struct Edge{
-			// the begin and end pos of this edge, note that INT_MAX stands for #(the changing end pos of this entire string)
-			unsigned int begin, end;
-			// Is there a better way to find test_str?
-			string& test_node_str;
-
-			Node * endpoint;
-
-			Edge(unsigned int b, unsigned int e, string& str): test_node_str(str) {
-				begin = b;
-				end = e;
-				endpoint = NULL;
-				//std::cout << "Edge initialized" << std::endl;
-			}
-
-			void change_edge(unsigned int b, unsigned int e) {
-				begin = b;
-				end = e;
-			}
-
-			int length(void) {
-				if (end > test_node_str.size())
-					return test_node_str.size() - begin;
-				else
-					return end - begin + 1; 
-			}
-
-			// needed by map
-			friend bool operator<(const Edge& me, const Edge& other) {
-				return me.begin < other.begin;
-			}
-
-			char operator[](unsigned int i) {
-				i += begin;
-				if (i > end)
-					throw out_of_range("Edge [] out of range.");
-
-				return test_node_str[i];
 			}
-
-			friend ostream& operator<<(ostream& os, Edge& edge) {
-				unsigned int end = edge.test_node_str.size()-1;
-				if (end >= edge.end)
-					end = edge.end;
-
-				char c;
-				for (unsigned int i=edge.begin; i<=end; i++) {
-					c = edge.test_node_str[i];
-					os << c;
+			else {
+				if (pos >= edge_len) {
+					node = edge->endpoint;
+					edge = NULL;
+					edge_len = 0;
+				}
+				else {
+					if (*result == (*edge)[pos]) {
+						result++;
+						pos++;
+					}
+					else
+						flag = false;
 				}
-				if (end != edge.end)
-					os << '#';
-
-				return os;
 			}
+		}
+		
+		return result;
+	}
+
+	struct Node;
+	struct Edge{
+		// the begin and end pos of this edge, note that INT_MAX stands for #(the changing end pos of this entire string)
+		unsigned int begin, end;
+		// Is there a better way to find test_str?
+		string& test_node_str;
+
+		Node * endpoint;
+
+		Edge(unsigned int b, unsigned int e, string& str):
+			test_node_str(str) 
+		{
+			begin = b;
+			end = e;
+			endpoint = NULL;
+			std::cout << "Edge initialized" << std::endl;
+		}
 
-			bool is_none(void) { return begin == 0 && end == 0; }
-		};
-
-		typedef struct Edge Edge;
-
-		struct Node {
-			string& test_node_str;
-			map<int, int> testmap;
-			map<Edge*, bool> edges;
-			// find the edge quicky by storing the leading char of this edge
-			map<char, Edge*> findedges;
-			Node* suffix_link;
+		void change_edge(unsigned int b, unsigned int e)
+		{
+			begin = b;
+			end = e;
+		}
 
-			friend class LinkState;
+		int length(void) 
+		{
 
-			Node(string& str) : test_node_str(str), suffix_link(NULL) { 
-				edges.clear(); 
-				findedges.clear(); 
-			}
+			if (end > test_node_str.size())
+				return test_node_str.size() - begin;
+			else
+				return end - begin + 1; 
+		}
+		
+		// needed by map
+		friend bool operator<(const Edge& me, const Edge& other)
+		{
+			return me.begin < other.begin;
+		}
 
-			void add_edge(Edge* edge) { 
-				if (edge->endpoint == NULL)
-					edge->endpoint = new Node(test_node_str);
-				make_pair(edge, true);
-				edges.insert(make_pair(edge, true)); 
-				findedges.insert(make_pair(test_node_str[edge->begin], edge));
-				//cout << "edge added. Now we have " << edges.size() << "edges." << endl;
-			}
+		char operator[](unsigned int i)
+		{
+			i += begin;
+			if (i > end)
+				throw out_of_range("Edge [] out of range.");
 
-			void del_edge(Edge* edge) {
-				map<Edge*, bool>::iterator iter = edges.find(edge);
+			return test_node_str[i];
+		}
 
-				if (iter == edges.end())
-					throw out_of_range("edge don't exit");
-				else {
-					// note we should erase the findedges too
-					edges.erase(edge);
-					//cout << "delete" << (*edge)[0] << endl;
-					findedges.erase((*edge)[0]);
-					//cout << "edge deleted. Now we have " << edges.size() << "edges." << endl;
-				}
+		friend ostream& operator<<(ostream& os, Edge& edge)
+		{
+			unsigned int end = edge.test_node_str.size()-1;
+			if (end >= edge.end)
+				end = edge.end;
 
+			char c;
+			for (unsigned int i=edge.begin; i<=end; i++) {
+				c = edge.test_node_str[i];
+				os << c;
 			}
+			if (end != edge.end)
+				os << '#';
 
-			// find edge by the first char
-			Edge* find_edge(char c) {
-				//cout << "finding edge";
-				map<char, Edge*>::iterator iter = findedges.find(c);
-				//cout << "founded?" << endl;
-				if (iter != findedges.end()) 
-					return iter->second;
-				else
-					return NULL;
-			}
+			return os;
+		}
 
-			bool isleaf() { return edges.empty(); }
+		bool is_none(void) { return begin == 0 && end == 0; }
+	};
+
+	struct Node{
+		string& test_node_str;
+		map<int, int> testmap;
+		map<Edge*, bool> edges;
+		// find the edge quicky by storing the leading char of this edge
+		map<char, Edge*> findedges;
+		Node* suffix_link;
+
+		friend class LinkState;
+
+		Node(string& str) : 
+			test_node_str(str), suffix_link(NULL) { edges.clear(); findedges.clear(); }
+
+		void add_edge(Edge* edge) { 
+			if (edge->endpoint == NULL)
+				edge->endpoint = new Node(test_node_str);
+			make_pair(edge, true);
+			edges.insert(make_pair(edge, true)); 
+			findedges.insert(make_pair(test_node_str[edge->begin], edge));
+			cout << "edge added. Now we have " << edges.size() << "edges." << endl;
+		}
 
-			bool operator==(Node& other) {
-				return (this) == (&other);
+		void del_edge(Edge* edge) {
+			map<Edge*, bool>::iterator iter = edges.find(edge);
+
+			if (iter == edges.end())
+				throw out_of_range("edge don't exit");
+			else {
+				// note we should erase the findedges too
+				edges.erase(edge);
+				cout << "delete" << (*edge)[0] << endl;
+				findedges.erase((*edge)[0]);
+				cout << "edge deleted. Now we have " << edges.size() << "edges." << endl;
 			}
 
-			friend ostream& operator<<(ostream& os, Node& node) {
-				map<Edge*, bool>::iterator iter;
-				map<char, Edge*>::iterator iter_f;
-
-				for (iter=node.edges.begin(); iter!=node.edges.end(); ++iter)
-					os << iter->first << '\t';
-				os << endl;
+		}
 
-				for (iter_f=node.findedges.begin(); iter_f!=node.findedges.end(); ++iter_f)
-					os << iter_f->first << "-->" << iter_f->second << endl;
+		// find edge by the first char
+		Edge* find_edge(char c)
+		{
+			cout << "finding edge char " << c;
+			map<char, Edge*>::iterator iter = findedges.find(c);
+			cout << " founded? ";
 
-				return os;
+			if (iter != findedges.end()) {
+				cout << "yes." << endl;
+				return iter->second;
 			}
-		};
-		//typedef struct Node Node;
-
-		class ActivePoint {
-			public:
-				Node* active_node;
-				char active_edge;
-				int active_length;
-
-				ActivePoint(Node* node, char edge, int length): active_node(node), 
-				active_edge(edge), active_length(length) { std::cout << "ActivePoint initialized" << std::endl; }
-		};
-
-		Node root;
-		ActivePoint active_point;
-
-		Node* get_active_node(void) { return active_point.active_node; }
-		void set_active_node(Node* node) { active_point.active_node = node; cout << "Active node set as " << node << endl; }
-		char get_active_edge(void) { return active_point.active_edge; }
-		void set_active_edge(char edge) { active_point.active_edge = edge; }
-		int get_active_length(void) { return active_point.active_length; }
-		void set_active_length(int len) { active_point.active_length = len; }
-		void inc_active_len() { active_point.active_length++; }
-		void dec_active_len() { active_point.active_length--; }
-
-		// how many suffixes is to be inserted?
-		int remainder;
-		// how many characters inserted?
-		unsigned int pos;
-		char get_ele(int i) { return test_str[i]; }
-		// insert a char from pos to suffix tree
-		int insert();
-		int insert_rule1();
-		int insert_rule3();
-		int print_node(Node* node, int level);
-
-
-		Node* seperate_edge(Node * node, Edge* edge, int rule);
-
-		// check if we can change active node
-		void check_an(void) {
-			Node* node = get_active_node();
-			Edge* edge = node->find_edge(get_active_edge());
-
-			if (edge == NULL)
-				return;
-
-			int edge_size = edge->end - edge->begin + 1;
-
-			// update
-			if (edge_size == get_active_length()) {
-				set_active_node(edge->endpoint);
-				set_active_edge(0);
-				set_active_length(0);
+			else {
+				cout << "no." << endl;
+				return NULL;
 			}
 		}
 
-		// this class indicate when shall we insert a suffix link
-		// ls should be a singleton
-		class LinkState {
-			bool first;
+		bool isleaf() { return edges.empty(); }
 
-			Node* prev, *curr;
+		bool operator==(Node& other)
+		{
+			return (this) == (&other);
+		}
 
-			public:
-			LinkState() : first(true), prev(NULL), curr(NULL) {}
+		friend ostream& operator<<(ostream& os, Node& node)
+		{
+			map<Edge*, bool>::iterator iter;
+			map<char, Edge*>::iterator iter_f;
 
-			void ins_link(Node* node) {
-				prev = curr;
-				curr = node;
+			for (iter=node.edges.begin(); iter!=node.edges.end(); ++iter)
+				os << iter->first << '\t';
+			os << endl;
+			
+			for (iter_f=node.findedges.begin(); iter_f!=node.findedges.end(); ++iter_f)
+				os << iter_f->first << "-->" << iter_f->second << endl;
 
-				if (!first) {
-					prev->suffix_link = curr;
-					cout << "Suffix link added from prev " << prev << " to curr " << curr << endl;
-				}
+			return os;
+		}
+	};
+	int print_tree(void);
+private:
+	string test_str;
+	class ActivePoint{
+	public:
+		Node* active_node;
+		char active_edge;
+		int active_length;
+
+		ActivePoint(Node* node, char edge, int length): 
+			active_node(node), active_edge(edge), active_length(length) { std::cout << "ActivePoint initialized" << std::endl; }
+	};
+
+	Node root;
+	ActivePoint active_point;
+
+	Node* get_active_node(void) { return active_point.active_node; }
+	void set_active_node(Node* node) { active_point.active_node = node; cout << "Active node set as " << node << endl; }
+	char get_active_edge(void) 
+	{ 
+		return test_str[active_e]; 
+	}
+
+	int get_active_length(void) { return active_point.active_length; }
+	void set_active_length(int len) { active_point.active_length = len; }
+	void inc_active_len() { active_point.active_length++; }
+	void dec_active_len() { active_point.active_length--; }
+	
+	// how many suffixes is to be inserted?
+	int remainder;
+	// how many characters inserted?
+	unsigned int pos;
+	unsigned int active_e;	// the beginning position of suffixes need to be inserted
+	char get_ele(int i) { return test_str[i]; }
+	// insert a char from pos to suffix tree
+	int insert();
+	int insert_rule1();
+	int insert_rule3();
+	int print_node(Node* node, int level);
+
+
+	Node* separate_edge(Node * node, Edge* edge);
+
+	// check if we can change active node
+	bool check_active_node(void)
+	{
+		Node* node = get_active_node();
+		char a_char = get_active_edge();
+		Edge* edge = node->find_edge(a_char);
+
+		if (edge == NULL)
+			return false;
+
+		unsigned int edge_size = edge->end - edge->begin + 1;
+		unsigned int length = get_active_length();
+		
+		// update
+		if (length >= edge_size) {
+			set_active_node(edge->endpoint);
+			set_active_length(length-edge_size);
+			active_e += edge_size;
+			
+			return true;
+		}
+		return false;
+	}
 
-				first = false;
-			}
+	// this class indicate when shall we insert a suffix link
+	// ls should be a singleton
+	class LinkState
+	{
+		bool first;
+		
+		Node* prev, *curr;
 
-			void clear(void) {
-				first = true;
-				prev = curr = NULL;
+	public:
+		LinkState() : first(true), prev(NULL), curr(NULL) {}
+
+		void ins_link(Node* node)
+		{
+			prev = curr;
+			curr = node;
+			
+			if (first == false) {
+				prev->suffix_link = curr;
+				cout << "Suffix link added from prev " << prev << " to curr " << curr << endl;
 			}
-		};
 
-		LinkState ls;
+			first = false;
+		}
+
+		void clear(void)
+		{
+			first = true;
+			prev = curr = NULL;
+		}
+	};
+	LinkState ls;
 };
diff --git a/include/trie.h b/include/trie.h
index c9990f28..0cdba5ef 100644
--- a/include/trie.h
+++ b/include/trie.h
@@ -10,8 +10,8 @@
  * http://en.wikipedia.org/wiki/Trie
  ******************************************************************************/
 
-#ifndef __TRIE_H__
-#define __TRIE_H__
+#ifndef ALGO_TRIE_H__
+#define ALGO_TRIE_H__
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
diff --git a/include/undirected_graph.h b/include/undirected_graph.h
index 5570267c..51804de4 100644
--- a/include/undirected_graph.h
+++ b/include/undirected_graph.h
@@ -14,8 +14,8 @@
  *
  ******************************************************************************/
 
-#ifndef __UNDIRECTED_GRAPH_H__
-#define __UNDIRECTED_GRAPH_H__
+#ifndef ALGO_UNDIRECTED_GRAPH_H__
+#define ALGO_UNDIRECTED_GRAPH_H__
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/include/universal_hash.h b/include/universal_hash.h
index 29afcf7d..40c454ce 100644
--- a/include/universal_hash.h
+++ b/include/universal_hash.h
@@ -11,8 +11,8 @@
  *
  ******************************************************************************/
 
-#ifndef __UNIVERSAL_HASH_H__
-#define __UNIVERSAL_HASH_H__
+#ifndef ALGO_UNIVERSAL_HASH_H__
+#define ALGO_UNIVERSAL_HASH_H__
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -63,7 +63,7 @@ namespace alg {
 	}
 
 	/**
-	 * hash an arbitary length integer.
+	 * hash an arbitrary length integer.
 	 * len, number of 32-bit integer, max len is 32
 	 */
 	static uint32_t uhash_bigint(const struct UHash * params, uint32_t * key, uint32_t len) {
diff --git a/include/word_seg.h b/include/word_seg.h
index eb0f65c7..ed99b763 100644
--- a/include/word_seg.h
+++ b/include/word_seg.h
@@ -17,8 +17,8 @@
  *
  ******************************************************************************/
 
-#ifndef __WORD_SEG_H__
-#define __WORD_SEG_H__
+#ifndef ALGO_WORD_SEG_H__
+#define ALGO_WORD_SEG_H__
 
 #include <stdio.h>
 #include <stdint.h>
diff --git a/msvc/alg_vs.h b/msvc/alg_vs.h
index 623174db..ca1d0163 100644
--- a/msvc/alg_vs.h
+++ b/msvc/alg_vs.h
@@ -1,5 +1,5 @@
-#ifndef __ALGVS_H__
-#define __ALGVS_H__
+#ifndef ALGO_ALGVS_H__
+#define ALGO_ALGVS_H__
 #ifdef _MSC_VER
 
 #define _CRT_SECURE_NO_WARNINGS
@@ -8,11 +8,11 @@
 
 #define strtok_r strtok_s
 
-#if _MSC_VER <= 1700
-#define ALG_VLA_NOT_SUPPORTED 1
+#if _MSC_VER <= 1800
+#define ALG_VLA_NOT_SUPPORTED
 #endif
 
 #define typeof decltype
 
 #endif//_MSC_VER
-#endif//__ALGVS_H__
\ No newline at end of file
+#endif//ALGO_ALGVS_H__
\ No newline at end of file
diff --git a/src/avl_demo.cpp b/src/avl_demo.cpp
new file mode 100644
index 00000000..444185f0
--- /dev/null
+++ b/src/avl_demo.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include "avl.h"
+
+using namespace std;
+using namespace alg;
+
+const unsigned N = 4096*32;
+const unsigned N_ELEMS_TO_REMOVE = N-128; // Must be between 0 and N-1
+
+template <typename T> 
+void printTreeStatus(const AVL<T> &t) {
+    cout << "----------------------------------------" << endl;
+    if (t.isEmpty()) cout << "The tree is empty" << endl;
+    else {
+        cout << "Tree root is: " << t.root() << endl;
+        cout << "Tree height is: " << t.height() << endl;
+        cout << "Tree contains " << t.size() << " elements" << endl;
+    }
+    cout << "----------------------------------------" << endl;
+}
+
+int main()
+{
+    int values[N];
+
+    AVL<int> avl;
+
+    cout << "Populating the tree with " << N << " random values... ";
+    for (unsigned i = 0; i < N; ++i) {
+        values[i] = rand();
+        avl.insert(values[i]);
+    }
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+
+    for (unsigned i = 0; i < N; ++i) {
+        unsigned idx = rand() % N;
+        if (!avl.contains(values[idx])) 
+	        cout << "ERROR: Value " << values[idx] << " was inserted and not found!" << endl;
+    }
+
+    cout << "Now removing a random element from the tree... ";
+    unsigned idx = rand() % N;
+    avl.erase(values[idx]);
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+    
+    cout << "Now removing the root of the tree " << N_ELEMS_TO_REMOVE << " times... ";
+    for (unsigned i = 0; i < N_ELEMS_TO_REMOVE; ++i) {
+        avl.erase(avl.root());
+    }
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+
+    // Outputting to cerr so the output can be redirected with ./avl_demo 2> <name>.gvz
+    cout << "Do you want to output the GraphViz representation of the tree to the cerr stream (Y/n)? ";
+    char usrInput;
+    cin >> usrInput;
+    if (usrInput == 'Y' || usrInput == 'y') avl.toGraphViz(cerr, "AVL");
+    
+    return 0;
+}
+
diff --git a/src/dictionary_demo.cpp b/src/dictionary_demo.cpp
new file mode 100644
index 00000000..d352cc88
--- /dev/null
+++ b/src/dictionary_demo.cpp
@@ -0,0 +1,49 @@
+#include "dictionary.h"
+#include "hash_table.h"
+#include "random.h"
+#include <chrono>
+
+using namespace alg;
+using namespace std::chrono;
+
+int main(void) {
+	
+	Dictionary<int, int> dict;
+
+	dict.Add(0, 1);
+	dict.Add(1, 2);
+	dict.Add(5, 2);
+	dict.Add(3, 3);
+	dict.Remove(5);
+	dict.AddOrUpdate(3, 4);
+
+	for (auto x : dict)
+	{
+		printf("%d - %d\n", x.Key, x.Value);
+	}
+
+	static const uint32_t TEST_LENGTH = 1000000;
+	Dictionary<uint32_t, uint32_t> d(TEST_LENGTH);
+	HashTable<uint32_t, uint32_t> h(TEST_LENGTH);
+
+	auto t0 = high_resolution_clock::now();
+
+	for (uint32_t i = 0; i < TEST_LENGTH; i++)
+	{
+		d.AddOrUpdate(alg::LCG(), alg::LCG());
+	}
+
+	auto t1 = high_resolution_clock::now();
+
+	for (uint32_t i = 0; i < TEST_LENGTH; i++)
+	{
+		h[alg::LCG()] = alg::LCG();
+	}
+
+	auto t2 = high_resolution_clock::now();
+
+	auto dt0 = duration_cast<milliseconds>(t1 - t0).count();
+	auto dt1 = duration_cast<milliseconds>(t2 - t1).count();
+
+	printf("Dictionary: %lld ms, HashTable: %lld ms\n", dt0, dt1);
+}
diff --git a/src/fenwick_tree_demo.cpp b/src/fenwick_tree_demo.cpp
new file mode 100644
index 00000000..d5e294de
--- /dev/null
+++ b/src/fenwick_tree_demo.cpp
@@ -0,0 +1,16 @@
+#include <cstdio>
+#include "fenwick_tree.h"
+
+int main()
+{
+	Fenwick ft(5);
+
+	ft.update(2, 1);
+	ft.update(4, 10);
+
+	printf("%d\n", ft.rsq(1));
+
+	ft.update(1, 5);	
+	printf("%d\n", ft.rsq(1));
+	return 0;
+}
\ No newline at end of file
diff --git a/src/heap_demo.cpp b/src/heap_demo.cpp
index bf761a66..ccae4aea 100644
--- a/src/heap_demo.cpp
+++ b/src/heap_demo.cpp
@@ -9,20 +9,25 @@ int main()
 	int MAXELEMENTS=10;
 	Heap<int> heap(MAXELEMENTS);
 
-	int32_t i;
+	int i;
 	srand(time(NULL));
 	for (i=0;i < MAXELEMENTS; i++) {
-		int32_t value = i;
-		heap.insert(i, value);
-		printf("inserting: %d->%d\n", i, value);
+		heap.push(100-i, i);
+		printf("push: key:%d->value:%d\n", 100-i, i);
 	}
+	heap.print_heap();
+
+	for (i=0;i<MAXELEMENTS/2;i++) {
+		heap.remove(i);
+		printf("remove value:%d\n", i);
+	}
+	heap.print_heap();
 
-	printf("decrease a value[%d] to %d\n", 5, -1);
-	heap.decrease_key(5, -1);
 	while(!heap.is_empty()) {
-		printf("deleting min: %d->%d\n", heap.min_key(), heap.min_value());
-		heap.delete_min();
+		Heap<int>::elem e = heap.pop();
+		printf("pop: key:%d->value:%d\n", e.key, e.data);
 	}
+	heap.print_heap();
 
 	return 0;
 }
diff --git a/src/lca_demo.cpp b/src/lca_demo.cpp
new file mode 100644
index 00000000..899cc1ba
--- /dev/null
+++ b/src/lca_demo.cpp
@@ -0,0 +1,117 @@
+#include "LCA.h"
+#include <cstdio>
+#include <vector>
+#include <iostream>
+/**
+*Constructor is initialized with a Adjacency List that
+*describe a tree and If It doesn't describe a tree it asserts failure.
+*/
+
+LCA::LCA(std::vector< std::pair<int,int> > edges): _numberOfNodes(edges.size() + 1), _maxLog(getMaxLog())
+{
+    //First we initialize the needed vectors
+    parent.resize(_numberOfNodes);
+    nodeHeight.resize(_numberOfNodes);
+    visited.resize(_numberOfNodes);
+    adjList.resize(_numberOfNodes);
+    binaryLiftDp = std::vector< std::vector<int> >(_numberOfNodes, std::vector<int>(_maxLog));
+    /**Construction of the Adjacency List to increase
+    *The efficiency of the tree traversal to O(V + E).
+    */
+    for(auto edge : edges){
+        adjList[edge.first].push_back(edge.second);
+        adjList[edge.second].push_back(edge.first);
+    }
+    //Initialize the Dynamic programming Vector.
+    initDP();
+}
+
+/**
+*DFS is used to find the parent and the height of each node
+*allowing the use of Binary Lifting.
+*/
+void LCA::dfs(int currentNode, int currentParent)
+{
+    visited[currentNode] = true;
+    parent[currentNode] = currentParent;
+    nodeHeight[currentNode] = nodeHeight[currentParent] + 1;
+    int adjacencySize = adjList[currentNode].size();
+    for(int idx = 0; idx < adjacencySize; idx++){
+        int nextNode = adjList[currentNode][idx];
+        if(!visited[nextNode])
+        {
+            dfs(nextNode, currentNode);
+        }
+    }
+}
+
+/**
+*Used to Calculate the Log to the base of two
+*for the number of the nodes to create the sparse table
+*used in binary Lifting.
+*/
+int LCA::getMaxLog(){
+    int curValue = 1;
+    int curLog = 1;
+    while(curValue < _numberOfNodes) curValue *= 2, curLog++;
+    return curLog;
+}
+
+void LCA::initDP()
+{
+    dfs(0, -1);
+    for(int i = 0; i < _numberOfNodes; i++) binaryLiftDp[i][0] = parent[i];
+    for(int i = 1; i <= _maxLog; i++)
+    {
+        for(int j = 0; j < _numberOfNodes; j++)
+        {
+            /**
+            * Since the ith parent of the current node is equal to
+            * the ith / 2 parent to the ith /2 parent of the current node
+            * That's why the Recurrence relation is described as follow
+            */
+            if(binaryLiftDp[j][i - 1] != -1)
+                binaryLiftDp[j][i] = binaryLiftDp[binaryLiftDp[j][i - 1]][i - 1];
+            else binaryLiftDp[j][i] = -1;
+        }
+    }
+}
+
+int LCA::lcaQuery(int a, int b)
+{
+    /**
+    * First Both nodes must have same height
+    * So we will rise the node with the deeper height up in
+    * the tree to where they're equal.
+    */
+    if(nodeHeight[a] < nodeHeight[b]) std::swap(a,b);
+    for(int i = _maxLog; i >= 0; i--)
+    {
+        if(binaryLiftDp[a][i] + 1 && nodeHeight[binaryLiftDp[a][i]] >= nodeHeight[b])
+            a = binaryLiftDp[a][i];
+    }
+    /**
+    * If the node Lower is the LCA then return it.
+    * Else keep moving both nodes up as much as they aren't the same
+    * until it's only 1 node left which is the direct parent of both of them
+    */
+    if(a == b) return a;
+    for(int i = _maxLog; i >= 0; i--)
+    {
+        if(binaryLiftDp[a][i] + 1 && binaryLiftDp[a][i] - binaryLiftDp[b][i])
+            a = binaryLiftDp[a][i], b = binaryLiftDp[b][i];
+    }
+    return parent[a];
+}
+
+int main(){
+    std::vector< std::pair<int,int> > edges;
+    edges.push_back({0,1});
+    edges.push_back({1,2});
+    edges.push_back({2,3});
+    edges.push_back({1,4});
+    LCA* l = new LCA(v);
+    std::cout << l->lcaQuery(0,1) << endl;
+    std::cout << l->lcaQuery(3,4) << endl;
+    std::cout << l->lcaQuery(3,2) << endl;
+}
diff --git a/src/lcs_demo.cpp b/src/lcs_demo.cpp
index 838c5d4b..71c2db20 100644
--- a/src/lcs_demo.cpp
+++ b/src/lcs_demo.cpp
@@ -6,9 +6,9 @@
 
 #define printlistC(list,n) \
 do { \
-	int __list_counter; \
-	for(__list_counter=0;__list_counter<n;__list_counter++) \
-		printf("%c\t ",list[__list_counter]); \
+	int list_counter_; \
+	for(list_counter_=0;list_counter_<n;list_counter_++) \
+		printf("%c\t ",list[list_counter_]); \
 	printf("\n"); \
 } while(0)
 
diff --git a/src/quicksort.cpp b/src/quicksort.cpp
new file mode 100644
index 00000000..a41cb257
--- /dev/null
+++ b/src/quicksort.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <vector>
+#include <string>
+
+using namespace std;
+void swap(int* a, int* b){
+    int store = *a;
+    *a = *b;
+    *b = store;
+}
+
+int part(int array[], int high, int low){
+    int pin = array[high];
+    int index = (low - 1);
+
+    for(int i = low; i <= high; i++){
+        if(array[i] <= pin){
+            index++;
+            swap(&array[index], &array[high]);
+        }
+    }
+    swap(&array[index + 1], &array[high]);
+    return (index + 1);
+}
+
+void quicksort(int array[], int high, int low){
+    if(low < high){
+        int pi = part(array,high,low);
+
+        quicksort(array, low, pi - 1 );
+        quicksort(array, pi + 1, high);
+    }
+}
+
+void printArray(int array[], int size){
+    int index;
+    for (index =0; index < size; index++){
+        cout << "" << array[index] << endl;
+        cout << endl;
+    }
+}
+
+int main(){
+    int array[] = {25,17,3,1,22};
+    int n = sizeof(array) / sizeof(array[0]);
+    quicksort(array, n-1, 0);
+    printArray(array, n);
+
+}
\ No newline at end of file
diff --git a/src/random_demo.cpp b/src/random_demo.cpp
index 3c5788a5..d2df1d8c 100644
--- a/src/random_demo.cpp
+++ b/src/random_demo.cpp
@@ -1,9 +1,9 @@
-#include <stdio.h>
+#include <iostream>
 #include "random.h"
 
 int main(void) {
-	printf("generate random numbers\n");
+	std::cout <<"generate random numbers\n";
 	for (int i=0;i<100;i++) {
-		printf("%u\n",alg::LCG());
+		std::cout<<alg::LCG()<<"\n";
 	}
 }
diff --git a/src/searchPatterns.cpp b/src/searchPatterns.cpp
new file mode 100644
index 00000000..75a728e0
--- /dev/null
+++ b/src/searchPatterns.cpp
@@ -0,0 +1,112 @@
+//
+// Created by Sithum on 2021-01-01.
+//
+
+#include "clientClass.h"
+
+#include <iostream>
+
+
+
+class patternSearchNaive {
+
+    char* pattern;
+    char* text;
+    // naive bias pattern search
+public: void search(char* pattern, char* text) {
+    int txt = strlen(text);
+    int pat = strlen(pattern);
+
+    for (int i = 0; i <= txt - pat; i++) {
+        // for pattern matching 
+        for (int j = 0; j < pat; j++) {
+            if (text[i + j] != pattern[j]) {
+                break;
+            }
+            // if pattern matches 
+            if (j = pat) {
+                std::cout << "Pattern found" << i << std::endl;
+            }
+        }
+    }
+
+}
+
+};
+
+//for Knuth morris pratt algorithm
+class patternSearchKMP {
+
+    //occurance of text[],pattern[]
+public:
+    void search(char* pattern, char* text) {
+
+        int txt = strlen(text);
+        int pat = strlen(pattern);
+
+        // to hold longest prefix suffix
+        // value for pattern
+        int lps[1];
+
+        //preprocess the pattern(calculate lps[] array)
+        LPS(pattern, pat, lps);
+
+        int index = 0;
+        int j_index = 0;
+
+        while (index < txt) {
+            if (pattern[j_index] == text[index]) {
+                j_index++; // index for pattern
+                index++; // index for text
+            }
+
+            if (j_index == pat) {
+                std::cout << "Index found " << index - j_index << std::endl;
+                j_index = lps[j_index - 1];
+            }
+
+            //mismatch after pattern match
+            else if (index < pat && pattern[j_index] != text[index]) {
+                if (j_index != 0) {
+                    j_index = lps[j_index - 1];
+                }
+                else {
+
+                    index = index++;
+                }
+            }
+        }
+
+    }
+
+public: void LPS(char* pattern, int pat, int* lps) {
+
+    int lenght = 0;
+
+    lps[0] = 0;
+
+    // the loop calculates lps[index] for index = 1 to pat-1 
+    int index = 1;
+
+    while (index < pat) {
+        if (pattern[index] == pattern[lenght]) {
+
+            lenght++;
+            lps[index] = lenght;
+            index++;
+        }
+        else {
+            if (lenght != 0) {
+                lenght = lps[lenght - 1];
+            }
+            else {
+                lps[index] = 0;
+                index++;
+
+            }
+        }
+    }
+
+
+}
+};
\ No newline at end of file
diff --git a/src/heap_sort_demo.cpp b/src/shell_sort_demo.cpp
similarity index 66%
rename from src/heap_sort_demo.cpp
rename to src/shell_sort_demo.cpp
index 7a8423c4..e284bd8d 100644
--- a/src/heap_sort_demo.cpp
+++ b/src/shell_sort_demo.cpp
@@ -1,9 +1,9 @@
-#include <stdio.h>
-#include <stdlib.h>
+#include <stdio.h>  
+#include <stdlib.h>  
 #include <time.h>
 
 #include "generic.h"
-#include "heap_sort.h"
+#include "shell_sort.h"
 
 using namespace alg;
 
@@ -22,13 +22,11 @@ int main()
 	printf("The list before sorting is:\n");
 	printlist(list,MAX_ELEMENTS);
 
-	// sort the list using heap sort
-	heapsort<int>(&list[0],MAX_ELEMENTS);
+	// sort the list using shell sort
+	shell_sort<int>(&list[0],MAX_ELEMENTS);  
 
 	// print the result
-	printf("The list after sorting using heapsort algorithm:\n");
+	printf("The list after sorting using shell sort algorithm:\n");
 	printlist(list,MAX_ELEMENTS);
 	return 0;
 }
-
-
diff --git a/src/suffix_tree_demo.cpp b/src/suffix_tree_demo.cpp
index e3ce387c..4a5170b5 100644
--- a/src/suffix_tree_demo.cpp
+++ b/src/suffix_tree_demo.cpp
@@ -50,223 +50,86 @@ int SuffixTree::construct(void)
 {
 	// test_str shouldn't have '#' until now
 	test_str = test_str + "#";
+	using std::numeric_limits;
 
 	while (pos < test_str.size()) {
 		ls.clear();
 		remainder++;
-		//cout << "Char:  "  << test_str[pos] << endl;
+		cout << "Char:  "  << test_str[pos] << endl;
+
+		while (remainder) {
+			int length = get_active_length();
+			if (length == 0)
+				active_e = pos;
+
+			Node* node = active_point.active_node;
+			char a_char = get_active_edge();
+			Edge* a_edge = node->find_edge(a_char);
+
+
+			if (a_edge == NULL) {
+				Edge* newedge = new Edge(pos, numeric_limits<unsigned int>::max(), test_str);
+				node->add_edge(newedge);
+				ls.ins_link(node);
+			}	
+			else {
+				if (check_active_node())
+					continue;
+
+				char expected_ele = (*a_edge)[get_active_length()];
+				if (expected_ele == get_ele(pos)) {
+					inc_active_len();
+					ls.ins_link(node);
+					break;
+				}
+				Node *newnode = separate_edge(node, a_edge);
+				Edge* newedge = new Edge(pos, numeric_limits<unsigned int>::max(), test_str);
+				newnode->add_edge(newedge);
+				ls.ins_link(newnode);
+			}
+			remainder--;
+			if (node == &root && get_active_length() > 0) {
+				dec_active_len();
+				active_e = pos - remainder + 1;
+			}
+			else if (node->suffix_link) {
+				set_active_node(node->suffix_link);
+			}
+			else
+				set_active_node(&root);
+		}
 
-		bool flag = true;
-		while (flag)
-			flag = insert();
 		pos++;
 	}
 	return 0;
 }
 
-int SuffixTree::insert(void)
-{
-	int result = 0;
-
-	Node* node = active_point.active_node;
-	if (node == (&root)) {
-		//cout << "ActiveNode is root." << endl;
-		result = insert_rule1();	
-	}
-	else {
-		//cout << "ActiveNode isn't root." << endl;
-		result = insert_rule3();
-	}
-
-	return result;
-}
-
-// rule1 applies when the active node is root
-int SuffixTree::insert_rule1(void)
+SuffixTree::Node* SuffixTree::separate_edge(Node * node, Edge* a_edge)
 {
-	using std::numeric_limits;
-	
-	//cout << "Rule 1" << endl;
-	Node* node = &root;
-
-	Edge* a_edge = node->find_edge(get_active_edge());
-
-	// next active edge
-	char active_char = 0;
-
-	// can we find a match at active node?
-	Edge* possible = NULL;
-	bool will_insert = false;
-	if (get_active_length() != 0 && a_edge != NULL) {
-		// shouldn't throw out_of_range here, e.g. abcabc*
-		char match_char = (*a_edge)[get_active_length()];
-		if (match_char == get_ele(pos))
-			possible = a_edge;
-		else
-			will_insert = true;	// will insert while active length is not 0 and activechar don't match
-		//cout << "Active char is " << active_char << endl;
-
-		// node for insertion
-	}
-	else if (get_active_length() == 0) {
-		//cout << "Active char is NULL." << endl;
-		possible = node->find_edge(get_ele(pos));
-
-		// new active edge here and only here!
-		if (possible)
-			active_char = get_ele(pos);
-		else
-			active_char = 0;
-	}
-	else {
-		cout << "Error!!!!!!!!!!!!!!!!!!!1" << endl;
-		//throw;
-	}
-
-	
-	if (possible) {
-		remainder++;
-
-		// if not 0, then it's not a new edge, should not set
-		if (get_active_length() == 0)
-			set_active_edge(active_char);
-
-		inc_active_len();
-		check_an();
-	}
-	else {
-		// seperate the old edge, set new active edge
-		if (a_edge != NULL) {
-			node = seperate_edge(node, a_edge, 1);
-		}
-		else
-			set_active_edge(0);
-
-		//cout << "append a new edge at endpoint" << endl;
-		Edge* new_edge2 = new Edge(pos, numeric_limits<int>::max(), test_str);
-		//cout << node << endl;
-		node->add_edge(new_edge2);
-	}
-
-	remainder--;
-	
-	return will_insert;
-}
-
-SuffixTree::Node* SuffixTree::seperate_edge(Node * node, Edge* a_edge, int rule)
-{
-	//cout << "seperate the old edge here: " << (*a_edge) << endl;
-			
-	char active_char;
-	 
-	if (remainder > 2)
-		active_char = (*a_edge)[1];
-	else 
-		active_char = get_ele(pos);
-
+	cout << "separate the old edge here: " << (*a_edge) << endl;
 	int new_begin = a_edge->begin + get_active_length();
 	int new_end = a_edge->end;
 
 	int old_begin = a_edge->begin;
 	int old_end = new_begin - 1;
 
-	//cout << node->find_edge(active_char) << "|||||||||||||||||||||||||| char " << active_char << endl;
-	//cout << (*node);
+	cout << (*node);
 
 	node->del_edge(a_edge);
 	a_edge->change_edge(new_begin, new_end);
 	Edge* old_edge1 = new Edge(old_begin, old_end, test_str);
 	node->add_edge(old_edge1);
-	//cout << node->find_edge(active_char) << "||||||||||||||||||||||||||2 char " << active_char << endl;
 
 	old_edge1->endpoint->add_edge(a_edge);
-	//cout << (*node);
-//	old_edge1->endpoint->suffix_link = a_edge->endpoint->suffix_link;
-//	a_edge->endpoint->suffix_link = NULL;
-/*-----------------------------------------------------------------------
-	Edge* new_edge1 = new Edge(new_begin, new_end, test_str);
-	a_edge->endpoint->add_edge(new_edge1);
-------------------------------------------------------------------*/
-
-	//cout << "change edge" << endl;
 
-	//cout << "What's wrong?" << endl;
 	cout << "The old edge split as -- " << (*a_edge) << " and -- " << (*old_edge1) << endl;
-	//cout << "What's wrong?" << endl;
-			
-	if (rule == 1) {
-		set_active_edge(active_char);
-		dec_active_len();
-	}
-	else if (rule == 3) {
-		Node* n = &root;	// new active node
-		//cout << node;
-		if (node->suffix_link) {
-			n = node->suffix_link;
-			cout << " Moved to suffix link!--------------" << endl;
-		}
-		else
-			cout << " Moved to root!------------------" << endl;
-		set_active_node(n);
-	}
 
 	cout << "root " << (&root) << endl;
-	//cout << node << endl;
+	cout << node << endl;
 	Node* new_node = old_edge1->endpoint;
-	ls.ins_link(new_node);
-	//cout << node << endl;
-
-	return new_node;
-}
-
-// applies when the active is not root
-int SuffixTree::insert_rule3()
-{
-	//cout << "Rule3" << endl;
-	Node * node = get_active_node();
-	cout << "Active node " << node << endl;
-	Edge * edge = node->find_edge(get_active_edge());
-
-	// input match a suffix?
-	bool match = false;
-	if (get_active_length() == 0) {
-		if (node->find_edge(get_ele(pos))) {
-			match = true;
-
-			set_active_edge(get_ele(pos));
-			inc_active_len();
-			check_an();
-		}
-	}
-	else {
-		// assert edge is not NULL
-		char match_char = (*edge)[get_active_length()];
-		if (match_char == get_ele(pos)) {
-			match = true;
-
-			inc_active_len();
-			check_an();
-		}
-	}
-
-	if (match)
-		return 0;
-
-	if (edge != NULL) {
-		node = seperate_edge(node, edge, 3);
-	}
-
-	using std::numeric_limits;
-
-	//cout << "append a new edge at endpoint" << endl;
-	Edge* new_edge2 = new Edge(pos, numeric_limits<int>::max(), test_str);
 	cout << node << endl;
-	node->add_edge(new_edge2);
 
-	remainder--;
-
-	return 1;	// should insert again at a different node
-	
+	return new_node;
 }
 
 int SuffixTree::print_tree()
@@ -312,8 +175,8 @@ using namespace std;
 
 int main()
 {
-	cout << "Begining" << endl;
-	SuffixTree st("BANANAS");
+	cout << "Beginning" << endl;
+	SuffixTree st("mississippi");
 
 	cout << "Constructing..." << endl;
 	st.construct();
diff --git a/utils/byteorder.h b/utils/byteorder.h
index ca2fada9..b54222df 100644
--- a/utils/byteorder.h
+++ b/utils/byteorder.h
@@ -1,5 +1,5 @@
-#ifndef __BYTEORDER_H__
-#define __BYTEORDER_H__
+#ifndef ALGO_BYTEORDER_H__
+#define ALGO_BYTEORDER_H__
 #include <stdint.h>
 #include <stdbool.h>
 
diff --git a/utils/gb18030.h b/utils/gb18030.h
index 88d28e85..5da8c9f3 100644
--- a/utils/gb18030.h
+++ b/utils/gb18030.h
@@ -1,5 +1,5 @@
-#ifndef __GB18030_H__
-#define __GB18030_H__
+#ifndef ALGO_GB18030_H__
+#define ALGO_GB18030_H__
 
 /**
  * Read from the string encoded in GB18030 into WORD