[Feat] Add some implementation on LinkedList

Author: AustinPardosi

002-AddTwoNumbers.py

@@ -0,0 +1,37 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(
+        self, l1: Optional[ListNode], l2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        # Reverse int L1
+        val1 = ""
+        curr1 = l1
+        while curr1:
+            temp = val1
+            val1 = str(curr1.val) + temp
+            curr1 = curr1.next
+
+        # Reverse int L2
+        val2 = ""
+        curr2 = l2
+        while curr2:
+            temp = val2
+            val2 = str(curr2.val) + temp
+            curr2 = curr2.next
+
+        # jumlahkan int L1 + int L2 dan buat listNode baru
+        result = str(int(val1) + int(val2))
+        length = len(result)
+        newList = ListNode()
+
+        temp = newList
+        while length > 0:
+            temp.next = ListNode(int(result[length - 1]), None)
+            temp = temp.next
+            length -= 1
+
+        return newList.next

019-RemoveNthNodeFromEndOfList.py

@@ -0,0 +1,20 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        newNode = ListNode(0, head)
+        left = newNode
+        right = head
+
+        for i in range(n):
+            right = right.next
+
+        while right:
+            right = right.next
+            left = left.next
+
+        left.next = left.next.next
+        return newNode.next

021-MergeTwoSortedLists.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(
+        self, list1: Optional[ListNode], list2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        dummy = ListNode()
+        current = dummy
+
+        while list1 and list2:
+            if list1.val <= list2.val:
+                current.next = list1
+                list1 = list1.next
+            else:
+                current.next = list2
+                list2 = list2.next
+            current = current.next
+
+        if list1:
+            current.next = list1
+        elif list2:
+            current.next = list2
+
+        return dummy.next

055-JumpGame.py

@@ -0,0 +1,12 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        goal = len(nums) - 1
+
+        for i in range(len(nums) - 1, -1, -1):
+            if i + nums[i] >= goal:
+                goal = i
+
+        if goal == 0:
+            return True
+        else:
+            return False

141-LinkedListCycle.py

@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        slow, fast = head, head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+            if slow == fast:
+                return True
+        
+        return False
+        

143-ReorderList.py

@@ -0,0 +1,35 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        """
+        Do not return anything, modify head in-place instead.
+        """
+        # Cari titik tengah
+        slow, fast = head, head.next
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        # Tangkap dan pecahkan linkedlist jadi 2
+        second = slow.next
+        prev, slow.next = None, None
+
+        # Reverse linkedlist second
+        while second:
+            temp = second.next
+            second.next = prev
+            prev = second
+            second = temp
+
+        # Merge Linkedlist
+        list1, list2 = head, prev
+        while list2:
+            temp1, temp2 = list1.next, list2.next
+            list1.next = list2
+            list2.next = temp1
+            list1, list2 = temp1, temp2
+        return list1

206-ReverseLinkedList.py

@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+# Iterative Approach
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        prev, curr = None, head
+
+        while curr:
+            temp = curr.next
+            curr.next = prev
+            prev = curr 
+            curr = temp
+        
+        return prev
+    

287-FindTheDuplicateNumber.py

@@ -0,0 +1,7 @@
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        valHistory = set()
+        for num in nums:
+            if num in valHistory:
+                return num
+            valHistory.add(num)