Data Structures From Scratch

Learn to implement a dynamic array list in C++, with private members, a user-sized constructor, dynamic memory allocation, capacity management, and insert operations that shift elements.

Explore dynamic linked lists by learning how nodes store data and a next pointer, enabling memory-based growth, efficient insertion and deletion, and flexible, size-unbounded structures.

Demonstrate inserting a new element at the end of a linked list and updating the last pointer and connections.

Discover how to insert a new node between two existing nodes in a linked list by allocating memory, setting data, and relinking pointers using traversal.

Learn how to delete a node from a linked list by updating the previous node next pointer and freeing the removed node memory.

Explore recursion as a divide-and-conquer technique, using factorial as a simple example to illustrate base cases and backtracking. Learn how breaking problems into smaller parts enables solving complex structures.

Explore basics of stacks, a data structure that adds and removes elements from the top. Examine push and pop operations, top and empty checks, and array versus linked list implementations.

Demonstrate stack fundamentals by showing push and pop operations, track top and size, and handle memory allocation and empty checks to manage elements in a last-in, first-out structure.

Explore dynamic stacks using a linked list, replacing static allocation limits with a flexible structure. Learn push and pop operations, top-at-beginning insertion, and constant-time access on the head-backed stack.

Learn how to use stacks to solve recursion and factorial problems, perform postfix operations, and reverse strings, while exploring stack applications in graphs and simple algorithms.

Explore how stacks apply to arithmetic expressions, covering operator precedence, infix versus postfix notation, and examples of evaluating and organizing expressions with stacks.

Learn how to convert infix expressions to postfix using a stack, handling operator precedence (multiplication over others) and producing a correct postfix sequence for evaluation.

Learn to convert infix to postfix expressions and evaluate postfix expressions using a stack, applying operators such as +, -, *, and / to produce the final result.

Define a queue as a first-in, first-out data structure where elements enqueue at the back and dequeue from the front, with isEmpty, front, back, and static or dynamic implementations.

Learn to implement a circular queue in C++ with enqueue and dequeue operations, showing how the front index moves in circular fashion, using a template and a memory pointer.

Explore the basics of trees and binary trees, including root nodes, left and right children, leaves, and siblings, plus complete and almost complete trees and level-based node counts.

Explore linked/dynamic representation of binary trees by building nodes with data, left and right pointers, and a root pointer for traversal.

Perform post-order traversal by visiting the left, then the right, and finally the root, using recursion to navigate the tree in C++ with pointers.

Construct a binary expression tree for an arithmetic expression, convert infix to postfix with a stack, and use preorder and postorder traversals for prefix and postfix notations.

Construct expression trees by reading symbols, using a stack to create operator and operand nodes, link left and right branches, and evaluate the expression.

Implementing binary trees teaches building binary search trees in C++, including insert, search, check empty, and node counting, with height and recursion concepts.

Learn a C++ implementation of binary trees, including node structures, pointers, constructors and destructors, and recursive operations like inorder traversal, height calculation, and sum.

Explore how binary search trees enable efficient search, insertion, and removal by organizing left keys smaller and right keys larger. Learn BST properties, balance considerations, and abstract data type concepts.

Learn to search for an item in a binary search tree by comparing the target with the current node and moving left or right, including handling of an empty tree.

Learn how to insert nodes into a binary search tree by comparing values and following left or right links, while understanding BST properties and practical examples.

Explore how AVL trees maintain balance to keep binary search trees efficient, compare balanced and unbalanced structures, and examine how insertion and deletion affect height.

avl trees balance binary search trees using rotations to keep height small, preventing unbalanced structures after insertions or deletions and speeding up search operations.

Explore how AVL trees maintain balance after insertion by applying single and double rotations, using balance factors to correct unbalanced cases.

This lecture demonstrates inserting nodes into AVL trees, tracking balancing factors and heights, identifying the right-left rotation case, and applying rotations to restore balance.

Explore the avl trees algorithm by building and modifying a binary tree, adjusting left and right branches, updating pointers, and calculating the tree height.

Explore a C++ AVL tree implementation, showing how to maintain node height during insertion, compute balance factors, and apply rotations to keep the tree balanced.