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.

This module provides generator functions for creating random and linear instances of various data structures for testing and demonstration purposes.

​
Array Generators

​
random_array

Generates a random array of integers. 
from dsa.generators import random_array

array = random_array(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the array
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
array
Array
Array containing random integers
Example
from dsa.generators import random_array

array = random_array(10, min_val=1, max_val=50)

​
random_dynamicarray

Generates a random dynamic array of integers. 
from dsa.generators import random_dynamicarray

array = random_dynamicarray(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the array
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
array
DynamicArray
DynamicArray containing random integers

​
Stack Generators

​
random_stack

Generates a random stack of integers. 
from dsa.generators import random_stack

stack = random_stack(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the stack
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
stack
Stack
Stack containing random integers

​
linear_stack

Generates a stack with sequential integers. 
from dsa.generators import linear_stack

stack = linear_stack(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the stack
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used, kept for API consistency)
​
stack
Stack
Stack containing sequential integers starting from min_val

​
random_dynamic_stack

Generates a random dynamic stack of integers. 
from dsa.generators import random_dynamic_stack

stack = random_dynamic_stack(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the stack
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
stack
DynamicStack
DynamicStack containing random integers

​
linear_dynamic_stack

Generates a dynamic stack with sequential integers. 
from dsa.generators import linear_dynamic_stack

stack = linear_dynamic_stack(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the stack
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used)
​
stack
DynamicStack
DynamicStack containing sequential integers

​
Queue Generators

​
random_queue

Generates a random queue of integers. 
from dsa.generators import random_queue

queue = random_queue(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the queue
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
queue
Queue
Queue containing random integers

​
linear_queue

Generates a queue with sequential integers. 
from dsa.generators import linear_queue

queue = linear_queue(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the queue
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used)
​
queue
Queue
Queue containing sequential integers

​
random_dynamic_queue

Generates a random dynamic queue of integers. 
from dsa.generators import random_dynamic_queue

queue = random_dynamic_queue(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the queue
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
queue
DynamicQueue
DynamicQueue containing random integers

​
linear_dynamic_queue

Generates a dynamic queue with sequential integers. 
from dsa.generators import linear_dynamic_queue

queue = linear_dynamic_queue(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the queue
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used)
​
queue
DynamicQueue
DynamicQueue containing sequential integers

​
Deque Generators

​
random_deque

Generates a random deque of integers. 
from dsa.generators import random_deque

deque = random_deque(size, min_val=0, max_val=100)
​
size
int
required
Number of elements in the deque
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
deque
Deque
Deque containing random integers added from both ends

​
Linked List Generators

​
random_linked_list

Generates a random singly linked list of integers. 
from dsa.generators import random_linked_list

ll = random_linked_list(size, min_val=0, max_val=100)
​
size
int
required
Number of nodes in the linked list
​
min_val
int
default:"0"
Minimum value of the elements
​
max_val
int
default:"100"
Maximum value of the elements
​
ll
LinkedList
LinkedList containing random integers

​
linear_linked_list

Generates a singly linked list with sequential integers. 
from dsa.generators import linear_linked_list

ll = linear_linked_list(size, min_val=0, max_val=100)
​
size
int
required
Number of nodes in the linked list
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used)
​
ll
LinkedList
LinkedList containing sequential integers

​
random_doubly_linked_list

Generates a random doubly linked list of integers. 
from dsa.generators import random_doubly_linked_list

dll = random_doubly_linked_list(size, min_val=0, max_val=100)
​
size
int
required
Number of nodes in the list
​
min_val
int
default:"0"
Minimum value of the nodes
​
max_val
int
default:"100"
Maximum value of the nodes
​
dll
DoublyLinkedList
DoublyLinkedList containing random integers

​
linear_doubly_linked_list

Generates a doubly linked list with sequential integers. 
from dsa.generators import linear_doubly_linked_list

dll = linear_doubly_linked_list(size, min_val=0, max_val=100)
​
size
int
required
Number of nodes in the list
​
min_val
int
default:"0"
Starting value
​
max_val
int
default:"100"
Maximum value (not used)
​
dll
DoublyLinkedList
DoublyLinkedList containing sequential integers

​
Tree Generators

​
random_binary_tree

Generates a random binary tree. 
from dsa.generators import random_binary_tree

tree = random_binary_tree(n)
​
n
int
required
Number of nodes in the tree
​
tree
Tree
Tree with randomly structured nodes
Example
from dsa.generators import random_binary_tree

tree = random_binary_tree(15)
# Tree with 15 nodes in random structure

​
random_binary_tree_node

Generates a random binary tree node structure. 
from dsa.generators import random_binary_tree_node

node = random_binary_tree_node(n)
​
n
int
required
Number of nodes in the tree
​
node
TreeNode
Root TreeNode of a randomly structured binary tree

​
Heap Generators

​
random_heap

Generates a random heap. 
from dsa.generators import random_heap

heap = random_heap(n)
​
n
int
required
Number of nodes in the heap
​
heap
Heap
Heap containing random integers from 0 to 100
Example
from dsa.generators import random_heap

heap = random_heap(20)
# Min-heap with 20 random values

​
Trie Generators

​
random_trie

Generates a random trie with random words. 
from dsa.generators import random_trie

trie = random_trie(n)
​
n
int
required
Number of words to insert into the trie
​
trie
Trie
Trie containing n random words (1-10 characters each)
Example
from dsa.generators import random_trie

trie = random_trie(50)
# Trie with 50 random words

​
Graph Generators

​
random_adjacency_matrix_graph

Generates a random unweighted graph using adjacency matrix representation. 
from dsa.generators import random_adjacency_matrix_graph

graph = random_adjacency_matrix_graph(n, density=0.1, directed=False)
​
n
int
required
Number of vertices
​
density
float
default:"0.1"
Probability of edge existence between any two vertices (0.0 to 1.0)
​
directed
bool
default:"False"
If True, creates directed edges
​
graph
AdjacencyMatrixGraph
Graph with n vertices labeled A, B, C, etc.

​
random_adjacency_matrix_weighted_graph

Generates a random weighted graph using adjacency matrix representation. 
from dsa.generators import random_adjacency_matrix_weighted_graph

graph = random_adjacency_matrix_weighted_graph(n, density=0.1, directed=False)
​
n
int
required
Number of vertices
​
density
float
default:"0.1"
Probability of edge existence between vertices
​
directed
bool
default:"False"
If True, creates directed edges
​
graph
AdjacencyMatrixWeightedGraph
Weighted graph with edge weights from 1 to 10

​
random_adjacency_list_graph

Generates a random unweighted graph using adjacency list representation. 
from dsa.generators import random_adjacency_list_graph

graph = random_adjacency_list_graph(n, density=0.1, directed=False)
​
n
int
required
Number of vertices
​
density
float
default:"0.1"
Probability of edge existence between vertices
​
directed
bool
default:"False"
If True, creates directed edges
​
graph
AdjacencyListGraph
Graph with n vertices labeled A, B, C, etc.

​
random_adjacency_list_weighted_graph

Generates a random weighted graph using adjacency list representation. 
from dsa.generators import random_adjacency_list_weighted_graph

graph = random_adjacency_list_weighted_graph(n, density=0.1, directed=False)
​
n
int
required
Number of vertices
​
density
float
default:"0.1"
Probability of edge existence between vertices
​
directed
bool
default:"False"
If True, creates directed edges
​
graph
AdjacencyListWeightedGraph
Weighted graph with edge weights from 1 to 10
from dsa.generators import random_adjacency_list_weighted_graph

# Create sparse graph with 10 vertices, 10% edge density
graph = random_adjacency_list_weighted_graph(10, density=0.1)

Build docs developers (and LLMs) love

Get started for freeTalk to us