Module dsa.queue

Expand source code
class Queue:
    """ 
    A static queue implementation in Python
    """
    def __init__(self, capacity=10):
        """ 
        Args:
            capacity: the initial size of the stack (defaults to 10)
        """
        self._array = [None] * capacity
        self._front = 0
        #: number of elements in queue
        self.count = 0
    
    def enqueue(self, element):
        """
        Enqueue an element into the queue. Raise Exception when trying to enqueue more elements than the capacity.

        Args:
            element: the element to enqueue
        """
        if self.count >= len(self._array):
            raise Exception("Capacity Reached")

        index = (self._front + self.count) % len(self._array)
        self._array[index] = element
        self.count += 1
        
    def dequeue(self):
        """
        Dequeue an element from the queue. Raise Exception when there are no elements to dequeue.

        Returns:
            the from element in the queue
        """
        if self.is_empty():
            raise Exception("Empty Queue")

        element = self._array[self._front]
        self._front += 1
        if self._front >= len(self._array):
            self._front = 0
        self.count -= 1

        return element
    
    def peek(self):
        """
        Return the element in front of the queue. Raise Exception if queue is empty.
        """
        if self.is_empty():
            raise Exception("Empty Queue")

        return self._array[self._front]

    def is_empty(self):
        """
        Return a Boolean on whether the stack is empty or not.
        """
        return self.count == 0
    
    def capacity(self):
        """
        Return the capacity of the queue.
        """
        return len(self._array)

    def __repr__(self):
        arr = []
        for i in range(self.count):
            index = (i + self._front) % len(self._array)
            arr.append(str(self._array[index]))
        arrstr = ", ".join(arr)
        return f"[{arrstr}] Front: {self._front} count: {self.count} Capacity: {self.capacity()}"
    

# shrink not implemented
class DynamicQueue(Queue):
    """ 
    A dynamic queue implementation in Python
    """
    def __init__(self, capacity=10):
        super().__init__(capacity)
    
    def grow(self):
        """ 
        double the capacity of the current array 
        """
        new_array = [ None ] * len(self._array) * 2
        
        # copy elements
        for i in range(self.count):
            new_array[i] = self._array[i + self._front]
        self._front = 0
        self._array = new_array

    def check_capacity(self):
        """ 
        if count >= capacity, grow the array
        """
        if self._front + self.count >= len(self._array):
            self.grow()

    def enqueue(self, element):
        """
        Enqueue an element into the queue. Increae capacity if count is greater than the capacity.

        Args:
            element: the element to enqueue
        """
        self.check_capacity()
        index = self._front + self.count
        self._array[index] = element
        self.count += 1

Classes

class DynamicQueue (capacity=10)

A dynamic queue implementation in Python

Args

capacity
the initial size of the stack (defaults to 10)
Expand source code
class DynamicQueue(Queue):
    """ 
    A dynamic queue implementation in Python
    """
    def __init__(self, capacity=10):
        super().__init__(capacity)
    
    def grow(self):
        """ 
        double the capacity of the current array 
        """
        new_array = [ None ] * len(self._array) * 2
        
        # copy elements
        for i in range(self.count):
            new_array[i] = self._array[i + self._front]
        self._front = 0
        self._array = new_array

    def check_capacity(self):
        """ 
        if count >= capacity, grow the array
        """
        if self._front + self.count >= len(self._array):
            self.grow()

    def enqueue(self, element):
        """
        Enqueue an element into the queue. Increae capacity if count is greater than the capacity.

        Args:
            element: the element to enqueue
        """
        self.check_capacity()
        index = self._front + self.count
        self._array[index] = element
        self.count += 1

Ancestors

Methods

def check_capacity(self)

if count >= capacity, grow the array

Expand source code
def check_capacity(self):
    """ 
    if count >= capacity, grow the array
    """
    if self._front + self.count >= len(self._array):
        self.grow()
def enqueue(self, element)

Enqueue an element into the queue. Increae capacity if count is greater than the capacity.

Args

