Skip to content

DataXForge data tools platform

Tools Categories Toolkits Guides Blog Notebook About

Free professional browser-based tools for data conversion, cleaning, validation, analysis, visualization, SQL, APIs, and dataset quality.

No accountBrowser-firstNo daily limit

Built by

Protik Das Utso

protikthedev@gmail.com WhatsApp: +8801883044415

Workflows

Toolkits
Problem guides
CSV templates
JSON tools
CSV tools
SQL tools
Cleaning tools
Visualization

Categories

Workspace
Transformation
Cleaning
Formatting
Validation
Visualization
Analysis
ETL
SQL & DB
Spreadsheets

Popular tools

JSON → CSV
CSV → JSON
JSON ↔ YAML
JSON Formatter
JSON Validator
XML → JSON
JSON → XML
Excel → CSV

DataXForge runs client-side where possible. Do not paste regulated production data into any web tool without your organization's approval.

About Tools Categories Toolkits Guides Templates Notebook Contact

© 2026 DataXForge. All rights reserved.

Privacy Policy Terms of Use

More on DataXForge

Toolkits Guides Templates Blog About Contact

Browse all tools

Home
Tools
Categories
Notebook

Back to categories

Algorithms

Animated data-structure and algorithm visualizers — sorting, pathfinding, trees, and more, step by step.

65 ready tools out of 65 listed in this workflow.

Visualizers

5

Sorting Algorithm VisualizerReadyWatch bubble, selection, insertion, merge, quick, and heap sort run step by step — animated bars, comparison and write counters, plain-English narration, and complexity cards.
Pathfinding VisualizerReadyDraw walls and weights on a grid, then watch BFS, DFS, Dijkstra, A*, and Greedy Best-First explore and find the shortest path — with step narration and visit-count comparisons.
Binary Search Tree VisualizerReadyInsert, delete, search, and traverse a BST, AVL tree (animated rotations with balance factors), or min-heap — every comparison narrated, every pointer move animated.
Data Structure PlaygroundReadyHands-on stack, queue, linked list, and hash table — every push, pop, pointer rewire, and collision narrated with its O(1)/O(n) cost, plus an interactive Big-O growth explorer.
Algorithm AcademyReady35+ classic algorithms animated step by step — searching, counting/radix/bucket sort, dynamic programming tables, greedy, backtracking, KMP, graph algorithms, max flow, and convex hull — with auto-play, next/prev stepping, adjustable interval, and pseudocode that highlights the running line.

Searching

2

Linear Search VisualizerReadyWatch linear search check each element one by one with a colored TRUE/FALSE verdict per probe, live pseudocode, and step-by-step narration.
Binary Search VisualizerReadyWatch binary search halve a sorted window each probe — lo/hi/mid pointers, TRUE/FALSE verdicts, live pseudocode, and your own numbers.

Sorting

7

Bubble Sort VisualizerReadyBubble sort animated with bars that lift and slide past each other on every swap, colored comparison verdicts, and running pseudocode.
Selection Sort VisualizerReadySelection sort animated: scan for the minimum with i/min pointers, slide it into place, and watch the sorted region grow — with counters and pseudocode.
Insertion Sort VisualizerReadyInsertion sort animated: watch the key lift out, larger values shift right, and the sorted prefix grow — with j/key pointers and live pseudocode.
Merge Sort VisualizerReadyMerge sort animated: runs split, then merge back as the smaller head wins each comparison — with lo/mid/hi pointers, counters, and pseudocode.
Quick Sort VisualizerReadyQuick sort animated: pivot highlighted, smaller values swapped into the left zone, pivot placed between — with i/p pointers, verdicts, and pseudocode.
Heap Sort VisualizerReadyHeap sort animated: build the max-heap, swap the root to the end, sift down — every comparison colored TRUE/FALSE with live pseudocode.
Counting Sort VisualizerReadyCounting sort animated: build the count array, then emit values in order with zero comparisons — buckets shown live with narration.

Graph

11

