Algorithms and Data Structures

WARNING: This is a work-in-progress and is therefore in an unfinished state. Frequent revisions\extensions are to be expected.

Want to skip the introduction? Find the exact algorithm or data structure you desire in the index.

Welcome to Algorithms and Data Structures presented by the Hideous Humpback Freak. As listed in my bio, my personal goal is to increase the technical acumen of as many software professionals as possible. That’s what this site is all about! The content caters to a broad audience, regardless of educational background, with an emphasis on intelligibility. It is a convenient review resource for experienced developers as well as a concise educational appliance for aspiring software experts. Every algorithm, or data structure as the case may be, receives proper treatment including detailed descriptions, cartoons, accessible pseudo code, asymptotic analysis, actual run time comparisons, and common use cases. The pièce de résistance, is fully functional C code (fluency in the C language is not a requirement) complete with unit tests showcasing the functionality.

Why Algorithms and Data Structures?

There are domains (e.g. embedded, operating systems, programming languages, kernel, etc…) where a deep understanding of data structures and algorithms is absolutely requisite. It’s simply not possible to write software in these contexts without it. The majority of developers work in other domains (business applications, web development, mobile apps, data science, etc…). For them, it’s possible to make the argument that such skill is superfluous. However, that is a myopic perspective.

There is no denying that high-level languages abstract away many algorithms and data structures from developers. For instance, utilizing an IEnumberable in C#, Iterable in Java, or list in Python does not require the developer to understand the difference between a linked list, binary tree, or array. This is a fair point, however; employing abstractions devoid of comprehension is nothing more than cobbling objects together until something eventually works which is adequate for only the most parochial of use cases. The standard set of language high-level abstractions are seldom sufficient for advanced scenarios.

For demonstration’s sake, suppose a programmer is never going to implement or even employ an abstraction of a particular algorithm. Is it still worth their time to study it? The answer is an emphatic YES! Studying algorithms is more than just memorizing patterns. It instills problem solving techniques into the adherent. Writing elegant code requires intimate knowledge of what elegance looks like. The classic algorithms are a catalog of code with unparalleled elegance. As Tim Roughgarden is fond of saying, they are the “greatest hits” of software. One of Frederick Nietzsche’s most famous quotes is, “if thou gaze long into an abyss, the abyss will also gaze into thee”. The meaning being that you will become what your mind focuses on. Simply gaining an understanding of famous algorithms and data structure will change the way you code.

Another common argument against studying algorithms is that the time could be better spent on more “modern” topics. Many software professionals spend inordinate amounts of time learning frameworks (e.g. React, Spring Boot, Boost). While this is laudable, the fruits of such labor are ephemeral because frameworks come and go and the earned competence is seldom transferable. Conversely, algorithms and data structures are at the very heart of software. They are enduring concepts that have been in use since the forties. Such knowledge makes every related subject, including frameworks, more accessible. Any individual adept in enduring concepts will outperform an individual adept in fads. Stated concisely, the return on investment from learning algorithms and data structures is considerably higher than any other software topic.

To sum up the why, any developer ignorant of what lies beneath is constrained by the simplified view that high-level abstractions expose and is therefore a slave to them. Advanced solutions require deep comprehension of core algorithmic concepts. The study of algorithms and data structures is the most efficient route to mastery of any software topic.

Why Use the C Programming Language?

The choice of the C language for demonstrating algorithms is uncontroversial. Its popularity1 implies that most software professionals have at least some exposure. Having only 32 keywords, it is easy to learn. The most compelling reason is that it provides little to no built-in data structures or algorithms. Simply invoking the high-level abstractions provided by other languages deprives programmers of the experience required to build acumen. The C language provides the opportunity to build from scratch which stimulates deep comprehension. It’s a language that every developer should learn and become proficient in regardless of whether they use it professionally or not.

As a final note, it’s important to understand that the choice of C for this content is not an endorsement for or against the language in other contexts. C’s low-level nature make it prohibitive for most standard business use cases. It’s typically advantageous for performance critical, real time, and embedded applications. However, even in those instances there are complications arising from security exploits and indeterministic undefined behaviors. Keep in mind that there is no best language for all applications. Thoroughly evaluate your context and choose the best fit.

What Makes this Content Unique?

There are already so many great resources for algorithms and data structures, why does the world need yet another one? This is a fair question that deserves a fair response. The truth is that most of the information covered here is derived from four popular books:

  1. Introduction to Algorithms, Third Edition by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein
  2. Algorithms Illuminated (Part 1): The Basics by Tim Roughgarden
  3. Algorithms Illuminated (Part 2): Graph Algorithms and Data Structures by Tim Roughgarden
  4. Algorithms Illuminated (Part 3): Greedy Algorithms and Dynamic Programming by Tim Roughgarden

These books are amazing, and the authors are no doubt geniuses. However, they aren’t the most accessible of resources as they assume the reader has a consummate background in mathematics and computer science. Even those with such a background must expend a good deal of mental energy to absorb the material. On the other end of the spectrum, sources for beginners rarely provide a thorough enough treatment to be useful in practice.

Much like Buddha’s Middle Way, this site aims to balance the two extremes. It provides content that is practically applicable without academic pomp. The Hideous Humpback Freak is an accomplished software professional that has applied algorithms in real world contexts which adds a level of profundity to the material. What’s more, nothing is presented here without working software accompaniment. Stated concisely, this is legitimate content for developers whose aim is to efficiently attain the skills required for practical application.

As a final added bonus, the Hideous Humpback Freak is happy to personally provide support. Please ask questions, leave comments, or make suggestions in the comments section located at the bottom of each page. Although I’ll ask you to respect my time, I’m also willing to speak via Google Hangouts if necessary. It’s a win-win situation because you will get the help that you need, and it will improve the content.

Without further ado, it’s time to start learning. Good luck to you!

  1. The IEEE ranked C as the 3rd most popular language of 2019.