TRT
Sign in

topic / algorithms

Algorithms

How algorithms and data structures spend time and memory, explained from zero.

Start from your first array and pointer and grow toward hash tables, trees, graphs, and modern C++ memory tools. Every idea ties to the costs the machine pays: comparisons, memory accesses, allocations, and cache misses.

  • 13 articles
  • 0 videos
  • 8 traces
  • 7 flows
  • 1 interviews
  • 29 total

Articles

algorithms

C++ Concurrency: Threads and Atomics

Learn how std::thread, std::mutex, and std::atomic share work safely, with the same programs in C++, Java, and Python.

4 min readRead article
algorithms

Move Semantics and Rvalue References

How std::move and rvalue references transfer ownership instead of copying, and when move constructors run.

4 min readRead article
algorithms

RAII and Smart Pointers

How Resource Acquisition Is Initialization prevents memory leaks, and how unique_ptr, shared_ptr, and weak_ptr manage ownership.

4 min readRead article
algorithms

Recursion: Functions Calling Themselves

How a function can solve a problem by delegating a smaller version of the same problem to itself, the call stack, and common pitfalls.

9 min readRead article
algorithms

Stack vs Heap: Where Memory Lives

Understand the difference between stack memory (fast, automatic) and heap memory (dynamic allocation), and when to use each.

4 min readRead article
algorithms

STL Containers and Algorithms

How std::vector, std::map, std::unordered_map, iterators, and the standard algorithm functions fit together, with code in three languages.

3 min readRead article
algorithms

Algorithms Are Procedures With Costs

Learn to connect an algorithm's correctness argument to the comparisons, branches, and memory accesses it performs.

7 min readRead article
algorithms

Arrays and Linked Lists: Cost Follows Access Pattern

Compare arrays and linked lists by memory layout, indexing cost, insertion cost, and cache behavior, with concrete numbers.

5 min readRead article
algorithms

A Practical Method for Analyzing Algorithms

An analysis begins by naming the input size and the operation whose growth matters.

5 min readRead article
algorithms

Representing a Graph Before Traversing It

Learn how vertices and edges model relationships, how to pick adjacency lists or matrices, and how BFS, DFS, and Dijkstra differ.

5 min readRead article
algorithms

Hash Tables: From Keys to Buckets

How hash tables turn keys into bucket positions, handle collisions, and stay fast through resizing, with concrete numbers.

5 min readRead article
algorithms

Choosing a Search or Sorting Strategy

Search and sorting choices depend on what is already known about the data and what operations the product needs.

5 min readRead article
algorithms

Trees and Heaps Solve Different Ordering Problems

Learn how search trees keep keys ordered in O(log n) height and how heaps expose the extreme element in O(1), with code in three languages.

5 min readRead article

Request flows

request flow · 5 stagesC++ Memory LayoutVisual map of C++ memory segments: text (code), data (globals), heap (dynamic), and stack (locals).request flow · 5 stagesArray Indexing Against Linked List WalkingFollow one read at position 3 through contiguous slots and pointer hops to see why layout decides speed.request flow · 5 stagesCounting Steps From a 4-by-4 Grid to Big-OCount 16 runs in nested loops, watch a halving loop shrink, and separate worst case from average and amortized cost.request flow · 5 stagesBreadth-First Search in Queue OrderWalk four vertices from source 0 in rings, mark at enqueue time, and record fewest-edge distances.request flow · 5 stagesA Hash Lookup From Key to Verified ValueHash amy to slot 5, collide with bob, probe to slot 6, and see why load factor forces an early resize.request flow · 5 stagesScan Once or Sort Once, Then SearchFind 8 in a five-element array by scan and by binary search, and learn when each plan wins.request flow · 5 stagesHeap for the Top, Tree for Any KeyPush 1 onto a heap and find 4 in a search tree to feel single-path repair and comparison-guided search.

Videos

// empty

No videos yet

Video coverage for this topic is planned. Watch the library page for updates.

Browse videos

Traces

trace 01 · applicationTrace an Array InsertionFollow an array insertion from capacity check through resize, element shift, and write, showing why middle insertion is O(n).trace 02 · applicationTrace a Recursive FactorialFollow factorial(5) from the initial call through five stack frames, the base case at factorial(0), and the return unwinding that produces 120.trace 03 · runtimeTrace an Array Read Against a Linked List WalkCompare reading array index 3 in one step with walking four linked nodes, and see why scans favor arrays.trace 04 · runtimeTrace Counting Steps on a 4-by-4 GridCount 16 body runs in nested loops, then contrast with a halving loop to see where n-squared and n log n come from.trace 05 · runtimeTrace Breadth-First Search Across Four VerticesRun BFS from vertex 0 over edges to 1, 2, and 3, watch the queue order, and record each distance.trace 06 · runtimeTrace Inserting amy Where Slot 5 Is TakenHash amy to slot 5, collide with bob, probe to slot 6, and see why the table doubles before it fills.trace 07 · runtimeTrace Finding 8 by Scan and by Binary SearchSearch [2, 4, 6, 8, 10] for 8 both ways: five reads by scan, two probes by binary search, and the boundary rules.trace 08 · runtimeTrace Pushing 1 Onto a Heap and Finding 4 in a TreeSift 1 up the heap [3, 5, 4], then walk a search tree down to 4, and feel why each follows one path.

Interviews

Explore adjacent

operating systemsdatabases