no message

Author: Partho Biswas

algoexpert.io/python/Linked_List_Construction.py

@@ -1,93 +1,102 @@
-# This is an input class. Do not edit.
-class Node:
-    def __init__(self, value):
-        self.value = value
-        self.prev = None
-        self.next = None
-
-
-# Code is OK but test cases are failing. DOn't know why
 class DoublyLinkedList:
     def __init__(self):
         self.head = None
         self.tail = None
 
+    # O(1) time | O(1) space
     def setHead(self, node):
         if self.head is None:
             self.head = node
             self.tail = node
             return
-        self.insertBefore(self.head, node)
+        self.insertBefore(self.head, node)  # corner case -- setting new head
 
+    # O(1) time | O(1) space
     def setTail(self, node):
         if self.tail is None:
             self.setHead(node)
             return
         self.insertAfter(self.tail, node)
 
+    # O(1) time | O(1) space
     def insertBefore(self, node, nodeToInsert):
+        # edge case
         if nodeToInsert == self.head and nodeToInsert == self.tail:
             return
-        self.remove(nodeToInsert)
+        self.remove(nodeToInsert)  # if the node exists in the linked list we will remove it. This step can be skipped
         nodeToInsert.prev = node.prev
         nodeToInsert.next = node
-        if not node.prev:
+        if node.prev is None:
             self.head = nodeToInsert
         else:
             node.prev.next = nodeToInsert
         node.prev = nodeToInsert
 
+    # O(1) time | O(1) space
     def insertAfter(self, node, nodeToInsert):
         if nodeToInsert == self.head and nodeToInsert == self.tail:
             return
-        self.remove(nodeToInsert)
+        self.remove(nodeToInsert)  # if the node exists in the linked list we will remove it. This step can be skipped
         nodeToInsert.prev = node
         nodeToInsert.next = node.next
-        if not node.next:
+        if node.next == None:
             self.tail = nodeToInsert
         else:
             node.next.prev = nodeToInsert
         node.next = nodeToInsert
 
+    # O(Position) time | O(1) space
     def insertAtPosition(self, position, nodeToInsert):
         if position == 1:
             self.setHead(nodeToInsert)
             return
         node = self.head
-        currPos = 1
-        while node and currPos != position:
+        currentPosition = 1
+        while node is not None and currentPosition != position:
             node = node.next
-            currPos += 1
-        if node:
-            self.insertBefore(nodeToInsert)
+            currentPosition += 1
+        if node is not None:
+            self.insertBefore(node, nodeToInsert)
         else:
             self.setTail(nodeToInsert)
 
+    # O(n) time | O(1) space
     def removeNodesWithValue(self, value):
         node = self.head
-        while node:
+        while node is not None:
+            # we need this temp variable because we are losing node.next in removeNodeBindinnodegs()
             nodeToRemove = node
             node = node.next
             if nodeToRemove.value == value:
                 self.remove(nodeToRemove)
 
+    # O(1) time | O(1) space
     def remove(self, node):
-        if node == self.head:
+        if (node == self.head):
             self.head = self.head.next
-        if node == self.tail:
+        if (node == self.tail):
             self.tail = self.tail.prev
+        # checks if we are removing head or tail and updating new head or tail
         self.removeNodeBindings(node)
 
+    # O(n) time | O(1) space
     def containsNodeWithValue(self, value):
         node = self.head
-        while node and node.value != value:
+        while node is not None and node.value != value:
             node = node.next
         return node is not None
 
     def removeNodeBindings(self, node):
-        if node.prev:
+        if node.prev is not None:
             node.prev.next = node.next
-        if node.next:
+        if node.next is not None:
             node.next.prev = node.prev
         node.prev = None
         node.next = None
+
+
+class node:
+    def __init__(self, value):
+        self.prev = None
+        self.next = None
+        self.value = value

algoexpert.io/python/Min_Number_Of_Jumps.py

@@ -1,6 +1,4 @@
 # Solution #1
-
-
 #   O(n^2) time | O(n) space
 def minNumberOfJumps(array):
     jumps = [float("inf")  for x in array]
@@ -11,15 +9,8 @@ def minNumberOfJumps(array):
                 jumps[i] = min(jumps[i], jumps[j] + 1)
     return jumps[-1]
 
-
-
-
-
-
 # Solution #2
-
-
-#   O(n) time | O(1) space
+# O(n) time | O(1) space
 def minNumberOfJumps(array):
     if len(array) == 1:
         return 0

algoexpert.io/python/Reverse_Linked_List.py

@@ -1,10 +1,9 @@
-
 # O(n) time | O(1) space
 def reverseLinkedList(head):
-    p1, p2 = None, head
-    while p2 is not None:
-        p3 = p2.next
-        p2.next = p1
-        p1 = p2
-        p2 = p3
-    return p1
+    prevN, nextN = None, None
+	while head is not None:
+		nextN = head.next
+		head.next = prevN
+		prevN = head
+		head = nextN
+	return prevN