Day-60 3 CTCI probs 2

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 84 |
-| Current Streak | 59 days |
-| Longest Streak | 59 ( August 17, 2015 - October 14, 2015 ) |
+| Total Problems | 87 |
+| Current Streak | 60 days |
+| Longest Streak | 60 ( August 17, 2015 - October 15, 2015 ) |
 
 </center>
 
@@ -84,7 +84,10 @@ Include contains single header implementation of data structures and some algori
 | Problem 1-9: Given two strings s1 and s2, determine s2 is rotation of s1 using only one call to a function which checks whether one string is rotation of another.|[1-9-string-rotation.cpp](cracking_the_coding_interview_problems/1-9-string-rotation.cpp)|
 | Problem 2-1: Remove duplicates from an *unsorted* linked list. What if no temporary buffer is allowed.|[2-1-remove-dups.cpp](cracking_the_coding_interview_problems/2-1-remove-dups.cpp)|
 | Problem 2-2: Determine k<sup>th</sup> node from the last of a singly linked list. (Iterative and Recursive Approaches) | [2-2-kthToLast.cpp](cracking_the_coding_interview_problems/2-2-kthToLast.cpp)|
-
+| Problem 2-3: Implement an algorithm to delete a node in the middle of a singly linked list | [2-3-delete-middle-node.cpp](cracking_the_coding_interview_problems/2-3-delete-middle-node.cpp)|
+| Problem 2-4: Partition a linked list around a value x, all the nodes smaller than x come before all the nodes greater than equal to x | [2-4-partition.cpp](cracking_the_coding_interview_problems/2-4-partition.cpp)|
+| Problem 2-5: You have two numberse represented by a linked list where each node contains a single digit. The digits are stored in reversed order, such that 1's digits are at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list.Example: <ul><li> Input: ( 7 --> 1 --> 6 ) + ( 5 --> 9 --> 2 ) that is 617 + 295 </li></ul>
+<ul><li> Output: ( 2 --> 1 --> 9 ) i.e. 912. </li><ul> <ul><li> FOLLOW UP : Suppose the lists are stored in forward order, Repeat the above problem.</ul></li><ul><li> Input: ( 6 --> 1 --> 7 ) + ( 2 --> 9 --> 5 ) i.e. 617 + 295  </li> </ul><ul><li> Output: ( 9 --> 1 --> 2 ) i.e. 912 </li></ul><ul><li>Implement it  recursively and iteratively.</li></ul> | [2-5-add-lists.cpp](cracking_the_coding_interview_problems/2-5-add-lists.cpp) |
 ###Dynamic Programming Problems
 | Problem | Solution |
 | :------------ | :----------: |

cracking_the_coding_interview_problems/2-1-remove-dups.cpp

@@ -1,8 +1,9 @@
 /*
  * Cracking the coding interview edition 6
  * Problem 2-1 : Remove duplicates from an unsorted linked list.
- * Approach 1 : Naive approach of iterating and remove all further duplicates of current node. Space complexity O(1) & time complexity O(n^2)
- * Approach 2: Use a hash table
+ * Approach 1 : Naive approach of iterating and remove all further duplicates of current node.
+ * 							Space complexity O(1) & time complexity O(n^2)
+ * Approach 2: Use a hash table, space complexity O(n), time complexity O(n)
  */
 
 
@@ -16,6 +17,11 @@ struct Node {
 	Node * next = nullptr;
 };
 
+/**
+ * [insert - insert a node at the head of list]
+ * @param head [head of the list]
+ * @param data [new node's data]
+ */
 void insert( Node * & head, int data )
 {
 	Node * newNode = new Node;
@@ -24,15 +30,25 @@ void insert( Node * & head, int data )
 	head = newNode;
 }
 
+/**
+ * [printList Helper routine to print list]
+ * @param head [head of the list]
+ */
 void printList( Node * head ) {
 	while( head ) {
-		std::cout << head->data << "  ";
+		std::cout << head->data << "-->";
 		head = head->next;
 	}
-	std::cout << std::endl;
+	std::cout << "nullptr" << std::endl;
 }
 
 //generate a random int between min and max
