Data Structure with C++ : Zero to Hero

Explore memory allocation for variables in C++, how the size of a variable reveals bytes, and how pointers store addresses while references alias variables.

Explore constant variables, constant references, and pointers in C++, including initialization rules, the difference between constant pointer and pointer to constant, and how constant functions affect overloading.

Explore passing arguments to functions in C++ by value, by pointer, and by reference, with memory, scope, and default parameter rules (from right to left) explained.

Explore how arrays in C++ occupy a contiguous memory block with zero-based indexing and five ints totaling 20 bytes, and how pointer-based function calls modify elements.

Explore row-major and column-major representations of two-dimensional arrays in C++, understanding memory layout, contiguous memory, and address calculation from the base address.

Learn how a linked list serves as a dynamic, noncontiguous data structure using head and nodes with data and next pointers, enabling easy insertion and deletion in C++ through templates.

Explore inserting elements into a linked list in C++ by adding at the beginning or end, using template methods, and displaying the list to verify order.

Learn to delete the first node and delete a node by value in a c++ linked list, handling empty lists with exceptions and demonstrating with hands-on examples.

Learn how to reverse a linked list in place in one pass using three pointers, without extra memory, and handle empty or single-element lists.

Explore doubly linked lists in C++ by comparing with singly linked lists, detailing node structure, data, next and previous pointers, and operations to insert, delete, and display.

Explore circularly linked lists in C++, using head and tail pointers to insert at start or end, delete by value, and display contents, with notes on empty lists.

Learn to represent polynomials with linked lists in c++ and compare with array-based storage. Explore coefficients, exponents, and polynomial order, and highlight linked lists' advantages for sparse polynomials.

Implement a stack using a template array in C++, with push and pop operations. Track the top index and size, handle overflow and underflow, and demonstrate last-in, first-out with 0–4.

Explore implementing a stack using a linked list in C++ templates, with push and pop operations, top pointers, and underflow handling for a last-in, first-out data structure.

Learn how to use a stack in C++ to convert infix expressions to postfix, highlighting operator precedence and parentheses, with a step-by-step example and its C++ implementation.

Learn postfix evaluation with a stack by converting infix to postfix and evaluating postfix expressions left to right using the algorithm and operators + - * / ^ in C++.

Learn to implement a queue with an array using front and rear pointers, performing insert and extract operations, and master a circular queue via modulus to reuse space.

Implement a queue using a linked list in C++, with a template node structure, supporting insert at the back and extract from the front, and an empty check.

Explore graph theory by modeling relationships with vertices and edges, including self-loops and multiple edges, and learn adjacency matrix, adjacency lists, and reading graphs from a file.

Learn to read a graph from a file and initialize a C++ graph object by counting lines, parsing lines with getline and string streams, and building a two-dimensional array.

Explore breadth-first search on a graph to find a path from source vertex 0 to goal vertex 7, reconstructing the route 0-1-4-6-7 with a queue and a previous vertex array.

Explore depth first search (dfs) on a graph using a stack, tracking visited and predecessors to reconstruct a path from start to goal, e.g., 0-2-3-5-6-7.

Explore trees and binary trees, including cycles, leaves, depth, level, and height, with examples and definitions. Define complete binary trees, full and strictly binary trees, and related node counts.

Learn how to traverse binary trees using preorder, inorder, and postorder traversals, visiting nodes in left and right subtrees, and reconstruct binary trees from preorder and inorder sequences.

Learn binary tree implementation in C++ with doubly linked lists, including node structure with left and right pointers, variants with predecessor and successor, and construction from preorder and inorder sequences.

Explore binary search trees in C++ by understanding how left and right subtrees enforce order, observe traversals yielding ascending sequences, and learn search, insert, and delete operations.

Learn to implement a binary search tree in C++, including constructing the root, inserting values, searching for nodes, deleting nodes, and performing in-order traversal to verify structure.

Explore red-black trees in C++, a balanced binary search tree with red or black nodes; root and leaves are black, and all paths share the same black height.

Explore red-black tree insertion in c++ with color properties, the root black rule, and balancing through rotations and recoloring to maintain tree invariants.

this lecture demonstrates red-black tree insertion in c++, introducing a protected insert method and using rotations and color flips to maintain balance, with verification via preorder and inorder traversals.

Explore red-black tree deletion in C++ by applying binary search deletion rules, handling black and red nodes, leaves, and sibling relationships through practical cases.

Identify the node to delete and remove it in a red-black tree. Apply color adjustments and rotations to preserve red-black properties.

Learn to represent a max-heap as a complete binary tree in an array and build it by comparing a node with its children and swapping to maintain max-heap property.

Apply heap sort by building a max heap from an array and repeatedly swapping the max to the end to produce a sorted sequence.

Learn how a priority queue is implemented with a heap in C++, where the highest-priority item is extracted first, using insert and extract operations with inversely proportional keys.

Learn how the selection sort procedure repeatedly finds the maximum in the unsorted portion and swaps it to its correct rightmost position, gradually sorting the array in ascending order.

This lecture explains insertion sort with a card-deck analogy, showing how to insert each unsorted card into a growing sorted list to form ascending order in C++.

Bubble sort moves the largest element to the right by swapping adjacent out-of-order pairs, then repeats on shrinking subarrays until the entire array is sorted in ascending order.

Explore the quicksort algorithm in C++, including recursive partitioning with a rightmost pivot, dividing arrays into left and right subarrays, and applying quicksort recursively to sort data.

Learn how merge sort divides an array into two halves, recursively sorts each half, and merges sorted subarrays to produce a fully sorted array in C++.

Learn how linear search, a simple sequential algorithm, finds a key in an array or list by checking elements from start to finish, returning the index or -1.

Learn binary search on a sorted array with iterative and recursive implementations, using left, right, and mid indices to locate a key efficiently while honoring the preconditions.

Explore interpolation search and compare it with binary and linear search, using sorted arrays, index calculations, and performance trade-offs in data structures with c++, zero to hero.

Explore hashing in data structures with C++, learn hash functions, hash table design, division method, and collision resolution with linear proving, quadratic proving, and chaining.