Merge pull request wyh267#1 from xtaci/master

fork

Author: wyh267

Makefile

@@ -3,7 +3,7 @@ CC=gcc
 CPP=g++
 AR=ar
 RANLIB=ranlib
-CFLAGS= -O2 -Wall -Wno-unused-function
+CFLAGS= -g -O2 -Wall -Wno-unused-function
 SRCDIR = ./src
 INCLUDEDIR = -I./include -I.
 DEPS = 
@@ -30,7 +30,7 @@ PROGRAMS = m_based \
 heap_demo \
 interval_tree_demo \
 dos_tree_demo \
-skip_list_demo \
+skiplist_demo \
 lcs_demo\
 prim_mst_demo \
 directed_graph_demo \
@@ -56,7 +56,11 @@ PROGRAMS = m_based \
 heap_sort_demo \
 kruskal_mst_demo \
 LRU_cache_demo \
-base64_demo
+base64_demo\
+max_subarray_demo \
+disjoint-set_demo \
+relabel_to_front_demo \
+btree_demo
 
 all: $(PROGRAMS)
 

README.md

@@ -7,14 +7,15 @@
  服务器端
   (based on linux/gcc)
  正确，易于使用和改造, 一个头文件一个算法，并附带一个demo.
-  (corret! and ease of use, one .header file per algorithm)
+  (correct! and ease of use, one .header file per algorithm)
 
 ####约定 ( Convention ):
 
  1. 一个算法用一个.h文件表示放到include下. ( one .header file per algorithm. )
  2. 算法演示的demo程序放到src下. ( one demo per algorithm. )
  3. 程序正确通过后，请发起Pull Requests，代码被验证后入库，并在README中发布新算法实现。
   (Please Use Fork+Pull Requests !!! Correctness is the most important!)
+4. TAB = 4 space. set ts=4 in vim
 
 ####已实现 ( Implemented ):
 
@@ -24,6 +25,7 @@
  2D Array
  Arbitary Integer
  Linear congruential generator
+Maximum subarray problem
 
  Bit-Set data structure
  Queue data structure
@@ -47,6 +49,7 @@
  Interval tree
  Prefix Tree(Trie)
  *Suffix Tree(未实现)*
+B-Tree
 
  Hash by multiplication
  Hash table
@@ -58,6 +61,7 @@
  Bloom Filter
  SHA-1 Message Digest Algorithm
  MD5
+Base64
 
  Graph data structure
  Prim's minimum spanning tree
@@ -68,14 +72,18 @@
  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
 
 ####贡献者 ( Contributors ) : 
  Samana : for heavy work of MSVC compatability
  wycg1984: for K-Means
  xmuliang: for HeapSort, Kruskal MST
+wyh267: for base64, LRU
+ZhangYou0122 : Push-Relabel algorithm

include/LRU_cache.h

@@ -1,68 +1,80 @@
-
+/*******************************************************************************
+ *
+ * /\ | _ _ ._ o _|_ |_ ._ _ _ 
+ * /--\ | (_| (_) | | |_ | | | | | _> 
+ * _| 
+ *
+ * Least Recently Used (LRU): 
+ *	discards the least recently used items first. This algorithm requires 
+ * keeping track of what was used when, which is expensive if one wants to make 
+ * sure the algorithm always discards the least recently used item. General 
+ * implementations of this technique require keeping "age bits" for cache-lines 
+ * and track the "Least Recently Used" cache-line based on age-bits. In such an 
+ * implementation, every time a cache-line is used, 
+ * the age of all other cache-lines changes
+ * 
+ * We use this double list to store the cache like this:
+ * 
+ * NodeHead <==> Node1 <==> Node2 <==> ... ... <==> NodeN <==>NodeNear
+ * 
+ * the "NodeHead" and "NodeNear" have no data , them just for head and near.
+ * 
+ * Two Interface:
+ * getValue : get the value by key ,and put the Node to first
+ * putValue : add or update the Node's Key and Value, and then, 
+ * put the Node to first
+ * 
+ * http://en.wikipedia.org/wiki/LRU_cache#Least_Recently_Used
+ * 
+ ******************************************************************************/
 
 #ifndef _LRUCACHE_
 #define _LRUCACHE_
 
-
 #include <iostream>
 #include <string>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-using namespace std;
