2025 Data Structures Using Python

Explain arrays as fixed-size containers of a single data type, with four-element example. Show how to create a one-dimensional array in Python by importing from array and initialize its type.

Learn to create a one-dimensional Python array using the array module with an integer type and initializer [10, 20, 30, 40, 50], then display its elements by index.

Access 1d array elements by index using a sample integer array [10, 20, 30, 40, 50], demonstrating zero-based indexing and retrieving values like 10 and 30.

Perform a search in a one-dimensional array using the array name and index, locating the value 40 at index 3.

Delete an element from a one-dimensional array by removing 40, and observe the array shrink from five to four elements (10, 20, 30, 50) with zero-based indices.

Perform the update operation on a one-dimensional integer array by replacing the element at index 2 with 80, then display the updated sequence 10, 20, 80, 40, 50.

Create and access two-dimensional arrays in Python with nested lists and zero-based indices, such as t[0] for the first row and t[1][2] for 10 in the second row.

perform an insertion in a two dimensional array at the second row, updating the matrix and displaying the updated content with nested loops that iterate rows and columns.

Delete a row from a two dimensional array (t[3]) and then iterate through the remaining rows and their columns to display the content.

Declare and access elements in a Python list, iterate with for loops or range indices, and display items; perform linear search and compute the total with sum.

Learn how the plus operator concatenates lists without altering originals, and how the star operator repeats list elements to create new lists.

Learn Python list indexing and slicing with zero-based and negative indices, practice accessing last elements and lengths, and create sublists and lists with alternate elements through slicing.

Learn how to use Python list methods to manipulate data, including append, clear, copy, count, extend, index, insert, pop, remove, reverse, and sort, with practical examples.

Discover list comprehension in Python by building lists with a for loop over a range and optional if filters, generating square sequences and even squares.

Learn to find the maximum and minimum elements in a Python list using built-in max and min functions, and by manually traversing the list to update max and min values.

Explore Python tuples as an ordered, unchangeable collection that stores multiple items in a single variable, using round brackets and commas, with examples of numbers, strings, and mixed data.

Learn how to manipulate tuples by converting to lists, performing append and pop operations, updating items by index, and converting back to tuples for final results.

Learn how to unpack a tuple in Python by assigning its three items to separate variables, such as name, age, and university, then display the contents to see the result.

Explore dictionaries in Python, a mutable, unordered key-value data structure that disallows duplicates; create, access, update, and delete entries using keys, get, and pop, with examples.

Use for loops to access dictionary elements, print key–value pairs with items, and fetch values by key, while exploring keys and values methods.

Learn how sets in Python act as containers that remove duplicates, use curly braces, are immutable, support conversion from lists, create empty sets, and use the in operator for membership.

Learn how to write and call Python functions, use parameters and a documentation string, return values (including square and multiply results), and return multiple values as tuples.

Define and call simple Python functions to compute the square and cube of a number, returning results and showing function calls, parameters, and program flow.

Implement a function to find the maximum of three numbers by comparing A, B, and C, returning the largest and printing the result from inputs x, y, z.

Learn to implement factorial in Python with both iterative and recursive functions, using a for loop and a base case in recursion, verifying with input 5 returning 120.

Explore direct and indirect recursion, and learn how base cases and recursive calls solve problems like factorials.

Master the basics of linked lists: nodes with data and a next pointer, head pointing to the first node, and operations to print, size, and insert at the head.

Learn how to insert a node into a linked list at the front, after a given node, and at the end, including creating the node and updating pointers.

Learn to search for an element in a linked list by traversing from the head with a current pointer, comparing each node's data to x, and returning true or false.

Apply the two-pointers approach to find the middle element of a linked list. Move slow by one and fast by two until fast ends, yielding the middle or second middle.

Compare two linked lists node by node to determine if they are identical by matching data and their arrangement, and output true if identical, false otherwise.

Learn to implement a Python linked list with Node and LinkedList classes, append nodes at the end, and traverse to find and return the maximum value.