+/**
+ * [random_range helper routine to generate a random number between min and max (including)]
+ * @param  min [min of range]
+ * @param  max [max of range]
+ * @return     [A random number between min and max]
+ */
 static inline int random_range(const int min, const int max) {
 	std::random_device rd;
 	std::mt19937 mt(rd());
@@ -44,6 +60,10 @@ static inline int random_range(const int min, const int max) {
 // Method 1
 //space complexity O(1)
 // time complexity O(n^2)
+/**
+ * [removeDuplicates Remove duplicates without using extra space]
+ * @param head [head of list]
+ */
 void removeDuplicates( Node * head ) {
 	if ( head == nullptr || ( head && (head->next == nullptr))) {
 		return;
@@ -65,6 +85,10 @@ void removeDuplicates( Node * head ) {
 // Method 2
 // space complexity - O(n)
 // time complexity - O(n)
+/**
+ * [removeDuplicates1 - Remove duplicates from the list using hash table]
+ * @param head [head of list]
+ */
 void removeDuplicates1( Node * head ) {
 	if ( head == nullptr || ( head && (head->next == nullptr) )) {
 		return ;
@@ -106,6 +130,5 @@ int main() {
 	printList(head1);
 	removeDuplicates1(head1);
 	printList(head1);
-
-
+	return 0;
 }

cracking_the_coding_interview_problems/2-2-kthToLast.cpp

@@ -53,7 +53,7 @@ void deleteList( Node * & head ) {
 }
 
 /**
- * printList - Print the list
+ * printList - Helper routine to print the list
  * @param head - Current head of the list.
  */
 void printList( Node * head ) {

cracking_the_coding_interview_problems/2-3-delete-middle-node.cpp

@@ -0,0 +1,62 @@
+/**
+ * Cracking the coding interview - edition 6
+ * Problem 2.3 Delete middle node:
+ * Implement an algorithm to delete a node in the middle of a singly linked list.
+ * We are given pointer to that node.
+ *
+ * Approach:
+ * In order to remove a node 'A' from a list, We will need to connect pointer of
+ * A's previous node to A's next node. Here we don't have access to previous node.
+ * However, we have pointer to that node, we can copy the data of next node to
+ * the pointed node and then remove the next node.
+ * Assumption here is that we are not given last node of the list for deletion.
+ */
+
+#include <iostream>
+
+struct Node {
+  char data;
+  Node * next;
+  Node( char c ) : data{ c }, next{ nullptr } { }
+};
+
+/**
+ * [printList - Helper routine to print the list]
+ * @param head [head of the list]
+ */
+void printList( Node * head ) {
+  while( head ) {
+    std::cout << head->data << "-->";
+    head = head->next;
+  }
+  std::cout << "nullptr" << std::endl;
+}
+
+/**
+ * [deleteNode - delete the "node" from the list]
+ * @param node [node to be deleted]
+ */
+void deleteNode( Node * node ) {
+  if ( node == nullptr || node->next == nullptr ) {
+    return;
+  }
+  Node * nextNode = node->next;
+  node->data = nextNode->data;
+  node->next = nextNode->next;
+  delete nextNode;
+}
+
+int main() {
+  Node * head = new Node('a');
+  head->next = new Node('b');
+  head->next->next = new Node('c');
+  head->next->next->next = new Node('d');
+  head->next->next->next->next = new Node('e');
+  std::cout << "List before deletion:\n";
+  printList(head);
+  std::cout << "Deleting node containing data as 'c'\n";
+  deleteNode(head->next->next);
+  std::cout << "List after deletion:\n";
+  printList(head);
+  return 0;
+}

cracking_the_coding_interview_problems/2-4-partition.cpp

@@ -0,0 +1,106 @@
+/**
+ *  Cracking the coding interview edition 6
+ *  Problem 2.4 Partition:
+ *  Write code to partition linked list around a value x, such that
+ *  nodes less than x come before all the nodes greater than or equal to x.
+ *  If x is in the list, the values of x only need to be after the elements less
+ *  than x.
+ *  Example
+ *  3-->5-->8-->5-->10-->2-->1 (x = 5)
+ *  3-->1-->2-->10-->5-->5-->8
+ *
+ *  Approach:
+ *  Start with first node, and add every thing bigger or equal to x at tail
+ *  and smaller values at head.
+ */
+
+#include <iostream>
+#include <random>
+
+struct Node {
+  int data;
+  Node * next;
+  Node( int d ) : data{ d }, next{ nullptr } { }
+};
+
+
+/**
+ * [insert - helper routine to insert a new node with data]
+ * @param head [head of the list]
+ * @param data [data of the new node]
+ */
+void insert( Node * & head, int data ) {
+  Node * newNode = new Node(data);
+  if ( head == nullptr ) {
+    head = newNode;
+  } else {
+    Node * curr = head;
+    while( curr->next ) {
+      curr = curr->next;
+    }
+    curr->next = newNode;
+  }
+}
+
+/**
+ * [printList - helper routine to print the list]
+ * @param head [head of the list]
+ */
+void printList( Node * head ) {
+  while ( head ) {
+    std::cout << head->data << "-->";
+    head = head->next;
+  }
+  std::cout << "nullptr" << std::endl;
+}
+
+/**
+ * [partition - routine to partition list around x]
+ * @param head [head of the list]
+ * @param x    [data around which partition is being done]
+ */
+void partition( Node * & head , int x ) {
+  Node * tail = head;
+  Node * curr = head;
+  while( curr != nullptr ) {
+    Node * nextNode = curr->next;
+    if ( curr->data < x ) {
+      //insert at head
+      curr->next = head;
+      head = curr;
+    } else {
+      // insert at tail
+      tail->next = curr;
+      tail = curr;
+    }
+    curr = nextNode;
+  }
+  tail->next = nullptr;
+}
+
+/**
+ * [random_range helper routine to generate a random number between min and max (including)]
+ * @param  min [min of range]
+ * @param  max [max of range]
+ * @return     [A random number between min and max]
+ */
+static inline int random_range(const int min, const int max) {
+	std::random_device rd;
+	std::mt19937 mt(rd());
+	std::uniform_int_distribution<int> distribution(min, max);
+	return distribution(mt);
+}
+
+
+int main() {
+  Node * head = nullptr;
+  for ( int i = 0; i < 10; ++i ) {
+		insert(head, random_range(1,9));
+	}
+  std::cout << "List before partition around 5:\n";
+  printList(head);
+  partition(head, 5);
+  std::cout << "List after partition around 5:\n";
+  printList(head);
+  return 0;
+}