Visualisation of Data Structures & Algorithms in Python

Explore arrays as structured data containers with boxes and indices starting at zero, enabling quick, direct access to numbers, words, or any data in Python's data structure visualizations.

Explore the advantages and limitations of arrays, including efficient access, memory efficiency, simplicity, and predictable performance, versus fixed size, wasted memory, and costly insertions or deletions.

Analyze time and space complexities for array operations, including access (O(1) time, O(1) space), append (average O(1), resize may be O(n)), and search (linear O(n) or binary O(log n)).

Explore inserting elements into a Python array at a specific index using the insert method, with zero-based indexing and printing the updated array.

Access elements in a Python array of gems using zero-based indexing to retrieve the second gem, sapphire, and print the treasure you extracted.

Modify elements in an array using Python by locating the target by index and assigning a new value. Print the updated list to verify the change.

Explore two-dimensional arrays as grids of rows and columns that store diverse data, accessible via nested indexing [row][col], with a classroom example illustrating names, ages, and grades.

Learn to declare, initialize, and access elements in Python's multidimensional arrays, including 2d and 3d grids, using zero-based indexing and row, column, and depth coordinates.

Explore linked lists, a data structure of nodes connected by next pointers, starting at the head and ending at null, enabling insertions and deletions for stacks or queues.

Explore the advantages and trade-offs of linked lists, including dynamic size, efficient insertions and deletions, memory efficiency, and no wasted space, alongside limited random access and higher overhead.

Explore the six kinds of linked lists—singly, doubly, circular, sorted, skip list, and self-adjusting list—discovering how each type stores data and enables efficient operations.

Learn how to implement a singly linked list in Python by building a node class, linking nodes with next pointers, and traversing from the head using a fruits example.

Delete a node from a singly linked list by locating the target, updating the previous node’s next pointer to skip it, and freeing the removed node’s memory.

Add a new node to the front of a singly linked list by creating the node, linking it to the current head, and updating the head to the new node.

Create a singly linked list class in Python and implement creating, inserting, deleting, and traversing nodes while using the head and next pointers to navigate the structure.

Learn to insert a node at the beginning of a single linked list by creating a new node, linking it to the head, and updating the head reference.

Explore inserting a node at the end of a single linked list with the insert_at_end method, using head and a current pointer to attach at the tail.

Learn to insert a new node after a given node in a linked list by creating the node with data, linking it to the next, and handling missing previous node.

Delete a node by key in a single linked list, updating the head when needed and linking the previous node to the current's next to keep the list coherent.

Explore stacks as linear data structures with last-in, first-out access, mastering push and pop, top interactions, and uses in function calls, undo, and expression evaluation.

Learn to implement a stack with a linked list in Python, creating a node class and a stack class with push, pop, peak, is_empty, and size.

Discover queues as a first-in, first-out data structure with enqueue, dequeue, and peek operations, and their use in task scheduling, printing, and breadth-first search in Python.

Demonstrates how to move the front pointer in a circular queue using self.front and the modulo operation to wrap at the end, ensuring correct order during enqueues and dequeues.

Implement a queue in python using an array by defining a Q class with size, a list filled with None, and front and rear pointers to support enqueue and dequeue.

Explore how the is_full method detects when a queue using an array reaches capacity and prevents overflow. Learn how rear and front, with modulo sizing, wrap around the array.

Enqueue items in a fixed-capacity queue using a circular array, checking is_full and is_empty before updating front and rear via modular arithmetic, then inserting the item.

Display the queue elements without removing them by traversing from front to rear, using modular arithmetic to wrap around, for clear debugging and understanding of queue based algorithms.

Create a queue in python using a class, enforce a max size of five, and perform enqueue, dequeue, display, and peek operations to demonstrate the fifo principle.

Implement a queue with a linked list in Python by defining a node class with data and next attributes, initializing via the constructor, and linking nodes for efficient queue management.

Define a queue class with a constructor that initializes front and rear pointers to none, creating an empty queue; implement a linked-list Q data structure for FIFO enqueuing and dequeuing.

