Skip to main content
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