refactor code

Author: TsungHsienLee

Approximate_sort.cpp

@@ -1,39 +1,51 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <functional>
 #include <iostream>
-#include <string>
+#include <queue>
+#include <random>
 #include <sstream>
+#include <string>
 #include <vector>
-#include <ctime>
-#include <cstdlib>
-#include <queue>
 
-using namespace std;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::greater;
+using std::istringstream;
+using std::priority_queue;
+using std::random_device;
+using std::string;
+using std::stringstream;
+using std::uniform_int_distribution;
+using std::vector;
 
 // @include
 template <typename T>
-void approximate_sort(istringstream &sin, const int &k) {
+void approximate_sort(istringstream &sin, int k) {
   priority_queue<T, vector<T>, greater<T>> min_heap;
-  // Firstly push k elements into min_heap
+  // Firstly push k elements into min_heap.
   T x;
   for (int i = 0; i < k && sin >> x; ++i) {
     min_heap.push(x);
   }
 
-  // Extract the minimum one for every incoming element
+  // Extract the minimum one for every incoming element.
   while (sin >> x) {
     min_heap.push(x);
     cout << min_heap.top() << endl;
     min_heap.pop();
   }
 
-  // Extract the remaining elements in min_heap
+  // Extract the remaining elements in min_heap.
   while (!min_heap.empty()) {
     cout << min_heap.top() << endl;
     min_heap.pop();
   }
 }
 // @exclude
 
-// It should print 1, 2, 3, 4, 5, 6, 7, ,8, 9
+// It should print 1, 2, 3, 4, 5, 6, 7, ,8, 9.
 void simple_test(void) {
   vector<int> A = {2, 1, 5, 4, 3, 9, 8, 7, 6};
   stringstream ss;
@@ -46,22 +58,26 @@ void simple_test(void) {
 
 int main(int argc, char *argv[]) {
   simple_test();
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   int n, k;
   if (argc == 2) {
     n = atoi(argv[1]);
-    k = 1 + rand() % n;
+    uniform_int_distribution<int> dis(1, n);
+    k = dis(gen);
   } else if (argc == 3) {
     n = atoi(argv[1]);
     k = atoi(argv[2]);
   } else {
-    n = 1 + rand() % 100000;
-    k = 1 + rand() % n;
+    uniform_int_distribution<int> n_dis(1, 100000);
+    n = n_dis(gen);
+    uniform_int_distribution<int> k_dis(1, n);
+    k = k_dis(gen);
   }
   cout << "n = " << n << " k = " << k << endl;
   vector<int> A;
+  uniform_int_distribution<int> dis(1, 999999);
   for (int i = 0; i < n; ++i) {
-    A.push_back(rand());
+    A.push_back(dis(gen));
   }
   stringstream ss;
   for (const int &a : A) {

BST_sorted_order_template.cpp

@@ -1,8 +1,13 @@
-#include "BST_prototype.h"
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <iostream>
 #include <stack>
 
-using namespace std;
+#include "./BST_prototype.h"
+
+using std::cout;
+using std::endl;
+using std::stack;
 
 // @include
 template <typename T>
@@ -28,12 +33,18 @@ int main(int argc, char *argv[]) {
   //      3
   //    2   5
   //  1    4 6
-  shared_ptr<BinarySearchTree<int>> root = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{3, nullptr});
-  root->left = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{2, nullptr});
-  root->left->left = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{1, nullptr});
-  root->right = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{5, nullptr});
-  root->right->left = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{4, nullptr});
-  root->right->right = shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{6, nullptr});
+  shared_ptr<BinarySearchTree<int>> root =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{3, nullptr});
+  root->left =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{2, nullptr});
+  root->left->left =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{1, nullptr});
+  root->right =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{5, nullptr});
+  root->right->left =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{4, nullptr});
+  root->right->right =
+      shared_ptr<BinarySearchTree<int>>(new BinarySearchTree<int>{6, nullptr});
   // should output 1 2 3 4 5 6
   print_BST_in_sorted_order<int>(root);
   return 0;