Create a Python linked list with node and list classes, add nodes at end, and delete entire list by setting head to None; print before and after deletion to demonstrate.

Explore the stack data structure, learn push and pop operations, track the top index, and use peak, is full, and is empty checks to manage elements efficiently.

Implement a stack data structure in Python by defining a Stack class with push, pop, peek, is_empty, is_full, and size operations, using a list as storage and a top index.

Learn to implement a stack with a Python list by using append to add elements and pop to remove them, observing the stack from a, b, c to empty.

Demonstrate implementing a stack with the DQ class from the collections module, using append and pop to build an abc stack and show it becomes empty after pops.

Explore implementing a stack in Python by using the queue module’s LifoQueue, with push and pop via put and get, and manage max size, full, empty, and size checks.

Implement a Python stack using a linked list by defining a node and stack class, with push at the front, pop, peak, and display to reveal last‑in, first‑out behavior.

Demonstrate using a stack to check balanced parentheses of three types, push on left parentheses and pop on matching right ones, determining well-formed expressions through traversal.

Learn to check if expressions are balanced using a Python stack: push left brackets, pop on right, and verify matching types for (), [], and {}.

Explore queues as first in, first out data structures, using front and rear ends for insertion and deletion. Learn array and linked list implementations, including overflow and underflow conditions.

Implement a queue using Python lists by appending elements with append and dequeuing in FIFO order using pop, demonstrating removal of A, B, and C until the queue is empty.

Learn to implement a Python queue using the collections deque, using append to insert and pop left to delete, and verify queue contents before and after removals.

Use Python's built-in queue module to implement a queue with a max size, insert items with put, check full and empty states, and remove items with get while tracking size.

Implement a queue with a linked list using nodes that hold data and a next pointer, manage front and rear pointers, and support insertion, deletion, is_empty checks, and display.

Explore circular queues, a fifo data structure that acts as a circular buffer, detailing front and rear, insertion and deletion operations, overflow and empty checks, and mod max.

Learn tree terminology, defining a tree as a recursively defined node set with a root, and identify leaf nodes, degree as children, and height as the longest root-to-deepest path.

Define binary trees by the root and at most two children, and describe complete binary trees as fully filled, except possibly the last level, filled left to right.

Explore array representation of a binary tree with root at index 1 and children at 2k and 2k+1, and see linked list nodes with left, data, and right.

Explain binary tree traversals by teaching in-order, preorder, and postorder methods, detailing left subtree, root node, and right subtree with simple traversal steps.

Implement preorder traversal in python by defining a binary tree node class with data, left, and right attributes, print the node data, then recursively visit left and right subtrees.

Learn how to implement postorder traversal on a binary tree in Python using a recursive approach. Define node structure with data, left, right, and print nodes in left-right-root order.

Compute the height of a binary tree in Python with a recursive approach, returning zero for a none node and taking the max of left and right heights plus one.

Learn to compute the sum of all elements in a binary tree using a recursive add function. Traverse root, left, and right to accumulate node keys.

Explore binary search trees by applying BST properties: left subtrees hold lesser keys, right subtrees hold greater keys. Observe examples and learn node structure with left, key, and right.

Learn how to search for elements in a binary search tree using recursive traversal of left and right subtrees, with base cases for empty trees and key matches.

Insert a node into a binary search tree using Python, starting at the root and recursively inserting into the left or right subtree based on key comparisons, returning the root.

Create a binary search tree by inserting elements 43, 10, 79, 90, 12, and 54 from a blank root, placing smaller values to the left and larger to the right.

Explore graph data structures by examining vertices V and edges E, and distinguish undirected graphs from directed graphs through bidirectional versus unidirectional traversal examples.

Explore how to store graphs in memory using adjacency matrix representation, learn to build the matrix from vertices and edges, and distinguish between directed and undirected graphs and their symmetry.

Explore adjacency list representations for both undirected and directed graphs, listing each vertex and its adjacent vertices to build per-vertex adjacency lists.