🚀 23-Aug-2020

Author: sureshmangs

competitive programming/leetcode/141. Linked List Cycle.cpp

@@ -0,0 +1,69 @@
+Given a linked list, determine if it has a cycle in it.
+
+To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
+
+
+
+Example 1:
+
+Input: head = [3,2,0,-4], pos = 1
+Output: true
+Explanation: There is a cycle in the linked list, where tail connects to the second node.
+
+
+Example 2:
+
+Input: head = [1,2], pos = 0
+Output: true
+Explanation: There is a cycle in the linked list, where tail connects to the first node.
+
+
+Example 3:
+
+Input: head = [1], pos = -1
+Output: false
+Explanation: There is no cycle in the linked list.
+
+
+
+
+Follow up:
+
+Can you solve it using O(1) (i.e. constant) memory?
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        if(!head) return false;
+        ListNode *slow=head, *fast=head;
+        while(fast!=NULL && fast->next!=NULL){
+            slow=slow->next;
+            fast=fast->next->next;
+            if(slow==fast) return true;
+        }
+
+        return false;  // no cycle found
+    }
+};
+
+
+
+// Alter: Can also use hashing approach

competitive programming/leetcode/142. Linked List Cycle II.cpp

@@ -0,0 +1,76 @@
+Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+
+To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
+
+Note: Do not modify the linked list.
+
+
+
+Example 1:
+
+Input: head = [3,2,0,-4], pos = 1
+Output: tail connects to node index 1
+Explanation: There is a cycle in the linked list, where tail connects to the second node.
+
+
+Example 2:
+
+Input: head = [1,2], pos = 0
+Output: tail connects to node index 0
+Explanation: There is a cycle in the linked list, where tail connects to the first node.
+
+
+Example 3:
+
+Input: head = [1], pos = -1
+Output: no cycle
+Explanation: There is no cycle in the linked list.
+
+
+
+
+Follow-up:
+Can you solve it without using extra space?
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        if(!head) return NULL;
+        if(head->next==NULL) return NULL;
+        ListNode *slow=head, *fast=head;
+        bool loop=false;
+        while(fast!=NULL && fast->next!=NULL){
+            slow=slow->next;
+            fast=fast->next->next;
+            if(slow==fast){
+                loop=true;
+                break;
+            }
+        }
+        if(!loop) return NULL; // no cycle
+        slow=head;
+        while(slow!=fast && fast!=NULL){
+            slow=slow->next;
+            fast=fast->next;
+        }
+        return slow;
+    }
+};

competitive programming/leetcode/160. Intersection of Two Linked Lists.cpp

@@ -0,0 +1,112 @@
+Write a program to find the node at which the intersection of two singly linked lists begins.
+
+For example, the following two linked lists:
+
+
+begin to intersect at node c1.
+
+
+
+Example 1:
+
+
+Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+Output: Reference of the node with value = 8
+Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+
+
+Example 2:
+
+
+Input: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+Output: Reference of the node with value = 2
+Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+
+
+Example 3:
+
+
+Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+Output: null
+Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
+Explanation: The two lists do not intersect, so return null.
+
+
+Notes:
+
+If the two linked lists have no intersection at all, return null.
+The linked lists must retain their original structure after the function returns.
+You may assume there are no cycles anywhere in the entire linked structure.
+Each value on each linked list is in the range [1, 10^9].
+Your code should preferably run in O(n) time and use only O(1) memory.
+
+
+
+
+
+
+
+
+// counting differences
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        if(!headA || !headB) return NULL;
+
+        int lenA=0, lenB=0;
+        ListNode *curr=headA;
+        while(curr!=NULL){
+            lenA++;
+            curr=curr->next;
+        }
+        curr=headB;
+        while(curr!=NULL){
+            lenB++;
+            curr=curr->next;
+        }
+        ListNode *curA=headA, *curB=headB;
+        if(lenA > lenB){
+            // move pointer of A to match length of B
+            int forward=lenA-lenB;
+            while(forward--){
+                curA=curA->next;
+            }
+        } else if(lenB > lenA){
+            // move pointer of B to match length of A
+            int forward=lenB-lenA;
+            while(forward--){
+                curB=curB->next;
+            }
+        }
+        while(curA && curB){
+            if(curA==curB) return curA;
+            curA=curA->next;
+            curB=curB->next;
+        }
+        return NULL;
+    }
+};
+
+
+/*
+Approach 1: Brute Force
+
+Approach 2: Hash Table
+
+Approach 3: Two Pointers
+Maintain two pointers pA and pB initialized at the head of A and B, respectively.
+Then let them both traverse through the lists, one node at a time.
+When pApA reaches the end of a list, then redirect it to the head of B (yes, B, that's right.);
+Similarly when pB pB reaches the end of a list, redirect it the head of A.
+If at any point pA meets pB, then pA/pB is the intersection node.
+
+Approach 4: Implemented above
+*/

competitive programming/leetcode/234. Palindrome Linked List.cpp

@@ -0,0 +1,77 @@
+Given a singly linked list, determine if it is a palindrome.
+
+Example 1:
+
+Input: 1->2
+Output: false
+Example 2:
+
+Input: 1->2->2->1
+Output: true
+Follow up:
+Could you do it in O(n) time and O(1) space?
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+
+
+    ListNode* getMiddle(ListNode* head){
+        ListNode *slow=head, *fast=head;
+        while(fast!=NULL && fast->next!=NULL){
+            slow=slow->next;
+            fast=fast->next->next;
+        }
+        return slow;
+    };
+
+    ListNode* reverseList(ListNode* head){
+    if(head==NULL) return head;
+    ListNode *cur=head, *prev=head, *ahead=head->next;
+    prev->next=NULL;
+    cur=ahead;
+    while(ahead!=NULL){
+        ahead=ahead->next;
+        cur->next=prev;
+        prev=cur;
+        cur=ahead;
+    }
+    head=prev;
+    return head;
+}
+
+    bool isPalindrome(ListNode* head) {
+        if(!head) return true;
+        ListNode* mid=getMiddle(head);
+        ListNode* last=reverseList(mid);  // start of reverses list
+
+        while(head!=mid){
+            if(head->val!=last->val) return false;
+                head=head->next;
+                last=last->next;
+        }
+        return true;
+
+    }
+};
+
+// After finding the result, we can again reverse the reversed list and join it back to the original list