SimuVeda
Open the lab

Computer science / interactive lab

Make every step
make sense.

92 algorithms and interview patterns, animated one step at a time. Type your own input, scrub backwards and forwards, and follow the Java code as each line runs. Then check yourself with a short quiz.

  • No sign-up
  • Java code for every algorithm
  • Works on phones
Live–

Pick an algorithm or shuffle the values. Open it with code and controls →
New · BetaRun your own codeWrite a small program and watch what it really does, line by line.

Explore

Every algorithm, step by step

Each one runs on your input, highlights the Java line being executed, and explains the idea, the complexity and the interview angle.

Learning paths

Not sure where to start? Follow a path

Each path strings algorithms together in an order that builds on itself. The lab shows your place and the next step.

Big-O playground

Feel how fast each complexity grows

Drag n and watch the curves pull apart. Hover the chart to read every curve at one n. The table turns the counts into real time at a billion simple steps per second.

    Cheat sheet

    Every complexity on one page

    Best, average and worst time plus extra space for every algorithm in the lab. Filter it, sort it, and click a name to watch it run.

    BestAverageWorstSpace
    Bubble sortSortingBeginnerO(n)O(n²)O(n²)O(1)
    Selection sortSortingBeginnerO(n²)O(n²)O(n²)O(1)
    Insertion sortSortingBeginnerO(n)O(n²)O(n²)O(1)
    Shell sort NewSortingIntermediateO(n log n)O(n^1.3)O(n²)O(1)
    Merge sortSortingIntermediateO(n log n)O(n log n)O(n log n)O(n)
    Quick sortSortingIntermediateO(n log n)O(n log n)O(n²)O(log n)
    Heap sortSortingAdvancedO(n log n)O(n log n)O(n log n)O(1)
    Counting sortSortingIntermediateO(n + k)O(n + k)O(n + k)O(k)
    Radix sort (LSD)SortingIntermediateO(d·(n + 10))O(d·(n + 10))O(d·(n + 10))O(n + 10)
    Linear searchSearchingBeginnerO(1)O(n)O(n)O(1)
    Jump search NewSearchingBeginnerO(1)O(√n)O(√n)O(1)
    Binary searchSearchingBeginnerO(1)O(log n)O(log n)O(1)
    Search in a rotated sorted array NewSearchingIntermediateO(1)O(log n)O(log n)O(1)
    First and last position of a value NewSearchingIntermediateO(log n)O(log n)O(log n)O(1)
    Search a sorted 2D matrix NewSearchingIntermediateO(1)O(r + c)O(r + c)O(1)
    Median of two sorted arrays NewSearchingIntermediateO(1)O(log min(m, n))O(log min(m, n))O(1)
    Reverse a linked listLists, stacks & queuesBeginnerO(n)O(n)O(n)O(1)
    Floyd's cycle detectionLists, stacks & queuesIntermediateO(n)O(n)O(n)O(1)
    Remove the Nth node from the end NewLists, stacks & queuesIntermediateO(n)O(n)O(n)O(1)
    Merge two sorted linked lists NewLists, stacks & queuesIntermediateO(n + m)O(n + m)O(n + m)O(1)
    Stack: valid parenthesesLists, stacks & queuesBeginnerO(n)O(n)O(n)O(n)
    Min stack NewLists, stacks & queuesIntermediateO(1)O(1)O(1)O(n)
    Queue using two stacks NewLists, stacks & queuesIntermediateO(1)O(1)*O(n)O(n)
    Circular queue (ring buffer) NewLists, stacks & queuesIntermediateO(1)O(1)O(1)O(k)
    LRU cache (hash map + linked list) NewLists, stacks & queuesIntermediateO(1)O(1)O(1)O(capacity)
    BST insertTreesBeginnerO(log n)O(log n)O(n)O(h)
    BST searchTreesBeginnerO(log n)O(log n)O(n)O(h)
    BST deleteTreesIntermediateO(log n)O(log n)O(n)O(h)
    Inorder traversalTreesBeginnerO(n)O(n)O(n)O(h)
    Preorder traversalTreesBeginnerO(n)O(n)O(n)O(h)
    Postorder traversalTreesBeginnerO(n)O(n)O(n)O(h)
    Level-order traversalTreesBeginnerO(n)O(n)O(n)O(w)
    Maximum depth of a tree NewTreesBeginnerO(n)O(n)O(n)O(h)
    Lowest common ancestor in a BST NewTreesIntermediateO(log n)O(log n)O(n)O(1)
    Invert a binary tree NewTreesIntermediateO(n)O(n)O(n)O(h)
    Validate a binary search tree NewTreesIntermediateO(n)O(n)O(n)O(h)
    Min-heap insertTreesIntermediateO(1)O(log n)O(log n)O(n)
    Min-heap extractTreesIntermediateO(log n)O(log n)O(log n)O(n)
    Kth largest element (min-heap of size k) NewTreesIntermediateO(n log k)O(n log k)O(n log k)O(k)
    AVL tree insertTreesAdvancedO(log n)O(log n)O(log n)O(n)
    Trie (prefix tree)TreesAdvancedO(L)O(L)O(L)O(total letters)
    Breadth-first searchGraphsBeginnerO(V+E)O(V+E)O(V+E)O(V)
    Depth-first searchGraphsBeginnerO(V+E)O(V+E)O(V+E)O(V)
    Dijkstra's shortest pathGraphsAdvancedO((V+E) log V)O((V+E) log V)O((V+E) log V)O(V)
    Bellman-Ford shortest pathGraphsAdvancedO(V·E)O(V·E)O(V·E)O(V)
    Floyd-Warshall all-pairs shortest paths NewGraphsAdvancedO(V³)O(V³)O(V³)O(V²)
    Topological sort (Kahn)GraphsIntermediateO(V + E)O(V + E)O(V + E)O(V)
    Detect a cycle in a directed graph NewGraphsIntermediateO(V + E)O(V + E)O(V + E)O(V)
    Union-Find (disjoint sets) NewGraphsAdvancedO(α(n))O(α(n))O(α(n))O(V)
    Kruskal's minimum spanning treeGraphsAdvancedO(E log E)O(E log E)O(E log E)O(V)
    Prim's minimum spanning treeGraphsAdvancedO(E log V)O(E log V)O(E log V)O(V + E)
    Number of islands (flood fill)GraphsIntermediateO(R·C)O(R·C)O(R·C)O(R·C)
    Sliding window (fixed size)PatternsBeginnerO(n)O(n)O(n)O(1)
    Sliding window (variable size)PatternsIntermediateO(n)O(n)O(n)O(1)
    Two pointers (opposite ends)PatternsBeginnerO(1)O(n)O(n)O(1)
    Container with most waterPatternsIntermediateO(n)O(n)O(n)O(1)
    Trapping rain waterPatternsAdvancedO(n)O(n)O(n)O(1)
    Fast and slow pointersPatternsBeginnerO(n)O(n)O(n)O(1)
    Kadane's algorithmPatternsIntermediateO(n)O(n)O(n)O(1)
    Prefix sum + hash mapPatternsAdvancedO(n)O(n)O(n)O(n)
    Monotonic stackPatternsIntermediateO(n)O(n)O(n)O(n)
    Dutch national flagPatternsIntermediateO(n)O(n)O(n)O(1)
    Boyer-Moore majority vote NewPatternsIntermediateO(n)O(n)O(n)O(1)
    Best time to buy and sell stock NewPatternsIntermediateO(n)O(n)O(n)O(1)
    Product of array except self NewPatternsIntermediateO(n)O(n)O(n)O(1)
    Rotate an array by k NewPatternsIntermediateO(n)O(n)O(n)O(1)
    Merge two sorted arrays NewPatternsIntermediateO(n + m)O(n + m)O(n + m)O(n + m)
    Sliding window maximum NewPatternsIntermediateO(n)O(n)O(n)O(k)
    Hash table with chainingHashingBeginnerO(1)O(1)O(n)O(n + m)
    Two Sum with a hash mapHashingBeginnerO(1)O(n)O(n)O(n)
    Longest substring without repeats NewHashingIntermediateO(n)O(n)O(n)O(k)
    Valid anagram NewHashingIntermediateO(n)O(n)O(n)O(1)
    Group anagrams NewHashingIntermediateO(n·k log k)O(n·k log k)O(n·k log k)O(n·k)
    Fibonacci with memoization NewDynamic programmingIntermediateO(n)O(n)O(n)O(n)
    1D DP: climbing stairsDynamic programmingBeginnerO(n)O(n)O(n)O(n)
    1D DP: house robber NewDynamic programmingBeginnerO(n)O(n)O(n)O(n)
    1D DP: coin changeDynamic programmingIntermediateO(n·k)O(n·k)O(n·k)O(n)
    1D DP: longest increasing subsequenceDynamic programmingIntermediateO(n²)O(n²)O(n²)O(n)
    Word break NewDynamic programmingIntermediateO(n²)O(n²)O(n²)O(n)
    2D DP: unique paths with obstacles NewDynamic programmingIntermediateO(R·C)O(R·C)O(R·C)O(R·C)
    2D DP: 0/1 knapsackDynamic programmingAdvancedO(n·W)O(n·W)O(n·W)O(n·W)
    2D DP: longest common subsequenceDynamic programmingAdvancedO(m·n)O(m·n)O(m·n)O(m·n)
    2D DP: edit distanceDynamic programmingAdvancedO(m·n)O(m·n)O(m·n)O(m·n)
    Backtracking: subsetsBacktrackingIntermediateO(n·2ⁿ)O(n·2ⁿ)O(n·2ⁿ)O(n)
    Backtracking: permutations NewBacktrackingIntermediateO(n·n!)O(n·n!)O(n·n!)O(n)
    Backtracking: N-QueensBacktrackingAdvancedO(n!)O(n!)O(n!)O(n)
    Jump game NewGreedyIntermediateO(n)O(n)O(n)O(1)
    Interval scheduling (non-overlapping) NewGreedyIntermediateO(n log n)O(n log n)O(n log n)O(1)
    Count set bits (Kernighan) NewBit manipulationBeginnerO(1)O(k)O(k)O(1)
    Single number with XOR NewBit manipulationBeginnerO(n)O(n)O(n)O(1)
    Subsets with a bitmask NewBit manipulationIntermediateO(n·2ⁿ)O(n·2ⁿ)O(n·2ⁿ)O(1)

    How it works

    Watch it, then explain it

    1. Pick an algorithmSorting, trees, graphs, DP or one of the interview patterns. It starts playing straight away.
    2. Use your own inputType values, a graph, two words or a grid, or hit Random. Edge cases are the best teachers.
    3. Step through itPause, scrub backwards, slow down to ¼×. The matching Java line lights up on every step.
    4. Check yourselfEach topic ends with a quiz that explains the answers, so you can say why, not just what.

    Inside the lab

    Built for understanding, not memorising

    Every algorithm is easy once you have watched it run.