update ch2

AceCoooool · AceCoooool · commit 9eb22ddbd855 · 2018-06-25T11:04:15.000+08:00
diff --git a/README.md b/README.md
@@ -35,10 +35,14 @@ Algorithms, 4th edition textbook code (using c++)
 
 ## ch2. Sorting
 
-|                             REF                              |                           PROGRAM                            | DESCRIPTION / JAVADOC |                             REF                              |                           PROGRAM                            |   DESCRIPTION / JAVADOC    |
-| :----------------------------------------------------------: | :----------------------------------------------------------: | :-------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: | :------------------------: |
-| [2.1](https://algs4.cs.princeton.edu/21elementary/index.php#2.1) |             [Insertion.h](ch2/head/Insertion.h)              |    insertion sort     | [-](https://algs4.cs.princeton.edu/21elementary/index.php#-) |            [InsertionX.h](ch2/head/InsertionX.h)             | insertion sort (optimized) |
-| [-](https://algs4.cs.princeton.edu/21elementary/index.php#-) |          [BinaryInsertion.h](ch2/head/InsertionX.h)          | binary insertion sort | [2.2](https://algs4.cs.princeton.edu/21elementary/index.php#2.2) |             [Selection.h](ch2/head/InsertionX.h)             |       selection sort       |
-| [2.3](https://algs4.cs.princeton.edu/21elementary/index.php#2.3) | [Shell.java](https://algs4.cs.princeton.edu/21elementary/Shell.java.html) |       shellsort       | [2.4](https://algs4.cs.princeton.edu/22mergesort/index.php#2.4) | [Merge.java](https://algs4.cs.princeton.edu/22mergesort/Merge.java.html) |     top-down mergesort     |
-| [-](https://algs4.cs.princeton.edu/22mergesort/index.php#-)  |               [MergeBU.h](ch2/head/MergeBU.h)                |  bottom-up mergesort  | [-](https://algs4.cs.princeton.edu/22mergesort/index.php#-)  |                [MergeX.h](ch2/head/MergeX.h)                 |    optimized mergesort     |
-|                                                              |                                                              |                       |                                                              |                                                              |                            |
+|                             REF                              |                           PROGRAM                            |       DESCRIPTION / JAVADOC       |                             REF                              |                           PROGRAM                            |   DESCRIPTION / JAVADOC    |
+| :----------------------------------------------------------: | :----------------------------------------------------------: | :-------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: | :------------------------: |
+| [2.1](https://algs4.cs.princeton.edu/21elementary/index.php#2.1) |             [Insertion.h](ch2/head/Insertion.h)              |          insertion sort           | [-](https://algs4.cs.princeton.edu/21elementary/index.php#-) |            [InsertionX.h](ch2/head/InsertionX.h)             | insertion sort (optimized) |
+| [-](https://algs4.cs.princeton.edu/21elementary/index.php#-) |          [BinaryInsertion.h](ch2/head/InsertionX.h)          |       binary insertion sort       | [2.2](https://algs4.cs.princeton.edu/21elementary/index.php#2.2) |             [Selection.h](ch2/head/InsertionX.h)             |       selection sort       |
+| [2.3](https://algs4.cs.princeton.edu/21elementary/index.php#2.3) | [Shell.java](https://algs4.cs.princeton.edu/21elementary/Shell.java.html) |             shellsort             | [2.4](https://algs4.cs.princeton.edu/22mergesort/index.php#2.4) | [Merge.java](https://algs4.cs.princeton.edu/22mergesort/Merge.java.html) |     top-down mergesort     |
+| [-](https://algs4.cs.princeton.edu/22mergesort/index.php#-)  |               [MergeBU.h](ch2/head/MergeBU.h)                |        bottom-up mergesort        | [-](https://algs4.cs.princeton.edu/22mergesort/index.php#-)  |                [MergeX.h](ch2/head/MergeX.h)                 |    optimized mergesort     |
+| [-](https://algs4.cs.princeton.edu/22mergesort/index.php#-)  | [Inversions.java](https://algs4.cs.princeton.edu/22mergesort/Inversions.java.html) |       number of inversions        | [2.5](https://algs4.cs.princeton.edu/23quicksort/index.php#2.5) |                 [Quick.h](ch2/head/Quick.h)                  |         quicksort          |
+| [-](https://algs4.cs.princeton.edu/23quicksort/index.php#-)  |             [Quick3way.h](ch2/head/Quick3way.h)              | quicksort with 3-way partitioning | [-](https://algs4.cs.princeton.edu/23quicksort/index.php#-)  |                [QuickX.h](ch2/head/QuickX.h)                 | optimized 2-way quicksort  |
+| [-](https://algs4.cs.princeton.edu/23quicksort/index.php#-)  |   [QuickBentleyMcIlroy.h](ch2/head/QuickBentleyMcIlroy.h)    |     optimized 3-way quicksort     |                                                              |                                                              |                            |
+|                                                              |                                                              |                                   |                                                              |                                                              |                            |
+
diff --git a/ch2/10_Quick/CMakeLists.txt b/ch2/10_Quick/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(10_Quick)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Insertion.h ../head/InsertionX.h ../head/Quick3way.h ../head/QuickX.h ../head/QuickBentleyMcIlroy.h)
+add_executable(10_Quick ${SOURCE_FILES})
diff --git a/ch2/10_Quick/main.cpp b/ch2/10_Quick/main.cpp
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <fstream>
+#include "../head/Quick.h"
+
+using namespace std;
+
+int main() {
+    ifstream file("/home/ace/AceDev/C++/algorithm/ch2/data/tiny.txt");
+    string tmp;
+    vector<string> vec;
+    while (file >> tmp) {
+        vec.push_back(tmp);
+    }
+    Quick::sort(vec);
+    for (auto a: vec)
+        cout << a << " ";
+    cout << endl;
+    // shuffle
+    shuffle(vec.begin(), vec.end(), g);
+    cout << "select kth large in array: " << endl;
+    for (auto a: vec)
+        cout << a << " ";
+    cout << endl;
+    for (int i = 0; i < vec.size(); ++i) {
+        auto str = Quick::select(vec, i);
+        cout << i << " th: " << str << endl;
+    }
+}
diff --git a/ch2/11_Quick3way/CMakeLists.txt b/ch2/11_Quick3way/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(11_Quick3way)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Insertion.h ../head/InsertionX.h ../head/Quick3way.h)
+add_executable(11_Quick3way ${SOURCE_FILES})
diff --git a/ch2/11_Quick3way/main.cpp b/ch2/11_Quick3way/main.cpp
@@ -0,0 +1,16 @@
+#include <iostream>
+#include <fstream>
+#include "../head/Quick3way.h"
+
+using namespace std;
+
+int main() {
+    ifstream file("/home/ace/AceDev/C++/algorithm/ch2/data/tiny.txt");
+    string tmp;
+    vector<string> vec;
+    while (file >> tmp) {
+        vec.push_back(tmp);
+    }
+    Quick3way::sort(vec);
+    Quick3way::show(vec);
+}
diff --git a/ch2/12_QuickX/CMakeLists.txt b/ch2/12_QuickX/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(12_QuickX)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Insertion.h ../head/InsertionX.h ../head/Quick3way.h)
+add_executable(12_QuickX ${SOURCE_FILES})
diff --git a/ch2/12_QuickX/main.cpp b/ch2/12_QuickX/main.cpp
@@ -0,0 +1,16 @@
+#include <iostream>
+#include <fstream>
+#include "../head/QuickX.h"
+
+using namespace std;
+
+int main() {
+    ifstream file("/home/ace/AceDev/C++/algorithm/ch2/data/tiny.txt");
+    string tmp;
+    vector<string> vec;
+    while (file >> tmp) {
+        vec.push_back(tmp);
+    }
+    QuickX::sort(vec);
+    QuickX::show(vec);
+}
diff --git a/ch2/13_QuickBentleyMcIlroy/CMakeLists.txt b/ch2/13_QuickBentleyMcIlroy/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(13_QuickBentleyMcIlroy)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Insertion.h ../head/InsertionX.h ../head/Quick3way.h)
+add_executable(13_QuickBentleyMcIlroy ${SOURCE_FILES})
diff --git a/ch2/13_QuickBentleyMcIlroy/main.cpp b/ch2/13_QuickBentleyMcIlroy/main.cpp
@@ -0,0 +1,16 @@
+#include <iostream>
+#include <fstream>
+#include "../head/QuickBentleyMcIlroy.h"
+
+using namespace std;
+
+int main() {
+    ifstream file("/home/ace/AceDev/C++/algorithm/ch2/data/words3.txt");
+    string tmp;
+    vector<string> vec;
+    while (file >> tmp) {
+        vec.push_back(tmp);
+    }
+    QuickBentleyMcIlroy::sort(vec);
+    QuickBentleyMcIlroy::show(vec);
+}
diff --git a/ch2/9_Inversions/CMakeLists.txt b/ch2/9_Inversions/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(9_Inversions)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Insertion.h ../head/InsertionX.h)
+add_executable(9_Inversions ${SOURCE_FILES})
diff --git a/ch2/9_Inversions/main.cpp b/ch2/9_Inversions/main.cpp
@@ -0,0 +1,18 @@
+// TODO: un-finish
+
+//#include <iostream>
+//#include <fstream>
+//#include "../head/MergeX.h"
+//
+//using namespace std;
+//
+//int main() {
+//    ifstream file("/home/ace/AceDev/C++/algorithm/ch2/data/words3.txt");
+//    string tmp;
+//    vector<string> vec;
+//    while (file >> tmp) {
+//        vec.push_back(tmp);
+//    }
+//    MergeX::sort(vec);
+//    MergeX::show(vec);
+//}
diff --git a/ch2/CMakeLists.txt b/ch2/CMakeLists.txt
@@ -12,4 +12,9 @@ add_subdirectory(4_Selection)
 add_subdirectory(5_Shell)
 add_subdirectory(6_Merge)
 add_subdirectory(7_MergeBU)
-add_subdirectory(8_MergeX)
+add_subdirectory(8_MergeX)
+add_subdirectory(9_Inversions)
+add_subdirectory(10_Quick)
+add_subdirectory(11_Quick3way)
+add_subdirectory(12_QuickX)
+add_subdirectory(13_QuickBentleyMcIlroy)
diff --git a/ch2/head/Inversions.h b/ch2/head/Inversions.h
@@ -0,0 +1,56 @@
+#ifndef CH2_INVERSIONS_H
+#define CH2_INVERSIONS_H
+
+#include <vector>
+
+using std::vector;
+
+/**
+ *  The {@code Inversions} class provides static methods to count the
+ *  number of <em>inversions</em> in either an array of integers or comparables.
+ *  An inversion in an array {@code a[]} is a pair of indicies {@code i} and
+ *  {@code j} such that {@code i < j} and {@code a[i] > a[j]}.
+ *  <p>
+ *  This implementation uses a generalization of mergesort. The <em>count</em>
+ *  operation takes time proportional to <em>n</em> log <em>n</em>,
+ *  where <em>n</em> is the number of keys in the array.
+ *  <p>
+ *  For additional documentation, see <a href="https://algs4.cs.princeton.edu/22mergesort">Section 2.2</a>
+ *  of <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
+ *
+ *  @author Robert Sedgewick
+ *  @author Kevin Wayne
+ */
+class Inversions {
+public:
+    // do not instantiate
+    Inversions() = delete;
+
+private:
+    // merge and count
+    template<typename T>
+    static long merge(vector<T> &a, vector<T> &aux, int lo, int mid, int hi) {
+        long inversions = 0;
+
+        // copy to aux[]
+        for (int k = lo; k <= hi; k++) {
+            aux[k] = a[k];
+        }
+
+        // merge back to a[]
+        int i = lo, j = mid + 1;
+        for (int k = lo; k <= hi; k++) {
+            if (i > mid) a[k] = aux[j++];
+            else if (j > hi) a[k] = aux[i++];
+            else if (aux[j] < aux[i]) {
+                a[k] = aux[j++];
+                inversions += (mid - i + 1);
+            }
+            else a[k] = aux[i++];
+        }
+        return inversions;
+    }
+
+};
+
+#endif //CH2_INVERSIONS_H
diff --git a/ch2/head/Quick.h b/ch2/head/Quick.h
@@ -0,0 +1,126 @@
+#ifndef CH2_QUICK_H
+#define CH2_QUICK_H
+
+#include <vector>
+#include <random>
+#include <iostream>
+#include <algorithm>
+#include <stdexcept>
+
+using std::vector;
+using std::swap;
+using std::cout;
+using std::endl;
+using std::to_string;
+using std::random_device;
+using std::mt19937;
+using std::shuffle;
+using std::runtime_error;
+
+random_device rd;
+mt19937 g(rd());
+
+/**
+ *  The {@code Quick} class provides static methods for sorting an
+ *  array and selecting the ith smallest element in an array using quicksort.
+ *  <p>
+ *  For additional documentation,
+ *  see <a href="https://algs4.cs.princeton.edu/23quick">Section 2.3</a> of
+ *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
+ *
+ *  @author Robert Sedgewick
+ *  @author Kevin Wayne
+ */
+class Quick {
+public:
+    // This class should not be instantiated.
+    Quick() = delete;
+
+    /**
+     * Rearranges the array in ascending order, using the natural order.
+     * @param a the array to be sorted
+     */
+    template<typename T>
+    static void sort(vector<T> &a) {
+        shuffle(a.begin(), a.end(), g);
+        sort(a, 0, a.size() - 1);
+    }
+
+    /**
+     * Rearranges the array so that {@code a[k]} contains the kth smallest key;
+     * {@code a[0]} through {@code a[k-1]} are less than (or equal to) {@code a[k]}; and
+     * {@code a[k+1]} through {@code a[n-1]} are greater than (or equal to) {@code a[k]}.
+     *
+     * @param  a the array
+     * @param  k the rank of the key
+     * @return the key of rank {@code k}
+     * @throws IllegalArgumentException unless {@code 0 <= k < a.length}
+     */
+    template<typename T>
+    static T select(vector<T> &a, int k) {
+        if (k < 0 || k >= a.size()) {
+            throw runtime_error("index is not between 0 and " + to_string(a.size()) + ": " + to_string(k));
+        }
+        shuffle(a.begin(), a.end(), g);
+        int lo = 0, hi = a.size() - 1;
+        while (hi > lo) {
+            int i = partition(a, lo, hi);
+            if (i > k) hi = i - 1;
+            else if (i < k) lo = i + 1;
+            else return a[i];
+        }
+        return a[lo];
+    }
+
+    // print array to standard output
+    template<typename T>
+    static void show(vector<T> &a) {
+        for (int i = 0; i < a.size(); i++) {
+            cout << a[i] << endl;
+        }
+    }
+
+
+private:
+    // quicksort the subarray from a[lo] to a[hi]
+    template<typename T>
+    static void sort(vector<T> &a, int lo, int hi) {
+        if (hi <= lo) return;
+        int j = partition(a, lo, hi);
+        sort(a, lo, j - 1);
+        sort(a, j + 1, hi);
+    }
+
+    // partition the subarray a[lo..hi] so that a[lo..j-1] <= a[j] <= a[j+1..hi]
+    // and return the index j.
+    template<typename T>
+    static int partition(vector<T> &a, int lo, int hi) {
+        int i = lo;
+        int j = hi + 1;
+        T v = a[lo];
+        while (true) {
+            // find item on lo to swap
+            while (a[++i] < v) {
+                if (i == hi) break;
+            }
+
+            // find item on hi to swap
+            while (v < a[--j]) {
+                if (j == lo) break;      // redundant since a[lo] acts as sentinel
+            }
+
+            // check if pointers cross
+            if (i >= j) break;
+
+            swap(a[i], a[j]);
+        }
+
+        // put partitioning item v at a[j]
+        swap(a[lo], a[j]);
+
+        // now, a[lo .. j-1] <= a[j] <= a[j+1 .. hi]
+        return j;
+    }
+};
+
+#endif //CH2_QUICK_H
diff --git a/ch2/head/Quick3way.h b/ch2/head/Quick3way.h
diff --git a/ch2/head/QuickBentleyMcIlroy.h b/ch2/head/QuickBentleyMcIlroy.h
diff --git a/ch2/head/QuickX.h b/ch2/head/QuickX.h
