small changes

Author: tsunghsienlee

0-1_knapsack.cpp

@@ -44,7 +44,22 @@ int knapsack(int w, const vector<Item>& items) {
 
 void small_test() {
   // The example in the book.
-  vector<Item> items = {{20, 65}, {8, 35}, {60, 245}, {55, 195}, {40, 65}, {70, 150}, {85, 275}, {25, 155}, {30, 120}, {65, 320}, {75, 75}, {10, 40}, {95, 200}, {50, 100}, {40, 220}, {10, 99}};
+  vector<Item> items = {{20, 65},
+                        {8, 35},
+                        {60, 245},
+                        {55, 195},
+                        {40, 65},
+                        {70, 150},
+                        {85, 275},
+                        {25, 155},
+                        {30, 120},
+                        {65, 320},
+                        {75, 75},
+                        {10, 40},
+                        {95, 200},
+                        {50, 100},
+                        {40, 220},
+                        {10, 99}};
   assert(695 == knapsack(130, items));
 }
 

2-exists.cpp

@@ -20,11 +20,7 @@ bool DFS(GraphVertex* cur, const GraphVertex* pre);
 
 // @include
 struct GraphVertex {
-  enum Color {
-    white,
-    gray,
-    black
-  } color;
+  enum Color { white, gray, black } color;
   vector<GraphVertex*> edges;
   // @exclude
   GraphVertex() : color(white) {}

Add_operators_in_string.cpp

@@ -17,12 +17,8 @@ using std::string;
 using std::uniform_int_distribution;
 using std::vector;
 
-bool exp_synthesis_helper(const vector<int>& A,
-                          int k,
-                          list<int>* operand_list,
-                          list<char>* oper_list,
-                          int cur,
-                          int level);
+bool exp_synthesis_helper(const vector<int>& A, int k, list<int>* operand_list,
+                          list<char>* oper_list, int cur, int level);
 int remaining_int(const vector<int>& A, int idx);
 int evaluate(list<int> operand_list, const list<char>& oper_list);
 
@@ -38,12 +34,9 @@ void exp_synthesis(const vector<int>& A, int k) {
   }
 }
 
-bool exp_synthesis_helper(const vector<int>& A,
-                          int k,
-                          list<int>* operand_list,
-                          list<char>* oper_list,
-                          int cur,
-                          int level) {
+bool exp_synthesis_helper(const vector<int>& A, int k,
+                          list<int>* operand_list, list<char>* oper_list,
+                          int cur, int level) {
   cur = cur * 10 + A[level];
   if (level == A.size() - 1) {
     operand_list->emplace_back(cur);
@@ -123,7 +116,8 @@ void small_test() {
   exp_synthesis(A, k);
   list<int> golden_operand_res = {123, 2, 5, 3, 7, 85, 9};
   assert(golden_operand_res.size() == operand_res.size());
-  assert(equal(operand_res.begin(), operand_res.end(), golden_operand_res.begin()));
+  assert(equal(operand_res.begin(), operand_res.end(),
+               golden_operand_res.begin()));
   list<char> golden_oper_res = {'+', '+', '*', '*', '+', '*'};
   assert(golden_oper_res.size() == oper_res.size());
   assert(equal(oper_res.begin(), oper_res.end(), golden_oper_res.begin()));

BST_lowest_common_ancestor.cpp

@@ -30,8 +30,7 @@ int main(int argc, char* argv[]) {
   //      3
   //    2   5
   //  1    4 6
-  unique_ptr<BSTNode<int>> root =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{3});
+  unique_ptr<BSTNode<int>> root = unique_ptr<BSTNode<int>>(new BSTNode<int>{3});
   root->left = unique_ptr<BSTNode<int>>(new BSTNode<int>{2});
   root->left->left = unique_ptr<BSTNode<int>>(new BSTNode<int>{1});
   root->right = unique_ptr<BSTNode<int>>(new BSTNode<int>{5});

BST_prototype_shared_ptr.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
 
-#ifndef SOLUTIONS_BST_PROTOTYPE_H_
-#define SOLUTIONS_BST_PROTOTYPE_H_
+#ifndef SOLUTIONS_BST_PROTOTYPE_SHARED_PTR_H_
+#define SOLUTIONS_BST_PROTOTYPE_SHARED_PTR_H_
 
 #include <memory>
 
@@ -14,4 +14,4 @@ struct BSTNode {
   shared_ptr<BSTNode<T>> left, right;
 };
 // @exclude
-#endif  // SOLUTIONS_BST_PROTOTYPE_H_
+#endif  // SOLUTIONS_BST_PROTOTYPE_SHARED_PTR_H_

BST_sorted_order.cpp

@@ -17,9 +17,9 @@ using std::vector;
 vector<int> result;
 
 // @include
-void print_BST_in_sorted_order(const unique_ptr<BSTNode<int>>& n) {
+void print_BST_in_sorted_order(const unique_ptr<BSTNode<int>>& r) {
   stack<const BSTNode<int>*> s;
-  const BSTNode<int>* curr = n.get();
+  const BSTNode<int>* curr = r.get();
 
   while (!s.empty() || curr) {
     if (curr) {
@@ -44,16 +44,11 @@ int main(int argc, char* argv[]) {
   //  1    4 6
   unique_ptr<BSTNode<int>> root =
       unique_ptr<BSTNode<int>>(new BSTNode<int>{3, nullptr});
-  root->left =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{2, nullptr});
-  root->left->left =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{1, nullptr});
-  root->right =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{5, nullptr});
-  root->right->left =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{4, nullptr});
-  root->right->right =
-      unique_ptr<BSTNode<int>>(new BSTNode<int>{6, nullptr});
+  root->left = unique_ptr<BSTNode<int>>(new BSTNode<int>{2, nullptr});
+  root->left->left = unique_ptr<BSTNode<int>>(new BSTNode<int>{1, nullptr});
+  root->right = unique_ptr<BSTNode<int>>(new BSTNode<int>{5, nullptr});
+  root->right->left = unique_ptr<BSTNode<int>>(new BSTNode<int>{4, nullptr});
+  root->right->right = unique_ptr<BSTNode<int>>(new BSTNode<int>{6, nullptr});
   // should output 1 2 3 4 5 6
   print_BST_in_sorted_order(root);
   vector<int> golden_res = {1, 2, 3, 4, 5, 6};

BST_to_sorted_doubly_list.cpp

@@ -13,32 +13,43 @@ using std::make_shared;
 using std::numeric_limits;
 using std::shared_ptr;
 
+shared_ptr<BSTNode<int>> BST_to_doubly_list_helper(
+    const shared_ptr<BSTNode<int>>& T);
+
 // @include
-// Transform a BST into a circular sorted doubly linked list in-place,
-// return the head of the list.
 shared_ptr<BSTNode<int>> BST_to_doubly_list(
-    const shared_ptr<BSTNode<int>>& n) {
+    const shared_ptr<BSTNode<int>>& T) {
+  auto res = BST_to_doubly_list_helper(T);
+  res->left->right = nullptr;  // breaks the link from tail to head.
+  res->left = nullptr;  // breaks the link from head to tail.
+  return res;
+}
+
+// Transforms a BST into a circular sorted circular doubly linked list
+// in-place, and return the head of the list.
+shared_ptr<BSTNode<int>> BST_to_doubly_list_helper(
+    const shared_ptr<BSTNode<int>>& T) {
   // Empty subtree.
-  if (!n) {
+  if (!T) {
     return nullptr;
   }
 
   // Recursively build the list from left and right subtrees.
-  auto l_head(BST_to_doubly_list(n->left));
-  auto r_head(BST_to_doubly_list(n->right));
+  auto l_head(BST_to_doubly_list_helper(T->left));
+  auto r_head(BST_to_doubly_list_helper(T->right));
 
-  // Append n to the list from left subtree.
+  // Append T to the list from left subtree.
   shared_ptr<BSTNode<int>> l_tail = nullptr;
   if (l_head) {
     l_tail = l_head->left;
-    l_tail->right = n;
-    n->left = l_tail;
-    l_tail = n;
+    l_tail->right = T;
+    T->left = l_tail;
+    l_tail = T;
   } else {
-    l_head = l_tail = n;
+    l_head = l_tail = T;
   }
 
-  // Append the list from right subtree to n.
+  // Append the list from right subtree to T.
   shared_ptr<BSTNode<int>> r_tail = nullptr;
   if (r_head) {
     r_tail = r_head->left;
@@ -71,6 +82,6 @@ int main(int argc, char* argv[]) {
     cout << curr->data << endl;
     pre = curr->data;
     curr = curr->right;
-  } while (curr != L);
+  } while (curr);
   return 0;
 }

Balanced_binary_tree.cpp

@@ -13,29 +13,29 @@ using std::endl;
 using std::max;
 using std::unique_ptr;
 
-int get_height(const unique_ptr<BinaryTreeNode<int>>& n);
+int get_height(const unique_ptr<BinaryTreeNode<int>>& T);
 
 // @include
-bool is_balanced_binary_tree(const unique_ptr<BinaryTreeNode<int>>& n) {
-  return get_height(n) != -2;
+bool is_balanced_binary_tree(const unique_ptr<BinaryTreeNode<int>>& T) {
+  return get_height(T) != -2;
 }
 
-int get_height(const unique_ptr<BinaryTreeNode<int>>& n) {
-  if (!n) {
+int get_height(const unique_ptr<BinaryTreeNode<int>>& T) {
+  if (!T) {
     return -1;  // base case.
   }
 
-  int l_height = get_height(n->left);
+  int l_height = get_height(T->left);
   if (l_height == -2) {
     return -2;  // left subtree is not balanced.
   }
-  int r_height = get_height(n->right);
+  int r_height = get_height(T->right);
   if (r_height == -2) {
     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 T is not balanced.
   }
   return max(l_height, r_height) + 1;  // return the height.
 }
@@ -51,8 +51,10 @@ int main(int argc, char* argv[]) {
   root->left = unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
   root->left->left = unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
   root->right = unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
-  root->right->left = unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
-  root->right->right = unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
+  root->right->left =
+      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
+  root->right->right =
+      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>());
   assert(is_balanced_binary_tree(root) == true);
   cout << boolalpha << is_balanced_binary_tree(root) << endl;
   // Non-balanced binary tree test.

Binary_search_unknown_length.cpp

@@ -15,7 +15,7 @@ using std::uniform_int_distribution;
 using std::vector;
 
 // @include
-int binary_search_unknown_len(const vector<int> &A, int k) {
+int binary_search_unknown_len(const vector<int>& A, int k) {
   // Find the possible range where k exists.
   int p = 0;
   while (true) {
@@ -63,7 +63,7 @@ void small_test() {
   assert(binary_search_unknown_len(A, 4) == -1);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   small_test();
   int n, k;
   default_random_engine gen((random_device())());

Binary_tree_level_order.cpp

@@ -12,14 +12,14 @@ using std::queue;
 using std::unique_ptr;
 
 // @include
-void print_binary_tree_level_order(const unique_ptr<BinaryTreeNode<int>>& n) {
-  // Prevent empty tree.
-  if (!n) {
+void print_binary_tree_level_order(const unique_ptr<BinaryTreeNode<int>>& r) {
+  // Prevents empty tree.
+  if (!r) {
     return;
   }
 
   queue<BinaryTreeNode<int>*> q;
-  q.emplace(n.get());
+  q.emplace(r.get());
   size_t count = q.size();
   while (!q.empty()) {
     cout << q.front()->data << ' ';
@@ -30,7 +30,7 @@ void print_binary_tree_level_order(const unique_ptr<BinaryTreeNode<int>>& n) {
       q.emplace(q.front()->right.get());
     }
     q.pop();
-    if (--count == 0) {
+    if (--count == 0) {  // Finish printing nodes in the current level.
       cout << endl;
       count = q.size();
     }
@@ -42,18 +42,18 @@ int main(int argc, char* argv[]) {
   //      3
   //    2   5
   //  1    4 6
-  unique_ptr<BinaryTreeNode<int>> root =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{3, nullptr, nullptr});
-  root->left =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{2, nullptr, nullptr});
-  root->left->left =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{1, nullptr, nullptr});
-  root->right =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{5, nullptr, nullptr});
-  root->right->left =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{4, nullptr, nullptr});
-  root->right->right =
-      unique_ptr<BinaryTreeNode<int>>(new BinaryTreeNode<int>{6, nullptr, nullptr});
+  unique_ptr<BinaryTreeNode<int>> root = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{3, nullptr, nullptr});
+  root->left = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{2, nullptr, nullptr});
+  root->left->left = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{1, nullptr, nullptr});
+  root->right = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{5, nullptr, nullptr});
+  root->right->left = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{4, nullptr, nullptr});
+  root->right->right = unique_ptr<BinaryTreeNode<int>>(
+      new BinaryTreeNode<int>{6, nullptr, nullptr});
   // should output 3
   //               2 5
   //               1 4 6

Binary_tree_to_doubly_linked_list.cpp

@@ -2,27 +2,23 @@
 
 using namespace std;
 
-class BinaryTree {
-  public:
-    int data;
-    BinaryTree *left, *right;
-    BinaryTree(
-        int val = 0,
-        BinaryTree* l = NULL,
-        BinaryTree* r = NULL)
+struct BinaryTree {
+  int data;
+  BinaryTree* left, *right;
+  BinaryTree(int val = 0, BinaryTree* l = nullptr, BinaryTree* r = nullptr)
       : data(val), left(l), right(r) {}
 };
 
 // @include
 BinaryTree* convert_tree_to_doubly_list(BinaryTree* n) {
-  if (n == NULL) {
-    return NULL;
+  if (n == nullptr) {
+    return nullptr;
   }
 
   BinaryTree* L = convert_tree_to_doubly_list(n->left);
   BinaryTree* R = convert_tree_to_doubly_list(n->right);
   // Join L and n as a doubly linked list
-  BinaryTree* L_tail = NULL;
+  BinaryTree* L_tail = nullptr;
   if (L) {
     L_tail = L->left;
     L_tail->right = n, n->left = L_tail;
@@ -32,7 +28,7 @@ BinaryTree* convert_tree_to_doubly_list(BinaryTree* n) {
   }
 
   // Join L and R as a doubly linked list
-  BinaryTree* R_tail = NULL;
+  BinaryTree* R_tail = nullptr;
   if (R) {
     R_tail = R->left;
     L_tail->right = R, R->left = L_tail;
@@ -44,19 +40,19 @@ BinaryTree* convert_tree_to_doubly_list(BinaryTree* n) {
 }
 // @exclude
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   //      3
   //    2   5
   //  1    4 6
-  BinaryTree *root = new BinaryTree(3);
+  BinaryTree* root = new BinaryTree(3);
   root->left = new BinaryTree(2);
   root->left->left = new BinaryTree(1);
   root->right = new BinaryTree(5);
   root->right->left = new BinaryTree(4);
   root->right->right = new BinaryTree(6);
   // should output 1, 2, 3, 4, 5, 6
-  BinaryTree *head = convert_tree_to_doubly_list(root);
-  BinaryTree *temp = head;
+  BinaryTree* head = convert_tree_to_doubly_list(root);
+  BinaryTree* temp = head;
   do {
     cout << temp->data << endl;
     temp = temp->right;