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.

Learn how to remove elements from a Python array by using the del keyword, targeting by index, updating the list, and verifying the result with print.

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.

Explore three dimensional arrays by visualizing data as a library across floors, shelves, and books; access elements with three indices in Python, and apply to 3D modelling, imaging, and data.

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.

Learn to insert at the end of a singly linked list by creating a new node, traversing from the head to the last node, and linking it.

Insert a new node after a given node in a singly linked list by creating the node, locating the previous node, and updating the next pointer 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.

Use the display_underscore_list method to traverse the linked list from the head, print each node's data as current moves to the next, and finish by printing none.

Explore a singly linked list in Python by building, inserting at end, displaying, inserting after a node, and deleting nodes, illustrated as a train journey through successive stops.

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.

Explore stack operations in Python: push adds to the top, pop removes the top item, peek shows the top, and use is empty and size to avoid underflow.

Build a stack using arrays in Python and explore push, pop, peek, is empty, and size with a dedicated stack class and practical examples.

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.

Implement the is_empty method to check if the queue is empty by comparing front to minus one. Initialize front and rear to minus one to mark an empty queue.

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.

Learn how the dequeue operation removes an item from the front of a circular queue, performs an empty check, uses modular arithmetic for pointer updates, and reports the dequeued item.

Implement a queue peek for an array-based queue to view the front via the front pointer without removing it, displaying the front element or a 'queue is empty' message.

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 dequeue method that removes the front element of the queue, updates the front pointer and rear when empty, and prints the dequeued item, reinforcing the first-in, first-out principle.

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.

Create a queue in Python by implementing a linked list class, then enqueue elements, dequeue from the front, peek at the front, and display the queue contents.

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 linked structure representations by building a binary tree with a Treenode class, linking left and right children, and performing a preorder traversal to visualize the tree.

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 graphs by learning vertices, edges, and neighbors, then measure a vertex's degree; compare undirected and directed graphs and understand how weighted edges convey distance or cost.

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.

Represent graphs using an adjacency list by mapping each node (0–4) to its neighbors, built from edges with bidirectional updates for an undirected graph, then display the final adjacency list.

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.