Data Structure - Part I

Explore arrays and their index-based access, learn how values are stored and retrieved, and see how to insert and print names within an array.

Explore the add method for a list data structure, covering insertion at specific indices, dynamic resizing, element pointers, and maintaining size while adding new elements.

Learn how the add method handles list sizing and indexing, fix bugs, and manage internal state without leaking implementation details to users.

Remove an item from a list by locating its index and shifting surrounding elements. Explore copying remaining elements and updating the structure for efficiency and correct ordering.

Mastering unit testing for a dynamic list by implementing remove, add, and get methods, using pointer-based data copying from right to left and size/index tests.

Explore linked lists, where head and last element connect via next references; learn why inserting at index 0 or deleting elements is costly, and understand singly and doubly linked variants.

Explore the add method for a data structure by adding a new element and updating the next reference.

Insert an element into a linked list at a fixed position, updating node references and next pointers so the new item sits at the target position and preserves list order.

Explore how to implement the remove method for a data structure, focusing on managing element references and removing elements from the list.

Master the remove method (part 2) in data structures by updating and nullifying references to safely detach nodes and prevent invalid references in pointer-based structures.

Explore the circle elimination problem by modeling people standing in a circle and removing participants until one remains, and discuss tracking eliminations to identify the last survivor.

Learn how to implement a problem’s solution by constructing it from the first element, moving pointers, and evaluating alternative approaches, with emphasis on selecting the appropriate data structure.

Explore how a stack stores items with lifo access and how to push and pop elements. Understand how overflow and underflow occur and how to implement a stack from scratch.

Explore how to use a stack to convert infix expressions to postfix, handle operator precedence, and evaluate expressions efficiently, comparing postfix readability with infix clarity.

Explore infix to postfix conversion using a stack, detailing operator precedence, parentheses handling, and the steps to transform expressions for efficient evaluation.

Implement infix to postfix conversion of expressions using a stack in part 1, applying operator precedence rules, and build a custom stack solution rather than relying on libraries.

Learn to convert infix expressions to postfix using a stack, respecting operator precedence, and implement the algorithm with code to evaluate the resulting expression.

Master postfix evaluation by using a stack to push operands, pop two values, apply operators, and compute the final result through a clear, step-by-step example.

Implement postfix expression evaluation using a stack, convert infix to postfix step by step, and apply operators to operands to compute the final result.

Assess time and space complexity to measure a program's efficiency as input size grows in data structure design. Compare different implementations and predict performance on real hardware.

Measure how time complexity grows with input size and compare algorithms by processing steps. Identify linear complexity and relate input size to program performance.

Explore time complexity concepts, including binary search and logarithms, and how divide-and-conquer strategies scale with input size in data structures.

Explains measuring time complexity with best and worst cases, exploring traveling salesman problem and factorial growth. Illustrates how problem size affects complexity, using logarithms and Khan Academy as review resources.

Analyzes how to measure code complexity by examining line costs, assignments, and for loops to contrast constant and growing costs.

Explore how core operations determine algorithm cost and how the highest-order term dominates complexity, with constant, square, and exponential growth examples.

Explore code analysis by tracing loops and recurrence patterns, measuring iterations as values are halved or raised to powers, and predicting printed outputs and overall complexity.