BFS VisualizerReadyBreadth-first search on a graph: the queue-driven frontier expands ring by ring with every discovery narrated — plus a grid version with walls.
DFS VisualizerReadyDepth-first search on a graph: the stack dives deep and backtracks, building a DFS tree — every push, pop, and visit narrated step by step.
Dijkstra's Algorithm VisualizerReadyDijkstra's shortest path animated: settle the closest node, relax its edges, watch distances improve — with a live distance table and pseudocode.
Bellman-Ford VisualizerReadyBellman-Ford animated: relax every edge V−1 rounds, watch distances converge, and see why a further improvement would prove a negative cycle.
Floyd-Warshall VisualizerReadyFloyd-Warshall animated: the all-pairs distance matrix updates as each node is allowed as a stopover — every improving triple shown in the table.
Prim's Algorithm VisualizerReadyPrim's minimum spanning tree animated: the tree grows by always taking the cheapest crossing edge — cut property in action with live narration.
Kruskal's Algorithm VisualizerReadyKruskal's MST animated: edges taken cheapest-first unless Union-Find detects a cycle — accepted edges green, rejected cycles red.
Topological Sort VisualizerReadyKahn's topological sort animated on a task DAG: in-degrees tick down, zero-degree tasks emit in order, and leftover nodes reveal a cycle.
Union-Find (DSU) VisualizerReadyDisjoint Set Union animated: union by rank merges trees, find compresses paths — parent and rank arrays shown live with every operation narrated.
Strongly Connected Components VisualizerReadyKosaraju's two DFS passes animated on a directed graph — finish order, reversed edges, and each component painted its own color.
Articulation Points & Bridges VisualizerReadyTarjan's low-link DFS animated: discovery times, low values, and every cut vertex and bridge — your graph's single points of failure — highlighted.

Network Flow

2

Ford-Fulkerson Max Flow VisualizerReadyMax flow animated: BFS finds augmenting paths, the bottleneck is pushed through, saturated edges turn red — ending at the min cut that equals the max flow.
Bipartite Matching VisualizerReadyMaximum matching by augmenting paths animated — free partners taken directly, occupied ones displaced along chains, one extra match per augmentation.

Greedy

4

Activity Selection VisualizerReadyThe classic greedy scheduling problem animated: sort by finish time, sweep, and select every compatible activity — with the exchange-argument intuition.
Huffman Coding VisualizerReadyHuffman coding animated on your own text: merge the two rarest symbols until one tree remains, read off the prefix codes, and see the compression ratio.
Fractional Knapsack VisualizerReadyGreedy by value density animated: take the densest items whole, split the last one — and see exactly why splitting is what makes greedy optimal here.
Job Sequencing VisualizerReadyGreedy job scheduling with deadlines animated: richest jobs first, each placed in the latest free slot before its deadline — rejections explained.

Dynamic Programming

8

0/1 Knapsack VisualizerReadyThe 0/1 knapsack DP table animated cell by cell: skip-or-take decisions with the exact cells each value reads from, ending at the optimal bottom-right answer.
LCS VisualizerReadyLongest Common Subsequence DP table animated: diagonal extensions on matches, max-of-neighbors otherwise, then the traceback that spells out the LCS.
Matrix Chain Multiplication VisualizerReadyInterval DP animated: every split point k tried for every chain window, the cost table fills diagonal by diagonal, and the optimal parenthesization emerges.
Coin Change VisualizerReadyFewest-coins DP animated — including the classic case where greedy fails (coins 1, 4, 5 for amount 8) and the table finds 4+4 instead.
Longest Palindromic Subsequence VisualizerReadyInterval DP animated on your own string: matching ends wrap the inner palindrome (+2), otherwise drop an end — the table fills window by window.
Rod Cutting VisualizerReadyThe classic revenue-maximization DP animated: every first-cut choice tried, best[L] built bottom-up, and the optimal cut list reconstructed.
Subset Sum & Partition VisualizerReadyBoolean DP animated: each number extends every reachable sum, answering subset-sum and equal-partition in pseudo-polynomial time.
Optimal BST VisualizerReadyInterval DP over search frequencies: every root tried per key range, expected lookup cost minimized — and the best root isn't always the hottest key.

Backtracking

5

