Add stack.h, queue.h

Author: lambdaxing

.vscode/settings.json

@@ -14,7 +14,57 @@
         "string_view": "cpp",
         "unordered_map": "cpp",
         "utility": "cpp",
-        "algorithm": "cpp"
+        "algorithm": "cpp",
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tuple": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp"
     },
     "files.exclude": {
         "**/.dSYM": true

II Sorting and Order Statistics/randomized_select.h

@@ -15,12 +15,29 @@ T& randomized_select(T* const A, unsigned p, unsigned r, unsigned i) {
     return randomized_select(A, q + 1, r, i - k);
 }
 
+template <typename T>
+T& randomized_select_mate(T* const A, unsigned p, unsigned r, unsigned i) {
+  while (p != r) {
+    auto q = randomized_partition(A, p, r);
+    auto k = q - p + 1;
+    if (i == k)
+      return A[q];
+    else if (i < k)
+      r = q - 1;
+    else {
+      p = q + 1;
+      i -= k;
+    }
+  }
+  return A[p];
+}
+
 template <typename T>
 T& randomized_select(T* const A, unsigned N, unsigned i) {
   return randomized_select(A, 0, N - 1, i);
 }
 
 template <typename T, unsigned N>
 T& randomized_select(T (&A)[N], unsigned i) {
-  return randomized_select(A, N, i);
+  return randomized_select_mate(A, 0, N - 1, i);
 }

II Sorting and Order Statistics/select.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "insertion_sort.h"

II Sorting and Order Statistics/test_randomized_select.cpp

@@ -19,5 +19,6 @@ int main() {
   }
   cout << endl;
 
-  cout << randomized_select(dn.get(), num, 3) << endl;
-  cout << randomized_select(n, 3) << endl;
+  cout << randomized_select(dn.get(), num, 5) << endl;
+  cout << randomized_select(n, 5) << endl;
+}

III Data Structures/Widget.h

@@ -0,0 +1,22 @@
+#pragma once
+// a class for test.
+
+#include <iostream>
+using std::cout;
+using std::endl;
+
+class Widget {
+ public:
+  Widget() { cout << "Widget()" << endl; }
+  Widget(const Widget& rhs) { cout << "Widget(const Widget&)" << endl; }
+  Widget(Widget&& rhs) { cout << "Widget(Widget&&)" << endl; }
+  ~Widget() { cout << "~Widget()" << endl; }
+  Widget& operator=(const Widget&) {
+    cout << "operator=(const Widget&)" << endl;
+    return *this;
+  }
+  Widget& operator=(Widget&&) {
+    cout << "operator=(Widget&&)" << endl;
+    return *this;
+  }
+};

III Data Structures/arrayList.h

@@ -0,0 +1,59 @@
+#pragma once
+
+template <typename T>
+class arrayList {
+ public:
+  typedef std::size_t size_t;
+  arrayList();
+  arrayList(const arrayList& rhs);
+  arrayList(arrayList&& rhs);
+  ~arrayList();
+  arrayList& operator=(const arrayList& rhs);
+  arrayList& operator=(arrayList&& rhs);
+  void swap(arrayList& rhs);
+
+ protected:
+  size_t length;
+  T* p;
+};
+
+template <typename T>
+arrayList<T>::arrayList() : length(10), p(new T[length]) {}
+
+template <typename T>
+arrayList<T>::arrayList(const arrayList& rhs)
+    : length(rhs.length), p(new T[length]) {
+  for (size_t i = 0; i < length; i++) p[i] = rhs.p[i];
+}
+
+template <typename T>
+arrayList<T>::arrayList(arrayList&& rhs) : length(rhs.length), p(rhs.p) {
+  rhs.p = nullptr;
+}
+
+template <typename T>
+arrayList<T>::~arrayList() {
+  delete[] p;
+}
+
+template <typename T>
+arrayList<T>& arrayList<T>::operator=(const arrayList& rhs) {
+  if (this != &rhs) {
+    arrayList t = rhs;
+    swap(t);
+  }  // t is destroyed, including old elments of this.
+  return *this;
+}
+
+template <typename T>
+arrayList<T>& arrayList<T>::operator=(arrayList&& rhs) {
+  swap(rhs);
+  return *this;
+}
+
+template <typename T>
+void arrayList<T>::swap(arrayList& rhs) {
+  using std::swap;
+  swap(p, rhs.p);
+  swap(length, rhs.length);
+}

