Day-26: More Bit manipulation problems

Author: mandliya

README.md

@@ -4,9 +4,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 40 |
-| Current Streak | 28 |
-| Longest Streak | 28 ( August 17, 2015 - September 13, 2015 ) |
+| Total Problems | 43 |
+| Current Streak | 29 |
+| Longest Streak | 29 ( August 17, 2015 - September 14, 2015 ) |
 
 </center>
 
@@ -22,7 +22,9 @@
 | Print middle node of linkedlist without iterating twice. | [printMiddleNode.cpp](linked_list_problems/printMiddleNode.cpp) | | Detecting and removing a cycle in linkedlist.| [floyedCycleDetection.cpp](linked_list_problems/floyedCycleDetection.cpp)|
 | Determine if a linked list is a pallindrome. | [listPallindrome.cpp](linked_list_problems/listPallindrome.cpp) |
 | Insert data in a sorted linked list.|[insertInASortedLinkedList.cpp](linked_list_problems/insertInASortedLinkedList.cpp) |
-
+| Determine the intersection(merging) point of two given linked list.| [findIntersectionPointOfLists.cpp](linked_list_problems/findIntersectionPointOfLists.cpp)|
+| Clone a linkedlist which has next and an random pointer, Space Complexity - O(1). | [cloneListWithRandomPtr.cpp](linked_list_problems/cloneListWithRandomPtr.cpp)|
+| Given a sorted linked list with duplicates, remove duplicates in one iteration. | [removeDuplicatesFromSortedList.cpp](linked_list_problems/removeDuplicatesFromSortedList.cpp)| 
 
 ### Include 
 Include contains single header implementation of data structures and some algorithms.

linked_list_problems/cloneListWithRandomPtr.cpp

@@ -0,0 +1,96 @@
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * next;
+  Node * random;
+  Node( int d ) : data{ d }, next{ nullptr }, random{ nullptr } { }
+};
+
+void printList( Node * head )
+{
+  std::cout << "List in format (Node data, Random Node data) : \n";
+  while( head ) {
+    std::cout << "(" << head->data << ", " << head->random->data << ")-->";
+    head = head->next;
+  }
+  std::cout << "NULL" << std::endl;
+}
+
+Node * clone ( Node * head )
+{
+  if ( head == nullptr || ((head != nullptr) && (head->next == nullptr))){
+    return head;
+  }
+  Node * newNode = nullptr;
+  Node * nextNode = nullptr;
+  Node * currNode = head;
+  /**
+   *  Adding a new node after each node with same data
+   *  1->2->3 becomes 1->1->2->2->3->3
+   */
+  while( currNode ) {
+    nextNode = currNode->next;
+    newNode  = new Node(currNode->data);
+    newNode->next = currNode->next;
+    currNode->next = newNode;
+    currNode = nextNode;
+  }
+
+  //Now copying random pointer to all newly added node.
+  currNode = head;
+  while( currNode && (currNode->next != nullptr) ) {
+    currNode->next->random = currNode->random->next;
+    currNode = currNode->next->next;
+  }
+
+  //splitting the list back
+  Node * list1ptr = head;
+  Node * list2ptr = head->next;
+  Node * cloneHead = head->next;
+  while( list1ptr->next && list2ptr->next ) {
+    list1ptr->next = list1ptr->next->next;
+    list2ptr->next = list2ptr->next->next;
+    list1ptr = list1ptr->next;
+    list2ptr = list2ptr->next;
+  }
+  return cloneHead;
+}
+
+bool verifyClone( Node * list1, Node * list2 )
+{
+  while( list1 && list2 ) {
+    if ( (list1->data != list2->data) ||
+         (list1->random->data != list2->random->data) ) {
+        return false;
+    }
+    list1 = list1->next;
+    list2 = list2->next;
+  }
+  return true;
+}
+
+
+
+int main()
+{
+   Node * head = new Node(1);
+   head->next = new Node(2);
+   head->next->next = new Node(3);
+   head->next->next->next = new Node(4);
+   head->next->next->next->next = new Node(5);
+
+   head->random = head->next->next;
+   head->next->random = head;
+   head->next->next->random = head->next->next->next->next;
+   head->next->next->next->random = head->next->next;
+   head->next->next->next->next->random = head->next;
+
+   printList(head);
+   Node *cloneHead = clone(head);
+   std::cout << "Are list cloned (0 for no, 1 for yes): "
+             << verifyClone(head, cloneHead) << std::endl;
+   printList(cloneHead);
+   return 0;
+
+}

