Completed Reinforcement section of Exercises

Author: MayankShah1

.idea/workspace.xml

@@ -0,0 +1,100 @@
+class Empty(Exception):
+    """Error attempting to access an element from an empty container"""
+    pass
+
+class LinkedQueue:
+    """FIFO Queue implementation using a singly linked list for storage"""
+
+    # --------------- nested _Node class -----------------
+    class _Node:
+        """Lightweight, nonpublic class for storing a singly linked node."""
+        __slots__ = '_element', '_next'
+
+        def __init__(self, element, next):
+            self._element = element
+            self._next = next
+
+
+    # -------------------- queue methods ------------------
+
+    def __init__(self):
+        """Create an empty queue."""
+
+        self._head = None
+        self._tail = None
+        self._size = 0
+
+    def __len__(self):
+        """Return the size of queue."""
+        return self._size
+
+    def is_empty(self):
+        """Return True if queue is empty."""
+        return self._size == 0
+
+    def first(self):
+        """Return the first element of the queue.
+
+        Raise Empty exception if stack is empty.
+        """
+        if self.is_empty():
+            raise Empty('Queue is empty')
+        return self._head._element
+
+    def enqueue(self,e):
+        """Add an element at the back of the queue"""
+        newest = self._Node(e, None)
+        if self.is_empty():
+            self._head = newest
+        else:
+            self._tail._next = newest
+        self._tail = newest
+        self._size += 1
+
+    def dequeue(self):
+        """ Return and remove the element at the front of the queue.
+
+        Raise empty exception if queue is empty. 
+        """
+        if self.is_empty():
+            raise Empty('Queue is empty.')
+        answer = self._head._element
+        self._head = self._head._next
+        if self.is_empty():
+            self._tail = None
+        return answer
+
+    def rotate(self):
+        """Rotate the front element to the back of the queue"""
+        if self.is_empty():
+            raise Empty('Queue is empty.')
+        print(self._tail._element)
+        answer = self._head._element
+        self._head = self._head._next
+        new_node = self._Node(answer, None)
+        self._tail._next = new_node
+        self._tail = new_node
+
+    def __str__(self):
+        """Return the string representation of string"""
+        elements = []
+        walk = self._head
+        while walk is not None:
+            elements.append(str(walk._element) + ' ')
+            walk = walk._next
+        return ''.join(elements)
+
+# Testing
+if __name__ == "__main__":
+    queue = LinkedQueue()
+
+    queue.enqueue(10)
+    queue.enqueue(20)
+    queue.enqueue(30)
+    print(queue.first())
+    queue.enqueue(40)
+    print(queue.dequeue())
+    print(queue)
+    queue.rotate()
+    print(queue)
+

07-Linked-Lists/Exercises/Reinforcement/R7-07.py

@@ -0,0 +1,68 @@
+import doubly_linked_list as DLL
+
+
+class Empty(Exception):
+    """Error attempting to access an element from an empty container"""
+    pass
+
+
+class LinkedDeque(DLL._DoublyLinkedBase):
+    """Double-ended queue implementation based on doubly linked list."""
+
+    def first(self):
+        """Return the element at the front of deque"""
+        if self.is_empty():
+            raise Empty('Deque is empty.')
+        return self._header._next._element
+
+    def last(self):
+        """Return the element at the end of the deque"""
+        if self.is_empty():
+            raise Empty('Deque is empty')
+        return self._trailer._prev._element
+
+    def insert_first(self, e):
+        """Add an element e to the front of the deque"""
+        self._insert_between(e, self._header, self._header._next)
+
+    def insert_last(self, e):
+        """Add an element e to the end of the deque"""
+        self._insert_between(e, self._trailer._prev, self._trailer)
+
+    def delet_first(self):
+        """Remove and the return the first element of deque.
+
+        Raise Empty exception if the deque is empty.
+        """
+        if self.is_empty():
+            raise Empty('Deque is empty')
+        return self._delete_node(self._header._next)
+
+    def delet_last(self):
+        """Remove and the return the first element of deque.
+
+        Raise Empty exception if the deque is empty.
+        """
+        if self.is_empty():
+            raise Empty('Deque is empty')
+        return self._delete_node(self._trailer._prev)
+
+
+def middle_node(doubly_list):
+    """Return the element at the middle node"""
+    walk_right = doubly_list._header
+    walk_left = doubly_list._trailer
+    while walk_right._next != walk_left._prev:
+        walk_right = walk_right._next
+        walk_left = walk_left._prev
+    return walk_right._next._element
+
+# Testing
+if __name__ == "__main__":
+    double_list = LinkedDeque()
+    double_list.insert_first(20)
+    double_list.insert_first(30)
+    double_list.insert_first(40)
+    double_list.insert_first(50)
+    double_list.insert_first(60)
+    print(middle_node(double_list))

07-Linked-Lists/Exercises/Reinforcement/R7-08.py

