some files updated

Author: Robertboy18

10-Elementary_Data_Structures/Python/__pycache__/linkedlist.cpython-39.pyc

@@ -1,31 +1,87 @@
+import unittest
+
+# Author: Robert Joseph
+
 class CircularQueue:
-	def init(self, max_size):
-		self.items = [None] * max_size
-		self.front = 0
-		self.rear = 0
-		self.max_size = max_size
-
-	def enqueue(self, item):
-		if (self.rear + 1) % self.max_size == self.front:
-			print("Queue is full")
-			return
-		self.items[self.rear] = item
-		self.rear = (self.rear + 1) % self.max_size
-
-	def dequeue(self):
-		if self.front == self.rear:
-			print("Queue is empty")
-			return
-		item = self.items[self.front]
-		self.items[self.front] = None
-		self.front = (self.front + 1) % self.max_size
-		return item
-
-	def peek(self):
-		return self.items[self.front]
-
-	def is_empty(self):
-		return self.front == self.rear
-
-	def size(self):
-		return (self.rear - self.front + self.max_size) % self.max_size
+    def __init__(self, max_size):
+        """
+        This function initializes a circular queue with a maximum size.
+        """
+        self.items = [None] * max_size
+        self.front = 0
+        self.rear = 0
+        self.max_size = max_size
+
+    def enqueue(self, item):
+        """
+        This function adds an item to the circular queue.
+        """
+        if (self.rear + 1) % self.max_size == self.front:
+            print("Queue is full")
+            return
+        self.items[self.rear] = item
+        self.rear = (self.rear + 1) % self.max_size
+
+    def dequeue(self):
+        """
+        This function removes an item from the circular queue and returns it.
+        """
+        if self.front == self.rear:
+            print("Queue is empty")
+            return
+        item = self.items[self.front]
+        self.items[self.front] = None
+        self.front = (self.front + 1) % self.max_size
+        return item
+
+    def peek(self):
+        """
+        This function returns the item at the front of the circular queue.
+        """
+        return self.items[self.front]
+
+    def is_empty(self):
+        """
+        This function checks if the circular queue is empty.
+        """
+        return self.front == self.rear
+
+    def size(self):
+        """
+        This function returns the current size of the circular queue.
+        """
+        return (self.rear - self.front + self.max_size) % self.max_size
+
+
+class TestCircularQueue(unittest.TestCase):
+    def test_circular_queue(self):
+        # Test empty queue
+        cq = CircularQueue(5)
+        self.assertTrue(cq.is_empty())
+        self.assertEqual(cq.size(), 0)
+
+        # Test enqueue
+        cq.enqueue(1)
+        cq.enqueue(2)
+        cq.enqueue(3)
+        self.assertFalse(cq.is_empty())
+        self.assertEqual(cq.size(), 3)
+
+        # Test dequeue
+        item = cq.dequeue()
+        self.assertEqual(item, 1)
+        self.assertEqual(cq.size(), 2)
+
+        # Test peek
+        peek_item = cq.peek()
+        self.assertEqual(peek_item, 2)
+
+        # Test full queue
+        cq.enqueue(4)
+        cq.enqueue(5)
+        cq.enqueue(6)  # This should print "Queue is full"
+        self.assertEqual(cq.size(), 4)
+
+
+if __name__ == '__main__':
+    unittest.main()

10-Elementary_Data_Structures/Python/circular-queue.py

@@ -1,58 +1,118 @@
+import unittest
+
+# Author: Robert Joseph
+
+
 class Node:
-	def init(self, data=None, next_node=None, prev_node=None):
-		self.data = data
-		self.next_node = next_node
-		self.prev_node = prev_node
+    def __init__(self, data=None, next_node=None, prev_node=None):
+        """
+        This class represents a node in a doubly linked list.
+        Each node contains data, a reference to the next node, and a reference to the previous node.
+        """
+        self.data = data
+        self.next_node = next_node
+        self.prev_node = prev_node
+
 
 class LinkedList:
-	def init(self):
-		self.head = None
-		self.tail = None
-
-	def append(self, data):
-		new_node = Node(data)
-		if self.head is None:
-			self.head = new_node
-			self.tail = new_node
-		else:
-			self.tail.next_node = new_node
-			new_node.prev_node = self.tail
-			self.tail = new_node
-
-	def prepend(self, data):
-		new_node = Node(data)
-		if self.head is None:
-			self.head = new_node
-			self.tail = new_node
-		else:
-			self.head.prev_node = new_node
-			new_node.next_node = self.head
-			self.head = new_node
-
-	def delete(self, data):
-		current_node = self.head
-		while current_node is not None:
-			if current_node.data == data:
-				if current_node.prev_node is not None:
-					current_node.prev_node.next_node = current_node.next_node
-				if current_node.next_node is not None:
-					current_node.next_node.prev_node = current_node.prev_node
-				if current_node == self.head:
-					self.head = current_node.next_node
-				if current_node == self.tail:
-					self.tail = current_node.prev_node
-			current_node = current_node.next_node
-
-	def search(self, data):
-		current_node = self.head
-		while current_node is not None:
-			if current_node.data == data:
-				return current_node
-			current_node = current_node.next_node
-		return None
-
-	def print_list(self):
-		current_node = self.head
-		while current_node is not None:
-			print(current_node.data)
-			current_node = current_node.next_node
+    def __init__(self):
+        """
+        This class represents a doubly linked list.
+        It contains a reference to the head (the first node) and the tail (the last node) of the list.
+        """
+        self.head = None
+        self.tail = None
+
+    def append(self, data):
+        """
+        Appends a new node with the given data to the end of the linked list.
+        Time complexity: O(1)
+        """
+        new_node = Node(data)
+        if self.head is None:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.tail.next_node = new_node
+            new_node.prev_node = self.tail
+            self.tail = new_node
+
+    def prepend(self, data):
+        """
+        Prepends a new node with the given data to the beginning of the linked list.
+        Time complexity: O(1)
+        """
+        new_node = Node(data)
+        if self.head is None:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.head.prev_node = new_node
+            new_node.next_node = self.head
+            self.head = new_node
+
+    def delete(self, data):
+        """
+        Deletes the first occurrence of a node with the given data from the linked list.
+        Time complexity: O(n)
+        """
+        current_node = self.head
+        while current_node is not None:
+            if current_node.data == data:
+                if current_node.prev_node is not None:
+                    current_node.prev_node.next_node = current_node.next_node
+                if current_node.next_node is not None:
+                    current_node.next_node.prev_node = current_node.prev_node
+                if current_node == self.head:
+                    self.head = current_node.next_node
+                if current_node == self.tail:
+                    self.tail = current_node.prev_node
+            current_node = current_node.next_node
+
+    def search(self, data):
+        """
+        Searches for the first occurrence of a node with the given data in the linked list.
+        Returns the node if found, None otherwise.
+        Time complexity: O(n)
+        """
+        current_node = self.head
+        while current_node is not None:
+            if current_node.data == data:
+                return current_node
+            current_node = current_node.next_node
+        return None
+
+    def print_list(self):
+        """
+        Prints the elements of the linked list.
+        Time complexity: O(n)
+        """
+        current_node = self.head
+        while current_node is not None:
+            print(current_node.data)
+            current_node = current_node.next_node
+
+
+class TestLinkedList(unittest.TestCase):
+    def test_linked_list(self):
+        # Initialize the linked list
+        linked_list = LinkedList()
+
+        # Append nodes
+        linked_list.append(1)
+        linked_list.append(2)
+        linked_list.append(3)
+
+        # Test the print_list method
+        self.assertEqual(linked_list.print_list(), None)  # No return value, so None is expected
+
+        # Test the search method
+        self.assertEqual(linked_list.search(2), linked_list.head.next_node)  # The second node should contain 2
+
+        # Test the delete method
+        linked_list.delete(2)
+        self.assertEqual(linked_list.search(2), None)  # The node with data 2 should no longer exist
+
+
+if __name__ == '__main__':
+    unittest.main()