linked_list_problems/findIntersectionPointOfLists.cpp

@@ -0,0 +1,80 @@
+/**
+ * Given two linked lists, they both merge at some point.
+ * Find out the merging point
+ */
+
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * next;
+  Node( int d ) : data{ d }, next{ nullptr } { }
+};
+
+void printList( Node * head )
+{
+  while( head ) {
+    std::cout << head->data << "-->";
+    head = head->next;
+  }
+  std::cout << "NULL" << std::endl;
+}
+
+int listLen( Node * head )
+{
+  int count = 0;
+  while( head ) {
+    head = head->next;
+    count++;
+  }
+  return count;
+}
+
+Node * mergePoint( Node * head1, Node * head2 )
+{
+  int len1 = listLen(head1);
+  int len2 = listLen(head2);
+  //figure out the bigger list ( and smaller )
+  //ptr points to bigger list, let us move the difference
+  //between the two.
+  Node * ptr1 = ( len1 > len2 ) ? head1 : head2;
+  Node * ptr2 = ( len1 > len2 ) ? head2 : head1;
+  int i = 0;
+  while ( i < abs(len1 - len2) && ptr1 ) {
+    ptr1 = ptr1->next;
+    ++i;
+  }
+  //Now we have equal nodes to travel on both the nodes
+  // traversing and comparing the pointers.
+
+  while( ptr1 && ptr2 ) {
+    if ( ptr1 == ptr2 ) {
+      return ptr1;
+    }
+    ptr1 = ptr1->next;
+    ptr2 = ptr2->next;
+  }
+  return nullptr;
+}
+
+
+int main()
+{
+  Node * list1 = new Node(3);
+  list1->next = new Node(6);
+  list1->next->next = new Node(9);
+  list1->next->next->next = new Node(12);
+  list1->next->next->next->next = new Node(15);
+  list1->next->next->next->next->next = new Node(18);
+
+  Node * list2 = new Node(7);
+  list2->next = new Node(10);
+  list2->next->next = list1->next->next->next;
+
+  printList(list1);
+  printList(list2);
+
+  Node * mergeNode = mergePoint( list1 , list2 );
+  std::cout << "Merge Node of lists is :" << mergeNode->data << std::endl;
+  return 0;
+}

linked_list_problems/removeDuplicatesFromSortedList.cpp

@@ -0,0 +1,77 @@
+/**
+ *  Given a sorted linkedlist remove duplicates from it.
+ *  5->5->5->7->7->9->11->13->13->15->15
+ *  5->7->9->11->13->15
+ */
+
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * next;
+  Node( int d ) : data{ d }, next{ nullptr } { }
+};
+
+void insert( Node * & head, int data )
+{
+  Node * newNode = new Node(data);
+  if ( head == nullptr ) {
+    head = newNode;
+  } else {
+    Node * temp = head;
+    while( temp->next != nullptr ) {
+      temp = temp->next;
+    }
+    temp->next = newNode;
+  }
+}
+
+void printList( Node * head )
+{
+  while( head ) {
+    std::cout << head->data << "-->";
+    head = head->next;
+  }
+  std::cout << "NULL" << std::endl;
+}
+
+void removeDuplicates ( Node * head )
+{
+  if ( !head || (head && !(head->next))) {
+    return;
+  }
+  Node * currNode = head;
+  Node * nextNode = nullptr;
+  while( currNode ) {
+    nextNode = currNode->next;
+    while(nextNode && nextNode->data == currNode->data) {
+      nextNode = nextNode->next;
+    }
+    currNode->next = nextNode;
+    currNode = nextNode;
+  }
+}
+
+int main()
+{
+  Node * head = nullptr;
+  // 5->5->5->7->7->9->11->13->13->13->15->15
+  insert(head, 5);
+  insert(head, 5);
+  insert(head, 5);
+  insert(head, 7);
+  insert(head, 7);
+  insert(head, 9);
+  insert(head, 11);
+  insert(head, 13);
+  insert(head, 13);
+  insert(head, 13);
+  insert(head, 13);
+  insert(head, 15);
+  insert(head, 15);
+  printList(head);
+
+  removeDuplicates(head);
+  printList(head);
+  return 0;
+}