element
the element to enqueue
Expand source code
def enqueue(self, element):
    """
    Enqueue an element into the queue. Increae capacity if count is greater than the capacity.

    Args:
        element: the element to enqueue
    """
    self.check_capacity()
    index = self._front + self.count
    self._array[index] = element
    self.count += 1
def grow(self)

double the capacity of the current array

Expand source code
def grow(self):
    """ 
    double the capacity of the current array 
    """
    new_array = [ None ] * len(self._array) * 2
    
    # copy elements
    for i in range(self.count):
        new_array[i] = self._array[i + self._front]
    self._front = 0
    self._array = new_array

Inherited members

class Queue (capacity=10)

A static queue implementation in Python

Args

capacity
the initial size of the stack (defaults to 10)
Expand source code
class Queue:
    """ 
    A static queue implementation in Python
    """
    def __init__(self, capacity=10):
        """ 
        Args:
            capacity: the initial size of the stack (defaults to 10)
        """
        self._array = [None] * capacity
        self._front = 0
        #: number of elements in queue
        self.count = 0
    
    def enqueue(self, element):
        """
        Enqueue an element into the queue. Raise Exception when trying to enqueue more elements than the capacity.

        Args:
            element: the element to enqueue
        """
        if self.count >= len(self._array):
            raise Exception("Capacity Reached")

        index = (self._front + self.count) % len(self._array)
        self._array[index] = element
        self.count += 1
        
    def dequeue(self):
        """
        Dequeue an element from the queue. Raise Exception when there are no elements to dequeue.

        Returns:
            the from element in the queue
        """
        if self.is_empty():
            raise Exception("Empty Queue")

        element = self._array[self._front]
        self._front += 1
        if self._front >= len(self._array):
            self._front = 0
        self.count -= 1

        return element
    
    def peek(self):
        """
        Return the element in front of the queue. Raise Exception if queue is empty.
        """
        if self.is_empty():
            raise Exception("Empty Queue")

        return self._array[self._front]

    def is_empty(self):
        """
        Return a Boolean on whether the stack is empty or not.
        """
        return self.count == 0
    
    def capacity(self):
        """
        Return the capacity of the queue.
        """
        return len(self._array)

    def __repr__(self):
        arr = []
        for i in range(self.count):
            index = (i + self._front) % len(self._array)
            arr.append(str(self._array[index]))
        arrstr = ", ".join(arr)
        return f"[{arrstr}] Front: {self._front} count: {self.count} Capacity: {self.capacity()}"

Subclasses

Instance variables

var count

number of elements in queue

Methods

def capacity(self)

Return the capacity of the queue.

Expand source code
def capacity(self):
    """
    Return the capacity of the queue.
    """
    return len(self._array)
def dequeue(self)

Dequeue an element from the queue. Raise Exception when there are no elements to dequeue.

Returns

the from element in the queue

Expand source code
def dequeue(self):
    """
    Dequeue an element from the queue. Raise Exception when there are no elements to dequeue.

    Returns:
        the from element in the queue
    """
    if self.is_empty():
        raise Exception("Empty Queue")

    element = self._array[self._front]
    self._front += 1
    if self._front >= len(self._array):
        self._front = 0
    self.count -= 1

    return element
def enqueue(self, element)

Enqueue an element into the queue. Raise Exception when trying to enqueue more elements than the capacity.

Args

element
the element to enqueue
Expand source code
def enqueue(self, element):
    """
    Enqueue an element into the queue. Raise Exception when trying to enqueue more elements than the capacity.

    Args:
        element: the element to enqueue
    """
    if self.count >= len(self._array):
        raise Exception("Capacity Reached")

    index = (self._front + self.count) % len(self._array)
    self._array[index] = element
    self.count += 1
def is_empty(self)

Return a Boolean on whether the stack is empty or not.

Expand source code
def is_empty(self):
    """
    Return a Boolean on whether the stack is empty or not.
    """
    return self.count == 0
def peek(self)

Return the element in front of the queue. Raise Exception if queue is empty.

Expand source code
def peek(self):
    """
    Return the element in front of the queue. Raise Exception if queue is empty.
    """
    if self.is_empty():
        raise Exception("Empty Queue")

    return self._array[self._front]