N-Queens VisualizerReadyBacktracking animated on a chessboard: queens placed row by row, attacked squares pruned, and dead ends visibly undone until a solution appears.
Graph Coloring VisualizerReadyBacktracking graph coloring animated: nodes take real colors, clashes flash red, dead ends backtrack — exam scheduling and map coloring made visible.
Sudoku Solver VisualizerReadyBacktracking on a real 9×9 puzzle: digits tried, constraints checked, dead ends erased before your eyes until the grid completes.
Knight's Tour VisualizerReadyWatch a knight number every square exactly once — Warnsdorff's fewest-onward-moves rule turns an exponential backtracking search nearly instant.
Hamiltonian Cycle VisualizerReadyBacktracking search for a cycle through every node exactly once — extensions, dead ends, and the NP-complete reality animated on a real graph.

String Matching

4

Rabin-Karp VisualizerReadyRolling-hash pattern matching animated: window hashes compared in O(1) per slide, with genuine matches verified and spurious collisions exposed.
KMP Algorithm VisualizerReadyKnuth-Morris-Pratt animated: the failure table is built first, then mismatches slide the pattern instead of restarting — the text pointer never moves back.
Boyer-Moore VisualizerReadyRight-to-left matching with the bad-character rule animated — watch mismatches teach the pattern how far to jump, skipping text wholesale.
Z Algorithm VisualizerReadyThe z-array built in linear time — Z-boxes recycle earlier comparisons, and pattern$text turns prefix lengths into exact matches.

Foundations

2

Master Theorem VisualizerReadyRecurrences unrolled into recursion trees level by level — sum each level, compare log_b(a) with d, and read off the master-theorem case for merge sort, binary search, Strassen, and Karatsuba.
Best / Average / Worst Case VisualizerReadyThe same algorithm run on three input shapes — see Ω(1), Θ(n), and O(n) emerge from identical code, with the comparisons counted live.

Divide & Conquer

1

Strassen Multiplication VisualizerReadyWatch seven block products replace the naive eight — the M1…M7 formulas, the recombination, and the recurrence that lands at Θ(n^2.807).

Geometry

4

Closest Pair of Points VisualizerReadyDivide-and-conquer closest pair animated: split by x, best of both halves, then the δ-strip where each point checks at most 7 neighbors.
Jarvis March VisualizerReadyGift wrapping animated: from the leftmost point, sweep to the most counter-clockwise neighbor until the hull closes — O(n·h) made visible.
Segment Intersection VisualizerReadyDo two segments cross? Four CCW orientation tests answer it with no division — every pair tested and verdicts colored on the canvas.
Convex Hull VisualizerReadyMonotone-chain convex hull animated: points sorted by x, lower and upper chains built with pops on every clockwise turn.

Branch & Bound

2

TSP Branch & Bound VisualizerReadyExact travelling-salesman solving animated: partial tours extend depth-first while the bound prunes any branch that can't beat the best tour found.
Knapsack Branch & Bound VisualizerReady0/1 knapsack solved exactly with a fractional-relaxation bound — watch whole subtrees die the moment their optimistic bound can't beat the best.

Tree Structures

3

Trie VisualizerReadyA prefix tree growing word by word — shared prefixes stored once, word-ends marked, and every insert costing only the word's length.
Segment Tree VisualizerReadyBuild, range-query, and update animated on a real tree — ranges tile into O(log n) blocks and updates touch only the root path.
Fenwick Tree (BIT) VisualizerReadyThe trailing-bit trick animated: i & −i jumps for updates and prefix sums, each covering a doubling block — ten lines of code, O(log n) everything.

Randomized

2

Randomized Quicksort VisualizerReadyQuicksort with uniformly random pivots — the adversarial O(n²) input disappears, and expected O(n log n) holds for every input. Las Vegas in action.
Quickselect VisualizerReadyFind the k-th smallest without sorting: one partition, recurse into a single side, discard the rest — expected linear time animated.

Approximation

2

Vertex Cover Approximation VisualizerReadyThe classic 2-approximation animated: take both endpoints of uncovered edges and get a provable ≤2×OPT guarantee for an NP-hard problem.
Bin Packing VisualizerReadyFirst-Fit Decreasing animated: items sorted large-to-small drop into the first bin that fits — with the famous 11/9·OPT+1 guarantee explained.

NP-Completeness

1

SAT & P vs NP VisualizerReadyBrute-force SAT over a truth table — verification instant, search exponential — with the Cook-Levin story of why SAT anchors all of NP.