Linked list

Author: rsamit26

.idea/workspace.xml

@@ -0,0 +1,68 @@
+"""
+Merge two sorted linked lists and return it as a new list.
+The new list should be made by splicing together the nodes of the first two lists, and should also be sorted.
+
+For example, given following linked lists :
+
+  5 -> 8 -> 20
+  4 -> 11 -> 15
+The merged list should be :
+
+4 -> 5 -> 8 -> 11 -> 15 -> 20
+"""
+
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def merge(self, h1, h2):
+
+        p1 = h1
+        p2 = h2
+        new_head = None
+
+        while (p1 is not None) and (p2 is not None):
+
+            if p1.val < p2.val:
+                e = Node(p1.val)
+                e.next = new_head
+                new_head = e
+                p1 = p1.next
+            else:
+                e = Node(p2.val)
+                e.next = new_head
+                new_head = e
+                p2 = p2.next
+
+        while p1 is not None:
+            e = Node(p1.val)
+            e.next = new_head
+            new_head, p1 = e, p1.next
+
+        while p2 is not None:
+            e = Node(p2.val)
+            e.next = new_head
+            new_head, p2 = e, p2.next
+
+        # Reversing the list
+        prev = None
+        current = new_head
+        while current is not None:
+            nx = current.next
+            current.next = prev
+            prev = current
+            current = nx
+            new_head = prev
+
+        return new_head
+
+
+"""Testing Code """
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    h1, h1.next, h1.next.next = Node(1), Node(2), Node(3)
+    h2, h2.next, h2.next.next, h2.next.next.next = Node(4), Node(5), Node(6), Node(7)
+    # printing the new list
+    Traverse().print_list(Solution().merge(h1, h2))

Python/Level4/LinkedList/List2Pointer/Merge Two Sorted Lists.py

@@ -0,0 +1,93 @@
+"""
+Given a singly linked list, determine if its a palindrome. Return 1 or 0 denoting if its a palindrome or not,
+respectively.
+
+Notes:
+
+Expected solution is linear in time and constant in space.
+For example,
+
+List 1-->2-->1 is a palindrome.
+List 1-->2-->3 is not a palindrome.
+"""
+
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def is_palindrome(self, head):
+        """
+        Using list :
+        append the value of linked list in a python array and checking if array and reverse of array is equal or not
+        :param head:
+        :return: isPalindrome
+        """
+
+        if not head or head.next is None:
+            return True
+
+        is_palindrome = 0
+
+        values = []
+
+        while head is not None:
+            values.append(head.val)
+            head = head.next
+
+        if values == values[::-1]:
+            is_palindrome = 1
+
+        return is_palindrome
+
+    def is_palindrome_02(self, head):
+        """ Create a list by traversing the current list value
+            Traverse both list :::
+                if all values are equal then return 1
+                else return 0
+            """
+        x = []
+        p = head
+        while p is not None:
+            x.append(p.val)
+            p = p.next
+        i = len(x) - 1
+        while head is not None and i > -1:
+            if head.val != x[i]:
+                return 0
+            else:
+                head = head.next
+                i -= 1
+        return 1
+
+    def is_palindrome_03(self, head):
+        reverse, fast = None, head
+        # Reverse the first half part of the list.
+        while fast and fast.next:
+            fast = fast.next.next
+            head.next, reverse, head = reverse, head, head.next
+
+        # If the number of the nodes is odd,
+        # set the head of the tail list to the next of the median node.
+        tail = head.next if fast else head
+
+        # Compare the reversed first half list with the second half list.
+        # And restore the reversed first half list.
+        is_palindrome = 1
+        while reverse:
+            is_palindrome = is_palindrome and reverse.val == tail.val
+            reverse.next, head, reverse = head, reverse, reverse.next
+            tail = tail.next
+
+        return is_palindrome
+
+
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    # h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next = Node(1), Node(4), Node(6), Node(4), Node(1)
+    h2, h2.next, h2.next.next = Node(1), Node(2), Node(1)
+    # printing the new list
+    # Traverse().print_list(Solution().is_palindrome(h1))
+    print(Solution().is_palindrome_02(h2))
+    # print(Solution().is_palindrome(h2))

Python/Level4/LinkedList/List2Pointer/Palindrome List.py

@@ -0,0 +1,56 @@
+"""
+Given a linked list, remove the nth node from the end of list and return its head.
+
+For example,
+Given linked list: 1->2->3->4->5, and n = 2.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+
+ Note:
+If n is greater than the size of the list, remove the first node of the list.
+Try doing it using constant additional space.
+"""
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def remove_nth_node(self, head, k):
+        count = 0
+        prev = head
+        curr_ptr = head
+        temp = head
+        length = 0
+        while temp is not None:
+            length += 1
+            temp = temp.next
+        if head is not None:
+            while count < k:
+                if prev is None:
+                    head = curr_ptr.next
+                    head.next = curr_ptr.next.next
+                    return head
+                prev = prev.next
+                count += 1
+        if count == length:
+            head = curr_ptr.next
+            return head
+        elif count == 0:
+            while curr_ptr.next is not None:
+                prev = curr_ptr
+                curr_ptr = curr_ptr.next
+            prev.next = None
+            return head
+        else:
+            while prev.next is not None:
+                curr_ptr = curr_ptr.next
+                prev = prev.next
+            curr_ptr.next = curr_ptr.next.next
+            return head
+
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    h1, h1.next, h1.next.next, h1.next.next.next = Node(1), Node(2), Node(3), Node(4)
+    # h2, h2.next, h2.next.next, h2.next.next.next = Node(4), Node(5), Node(6), Node(7)
+    # printing the new list
+    Traverse().print_list(Solution().remove_nth_node(h1, 6))

