phishman3579#19 improved readability of StringFunctions, also added a iterative version of Levenshtein Distance

Author: Justin Wetherell

src/com/jwetherell/algorithms/strings/StringFunctions.java

@@ -203,15 +203,15 @@ public static final boolean isPalindromeInPlace(String string) {
         return true;
     }
 
-    public static final String[] generateSubsets(String input) {
-        int length = input.length();
-        int size = (int) Math.pow(2, length);
-        BitSet[] sets = new BitSet[size];
-        String[] output = new String[size];
+    public static final String[] generateSubsets(String inputString) {
+        final int length = inputString.length();
+        final int size = (int) Math.pow(2, length);
+        final BitSet[] sets = new BitSet[size];
+        final String[] output = new String[size];
 
         for (int i = 0; i < size; i++) {
-            BitSet set = new BitSet(size);
-            StringBuilder builder = new StringBuilder();
+            final BitSet set = new BitSet(size);
+            final StringBuilder builder = new StringBuilder();
             if (i > 0) {
                 for (int j = length - 1; j >= 0; j--) {
                     if (j == length - 1) {
@@ -228,13 +228,12 @@ public static final String[] generateSubsets(String input) {
                         set.set(j, prev);
                     }
                     if (set.get(j))
-                        builder.append(input.charAt(j));
+                        builder.append(inputString.charAt(j));
                 }
             }
             sets[i] = set;
             output[i] = builder.toString();
         }
-
         return output;
     }
 
@@ -268,21 +267,21 @@ private static final int permutations(String[] list, int index, char[] prefix, c
     }
 
     /** N! permutation of the characters of the string (in order) **/
-    public static String[] permutations(String string) {
-        final int size = numberOfPermutations(string.length());
+    public static String[] permutations(String stringToGeneratePermutationsFrom) {
+        final int size = numberOfPermutations(stringToGeneratePermutationsFrom.length());
         final String[] list = new String[size];
         final char[] prefix = new char[0];
-        final char[] chars = string.toCharArray();
+        final char[] chars = stringToGeneratePermutationsFrom.toCharArray();
         permutations(list, 0, prefix, chars, 0, chars.length);
         return list;
     }
 
-    public static final int levenshteinDistance(String s, String t) {
-        int sLength = s.length();
-        int tLength = t.length();
-
-        char[] sChars = s.toCharArray();
-        char[] tChars = t.toCharArray();
+    /** recursive **/
+    public static final int levenshteinDistanceRecursive(String s, String t) {
+        final int sLength = s.length();
+        final int tLength = t.length();
+        final char[] sChars = s.toCharArray();
+        final char[] tChars = t.toCharArray();
 
         int cost = 0;
         if ((sLength > 0 && tLength > 0) && sChars[0] != tChars[0])
@@ -293,12 +292,51 @@ public static final int levenshteinDistance(String s, String t) {
         else if (tLength == 0)
             return sLength;
         else {
-            int min1 = levenshteinDistance(s.substring(1), t) + 1;
-            int min2 = levenshteinDistance(s, t.substring(1)) + 1;
-            int min3 = levenshteinDistance(s.substring(1), t.substring(1)) + cost;
+            final int min1 = levenshteinDistanceRecursive(s.substring(1), t) + 1;
+            final int min2 = levenshteinDistanceRecursive(s, t.substring(1)) + 1;
+            final int min3 = levenshteinDistanceRecursive(s.substring(1), t.substring(1)) + cost;
 
             int minOfFirstSet = Math.min(min1, min2);
             return (Math.min(minOfFirstSet, min3));
         }
     }
+
+    /** iterative - dynamic programming **/
+    public static final int levenshteinDistanceIterative(String string1, String string2) {
+        final char[] s = string1.toCharArray();
+        final char[] t = string2.toCharArray();
+        final int m = s.length;
+        final int n = t.length;
+
+        // for all i and j, d[i,j] will hold the Levenshtein distance between
+        // the first i characters of s and the first j characters of t
+        // note that d has (m+1)*(n+1) values
+        final int[][] d = new int[m+1][n+1];
+
+        // source prefixes can be transformed into empty string by
+        // dropping all characters
+        for (int i=1; i<=m; i++)
+            d[i][0] = i;
+
+        // target prefixes can be reached from empty source prefix
+        // by inserting every character
+        for (int j=1; j<=n; j++)
+            d[0][j] = j;
+
+        int substitutionCost;
+        for (int j=1; j<=n; j++) {
+            for (int i=1; i<=m; i++) {
+                if (s[i-1] == t[j-1])
+                    substitutionCost = 0;
+                else
+                    substitutionCost = 1;
+
+                int minOfInsAndDel = Math.min(d[i-1][j] + 1,          // deletion
+                                              d[i][j-1] + 1);         // insertion
+                d[i][j] =  Math.min(minOfInsAndDel,                   // minimum of insert and delete
+                                    d[i-1][j-1] + substitutionCost);  // substitution
+            }
+        }
+        return d[m][n];
+    }
 }

test/com/jwetherell/algorithms/strings/test/Strings.java

@@ -79,12 +79,22 @@ public void testGenerateSubSets() {
     }
 
     @Test
-    public void testEditDistance() {
+    public void testEditDistanceRecursive() {
         // Edit Distance
         String string1 = "kitten";
         String string2 = "sitting";
         int check = 3;
-        int result = StringFunctions.levenshteinDistance(string1, string2);
+        int result = StringFunctions.levenshteinDistanceRecursive(string1, string2);
+        assertTrue("Edit Distance error. expected="+check+" got="+result, (check==result));
+    }
+
+    @Test
+    public void testEditDistanceDP() {
+        // Edit Distance
+        String string1 = "kitten";
+        String string2 = "sitting";
+        int check = 3;
+        int result = StringFunctions.levenshteinDistanceIterative(string1, string2);
         assertTrue("Edit Distance error. expected="+check+" got="+result, (check==result));
     }
 

test/com/jwetherell/algorithms/strings/timing/StringsTiming.java

@@ -142,9 +142,22 @@ public static void main(String[] args) {
         {
             String string1 = "kitten";
             String string2 = "sitting";
-            System.out.println("Edit Distance");
+            System.out.println("Edit Distance Recursive");
             long before = System.nanoTime();
-            StringFunctions.levenshteinDistance(string1, string2);
+            StringFunctions.levenshteinDistanceRecursive(string1, string2);
+            long after = System.nanoTime();
+            System.out.println("Computed in " + FORMAT.format(after - before) + " ns");
+            System.out.println();
+            System.gc();
+        }
+
+        // Edit Distance
+        {
+            String string1 = "kitten";
+            String string2 = "sitting";
+            System.out.println("Edit Distance Iterative");
+            long before = System.nanoTime();
+            StringFunctions.levenshteinDistanceIterative(string1, string2);
             long after = System.nanoTime();
             System.out.println("Computed in " + FORMAT.format(after - before) + " ns");
             System.out.println();