DSA

Move every disk from A to C. Move only one top disk at a time, and never place a larger disk on a smaller one. Study the recursive trace or solve the puzzle yourself.

02Sorting

Merge sort

Split the range into smaller halves, then merge sorted halves with an auxiliary buffer.

03Sorting

Quick sort

Use the last value as a pivot. Partition the range so smaller-or-equal values precede the pivot, then recursively sort both sides.

04Sorting

Heap sort

Build a max heap, repeatedly exchange the root with the last active value, then restore the heap in the reduced range.

05Sorting

Counting sort

Count each nonnegative integer value, then write values back in increasing order. This version reconstructs values from frequencies; it does not preserve associated records.

06Array patterns

Two pointers / pair sum

On a sorted copy, move the left or right pointer according to the pair sum. The target is a required sum, not a value to locate.

07Array patterns

Fixed sliding window

Find the maximum sum of exactly k consecutive values. Add the incoming value and subtract the outgoing value instead of rebuilding every sum.

08Array patterns

Variable sliding window

Find the shortest consecutive subarray whose sum is at least a positive target. This shrinking-window strategy here is restricted to nonnegative input values.

09Array patterns

Kadane’s algorithm

Find a maximum-sum nonempty subarray. At each value, choose whether to extend the previous candidate or start again here. Signed input is allowed for this lesson.

10Array patterns

Merge intervals

Sort intervals by start, then merge each overlap with the active result. Intervals that merely touch are merged in this demo.

11Data structures

Linked lists

Follow next links from the head. Values need not live next to each other in memory, so index access requires traversal.

12Data structures

Hash tables & collisions

Map each nonnegative key to key mod 5. Store colliding keys in a bucket chain. The table shows why collisions need an explicit policy.

13Data structures

Min heaps / priority queues

Insert values into a binary min heap, then extract the minimum. Heap order is local: every parent is no larger than its children; the array need not be globally sorted.

14Trees

Binary search trees

Insert each distinct value by comparing with the current node. Smaller values go left; larger values go right. This demo ignores duplicate insertions.

15Trees

Inorder traversal

Build the example BST, then visit its nodes in left → node → right order. The call stack shows the recursion that makes the order work.

16Trees

Preorder traversal

Build the example BST, then visit its nodes in node → left → right order. The call stack shows the recursion that makes the order work.

17Trees

Postorder traversal

Build the example BST, then visit its nodes in left → right → node order. The call stack shows the recursion that makes the order work.

18Graphs

Breadth-first search

Explore a fixed undirected graph from a selected source. A FIFO frontier visits vertices in increasing unweighted distance from that source. Neighbours are considered in increasing vertex order.

19Graphs

Depth-first search

Explore a fixed undirected graph by following an unvisited neighbour as far as possible before returning. Neighbours are considered in increasing vertex order.

20Dynamic programming

Fibonacci / memoisation

Build Fibonacci numbers from the base cases and reuse each earlier result rather than recomputing a recursion tree. This bottom-up demo keeps the whole table.

21Greedy algorithms

Greedy interval scheduling

Choose a maximum-size set of non-overlapping fixed activities. Sort by finish time, then take the next activity that starts at or after the previous finish.

22Bit techniques

Binary exponentiation

Compute a nonnegative whole-number power by repeatedly halving the exponent. Multiply the result by the current base when the low bit of the exponent is 1.