{
  "name": "DSA · Reimagined",
  "description": "Data structures & algorithms visualized correct-by-construction — the picture is a pure function of the real data. Each visualization exposes its full deterministic run as JSON.",
  "version": 1,
  "count": 50,
  "categories": [
    {
      "key": "Arrays",
      "blurb": "The contiguous line — index, insert, delete, rotate, window.",
      "visualizations": [
        {
          "slug": "array-traverse",
          "title": "Traverse an Array",
          "tagline": "Walk every element left to right.",
          "difficulty": "intro",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/array-traverse",
          "run": "/dsa-viz-v2/array-traverse.json"
        },
        {
          "slug": "array-insert",
          "title": "Insert into an Array",
          "tagline": "Open a gap, then drop the value in.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/array-insert",
          "run": "/dsa-viz-v2/array-insert.json"
        },
        {
          "slug": "array-delete",
          "title": "Delete from an Array",
          "tagline": "Remove one, and watch the gap close.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/array-delete",
          "run": "/dsa-viz-v2/array-delete.json"
        },
        {
          "slug": "array-reverse",
          "title": "Reverse an Array",
          "tagline": "Two pointers walk inward, trading ends.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/array-reverse",
          "run": "/dsa-viz-v2/array-reverse.json"
        },
        {
          "slug": "rotate-array",
          "title": "Rotate an Array",
          "tagline": "Shift every element left by k — with three reversals.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/rotate-array",
          "run": "/dsa-viz-v2/rotate-array.json"
        },
        {
          "slug": "dutch-national-flag",
          "title": "Dutch National Flag",
          "tagline": "Sort 0s, 1s and 2s in a single pass, three pointers.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/dutch-national-flag",
          "run": "/dsa-viz-v2/dutch-national-flag.json"
        },
        {
          "slug": "prefix-sum",
          "title": "Prefix Sum",
          "tagline": "Turn an array into running totals — in place.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/prefix-sum",
          "run": "/dsa-viz-v2/prefix-sum.json"
        },
        {
          "slug": "kadane",
          "title": "Kadane's Algorithm",
          "tagline": "Find the largest-sum contiguous subarray in one pass.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/kadane",
          "run": "/dsa-viz-v2/kadane.json"
        },
        {
          "slug": "sliding-window",
          "title": "Sliding Window (Max Sum)",
          "tagline": "Slide a fixed window to find the largest sum of k in a row.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/sliding-window",
          "run": "/dsa-viz-v2/sliding-window.json"
        },
        {
          "slug": "move-zeroes",
          "title": "Move Zeroes",
          "tagline": "Push every zero to the end, keeping order — in place.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/move-zeroes",
          "run": "/dsa-viz-v2/move-zeroes.json"
        }
      ]
    },
    {
      "key": "Strings",
      "blurb": "Text is a sequence of characters — scan it, reverse it, test it.",
      "visualizations": [
        {
          "slug": "palindrome-check",
          "title": "Palindrome Check",
          "tagline": "Two pointers close in — do the ends always match?",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/palindrome-check",
          "run": "/dsa-viz-v2/palindrome-check.json"
        },
        {
          "slug": "reverse-string",
          "title": "Reverse a String",
          "tagline": "Swap the ends inward until the whole word flips.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/reverse-string",
          "run": "/dsa-viz-v2/reverse-string.json"
        }
      ]
    },
    {
      "key": "Searching",
      "blurb": "Find a value or a pair — scan, halve the range, or converge.",
      "visualizations": [
        {
          "slug": "linear-search",
          "title": "Linear Search",
          "tagline": "Check each element until the key turns up.",
          "difficulty": "intro",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/linear-search",
          "run": "/dsa-viz-v2/linear-search.json"
        },
        {
          "slug": "binary-search",
          "title": "Binary Search",
          "tagline": "Halve the range each step — discard the half that can’t hold the key.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(log n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/binary-search",
          "run": "/dsa-viz-v2/binary-search.json"
        },
        {
          "slug": "two-sum-sorted",
          "title": "Two Sum (Sorted)",
          "tagline": "Two pointers close in from both ends to hit the target.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/two-sum-sorted",
          "run": "/dsa-viz-v2/two-sum-sorted.json"
        }
      ]
    },
    {
      "key": "Sorting",
      "blurb": "Bring order out of chaos — from simple swaps to merge & heap.",
      "visualizations": [
        {
          "slug": "bubble-sort",
          "title": "Bubble Sort",
          "tagline": "Adjacent swaps float the biggest value to the end each pass.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n²)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/bubble-sort",
          "run": "/dsa-viz-v2/bubble-sort.json"
        },
        {
          "slug": "selection-sort",
          "title": "Selection Sort",
          "tagline": "Find the smallest, send it to the front, repeat.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n²)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/selection-sort",
          "run": "/dsa-viz-v2/selection-sort.json"
        },
        {
          "slug": "insertion-sort",
          "title": "Insertion Sort",
          "tagline": "Grow a sorted prefix; slide each new value back into place.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n²)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/insertion-sort",
          "run": "/dsa-viz-v2/insertion-sort.json"
        },
        {
          "slug": "merge-sort",
          "title": "Merge Sort",
          "tagline": "Split to single elements, then merge halves through a buffer.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n log n)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/merge-sort",
          "run": "/dsa-viz-v2/merge-sort.json"
        },
        {
          "slug": "quick-sort",
          "title": "Quick Sort",
          "tagline": "Partition around a pivot, then recurse on each side.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n log n) avg",
            "space": "O(log n)"
          },
          "page": "/dsa-viz-v2/quick-sort",
          "run": "/dsa-viz-v2/quick-sort.json"
        },
        {
          "slug": "heap-sort",
          "title": "Heap Sort",
          "tagline": "Build a max-heap in the array, then pull the max to the end, repeat.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(n log n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/heap-sort",
          "run": "/dsa-viz-v2/heap-sort.json"
        },
        {
          "slug": "counting-sort",
          "title": "Counting Sort",
          "tagline": "Tally each value, then place them all in order — no comparisons.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n + k)",
            "space": "O(n + k)"
          },
          "page": "/dsa-viz-v2/counting-sort",
          "run": "/dsa-viz-v2/counting-sort.json"
        },
        {
          "slug": "radix-sort",
          "title": "Radix Sort",
          "tagline": "Stably sort by each digit, least-significant first.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(d · (n + b))",
            "space": "O(n + b)"
          },
          "page": "/dsa-viz-v2/radix-sort",
          "run": "/dsa-viz-v2/radix-sort.json"
        }
      ]
    },
    {
      "key": "Stacks & Queues",
      "blurb": "Order of arrival — last in first out, or first in first out.",
      "visualizations": [
        {
          "slug": "stack-push-pop",
          "title": "Stack — Push & Pop",
          "tagline": "Last in, first out — everything happens at the top.",
          "difficulty": "intro",
          "complexity": {
            "time": "O(1) per op",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/stack-push-pop",
          "run": "/dsa-viz-v2/stack-push-pop.json"
        },
        {
          "slug": "queue-enqueue-dequeue",
          "title": "Queue — Enqueue & Dequeue",
          "tagline": "First in, first out — join at the back, leave from the front.",
          "difficulty": "intro",
          "complexity": {
            "time": "O(1) amortised",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/queue-enqueue-dequeue",
          "run": "/dsa-viz-v2/queue-enqueue-dequeue.json"
        },
        {
          "slug": "monotonic-stack",
          "title": "Monotonic Stack — Next Greater",
          "tagline": "One pass, one stack: find each value’s next greater neighbour.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(n)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/monotonic-stack",
          "run": "/dsa-viz-v2/monotonic-stack.json"
        }
      ]
    },
    {
      "key": "Linked Lists",
      "blurb": "Nodes joined by pointers — rewire instead of shifting.",
      "visualizations": [
        {
          "slug": "linked-list-traverse",
          "title": "Traverse a Linked List",
          "tagline": "Follow next pointers from head to ∅.",
          "difficulty": "intro",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/linked-list-traverse",
          "run": "/dsa-viz-v2/linked-list-traverse.json"
        },
        {
          "slug": "linked-list-insert",
          "title": "Insert into a Linked List",
          "tagline": "Rewire two pointers — nothing shifts.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(1) at a known node",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/linked-list-insert",
          "run": "/dsa-viz-v2/linked-list-insert.json"
        },
        {
          "slug": "linked-list-delete",
          "title": "Delete from a Linked List",
          "tagline": "Point past the node — it simply drops out of the chain.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(1) at a known node",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/linked-list-delete",
          "run": "/dsa-viz-v2/linked-list-delete.json"
        },
        {
          "slug": "linked-list-reverse",
          "title": "Reverse a Linked List",
          "tagline": "Move each node, one at a time, to the front of a new list.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/linked-list-reverse",
          "run": "/dsa-viz-v2/linked-list-reverse.json"
        }
      ]
    },
    {
      "key": "Hashing",
      "blurb": "Turn a key into a slot — and handle the collisions.",
      "visualizations": [
        {
          "slug": "hash-linear-probing",
          "title": "Hash Table — Linear Probing",
          "tagline": "h(k) picks a slot; if it’s taken, walk forward until one is free.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(1) average",
            "space": "O(m)"
          },
          "page": "/dsa-viz-v2/hash-linear-probing",
          "run": "/dsa-viz-v2/hash-linear-probing.json"
        },
        {
          "slug": "hash-chaining",
          "title": "Hash Table — Chaining",
          "tagline": "Every bucket holds a little list; collisions just grow a chain.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(1) average",
            "space": "O(n + m)"
          },
          "page": "/dsa-viz-v2/hash-chaining",
          "run": "/dsa-viz-v2/hash-chaining.json"
        }
      ]
    },
    {
      "key": "Trees",
      "blurb": "Branching structure — search trees, traversals and heaps.",
      "visualizations": [
        {
          "slug": "bst-insert",
          "title": "BST — Insert",
          "tagline": "Smaller keys go left, larger go right — every key finds one path.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(h)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/bst-insert",
          "run": "/dsa-viz-v2/bst-insert.json"
        },
        {
          "slug": "bst-search",
          "title": "BST — Search",
          "tagline": "One comparison per level throws away half the tree.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(h)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/bst-search",
          "run": "/dsa-viz-v2/bst-search.json"
        },
        {
          "slug": "bst-inorder",
          "title": "In-order Traversal",
          "tagline": "Left, node, right — and the keys come out sorted.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(h)"
          },
          "page": "/dsa-viz-v2/bst-inorder",
          "run": "/dsa-viz-v2/bst-inorder.json"
        },
        {
          "slug": "bst-delete",
          "title": "BST — Delete",
          "tagline": "Leaf, one child, or two — the third case needs a successor.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(h)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/bst-delete",
          "run": "/dsa-viz-v2/bst-delete.json"
        },
        {
          "slug": "heap-build",
          "title": "Build a Max-Heap",
          "tagline": "Sift every parent down until each one outranks its children.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/heap-build",
          "run": "/dsa-viz-v2/heap-build.json"
        },
        {
          "slug": "heap-pop",
          "title": "Heap — Extract Max",
          "tagline": "Take the root, move the last node up, and sink it back down.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(log n)",
            "space": "O(1)"
          },
          "page": "/dsa-viz-v2/heap-pop",
          "run": "/dsa-viz-v2/heap-pop.json"
        }
      ]
    },
    {
      "key": "Graphs",
      "blurb": "A web of nodes and edges — traverse it, order it, find the cheapest way.",
      "visualizations": [
        {
          "slug": "graph-bfs",
          "title": "Breadth-First Search",
          "tagline": "Explore ring by ring, using a queue.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(V + E)",
            "space": "O(V)"
          },
          "page": "/dsa-viz-v2/graph-bfs",
          "run": "/dsa-viz-v2/graph-bfs.json"
        },
        {
          "slug": "graph-dfs",
          "title": "Depth-First Search",
          "tagline": "Follow one path as deep as it goes, then back up.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(V + E)",
            "space": "O(V)"
          },
          "page": "/dsa-viz-v2/graph-dfs",
          "run": "/dsa-viz-v2/graph-dfs.json"
        },
        {
          "slug": "topological-sort",
          "title": "Topological Sort",
          "tagline": "Order tasks so every arrow points forward.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(V + E)",
            "space": "O(V)"
          },
          "page": "/dsa-viz-v2/topological-sort",
          "run": "/dsa-viz-v2/topological-sort.json"
        },
        {
          "slug": "dijkstra",
          "title": "Dijkstra’s Shortest Path",
          "tagline": "Always expand the closest unsettled node.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(E log V)",
            "space": "O(V)"
          },
          "page": "/dsa-viz-v2/dijkstra",
          "run": "/dsa-viz-v2/dijkstra.json"
        },
        {
          "slug": "mst-kruskal",
          "title": "Minimum Spanning Tree (Kruskal)",
          "tagline": "Take the cheapest edge that doesn’t close a cycle.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(E log E)",
            "space": "O(V)"
          },
          "page": "/dsa-viz-v2/mst-kruskal",
          "run": "/dsa-viz-v2/mst-kruskal.json"
        }
      ]
    },
    {
      "key": "Recursion & DP",
      "blurb": "Branch and backtrack — then stop repeating yourself with a table.",
      "visualizations": [
        {
          "slug": "recursion-fibonacci",
          "title": "Recursion — Fibonacci Call Tree",
          "tagline": "Watch the same subproblem get solved again and again.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(2ⁿ)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/recursion-fibonacci",
          "run": "/dsa-viz-v2/recursion-fibonacci.json"
        },
        {
          "slug": "subsets-backtracking",
          "title": "Backtracking — All Subsets",
          "tagline": "Every element: take it or leave it. Each path spells a subset.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(2ⁿ)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/subsets-backtracking",
          "run": "/dsa-viz-v2/subsets-backtracking.json"
        },
        {
          "slug": "n-queens",
          "title": "Backtracking — N-Queens",
          "tagline": "Place a queen per row; retreat the moment it cannot work.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(n!)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/n-queens",
          "run": "/dsa-viz-v2/n-queens.json"
        },
        {
          "slug": "dp-fibonacci",
          "title": "DP — Fibonacci Table",
          "tagline": "The same answer in n steps instead of 2ⁿ calls.",
          "difficulty": "easy",
          "complexity": {
            "time": "O(n)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/dp-fibonacci",
          "run": "/dsa-viz-v2/dp-fibonacci.json"
        },
        {
          "slug": "coin-change",
          "title": "DP — Coin Change",
          "tagline": "Fewest coins for every amount up to the target.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(amount × coins)",
            "space": "O(amount)"
          },
          "page": "/dsa-viz-v2/coin-change",
          "run": "/dsa-viz-v2/coin-change.json"
        },
        {
          "slug": "lis",
          "title": "DP — Longest Increasing Subsequence",
          "tagline": "For each element, the best chain that ends there.",
          "difficulty": "medium",
          "complexity": {
            "time": "O(n²)",
            "space": "O(n)"
          },
          "page": "/dsa-viz-v2/lis",
          "run": "/dsa-viz-v2/lis.json"
        },
        {
          "slug": "edit-distance",
          "title": "DP — Edit Distance",
          "tagline": "Fewest insert / delete / replace steps between two words.",
          "difficulty": "hard",
          "complexity": {
            "time": "O(m × n)",
            "space": "O(m × n)"
          },
          "page": "/dsa-viz-v2/edit-distance",
          "run": "/dsa-viz-v2/edit-distance.json"
        }
      ]
    }
  ]
}