edit suffix tree

Author: ZhangYou0122

Makefile

@@ -3,7 +3,7 @@ CC=gcc
 CPP=g++
 AR=ar
 RANLIB=ranlib
-CFLAGS= -g -Wall -Wno-unused-function
+CFLAGS= -g -Wall -Wno-unused-function -std=gnu++0x
 SRCDIR = ./src
 INCLUDEDIR = -I./include -I.
 DEPS = 
@@ -69,6 +69,7 @@ PROGRAMS = m_based_demo \
 selection_sort_demo\
 8queue_demo \
 palindrome_demo \
+suffix_array_demo \
 suffix_tree_demo
 
 all: $(PROGRAMS)

README.md

@@ -55,8 +55,9 @@
  Red-black tree
  Interval tree
  Prefix Tree(Trie)
- *Suffix Tree(未实现)*
+ Suffix Tree
  B-Tree
+Suffix Array
 
  Hash by multiplication
  Hash table
@@ -96,4 +97,5 @@
  wycg1984: for K-Means
  xmuliang: for HeapSort, Kruskal MST
  wyh267: for base64, LRU, bubble sort, selection sort
- ZhangYou0122 : Push-Relabel algorithm
+ ZhangYou0122: Push-Relabel algorithm, Suffix Tree 
+UsingtcNower: Suffix Array 

include/prime.h

@@ -35,7 +35,7 @@ namespace alg {
 if (n%2== 0) return false;
 
 unsigned sqrtn = sqrt(n);
-for (unsigned int i = 2; i <= sqrtn; ++i) {
+for (unsigned int i = 3; i <= sqrtn; i+=2) {
 if (n % i == 0) {
 return false;
 }

include/suffix_array.h

@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * ALGORITHM IMPLEMENTAIONS
+ *
+ * /\ | _ _ ._ o _|_ |_ ._ _ _ 
+ * /--\ | (_| (_) | | |_ | | | | | _> 
+ * _| 
+ *
+ * SUFFIX ARRAY
+ *
+ * Features: 
+ * suffix array can sort all the suffixs in time complexity O(n*log^2(n)), 
+ * and use memory in O(n). And suffix array can get two suffixs' longest 
+ * common prefix(lcp) in O(log(n)) complexity. 
+ *
+ * You can test it by running suffix_array_demo.cpp
+ * Want to get more detailed information about suffix array? 
+ *
+ * Please google SUFF_AR_ENG.pdf
+ *
+ * AUTHOR: nowerzt@gmail.com
+ ******************************************************************************/
+
+#ifndef __SUFFIX_ARRAY_H__
+#define __SUFFIX_ARRAY_H__
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <math.h>
+
+using namespace std;
+
+namespace alg {
+class SuffixArray {
+private:
+vector<vector<int> > bucket;
+vector<int> suffix;
+int N, L, K;
+const string& str;
+void suffix_sort();
+void update_bucket();
+
+bool less_than(int a, int b) { 
+if(K==0) return str[a]<str[b];
+else {
+if(bucket[K-1][a]==bucket[K-1][b]) return bucket[K-1][a+L/2]<bucket[K-1][b+L/2];
+else return bucket[K-1][a]<bucket[K-1][b];
+}
+}
+
+bool equal(int a, int b) {
+return !less_than(a,b) && !less_than(b,a);
+}
+
+public:
+explicit SuffixArray(const string& s) : N(s.size()), L(0), K(0), str(s) { suffix_sort();}
+// return the sorted suffix
+int operator [] (int i) { return suffix[i];}
+// Given two suffixs of string, return the longest common prefix length
+int lcp_length(int x, int y);
+};
+
+void SuffixArray::suffix_sort() {
+// init suffix
+suffix.resize(N);
+for(int i=0;i<N;i++) suffix[i]=i;
+// init bucket
+bucket.resize(ceil(log2(N))+1);
+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));
+update_bucket();
+}
+}
+
+
+void SuffixArray::update_bucket() {
+int seq=0;
+bucket[K][suffix[0]]=0;
+for(int i=1;i<N;i++) {
+if(!equal(suffix[i],suffix[i-1])) seq++;
+bucket[K][suffix[i]]=seq;
+}
+fill(bucket[K].begin()+N, bucket[K].end(), -1);
+}
+
+int SuffixArray::lcp_length(int x, int y) {
+if(x==y) return N-x;
+int ret=0;
+for(int k=K-1;k>=0 && x<N && y<N;k--) {
+if(bucket[k][x]==bucket[k][y]) {
+x += (1<<k);
+y += (1<<k);
+ret += (1<<k);
+}
+}
+return ret;
+}
+}
+
+#endif // __SUFFIX_ARRAY_H__

include/suffix_tree.h

@@ -21,7 +21,7 @@ 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, NULL, 0), remainder(0), pos(0), base_pos(0), ls() {}
+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 postion of this substring in thr original string if it exist
@@ -229,10 +229,10 @@ class SuffixTree
 class ActivePoint{
 public:
 Node* active_node;
-Edge* active_edge;
+char active_edge;
 int active_length;
 
-ActivePoint(Node* node, Edge* edge, int length): 
+ActivePoint(Node* node, char edge, int length): 
 active_node(node), active_edge(edge), active_length(length) { std::cout << "ActivePoint initialized" << std::endl; }
 };
 