Implement the isEmpty method to check if a queue has no elements by testing whether the front pointer is None.

Enqueue adds a new node to the queue's rear, updates front and rear when empty, and links the new node to the rear to maintain first in, first out order.

Define a peek method to inspect front element of a queue without removing it. Handle empty queues by printing a message; otherwise, print front data, offering a non-destructive view.

Define a display method that shows all queue elements by iterating from the front through a linked list, handling empty queues and printing elements on one line.

Dive into trees in data structures, learning root, nodes, edges, depth, height, and traversal, and discover their use in binary search trees, balancing, and recursion.

Explore binary trees, their nodes and edges, learn left and right children, and discover how traversal, searching, and balancing enable fast data retrieval with binary search trees and self-balancing variants.

Explore the various types of binary trees, including full, complete, perfect, balanced, degenerate, and skewed, and learn how their structures affect performance in heaps and search operations.

Explore three binary tree representations: array, linked structure, and level order traversal. Compare their advantages and limitations for complete versus incomplete trees and breadth-first algorithms.

Demonstrate binary tree array representation by mapping nodes to an index-based array, with root at zero and left and right children at 2i+1 and 2i+2, enabling access and compact storage.

Explore array-based representations of binary trees, where left and right children sit at indices 2i+1 and 2i+2. Create, insert, and display a ten-node tree to visualize initialization, insertion, and traversal.

Explore linked structure tree representation in Python, where nodes hold data and two pointers to left and right children, enabling dynamic, memory-efficient trees with trade-offs of overhead and slower access.

Explore binary search trees as ordered, hierarchical structures where left subtrees hold smaller values and right subtrees hold larger values, enabling efficient searching and straightforward insertion and deletion in Python.

Explore binary search tree operations, including searching, inserting, and deleting nodes, while preserving order and analyzing time and space complexity with library-like analogies.

Build a binary search tree in python by defining a TreeNode class, inserting keys, and using in-order traversal to print ascending keys, producing 20, 30, 40, 50, 60, 70, 80.

Explore in-order, pre-order, and post-order traversals of a binary search tree in Python, illustrated by a simple node class with left and right children and print-based traversal demonstrations.

Explore preorder traversal of a binary tree, visiting the root before left and right subtrees, as shown on a sample tree with nodes 10, 6, 3, and 18.

Master in-order traversal in a binary search tree by visiting left subtree, then root, then right subtree; illustrated with nodes 8, 10, 15, 20, 25.

Master postorder traversal by visiting left and right subtrees before the root, illustrated on a numeric tree and highlighted for applications like expression evaluation and tree deletion.

Explore in-order, pre-order, and post-order traversals in a Python binary search tree, implementing a node class and printing traversal outputs; in-order yields ascending order.

Explore graphs as data structures built from vertices and edges, including undirected and directed graphs, with representations like adjacency lists and matrices, and applications like shortest paths and social networks.

Explore cyclic graphs with loops that return to the starting vertex and contrast acyclic graphs, which have no cycles, illustrating dependencies and tasks in project planning and scheduling.

Explore how an adjacency matrix represents a graph as a vertex grid with edges and weights. It enables edge checks for dense graphs but is space inefficient for sparse ones.

Represent a graph with an adjacency matrix in Python. Initialize a 5x5 zero matrix for an undirected graph, define edges, update symmetric entries to one, and visualize the final matrix.

Learn to represent a graph in Python with an adjacency list. Build a five-node undirected graph using a dictionary of neighbor lists, update from edges, and print the adjacency list.

Explore graph traversal with DFS and BFS, using stack or recursion for depth exploration and a queue for layer-by-layer breadth, to find shortest paths and analyze networks.

Dive into depth first search, exploring a path at a time, marking junctions to remember the way back, and backtracking from dead ends to find treasure.

Explore the BFS algorithm from a starting node, visiting neighboring nodes at each depth level via a queue to reveal the shortest routes through a network of edges.