add ch5

AceCoooool · AceCoooool · commit ed9f8e499582 · 2018-07-05T20:52:41.000+08:00
diff --git a/README.md b/README.md
@@ -95,3 +95,11 @@ Algorithms, 4th edition textbook code (using c++)
 |     [-](https://algs4.cs.princeton.edu/44sp/index.php#-)     |          [Arbitrage.cpp](ch4/49_Arbitrage/main.cpp)          |       arbitrage detection        |     [-](https://algs4.cs.princeton.edu/44sp/index.php#-)     |         [FloydWarshall.h](ch4/head/FloydWarshall.h)          |   all-pairs shortest paths (dense)   |
 |     [-](https://algs4.cs.princeton.edu/44sp/index.php#-)     | [AdjMatrixEdgeWeightedDigraph.h](ch4/head/AdjMatrixEdgeWeightedDigraph.h) |   edge-weighted graph (dense)    |                                                              |                                                              |                                      |
 
+## ch5. Strings
+
+|                             REF                             |                           PROGRAM                            |   DESCRIPTION / C++DOC   |                             REF                             |                           PROGRAM                            | DESCRIPTION / C++DOC |
+| :---------------------------------------------------------: | :----------------------------------------------------------: | :----------------------: | :---------------------------------------------------------: | :----------------------------------------------------------: | :------------------: |
+|  [-](https://algs4.cs.princeton.edu/50strings/index.php#-)  | [Alphabet.java](https://algs4.cs.princeton.edu/50strings/Alphabet.java.html) |         alphabet         |  [-](https://algs4.cs.princeton.edu/50strings/index.php#-)  | [Count.java](https://algs4.cs.princeton.edu/50strings/Count.java.html) |   alphabet client    |
+| [5.1](https://algs4.cs.princeton.edu/51radix/index.php#5.1) |                   [LSD.h](ch5/head/LSD.h)                    |      LSD radix sort      | [5.2](https://algs4.cs.princeton.edu/51radix/index.php#5.2) |                   [MSD.h](ch5/head/MSD.h)                    |    MSD radix sort    |
+|   [-](https://algs4.cs.princeton.edu/51radix/index.php#-)   |            [InplaceMSD.h](ch5/head/InplaceMSD.h)             | In-place MSD radix sort1 |                                                             |                                                              |                      |
+
diff --git a/ch5/3_LSD/CMakeLists.txt b/ch5/3_LSD/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(3_LSD)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/LSD.h ../head/MSD.h ../head/InplaceMSD.h)
+add_executable(3_LSD ${SOURCE_FILES})
diff --git a/ch5/3_LSD/main.cpp b/ch5/3_LSD/main.cpp
@@ -0,0 +1,31 @@
+#include "../head/LSD.h"
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+/**
+ * Reads in a sequence of fixed-length strings from standard input;
+ * LSD radix sorts them;
+ * and prints them to standard output in ascending order.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    string file = "/home/ace/AceDev/C++/algorithm/ch5/data/words3.txt";
+    fstream in(file);
+    string tmp;
+    vector<string> a;
+    while (in >> tmp)
+        a.push_back(tmp);
+
+    int n = a.size();
+    int w = a[0].length();
+
+    // sort the strings
+    LSD::sort(a, w);
+
+    // print results
+    for (int i = 0; i < n; ++i)
+        cout << a[i] << endl;
+}
diff --git a/ch5/4_MSD/CMakeLists.txt b/ch5/4_MSD/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(4_MSD)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/LSD.h ../head/MSD.h)
+add_executable(4_MSD ${SOURCE_FILES})
diff --git a/ch5/4_MSD/main.cpp b/ch5/4_MSD/main.cpp
@@ -0,0 +1,31 @@
+#include "../head/MSD.h"
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+/**
+ * Reads in a sequence of extended ASCII strings from standard input;
+ * MSD radix sorts them;
+ * and prints them to standard output in ascending order.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    string file = "/home/ace/AceDev/C++/algorithm/ch5/data/shells.txt";
+    fstream in(file);
+    string tmp;
+    vector<string> a;
+    while (in >> tmp)
+        a.push_back(tmp);
+
+    int n = a.size();
+    int w = a[0].length();
+
+    // sort the strings
+    MSD::sort(a);
+
+    // print results
+    for (int i = 0; i < n; ++i)
+        cout << a[i] << endl;
+}
diff --git a/ch5/5_InplaceMSD/CMakeLists.txt b/ch5/5_InplaceMSD/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(5_InplaceMSD)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/LSD.h ../head/MSD.h)
+add_executable(5_InplaceMSD ${SOURCE_FILES})
diff --git a/ch5/5_InplaceMSD/main.cpp b/ch5/5_InplaceMSD/main.cpp
@@ -0,0 +1,31 @@
+#include "../head/InplaceMSD.h"
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+/**
+ * Reads in a sequence of extended ASCII strings from standard input;
+ * in-place MSD radix sorts them;
+ * and prints them to standard output in ascending order.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    string file = "/home/ace/AceDev/C++/algorithm/ch5/data/shells.txt";
+    fstream in(file);
+    string tmp;
+    vector<string> a;
+    while (in >> tmp)
+        a.push_back(tmp);
+
+    int n = a.size();
+    int w = a[0].length();
+
+    // sort the strings
+    InplaceMSD::sort(a);
+
+    // print results
+    for (int i = 0; i < n; ++i)
+        cout << a[i] << endl;
+}
diff --git a/ch5/CMakeLists.txt b/ch5/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.8)
+project(ch5)
+
+set(CMAKE_CXX_STANDARD 14)
+
+include_directories(head)
+include_directories(data)
+
+add_subdirectory(3_LSD)
+add_subdirectory(4_MSD)
+add_subdirectory(5_InplaceMSD)
+
diff --git a/ch5/data/shells.txt b/ch5/data/shells.txt
@@ -0,0 +1,2 @@
+she sells seashells by the sea shore
+the shells she sells are surely seashells
diff --git a/ch5/data/words3.txt b/ch5/data/words3.txt
@@ -0,0 +1,7 @@
+bed bug dad yes zoo
+now for tip ilk dim 
+tag jot sob nob sky
+hut men egg few jay
+owl joy rap gig wee
+was wad fee tap tar
+dug jam all bad yet
diff --git a/ch5/head/InplaceMSD.h b/ch5/head/InplaceMSD.h
@@ -0,0 +1,108 @@
+#ifndef CH5_INPLACEMSD_H
+#define CH5_INPLACEMSD_H
+
+#include <vector>
+#include <string>
+
+using std::vector;
+using std::string;
+
+/**
+ *  The {@code InplaceMSD} class provides static methods for sorting an
+ *  array of extended ASCII strings using in-place MSD radix sort.
+ *  <p>
+ *  For additional documentation,
+ *  see <a href="https://algs4.cs.princeton.edu/51radix">Section 5.1</a> of
+ *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
+ *
+ *  @author Ivan Pesin
+ */
+class InplaceMSD {
+public:
+    InplaceMSD() = delete;
+
+    /**
+     * Rearranges the array of extended ASCII strings in ascending order.
+     * This is an unstable sorting algorithm.
+     *
+     * @param a the array to be sorted
+     */
+    static void sort(vector<string> &a) {
+        int n = a.size();
+        sort(a, 0, n - 1, 0);
+    }
+
+private:
+    // sort from a[lo] to a[hi], starting at the dth character
+    static void sort(vector<string> &a, int lo, int hi, int d) {
+
+        // cutoff to insertion sort for small subarrays
+        if (hi <= lo + CUTOFF) {
+            insertion(a, lo, hi, d);
+            return;
+        }
+
+        // compute frequency counts
+        vector<int> heads(R + 2);
+        vector<int> tails(R + 1);
+        for (int i = lo; i <= hi; i++) {
+            int c = charAt(a[i], d);
+            heads[c + 2]++;
+        }
+
+        // transform counts to indices
+        heads[0] = lo;
+        for (int r = 0; r < R + 1; r++) {
+            heads[r + 1] += heads[r];
+            tails[r] = heads[r + 1];
+        }
+
+        // sort by d-th character in-place
+        for (int r = 0; r < R + 1; r++) {
+            while (heads[r] < tails[r]) {
+                int c = charAt(a[heads[r]], d);
+                while (c + 1 != r) {
+                    swap(a[heads[r]], a[heads[c + 1]++]);
+                    c = charAt(a[heads[r]], d);
+                }
+                heads[r]++;
+            }
+        }
+
+        // recursively sort for each character (excludes sentinel -1)
+        for (int r = 0; r < R; r++)
+            sort(a, tails[r], tails[r + 1] - 1, d + 1);
+    }
+
+    // insertion sort a[lo..hi], starting at dth character
+    static void insertion(vector<string> &a, int lo, int hi, int d) {
+        for (int i = lo; i <= hi; i++)
+            for (int j = i; j > lo && less(a[j], a[j - 1], d); j--)
+                swap(a[j], a[j - 1]);
+    }
+
+    // is v less than w, starting at character d
+    static bool less(string v, string w, int d) {
+        // assert v.substring(0, d).equals(w.substring(0, d));
+        for (int i = d; i < std::min(v.length(), w.length()); i++) {
+            if (v[i] < w[i]) return true;
+            if (v[i] > w[i]) return false;
+        }
+        return v.length() < w.length();
+    }
+
+    // return dth character of s, -1 if d = length of string
+    static int charAt(string s, int d) {
+        if (d == s.length()) return -1;
+        return s[d];
+    }
+
+private:
+    static int R;        // extended ASCII alphabet size
+    static int CUTOFF;   // cutoff to insertion sort
+};
+
+int InplaceMSD::R = 256;
+int InplaceMSD::CUTOFF = 15;
+
+#endif //CH5_INPLACEMSD_H
diff --git a/ch5/head/LSD.h b/ch5/head/LSD.h
@@ -0,0 +1,116 @@
+#ifndef CH5_LSD_H
+#define CH5_LSD_H
+
+#include <string>
+#include <vector>
+
+using std::string;
+using std::vector;
+
+/**
+ *  The {@code LSD} class provides static methods for sorting an
+ *  array of <em>w</em>-character strings or 32-bit integers using LSD radix sort.
+ *  <p>
+ *  For additional documentation,
+ *  see <a href="https://algs4.cs.princeton.edu/51radix">Section 5.1</a> of
+ *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
+ *
+ *  @author Robert Sedgewick
+ *  @author Kevin Wayne
+ */
+class LSD {
+public:
+    // do not instantiate
+    LSD() = delete;
+
+    /**
+     * Rearranges the array of W-character strings in ascending order.
+     *
+     * @param a the array to be sorted
+     * @param w the number of characters per string
+     */
+    static void sort(vector<string> &a, int w) {
+        int n = a.size();
+        int R = 256;   // extend ASCII alphabet size
+        vector<string> aux(n);
+
+        for (int d = w - 1; d >= 0; d--) {
+            // sort by key-indexed counting on dth character
+
+            // compute frequency counts
+            vector<int> count(R + 1);
+            for (int i = 0; i < n; i++)
+                count[a[i][d] + 1]++;
+
+            // compute cumulates
+            for (int r = 0; r < R; r++)
+                count[r + 1] += count[r];
+
+            // move data
+            for (int i = 0; i < n; i++)
+                aux[count[a[i][d]]++] = a[i];
+
+            // copy back
+            for (int i = 0; i < n; i++)
+                a[i] = aux[i];
+        }
+    }
+
+    /**
+     * Rearranges the array of 32-bit integers in ascending order.
+     * This is about 2-3x faster than Arrays.sort().
+     *
+     * @param a the array to be sorted
+     */
+    static void sort(vector<int> &a) {
+        int BITS = 32;                 // each int is 32 bits
+        int R = 1 << BITS_PER_BYTE;    // each bytes is between 0 and 255
+        int MASK = R - 1;              // 0xFF
+        int w = BITS / BITS_PER_BYTE;  // each int is 4 bytes
+
+        int n = a.size();
+
+        vector<int> aux(n);
+
+        for (int d = 0; d < w; d++) {
+
+            // compute frequency counts
+            vector<int> count(R+1);
+            for (int i = 0; i < n; i++) {
+                int c = (a[i] >> BITS_PER_BYTE * d) & MASK;
+                count[c + 1]++;
+            }
+
+            // compute cumulates
+            for (int r = 0; r < R; r++)
+                count[r + 1] += count[r];
+
+            // for most significant byte, 0x80-0xFF comes before 0x00-0x7F
+            if (d == w - 1) {
+                int shift1 = count[R] - count[R / 2];
+                int shift2 = count[R / 2];
+                for (int r = 0; r < R / 2; r++)
+                    count[r] += shift1;
+                for (int r = R / 2; r < R; r++)
+                    count[r] -= shift2;
+            }
+
+            // move data
+            for (int i = 0; i < n; i++) {
+                int c = (a[i] >> BITS_PER_BYTE * d) & MASK;
+                aux[count[c]++] = a[i];
+            }
+
+            // copy back
+            for (int i = 0; i < n; i++)
+                a[i] = aux[i];
+        }
+    }
+
+private:
+    static int BITS_PER_BYTE;
+};
+
+int LSD::BITS_PER_BYTE = 8;
+
+#endif //CH5_LSD_H
diff --git a/ch5/head/MSD.h b/ch5/head/MSD.h

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+she sells seashells by the sea shore`
	`2`	`+the shells she sells are surely seashells`