III Data Structures/myExceptions.h

@@ -0,0 +1,41 @@
+#pragma once
+// exception classes for various error types
+
+#include <iostream>
+#include <string>
+
+// illegal parameter value
+class illegalParameterValue {
+ public:
+  illegalParameterValue(std::string theMessage = "Illegal parameter value") {
+    message = theMessage;
+  }
+  void outputMessage() { std::cout << message << std::endl; }
+
+ private:
+  std::string message;
+};
+
+// illegal input data
+class illegalInputData {
+ public:
+  illegalInputData(std::string theMessage = "Illegal data input") {
+    message = theMessage;
+  }
+  void outputMessage() { std::cout << message << std::endl; }
+
+ private:
+  std::string message;
+};
+
+// illegal index
+class illegalIndex {
+ public:
+  illegalIndex(std::string theMessage = "Illegal index") {
+    message = theMessage;
+  }
+  void outputMessage() { std::cout << message << std::endl; }
+
+ private:
+  std::string message;
+};

III Data Structures/queue.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "arrayList.h"
+#include "myExceptions.h"
+
+template <typename T>
+class queue : private arrayList<T> {
+ public:
+  using typename arrayList<T>::size_t;
+  queue();
+  queue(const queue& rhs);
+  queue(queue&& rhs);
+  queue& operator=(const queue& rhs);
+  queue& operator=(queue&& rhs);
+  ~queue() {}
+
+  bool empty() const;
+  void enqueue(const T& x);
+  template <typename... Ts>
+  void enqueue(Ts&&... params);
+  T dequeue();
+
+ private:
+  using arrayList<T>::length;
+  using arrayList<T>::p;
+  size_t head;
+  size_t size;
+  void enlarge();
+  size_t tail() const { return (head + size) % length; }
+};
+
+template <typename T>
+void queue<T>::enqueue(const T& x) {
+  enlarge();
+  p[tail()] = x;
+  size++;
+}
+
+template <typename T>
+template <typename... Ts>
+void queue<T>::enqueue(Ts&&... params) {
+  enlarge();
+  p[tail()] = T(std::forward<Ts>(params)...);
+  // 对于 local objects，上一步中的拷贝赋值可能会优化为移动赋值。
+  size++;
+}
+
+template <typename T>
+T queue<T>::dequeue() {
+  if (empty()) {
+    throw illegalIndex("Underflow. queue is empty!");
+  }
+  auto x = p[head++];
+  head %= length;
+  size--;
+  return x;
+}
+
+template <typename T>
+queue<T>::queue() : arrayList<T>(), head(0), size(0) {}
+
+template <typename T>
+queue<T>::queue(const queue& rhs)
+    : arrayList<T>(rhs), head(rhs.head), size(rhs.size) {}
+
+template <typename T>
+queue<T>::queue(queue&& rhs)
+    : arrayList<T>(std::move(rhs)), head(rhs.head), size(rhs.size) {}
+
+template <typename T>
+queue<T>& queue<T>::operator=(const queue& rhs) {
+  arrayList<T>::operator=(rhs);
+  head = rhs.head;
+  size = rhs.size;
+  return *this;
+}
+
+template <typename T>
+queue<T>& queue<T>::operator=(queue&& rhs) {
+  arrayList<T>::operator=(std::move(rhs));
+  head = rhs.head;
+  size = rhs.size;
+  return *this;
+}
+
+template <typename T>
+bool queue<T>::empty() const {
+  return size == 0;
+}
+
+template <typename T>
+void queue<T>::enlarge() {
+  if (size == length) {
+    T* tp = new T[length * 2];
+    for (size_t i = 0; i < size; i++) tp[i] = p[(head + i) % length];
+    delete[] p;
+    p = tp;
+    length *= 2;
+    head = 0;
+  }
+}