data_structures/linked_list: Add __len__() function and tests

data_structures/linked_list/__init__.py

@@ -3,20 +3,44 @@ def __init__(self, item, next):
         self.item = item
         self.next = next
 
+
 class LinkedList:
     def __init__(self):
         self.head = None
+        self.size = 0
 
     def add(self, item):
         self.head = Node(item, self.head)
+        self.size += 1
 
     def remove(self):
         if self.is_empty():
             return None
         else:
             item = self.head.item
             self.head = self.head.next
+            self.size -= 1
             return item
 
     def is_empty(self):
         return self.head is None
+
+    def __len__(self):
+        """
+        >>> linked_list = LinkedList()
+        >>> len(linked_list)
+        0
+        >>> linked_list.add("a")
+        >>> len(linked_list)
+        1
+        >>> linked_list.add("b")
+        >>> len(linked_list)
+        2
+        >>> _ = linked_list.remove()
+        >>> len(linked_list)
+        1
+        >>> _ = linked_list.remove()
+        >>> len(linked_list)
+        0
+        """
+        return self.size

data_structures/linked_list/doubly_linked_list.py

@@ -1,77 +1,84 @@
-'''
-- A linked list is similar to an array, it holds values. However, links in a linked list do not have indexes.
+"""
+- A linked list is similar to an array, it holds values. However, links in a linked
+    list do not have indexes.
 - This is an example of a double ended, doubly linked list.
 - Each link references the next link and the previous one.
-- A Doubly Linked List (DLL) contains an extra pointer, typically called previous pointer, together with next pointer and data which are there in singly linked list.
- - Advantages over SLL - IT can be traversed in both forward and backward direction.,Delete operation is more efficent'''
-from __future__ import print_function
+- A Doubly Linked List (DLL) contains an extra pointer, typically called previous
+    pointer, together with next pointer and data which are there in singly linked list.
+ - Advantages over SLL - IT can be traversed in both forward and backward direction.,
+     Delete operation is more efficient"""
 
 
-class LinkedList:           #making main class named linked list
+class LinkedList:  # making main class named linked list
     def __init__(self):
         self.head = None
         self.tail = None
-        
+
     def insertHead(self, x):
-        newLink = Link(x)                            #Create a new link with a value attached to it
-        if(self.isEmpty() == True):                  #Set the first element added to be the tail
+        newLink = Link(x)  # Create a new link with a value attached to it
+        if self.isEmpty():  # Set the first element added to be the tail
             self.tail = newLink
         else:
-            self.head.previous = newLink             # newLink <-- currenthead(head)
-        newLink.next = self.head                     # newLink <--> currenthead(head)
-        self.head = newLink                          # newLink(head) <--> oldhead
-    
+            self.head.previous = newLink  # newLink <-- currenthead(head)
+        newLink.next = self.head  # newLink <--> currenthead(head)
+        self.head = newLink  # newLink(head) <--> oldhead
+
     def deleteHead(self):
         temp = self.head
-        self.head = self.head.next                   # oldHead <--> 2ndElement(head) 
-        self.head.previous = None                    # oldHead --> 2ndElement(head) nothing pointing at it so the old head will be removed
-        if(self.head is None):
-            self.tail = None                         #if empty linked list
+        self.head = self.head.next  # oldHead <--> 2ndElement(head)
+        # oldHead --> 2ndElement(head) nothing pointing at it so the old head will be
+        # removed
+        self.head.previous = None
+        if self.head is None:
+            self.tail = None  # if empty linked list
         return temp
-    
+
     def insertTail(self, x):
         newLink = Link(x)
-        newLink.next = None                         # currentTail(tail)    newLink -->
-        self.tail.next = newLink                    # currentTail(tail) --> newLink -->
-        newLink.previous = self.tail                #currentTail(tail) <--> newLink -->
-        self.tail = newLink                         # oldTail <--> newLink(tail) -->
-    
+        newLink.next = None  # currentTail(tail)    newLink -->
+        self.tail.next = newLink  # currentTail(tail) --> newLink -->
+        newLink.previous = self.tail  # currentTail(tail) <--> newLink -->
+        self.tail = newLink  # oldTail <--> newLink(tail) -->
+
     def deleteTail(self):
         temp = self.tail
-        self.tail = self.tail.previous              # 2ndLast(tail) <--> oldTail --> None
-        self.tail.next = None                       # 2ndlast(tail) --> None
+        self.tail = self.tail.previous  # 2ndLast(tail) <--> oldTail --> None
+        self.tail.next = None  # 2ndlast(tail) --> None
         return temp
-    
+
     def delete(self, x):
         current = self.head
-        
-        while(current.value != x):                  # Find the position to delete
+
+        while current.value != x:  # Find the position to delete
             current = current.next
-            
-        if(current == self.head):
+
+        if current == self.head:
             self.deleteHead()
-            
-        elif(current == self.tail):
+
+        elif current == self.tail:
             self.deleteTail()
-            
-        else: #Before: 1 <--> 2(current) <--> 3
-            current.previous.next = current.next # 1 --> 3
-            current.next.previous = current.previous # 1 <--> 3
-    
-    def isEmpty(self):                               #Will return True if the list is empty
-        return(self.head is None)
-        
-    def display(self):                                #Prints contents of the list
+
+        else:  # Before: 1 <--> 2(current) <--> 3
+            current.previous.next = current.next  # 1 --> 3
+            current.next.previous = current.previous  # 1 <--> 3
+
+    def isEmpty(self):  # Will return True if the list is empty
+        return self.head is None
+
+    def display(self):  # Prints contents of the list
         current = self.head
-        while(current != None):
+        while current is not None:
             current.displayLink()
-            current = current.next  
+            current = current.next
         print()
 
+
 class Link:
-    next = None                                       #This points to the link in front of the new link
-    previous = None                                   #This points to the link behind the new link
+    next = None  # This points to the link in front of the new link
+    previous = None  # This points to the link behind the new link
+
     def __init__(self, x):
         self.value = x
+
     def displayLink(self):
-        print("{}".format(self.value), end=" ")
+        print(f"{self.value}", end=" ")