Data Structures and Algorithms: Merge Sort
Jonathan Lee Martin's Pro-tier deep-dive: about 1.1 hours coding six different merge sort implementations in JavaScript, the sorting-focused sibling of his binary search course.
Quick answer
Merge Sort is a 1.1-hour, Pro-tier, intermediate course taught by Jonathan Lee Martin. Like its binary search sibling, it goes deep on a single algorithm: you code six different merge sort implementations, each surfacing a lesson about writing clean, correct code. It is a narrow, deliberate deep-dive rather than a broad survey. Worth it if you want to study how to implement a sorting algorithm well, not just understand the idea.
Data Structures and Algorithms: Merge Sort
ProTaught by Jonathan Lee Martin (opens in a new tab)
Code six different merge sort implementations in JavaScript, each teaching a software-craftsmanship lesson.
View on Scrimba (opens in a new tab)Is it worth your time?
The format is the same depth-over-breadth idea as the binary search course: implementing merge sort six ways forces you to think about structure, edge cases, and readability rather than just getting a sort to run. If you already grasp the divide-and-conquer concept and want to write it well, this is a focused, instructive hour.
The honest caveat is that it is narrow and a touch repetitive by design. At 12 lessons it covers one algorithm, not a curriculum, and while it is rated Intermediate it still assumes you know what merge sort is. If you want broad algorithmic coverage, this is not the course for that.
What you'll learn
Across 12 lessons you implement merge sort six different ways in JavaScript. As with the binary search course, the variety is the point: each implementation highlights a different craftsmanship lesson, whether in how you split and merge, handle recursion, or keep the code readable. The lasting takeaway is a sharper sense of how to implement any algorithm cleanly.
It is a deep-dive, not a survey. For breadth, the general Data Structures and Algorithms course is the place to start; this trades range for depth on one sorting algorithm.
Who it's for, and who should skip it
It fits developers who understand basic algorithms and want to practice implementing them thoughtfully, using one familiar sort as a lens on craftsmanship.
Skip it if you need a broad introduction; begin with the general Data Structures and Algorithms course. Also skip it if you have never seen merge sort, since it does not teach the concept from zero.
Prerequisites
Comfortable JavaScript and a basic understanding of what merge sort and divide-and-conquer mean. The course is about implementing the algorithm well, not introducing the idea.
Where it fits
It is a focused deep-dive that complements the Frontend Developer Path and the Fullstack Developer Path, best taken after the broad Data Structures and Algorithms course and alongside its sibling binary search deep-dive.
Free or Pro
This is a Pro course, so it requires a Scrimba subscription. Pro also covers the full career paths, the coding challenges, the Discord, and certificates. See current plans for what Pro costs in your region.
Strengths and limits
What it does well: the six-implementations format turns one familiar sort into a focused lesson on writing algorithms well, and Jonathan Lee Martin ties each version to a concrete craftsmanship idea.
Where it is limited: it is deliberately narrow, covering a single algorithm, it assumes you already know what merge sort is, and at 12 lessons it is a short exercise rather than broad coverage.
Related courses and comparisons
- Data Structures and Algorithms, the broad foundation to take first
- Data Structures and Algorithms: Binary Search, the sibling deep-dive, same instructor
- JavaScript Interview Challenges, for broader interview practice
No. It is a Scrimba Pro course and requires a subscription.
Not really. It assumes you know the concept and focuses on implementing it six different ways, each teaching a craftsmanship lesson.
It is the sibling deep-dive by the same instructor. Same six-implementations format, applied to a sorting algorithm instead of a search algorithm.
Yes, if you want breadth. This is a narrow deep-dive that complements the broad Data Structures and Algorithms course.
Jonathan Lee Martin, who also teaches the companion Binary Search course on Scrimba.