Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/ucxinstructor/dsa_package/llms.txt

Use this file to discover all available pages before exploring further.

The Queue and DynamicQueue classes provide FIFO (First In, First Out) queue implementations with fixed and dynamic capacity respectively.

​
Queue

A static queue implementation with fixed capacity.

​
Constructor

​
contents
list
default:"None"
Optional list with contents to enqueue during initialization
​
capacity
int
default:"10"
The initial size of the queue
from dsa.queue import Queue

# Create a queue with default capacity
queue = Queue()

# Create a queue with custom capacity
queue = Queue(capacity=20)

# Create a queue with initial contents
queue = Queue(contents=[1, 2, 3])

​
Properties

​
count
int
The number of elements currently in the queue

​
Methods

​
enqueue(element)

Add an element to the back of the queue.
​
element
any
required
The element to enqueue
Returns: None Raises:
  • Exception: When trying to enqueue more elements than the capacity
queue = Queue(capacity=3)
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
# queue.enqueue(4)  # Raises Exception: "Capacity Reached"

​
dequeue()

Remove and return the front element from the queue. Returns: The front element in the queue Raises:
  • Exception: When there are no elements to dequeue
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue())  # Output: 1
print(queue.dequeue())  # Output: 2
# queue.dequeue()  # Raises Exception: "Empty Queue"

​
peek()

Return the front element without removing it. Returns: The element in front of the queue Raises:
  • Exception: When the queue is empty
queue = Queue()
queue.enqueue(10)
print(queue.peek())  # Output: 10
print(queue.peek())  # Output: 10 (element still in queue)

​
is_empty()

Check if the queue is empty. Returns: True if the queue is empty, False otherwise 
queue = Queue()
print(queue.is_empty())  # Output: True
queue.enqueue(1)
print(queue.is_empty())  # Output: False

​
capacity()

Return the total capacity of the queue. Returns: The capacity of the queue 
queue = Queue(capacity=15)
print(queue.capacity())  # Output: 15

​
from_list(alist)

Class method to create a queue from a list.
​
alist
list
required
The list with contents to enqueue
Returns: A new Queue instance Raises:
  • Exception: When the list has more elements than the default capacity
queue = Queue.from_list([1, 2, 3, 4, 5])
print(queue.peek())  # Output: 1

​
to_ordered_list()

Convert the queue contents to a Python list in order. Returns: A list containing the queue elements in order 
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.to_ordered_list())  # Output: [1, 2, 3]

​
raw_view()

Return the queue in its internal array representation. Returns: The array representation of the queue 
queue = Queue(capacity=5)
queue.enqueue(1)
queue.enqueue(2)
print(queue.raw_view())  # Output: [1, 2, None, None, None]

​
Special Methods

​
__len__()

Return the count of items in the queue. 
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(len(queue))  # Output: 2

​
__eq__(other)

Compare two queues for value-based equality. Returns: True if both queues have equal contents, False otherwise 
queue1 = Queue.from_list([1, 2, 3])
queue2 = Queue.from_list([1, 2, 3])
queue3 = Queue.from_list([1, 2, 4])

print(queue1 == queue2)  # Output: True
print(queue1 == queue3)  # Output: False

​
__repr__()

Return a string representation with queue details. 
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue)  # Output: [1, 2] Count: 2 Capacity: 10

​
DynamicQueue

A dynamic queue implementation that automatically grows capacity. Inherits from Queue.
Shrinking is not implemented in DynamicQueue - the capacity only grows.

​
Constructor

​
contents
list
default:"None"
Optional list with contents to enqueue during initialization
​
capacity
int
default:"10"
The initial size of the queue
from dsa.queue import DynamicQueue

# Create a dynamic queue
queue = DynamicQueue()

# Create with initial contents
queue = DynamicQueue(contents=[1, 2, 3], capacity=5)

​
Methods

DynamicQueue inherits all methods from Queue with the following differences:

​
enqueue(element)

Add an element to the queue. Automatically increases capacity if count is greater than capacity.
​
element
any
required
The element to enqueue
Returns: None 
queue = DynamicQueue(capacity=2)
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)  # Automatically grows capacity
queue.enqueue(4)
print(queue.capacity())  # Output: 4 (doubled from 2)

​
grow()

Double the capacity of the current array. Returns: None 
queue = DynamicQueue(capacity=10)
print(queue.capacity())  # Output: 10
queue.grow()
print(queue.capacity())  # Output: 20

​
check_capacity()

Check if count ≥ capacity, and grow the array if needed. Returns: None 
queue = DynamicQueue(capacity=10)
for i in range(10):
    queue.enqueue(i)
queue.check_capacity()  # Will grow if needed

​
Complete Example

from dsa.queue import Queue, DynamicQueue

# Create a dynamic queue
queue = DynamicQueue(capacity=2)

# Enqueue elements - capacity grows automatically
for i in range(10):
    queue.enqueue(i)
    print(f"Enqueued {i}, Capacity: {queue.capacity()}, Count: {len(queue)}")

# Dequeue elements
while not queue.is_empty():
    element = queue.dequeue()
    print(f"Dequeued {element}, Remaining: {len(queue)}")

# Compare queues
queue1 = DynamicQueue()
queue2 = Queue()
for i in [1, 2, 3]:
    queue1.enqueue(i)
    queue2.enqueue(i)

print(queue1 == queue2)  # Output: True

# Process items in order
queue3 = DynamicQueue.from_list([10, 20, 30, 40])
print(queue3.peek())  # Output: 10 (first in)
print(queue3.to_ordered_list())  # Output: [10, 20, 30, 40]

Build docs developers (and LLMs) love

Get started for freeTalk to us