Add suffix array (TheAlgorithms#383)

Author: merelymyself

README.md

@@ -120,6 +120,7 @@ These are for demonstration purposes only.
 - [x] [Run Length Encoding](.src/string/run_length_encoding.rs)
 - [x] [Hamming Distance](./src/string/hamming_distance.rs)
 - [x] [Suffix Tree](./src/string/suffix_tree.rs)
+- [x] [Suffix Array](./src/string/suffix_array.rs)
 
 ## [General](./src/general)
 

src/string/mod.rs

@@ -6,6 +6,7 @@ mod manacher;
 mod rabin_karp;
 mod reverse;
 mod run_length_encoding;
+mod suffix_array;
 mod suffix_tree;
 mod z_algorithm;
 
@@ -19,6 +20,7 @@ pub use self::manacher::manacher;
 pub use self::rabin_karp::rabin_karp;
 pub use self::reverse::reverse;
 pub use self::run_length_encoding::{run_length_decoding, run_length_encoding};
+pub use self::suffix_array::generate_suffix_array;
 pub use self::suffix_tree::{Node, SuffixTree};
 pub use self::z_algorithm::match_pattern;
 pub use self::z_algorithm::z_array;

src/string/suffix_array.rs

@@ -0,0 +1,95 @@
+// In computer science, a suffix array is a sorted array of all suffixes of a string.
+// It is a data structure used in, among others, full-text indices, data-compression algorithms,
+// and the field of bibliometrics. Source: https://en.wikipedia.org/wiki/Suffix_array
+
+use std::cmp::Ordering;
+
+#[derive(Clone)]
+struct Suffix {
+    index: usize,
+    rank: (i32, i32),
+}
+
+impl Suffix {
+    fn cmp(&self, b: &Self) -> Ordering {
+        let a = self;
+        let ((a1, a2), (b1, b2)) = (a.rank, b.rank);
+        match a1.cmp(&b1) {
+            Ordering::Equal => {
+                if a2 < b2 {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                }
+            }
+            o => o,
+        }
+    }
+}
+
+pub fn generate_suffix_array(txt: &str) -> Vec<usize> {
+    let n = txt.len();
+    let mut suffixes: Vec<Suffix> = vec![
+        Suffix {
+            index: 0,
+            rank: (-1, -1)
+        };
+        n
+    ];
+    for (i, suf) in suffixes.iter_mut().enumerate() {
+        suf.index = i;
+        suf.rank.0 = (txt.chars().nth(i).expect("this should exist") as u32 - 'a' as u32) as i32;
+        suf.rank.1 = if (i + 1) < n {
+            (txt.chars().nth(i + 1).expect("this should exist") as u32 - 'a' as u32) as i32
+        } else {
+            -1
+        }
+    }
+    suffixes.sort_by(|a, b| a.cmp(b));
+    let mut ind = vec![0; n];
+    let mut k = 4;
+    while k < 2 * n {
+        let mut rank = 0;
+        let mut prev_rank = suffixes[0].rank.0;
+        suffixes[0].rank.0 = rank;
+        ind[suffixes[0].index] = 0;
+
+        for i in 1..n {
+            if suffixes[i].rank.0 == prev_rank && suffixes[i].rank.1 == suffixes[i - 1].rank.1 {
+                prev_rank = suffixes[i].rank.0;
+                suffixes[i].rank.0 = rank;
+            } else {
+                prev_rank = suffixes[i].rank.0;
+                rank += 1;
+                suffixes[i].rank.0 = rank;
+            }
+            ind[suffixes[i].index] = i;
+        }
+        for i in 0..n {
+            let next_index = suffixes[i].index + (k / 2);
+            suffixes[i].rank.1 = if next_index < n {
+                suffixes[ind[next_index]].rank.0
+            } else {
+                -1
+            }
+        }
+        suffixes.sort_by(|a, b| a.cmp(b));
+        k *= 2;
+    }
+    let mut suffix_arr = Vec::new();
+    for suf in suffixes {
+        suffix_arr.push(suf.index);
+    }
+    suffix_arr
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_suffix_array() {
+        let a = generate_suffix_array("banana");
+        assert_eq!(a, vec![5, 3, 1, 0, 4, 2]);
+    }
+}