@@ -241,8 +241,11 @@ class SuffixTree
 
 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; }
-Edge* get_active_edge(void) { return active_point.active_edge; }
-void set_active_edge(Edge* edge) { active_point.active_edge = edge; }
+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++; }
@@ -252,7 +255,7 @@ class SuffixTree
 int remainder;
 // how many characters inserted?
 unsigned int pos;
-unsigned int base_pos;// the beginnig position of suffixes need to be inserted
+unsigned int active_e;// the beginnig 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();
@@ -261,36 +264,30 @@ class SuffixTree
 int print_node(Node* node, int level);
 
 
-Node* seperate_edge(Node * node, Edge* edge, int rule);
+Node* seperate_edge(Node * node, Edge* edge);
 
 // check if we can change active node
-void check_active_node(void)
+bool check_active_node(void)
 {
 Node* node = get_active_node();
-Edge* edge = get_active_edge();
+char a_char = get_active_edge();
+Edge* edge = node->find_edge(a_char);
 
 if (edge == NULL)
-return;
+return false;
 
 unsigned int edge_size = edge->end - edge->begin + 1;
 unsigned int length = get_active_length();
 
 // update
-if (edge_size == length) {
+if (length >= edge_size) {
 set_active_node(edge->endpoint);
-set_active_edge(0);
-set_active_length(0);
-base_pos += edge_size;
-}
-else if (length > edge_size) {
 set_active_length(length-edge_size);
-set_active_node(edge->endpoint);
-int new_length = get_active_length();
-base_pos += edge_size;
-Edge *new_active_edge = edge->endpoint->find_edge(get_ele(base_pos));
-set_active_edge(new_active_edge);
-check_active_node();
+active_e += edge_size;
+
+return true;
 }
+return false;
 }
 
 // this class indicate when shall we insert a suffix link

src/suffix_array_demo.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <string>
+#include <math.h>
+
+#include "suffix_array.h"
+
+using namespace std;
+using namespace alg;
+
+void print(string::iterator b, string::iterator e) {
+for(auto it=b;it!=e;++it) cout<<*it;
+}
+
+int main()
+{
+string str;
+while(cin>>str) {
+SuffixArray sa(str);
+cout<<endl;
+cout<<"sorted suffixs are:"<<endl;
+for(size_t i=0;i<str.size();i++) {
+print(str.begin()+sa[i], str.end());
+cout<<endl;
+}
+cout<<endl;
+cout<<"The length of the longest common prefix of two suffixs ";
+int i=rand()%str.size();
+int j=rand()%str.size();
+print(str.begin()+i,str.end());
+cout<<" and ";
+print(str.begin()+j,str.end());
+cout<<" is ";
+cout<<sa.lcp_length(i,j)<<endl;
+cout<<endl;
+}
+return 0;
+}