Python/Level4/LinkedList/List2Pointer/Remove Nth Node from List End.py

@@ -0,0 +1,65 @@
+"""
+Given a singly linked list
+
+    L: L0 → L1 → … → Ln-1 → Ln,
+reorder it to:
+
+    L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …
+You must do this in-place without altering the nodes’ values.
+
+For example,
+Given {1,2,3,4}, reorder it to {1,4,2,3}.
+
+"""
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def reorder_list(self, head):
+
+        ptr1 = head
+        count = 0
+        temp = head
+        while temp is not None:
+            count += 1
+            temp = temp.next
+        i = 0
+        new_head = head
+        pre = head
+        while i < (count // 2):
+            pre = new_head
+            new_head = new_head.next
+            i += 1
+        pre.next = None
+        ptr3 = None
+        while ptr1 is not None:
+            ptr2 = new_head
+            while ptr2.next is not None:
+                ptr3 = ptr2
+                ptr2 = ptr2.next
+            ptr4 = ptr1.next
+            ptr1.next = ptr2
+            ptr2.next = ptr4
+            if ptr3 is not None:
+                ptr3.next = None
+            ptr1 = ptr4
+        res = head
+        if count % 2 != 0:
+            while res.next is not None:
+                res = res.next
+            res.next = ptr3
+        return head
+
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    # h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next, h1.next.next.next.next.next = Node(1), Node(
+    #     2), Node(3), Node(4), Node(5), Node(6)
+    # h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next = Node(1), Node(2), Node(3), Node(4), Node(5)
+    h1, h1.next,h1.next.next = Node(1), Node(2), Node(3)
+    # h2, h2.next, h2.next.next = Node(1), Node(2), Node(1)
+    # printing the new list
+    Traverse().print_list(Solution().reorder_list(h1))
+    # print(Solution().is_palindrome_02(h2))
+    # print(Solution().is_palindrome(h2))

Python/Level4/LinkedList/List2Pointer/Reorder List.py

@@ -0,0 +1,41 @@
+"""
+Reverse a linked list from position m to n. Do it in-place and in one-pass.
+
+For example:
+Given 1->2->3->4->5->6->NULL, m = 2 and n = 4,
+
+return 1->4->3->2->5->NULL.
+"""
+
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def reverse_list(self, head, m, n):
+
+        diff, dummy, cur = n - m + 1, Node(-1), head
+        dummy.next = head
+
+        last_unswapped = dummy
+        while cur and m > 1:
+            cur, last_unswapped, m = cur.next, cur, m - 1
+
+        prev, first_swapped = last_unswapped, cur
+        while cur and diff > 0:
+            cur.next, prev, cur, diff = prev, cur, cur.next, diff - 1
+
+        last_unswapped.next, first_swapped.next = prev, cur
+
+        return dummy.next
+
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next, h1.next.next.next.next.next = Node(1), Node(
+        2), Node(3), Node(4), Node(5), Node(6)
+    # h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next = Node(1), Node(2), Node(3), Node(4), Node(5)
+    # h1, h1.next, h1.next.next = Node(1), Node(2), Node(3)
+    # h2, h2.next, h2.next.next = Node(1), Node(2), Node(1)
+    # printing the new list
+    Traverse().print_list(Solution().reverse_list(h1, 2, 4))

Python/Level4/LinkedList/List2Pointer/Reverse Link List II.py

@@ -0,0 +1,45 @@
+"""
+Given a list, rotate the list to the right by k places, where k is non-negative.
+
+For example:
+
+Given 1->2->3->4->5->NULL and k = 2,
+return 4->5->1->2->3->NULL.
+"""
+from Python.Level4.LinkedList import Node, Traverse
+
+
+class Solution:
+
+    def rotate_list(self, head, k):
+
+        if not head or not head.next:
+            return head
+        count = 1
+        curr = head
+        while curr.next is not None:
+            count += 1
+            curr = curr.next
+        curr.next = head
+
+        curr, last, i = head, curr, 0
+
+        while i < (count - k % count):
+            last = curr
+            curr = curr.next
+            i += 1
+        last.next = None
+        return curr
+
+
+if __name__ == "__main__":
+    # initializing the linked list values
+    h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next, h1.next.next.next.next.next = Node(1), Node(
+        2), Node(3), Node(4), Node(5), Node(6)
+    # h1, h1.next, h1.next.next, h1.next.next.next, h1.next.next.next.next = Node(1), Node(2), Node(3), Node(4), Node(5)
+    # h1, h1.next, h1.next.next = Node(1), Node(2), Node(3)
+    # h2, h2.next, h2.next.next = Node(1), Node(2), Node(1)
+    # printing the new list
+    Traverse().print_list(Solution().rotate_list(h1, 89))
+    # print(Solution().is_palindrome_02(h2))
+    # print(Solution().is_palindrome(h2))

Python/Level4/LinkedList/List2Pointer/Rotate List.py

@@ -24,3 +24,4 @@ def print_list(self, head):
         while p is not None:
             print(p.val, end="->")
             p = p.next
+        print("\n")