-
-typedef struct _Node_{
-
-int key;
-int value;
-
-struct _Node_ *next;
-struct _Node_ *pre;
-
-}CacheNode;
-
-
-
-class LRUCache{
-
-public:
-
-LRUCache(int cache_size=10)
-{
-cache_size_=cache_size;
-cache_real_size_=0;
-p_cache_list_head=new CacheNode();
-p_cache_list_near=new CacheNode();
-p_cache_list_head->next=p_cache_list_near;
-p_cache_list_head->pre=NULL;
-p_cache_list_near->pre=p_cache_list_head;
-p_cache_list_near->next=NULL;
-
+namespace alg {
+class LRUCache{
+typedef struct _Node_{
+int key;
+int value;
+
+struct _Node_ *next;
+struct _Node_ *pre;
+
+} CacheNode;
+
+public:
+LRUCache(int cache_size=10) {
+cache_size_ = cache_size;
+cache_real_size_ = 0;
+p_cache_list_head = new CacheNode();
+p_cache_list_near = new CacheNode();
+p_cache_list_head->next = p_cache_list_near;
+p_cache_list_head->pre = NULL;
+p_cache_list_near->pre = p_cache_list_head;
+p_cache_list_near->next = NULL;
 }
-~LRUCache()
-{
+
+~LRUCache() {
 CacheNode *p;
-p=p_cache_list_head->next;
-while(p!=NULL)
-{
+p = p_cache_list_head->next;
+while(p!=NULL) {
 delete p->pre;
 p=p->next;
 }
 
 delete p_cache_list_near;
 }
 
-
-int getValue(int key)
-{
+int getValue(int key) { 
 CacheNode *p=p_cache_list_head->next;
-while(p->next!=NULL)
-{
-
-if(p->key == key) //catch node
-{
-
+while (p->next!=NULL) {
+if (p->key == key) { //catch node
 detachNode(p);
 addToFront(p);
 return p->value;
@@ -72,87 +84,68 @@ class LRUCache{
 return -1;
 }
 
-bool putValue(int key,int value)
-{
+bool putValue(int key,int value) {
 CacheNode *p=p_cache_list_head->next;
-while(p->next!=NULL)
-{
-
-
-if(p->key == key) //catch node
-{
+while (p->next!=NULL) {
+if(p->key == key) { //catch node
 p->value=value;
 getValue(key);
 return true;
 }
 p=p->next;
 }
-
-
-if(cache_real_size_ >= cache_size_)
-{
-cout << "free" <<endl;
+
+if (cache_real_size_ >= cache_size_) {
+std::cout << "free" <<std::endl;
 p=p_cache_list_near->pre->pre;
 delete p->next;
 p->next=p_cache_list_near;
 p_cache_list_near->pre=p;
 }
-
-p=new CacheNode();//(CacheNode *)malloc(sizeof(CacheNode));
-
-if(p==NULL)
+
+p = new CacheNode();//(CacheNode *)malloc(sizeof(CacheNode));
+
+if (p==NULL)
 return false;
 
 addToFront(p);
 p->key=key;
 p->value=value;
-
+
 cache_real_size_++;
-
+
 return true;
 }
-void displayNodes()
-{
+
+void displayNodes() {
 CacheNode *p=p_cache_list_head->next;
-
-while(p->next!=NULL)
-{
-cout << " Key : " << p->key << " Value : " << p->value << endl; 
+
+while(p->next!=NULL) {
+std::cout << " Key : " << p->key << " Value : " << p->value << std::endl; 
 p=p->next;
-
+
 }
-cout << endl;
-
+std::cout << std::endl;
 }
-
-
-private:
-
-int cache_size_;
-int cache_real_size_;
-CacheNode *p_cache_list_head;
-CacheNode *p_cache_list_near;
-
-void detachNode(CacheNode *node)
-{
+
+private:
+int cache_size_;
+int cache_real_size_;
+CacheNode *p_cache_list_head;
+CacheNode *p_cache_list_near;
+
+void detachNode(CacheNode *node) {
 node->pre->next=node->next;
 node->next->pre=node->pre;
 }
-void addToFront(CacheNode *node)
-{
-
+
+void addToFront(CacheNode *node) {
 node->next=p_cache_list_head->next;
 p_cache_list_head->next->pre=node;
 p_cache_list_head->next=node;
 node->pre=p_cache_list_head;
-
 }
-
-};
-
-
+};
+}
 
 #endif
-
-
-