I want to dial back a bit on specific technologies, and return to the fundamentals. Understanding the core algorithms that are a part of every major piece of software is an important hurdle every engineer has to cross. That’s why in this article, we’ll explore 10 algorithms every programmer must know, complete with examples, real-world applications, and why they matter.

[more]

1. Sorting Algorithms

Sorting is a classic problem in computer science and one of the most common operations in programming. If there is an algorithm you’re familiar with, even as a total beginner, it’s probably sorting.

Examples:Quick Sort – Perhaps the most iconic of the sorting algorithms, a quick sort is a divide-and-conquer sort that works by partitioning the array and recursively sorting the partitions. It’s fast in practice, but can degrade to O(n²) in the worst case.
Merge Sort – An efficient algorithm with O(n log n) time complexity, great for linked lists or when stability in sorting matters.
Bubble Sort – A great beginner’s algorithm – simple and easy to learn, though it is inefficient for real-world datasets.
Why It Matters:The use case of sorting is pretty straightforward, since you probably do it every single day. How many times do you press the sort button on your Excel doc, or have your computer show you your files in order of when they were last accessed? All of this, of course, uses sorting algorithms!
2. Searching Algorithms

Another straightforward one, searching lets you retrieve information quickly—whether you’re locating a name in a contact list, or checking if a value exists in a database.

Examples:Linear Search – Go through elements one by one. Simple, but (very) inefficient.
Binary Search – Divide-and-conquer on sorted arrays; reduces time complexity to O(log n). This is a pretty common answer for Leetcode questions!
Why It Matters:You search all the time!
3. Recursion and Backtracking

Alright, here’s where things start to get a bit more interesting. Recursion is a technique in computer science in which a function calls itself to solve a problem. While this might sound counterintuitive at first, there are actually tons of cases where recursion is very helpful. One such case, backtracking, builds on recursion to explore all possibilities in a given problem and “backtracks” when a path leads to a dead end.

Examples:N-Queens Problem – Building a chessboard filled with queens such that no queen is attacking another. A classic problem for teaching recursion.
Maze Solvers – Going through all possibilities to explore a maze to its conclusion.
Sudoku Solvers – Going through all possibilities of a sudoku board to find the correct combinations.
Why It Matters:Essential for solving combinatorial problems (such as Sudoku or Wordle).
Forms the backbone of many puzzle solvers, decision trees, and AI logic!
4. Dynamic Programming (DP)

Dynamic Programming is used when a problem has overlapping subproblems and an optimal substructure. In other words, it avoids having to do redundant calculations by storing solutions to subproblems and using them to solve the bigger problem.

Examples:Fibonacci Sequence (with memoization) – Memoization (not “memorization”, though it might as well be the same thing) helps store previously computed information in a cache. Since Fibonacci is all about calculating a long string of previous numbers, this is a great dynamic programming example!
0/1 Knapsack Problem – Let’s say you have a knapsack, and a set of items. You can choose to bring an item with you (1) or not (0), and each item has a set weight. What is the maximum amount of items you can put in your knapsack until the knapsack goes over the weight limit? (Didn’t know dynamic programming would be helpful in playing Fallout…)
Longest Common Subsequence – Similar problem to the fibonacci sequence, but for an array of characters. We’re caching the previous common subsequences we see in order to find the overall longest!Why It Matters:Improves efficiency dramatically in problems that seem impossible at first glance!
Common in interviews, thanks to their ability to solve real-world problems like scheduling, optimization, and some quant finance use cases.
5. Divide and Conquer

Divide and Conquer splits a problem into smaller parts, solves each one, and combines them to form the solution. If you’re paying attention, this should sound familiar: we’ve already covered a few divide and conquer algorithms earlier in this list!

Examples:Merge Sort
Quick Sort
Binary Search
Why It Matters:Helps break complex problems into manageable chunks.
Allows for parallel processing on CPUs and optimization in large-scale systems.
6. Graph Algorithms

Graphs model real-world relationships: social networks, maps, workflows, and more. Unsurprisingly, understanding graph traversal becomes crucial for working with many real world issues.

Examples:Breadth-First Search (BFS) – Explores all neighbors before going deeper.
Depth-First Search (DFS) – Explores as deep as possible before backtracking.
Dijkstra’s Algorithm – Finds the shortest path in a weighted graph. Most GPS tools use some form of this algorithm!
Why It Matters:Fundamental for solving pathfinding, networking, recommendation systems, and pretty much anything you can turn into a node-based graph!7. Greedy Algorithms

Greedy algorithms build up a solution step-by-step, always choosing the option that looks best at the given moment; this makes them very speedy, even though they might not always give the best complete solution.

Examples:Activity Selection Problem – This is a classic scheduling problem, and very common in interviews. You are trying to find the maximum number of non-overlapping activities that can be performed by a person (or sometimes a computer) given a start/stop time. (Didn’t know greedy algorithms would be helpful in playing Stardew Valley…) Huffman Encoding – One of the original foundations in lossless data compression for images, video, audio, and more. While Huffman is no longer directly used, it’s easy to teach and is usually a programmer’s first understanding of the encoding process.Kruskal’s and Prim’s Algorithms – Very similar algorithms that are used to find the minimum spanning tree of a graph.
Why It Matters:Fast and efficient when they work.
Great for optimization problems, though they don’t always give the most optimal solution!
8. Hashing and Hash Tables

Common in data science, hashing allows fast data lookup, insertion, and deletion using key-value pairs.

Examples:Hash Maps – One of the most common data structures in existence, a hash map is usually more commonly known as a “dictionary”, a key-value form of an array/list.
Hash Sets – A variation on a hash map, except this one only stores unique elements (no key-value pairs) and simply maintains a collection of distinct values.
Bloom Filters – This is a probabilistic algorithm that checks the likelihood of an object being part of a set, making it much faster than manually checking but still having a chance of a false positive.
Why It Matters:Powers databases, caching systems, and language internals (like variable scope resolution).
A must-have for reducing time complexity in many problems. When it comes to Leetcode, hashing is your friend!
9. Tree Traversals

Trees are another hierarchical structures found in many applications: UI elements, file systems, and more. Much like graphs, it helps to create tree-based algorithms to get through this data structure quickly and efficiently.

Traversal Methods:In-order – Left → Root → Right (used in binary search trees)
Pre-order – Root → Left → Right (useful for cloning trees)
Post-order – Left → Right → Root (deleting nodes)
Level-order – A form of breadth first search for trees
Why It Matters:Enables you to systematically access and manipulate hierarchical data.
10. String Matching and Manipulation

Text processing is another essential for many tasks—whether it be compiling code, searching in documents, or building search engines.

Examples:Knuth-Morris-Pratt (KMP) – Efficient pattern matching in O(n + m)!
Rabin-Karp – A hash-based pattern search.
Trie (Prefix Tree) – Great for autocomplete and prefix-based searching!
Why It Matters:These algorithms are vital for applications in natural language processing, data mining, and real-time search… though the future of machine learning based algorithms such as neural networks might make this a bit more interesting. Of course, those are a topic for another time!
Next Steps:Practice problems: LeetCode, HackerRank, Codeforces
Other tools: VisuAlgo, AlgoExpert
Book recommendations:
Grokking Algorithms by Aditya Bhargava
Introduction to Algorithms (CLRS)

[substack]

The post 10 Algorithms Every Programmer MUST Know appeared first on Jacob Robinson.