Balanced_binary_tree_template.cpp

@@ -1,30 +1,37 @@
-#include "Binary_tree_prototype_template.h"
-#include <iostream>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <algorithm>
 #include <cassert>
 #include <cstdlib>
+#include <iostream>
+
+#include "./Binary_tree_prototype_template.h"
 
-using namespace std;
+using std::boolalpha;
+using std::cout;
+using std::endl;
+using std::max;
 
 // @include
 template <typename T>
 int get_height(const shared_ptr<BinaryTree<T>> &n) {
   if (!n) {
-    return -1;  // base case
+    return -1;  // base case.
   }
 
   int l_height = get_height(n->left);
   if (l_height == -2) {
-    return -2;  // left subtree is not balanced
+    return -2;  // left subtree is not balanced.
   }
   int r_height = get_height(n->right);
   if (r_height == -2) {
-    return -2;  // right subtree is not balanced
+    return -2;  // right subtree is not balanced.
   }
 
   if (abs(l_height - r_height) > 1) {
-    return -2;  // current node n is not balanced
+    return -2;  // current node n is not balanced.
   }
-  return max(l_height, r_height) + 1;  // return the height
+  return max(l_height, r_height) + 1;  // return the height.
 }
 
 template <typename T>
@@ -38,7 +45,8 @@ int main(int argc, char *argv[]) {
   //      3
   //    2   5
   //  1    4 6
-  shared_ptr<BinaryTree<int>> root = shared_ptr<BinaryTree<int>>(new BinaryTree<int>());
+  shared_ptr<BinaryTree<int>> root =
+      shared_ptr<BinaryTree<int>>(new BinaryTree<int>());
   root->left = shared_ptr<BinaryTree<int>>(new BinaryTree<int>());
   root->left->left = shared_ptr<BinaryTree<int>>(new BinaryTree<int>());
   root->right = shared_ptr<BinaryTree<int>>(new BinaryTree<int>());

Binary_search_Ai=i.cpp

@@ -1,19 +1,19 @@
-#include <iostream>
-#include <cstdlib>
-#include <ctime>
-#include <vector>
-#include <cassert>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <algorithm>
-#ifdef __clang__
+#include <cassert>
+#include <iostream>
+#include <random>
 #include <unordered_set>
-#else
-#include <tr1/unordered_set>
-#endif
+#include <vector>
 
-using namespace std;
-#ifndef __clang__
-using namespace std::tr1;
-#endif
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::uniform_int_distribution;
+using std::unordered_set;
+using std::vector;
 
 // @include
 int search_index_value_equal(const vector<int> &A) {
@@ -45,21 +45,24 @@ int check_ans(const vector<int> &A) {
 }
 
 int main(int argc, char *argv[]) {
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   for (int times = 0; times < 1000; ++times) {
     int n;
     vector<int> A;
     unordered_set<int> table;
     if (argc == 2) {
       n = atoi(argv[1]);
     } else {
-      n = 1 + rand() % 1000;
+      uniform_int_distribution<int> dis(1, 1000);
+      n = dis(gen);
     }
     for (int i = 0; i < n; ++i) {
       int x;
       unordered_set<int>::iterator iter;
       do {
-        x = ((rand() & 1) ? -1 : 1) * rand() % 1000;
+        uniform_int_distribution<int> pos_or_neg(0, 1);
+        uniform_int_distribution<int> dis(0, 999);
+        x = ((pos_or_neg(gen) & 1) ? -1 : 1) * dis(gen);
         iter = table.find(x);
       } while (iter != table.cend());
       table.emplace_hint(iter, x);

Binary_search_circular_array_template.cpp

@@ -1,19 +1,19 @@
-#include <iostream>
-#include <cassert>
-#include <vector>
-#include <cstdlib>
-#include <ctime>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <algorithm>
-#ifdef __clang__
+#include <cassert>
+#include <iostream>
+#include <random>
 #include <unordered_set>
-#else
-#include <tr1/unordered_set>
-#endif
+#include <vector>
 
-using namespace std;
-#ifndef __clang__
-using namespace std::tr1;
-#endif
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::uniform_int_distribution;
+using std::unordered_set;
+using std::vector;
 
 // @include
 template <typename T>
@@ -32,27 +32,30 @@ int search_smallest(const vector<T> &A) {
 // @exclude
 
 int main(int argc, char *argv[]) {
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   for (int times = 0; times < 1000; ++times) {
     int n;
     if (argc == 2) {
       n = atoi(argv[1]);
     } else {
-      n = 1 + rand() % 10000;
+      uniform_int_distribution<int> dis(1, 10000);
+      n = dis(gen);
     }
     vector<int> A;
     unordered_set<int> table;
     for (size_t i = 0; i < n; ++i) {
       while (true) {
-        int x = rand();
+        uniform_int_distribution<int> dis(0, 100000);
+        int x = dis(gen);
         if (table.emplace(x).second) {
           A.emplace_back(x);
           break;
         }
       }
     }
     sort(A.begin(), A.end());
-    int shift = rand() % n;
+    uniform_int_distribution<int> n_dis(0, n - 1);
+    int shift = n_dis(gen);
     reverse(A.begin(), A.end());
     reverse(A.begin(), A.begin() + shift + 1);
     reverse(A.begin() + shift + 1, A.end());

Binary_search_circular_array_with_duplicates_template.cpp

@@ -1,11 +1,17 @@
-#include <iostream>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <algorithm>
 #include <cassert>
+#include <iostream>
+#include <random>
 #include <vector>
-#include <cstdlib>
-#include <ctime>
-#include <algorithm>
 
-using namespace std;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::uniform_int_distribution;
+using std::vector;
 
 /*
 template <typename T>
@@ -46,9 +52,10 @@ int search_smallest(const vector<T> &A) {
   return search_smallest_helper(A, 0, A.size() - 1);
 }
 */
+
 // @include
 template <typename T>
-int search_smallest_helper(const vector<T> &A, const int &l, const int &r) {
+int search_smallest_helper(const vector<T> &A, int l, int r) {
   if (l == r) {
     return l;
   }
@@ -59,7 +66,7 @@ int search_smallest_helper(const vector<T> &A, const int &l, const int &r) {
   } else if (A[m] < A[r]) {
     return search_smallest_helper(A, l, m);
   } else {  // A[m] == A[r]
-    // Smallest element must exist in either left or right side
+    // Smallest element must exist in either left or right side.
     int l_res = search_smallest_helper(A, l, m);
     int r_res = search_smallest_helper(A, m + 1, r);
     return A[r_res] < A[l_res] ? r_res : l_res;
@@ -73,20 +80,23 @@ int search_smallest(const vector<T> &A) {
 // @exclude
 
 int main(int argc, char *argv[]) {
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   for (int times = 0; times < 10000; ++times) {
     int n;
     if (argc == 2) {
       n = atoi(argv[1]);
     } else {
-      n = 1 + rand() % 10000;
+      uniform_int_distribution<int> dis(1, 10000);
+      n = dis(gen);
     }
     vector<int> A;
     for (size_t i = 0; i < n; ++i) {
-      A.emplace_back(rand());
+      uniform_int_distribution<int> dis(0, 999999);
+      A.emplace_back(dis(gen));
     }
     sort(A.begin(), A.end());
-    int shift = rand() % n;
+    uniform_int_distribution<int> n_dis(0, n - 1);
+    int shift = n_dis(gen);
     reverse(A.begin(), A.end());
     reverse(A.begin(), A.begin() + shift + 1);
     reverse(A.begin() + shift + 1, A.end());