@@ -0,0 +1,19 @@
+import positional_list as PL
+
+def max(positional_list):
+    """Return the maximum"""
+    max = positional_list.first().element()
+    for item in positional_list:
+        if item > max:
+            max = item
+    return max
+
+# Testing
+if __name__ == "__main__":
+    pos_list = PL.PositionalList()
+    pos_list.add_first(20)
+    pos_list.add_first(30)
+    pos_list.add_first(50)
+    pos_list.add_first(40)
+    pos_list.add_first(10)
+    print(max(pos_list))

07-Linked-Lists/Exercises/Reinforcement/R7-11.py

@@ -0,0 +1,156 @@
+import doubly_linked_list as DLL
+
+
+class Empty(Exception):
+    """Error attempting to access an element from an empty container"""
+    pass
+
+
+class PositionalList(DLL._DoublyLinkedBase):
+    """A sequential container of elements allowing positional access."""
+
+    # ------------- nested Position Class --------------
+    class Position:
+        """An abstraction representing the location of a single element."""
+
+        def __init__(self, container, node):
+            """Constructor should not be invoked by user."""
+            self._container = container
+            self._node = node
+
+        def element(self):
+            """Return the element stored at this Position."""
+            return self._node._element
+
+        def __eq__(self, other):
+            """Return True if other is a Position representing the same location."""
+            return type(other) is type(self) and other._node is self._node
+
+        def __ne__(self, other):
+            """Return True if other does not represent the same location."""
+            return not (self == other)
+
+    # ------------- utility methods --------------------------
+
+    def _validate(self, p):
+        """Return position's node, or raise appropriate error if invalid."""
+        if not isinstance(p, self.Position):
+            raise TypeError('p must be proper Position type.')
+        if p._container is not self:
+            raise ValueError('p does not belong to this container.')
+        if p._node._next is None:  # deprecated nodes
+            raise ValueError('p is no longer valid.')
+        return p._node
+
+    def _make_position(self, node):
+        """Return position instance for given node."""
+        if node is self._header or node is self._trailer:
+            return None
+        else:
+            return self.Position(self, node)
+
+    # ------------------- accessors --------------------------
+
+    def first(self):
+        """Return the first position in the list."""
+        return self._make_position(self._header._next)
+
+    def last(self):
+        """Return the last position in the list."""
+        return self._make_position(self._trailer._prev)
+
+    def before(self, p):
+        """Return the position just before Position p"""
+        node = self._validate(p)
+        return self._make_position(node._prev)
+
+    def after(self, p):
+        """Return the position just after Position p"""
+        node = self._validate(p)
+        return self._make_position(node._next)
+
+    def __iter__(self):
+        """Generate a forward iteration of elements in the list."""
+        cursor = self.first()
+        while cursor is not None:
+            yield cursor.element()
+            cursor = self.after(cursor)
+
+    # ----------------------- mutators ---------------------------
+
+    # override to return Position instead of node
+    def _insert_between(self, e, predecessor, successor):
+        """Add an element e between two existing nodes and return Position of new node"""
+        node = super()._insert_between(e, predecessor, successor)
+        return self._make_position(node)
+
+    def add_first(self, e):
+        """Insert element at the front of the list and return new Position"""
+        return self._insert_between(e, self._header, self._header._next)
+
+    def add_last(self, e):
+        """Insert element at the last of the list and return new Position"""
+        return self._insert_between(e, self._trailer._prev, self._trailer)
+
+    def add_before(self, p, e):
+        """Insert element into list before Postion p and return new Position"""
+        original = self._validate(p)
+        return self._insert_between(e, original._prev, original)
+
+    def add_after(self, p, e):
+        """Insert element into list after Postion p and return new Position"""
+        original = self._validate(p)
+        return self._insert_between(e, original, original._next)
+
+    def delete(self, p):
+        """Remove and return the element at position P"""
+        original = self._validate(p)
+        return self._delete_node(original)
+
+    def replace(self, p, e):
+        """Replace the element at positon p with e
+
+        Return the element formerly at position p
+        """
+        original = self._validate(p)
+        old_value = original._element
+        original._element = e
+        return old_value
+
+    def find(self, e):
+        """Find the first position of element if in the list"""
+        cursor = self.first()
+        position = 1
+        while cursor is not None:
+            if cursor.element() == e:
+                return position
+            cursor = self.after(cursor)
+            position += 1
+        return None
+
+
+# Testing
+if __name__ == "__main__":
+    position_list = PositionalList()
+
+    position_list.add_last(8)
+    for element in position_list:
+        print(element)
+
+    pos = position_list.first()
+    pos2 = position_list.add_after(pos, 5)
+    for element in position_list:
+        print(element, end=' ')
+
+    print()
+    pos3 = position_list.add_before(pos2, 3)
+    for element in position_list:
+        print(element, end=' ')
+
+    print()
+    print(pos3.element())
+    print(position_list.after(pos) == pos3)
+    print(position_list.find(3))
+
+
+