# Improving your Algorithms & Data Structure Skills
Image from [Dynamo Primer](http://dynamobim.org/more-primer/).
*Some of the resources in this article originally appeared in one of my comments on a reddit post that became quite popular. Here’s the* [*original*](https://www.reddit.com/r/learnprogramming/comments/6ytb4r/what_would_be_a_fun_and_brain_friendly_way_to/)*thread, and my new write-up is below.*
#### Fundamentals
The first thing you’ll need if you want to get better at algorithms and data structures is a solid base. This base can be learned one of several ways, either through a computer science program at university, some [coding bootcamps](https://www.hackreactor.com/blog/software-development-school-program-specifics-hiring-outcomes-housing-and-more) focus a bit on the topics below, or you can learn on your own from [books](https://www.quora.com/What-are-the-best-books-to-learn-algorithms-and-data-structures-Are-there-any-good-blogs-posts-on-these-Which-books-explain-these-concepts-in-a-simpler-way), videos, or [online](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/) lectures. So you’ll need a basic understanding of the following topics to get started:
**Data Structures**
Learn about arrays, linked lists, binary trees, hash tables, graphs, stacks, queues, heaps, and other fundamental data structures.
**Math & Logic**
You’ll need to know some mathematical concepts from several different areas if you want to excel at algorithms. Learn about set theory, finite-state machines, regular expressions, matrix multiplication, bitwise operations, solving linear equations, important combinatorics concepts such as permutations, combinations, pigeonhole principle.
**Computer Architecture**
Learn how data is represented in a computer, the basics of digital logic design, boolean algebra, computer arithmetic, floating-point representation, cache design. *Try and learn a little about C and Assembly programming.*
#### Moving Forward Past the Fundamentals
Once you feel like you have a good understanding of *most* of the concepts listed above, it’s time to start diving into the algorithms part. Here is a list of resources and things I did to get better at writing and understanding important algorithms.
Pages taken from [The Algorithm Design Manual](https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202).
**Big-O & Runtime**
* Learn what [Big-O](https://en.wikipedia.org/wiki/Big_O_notation) is and how to analyze the [running times](https://cs.stackexchange.com/questions/192/how-to-come-up-with-the-runtime-of-algorithms) of algorithms. This is a [classic book](https://en.wikipedia.org/wiki/Introduction_to_Algorithms) on the topic (here is the chapter on the [growth of functions](http://www.cs.dartmouth.edu/~ac/Teach/CS19-Winter06/SlidesAndNotes/CLRS-3.1.pdf)).
* Here is a good [list of online courses](https://github.com/tayllan/awesome-algorithms#online-courses) that teach algorithms.
**Implement Some Algorithms Yourself**
Start off by implementing several important algorithms yourself and learning about their running times. Some examples are:
* Binary search
* Euclid’s algorithm
* Depth and breadth first search
* Dijkstra’s shortest path
* Binary tree traversals
* Insertion sort, Mergesort, Quicksort
* Min & max heaps
* [More](https://www.quora.com/Which-are-the-10-algorithms-every-computer-science-student-must-implement-at-least-once-in-life) [examples](https://hbfs.wordpress.com/2008/12/23/the-10-classes-of-algorithms-every-programmer-must-know-about/) and [lists](https://softwareengineering.stackexchange.com/questions/155639/which-algorithms-data-structures-should-i-recognize-and-know-by-name).
**Algorithm Books**
* Read the [Algorithm Design Manual](https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202). It’s a great book and it’s my favorite.
* [Introduction to Algorithms](https://en.wikipedia.org/wiki/Introduction_to_Algorithms) is a classic book that covers a lot of material.
* [Elements of Programming Interviews](https://www.amazon.com/Elements-Programming-Interviews-Insiders-Guide/dp/1479274836) contains a lot of challenges and code solutions that will help you prepare for interviews.
**Challenges**
* Practice coding simple and then more advanced algorithms on sites like [Coderbyte](https://www.coderbyte.com/) and [HackerRank](https://www.hackerrank.com/) which provide explanations and solutions so you can learn from other coders as well.
* Go through the challenges on this [interactive python algorithms website](http://interactivepython.org/runestone/static/pythonds/index.html).
* [The 10 most popular coding challenge websites for 2017](https://medium.freecodecamp.org/the-10-most-popular-coding-challenge-websites-of-2016-fb8a5672d22f).
* [The 5 hardest code challenges for beginners](https://medium.com/coderbyte/the-5-hardest-code-challenges-for-beginners-e410da4474b).
**Algorithms Explanations & Interview Questions**
* Read as many algorithm explanations and code examples as you can on [GeeksforGeeks](http://www.geeksforgeeks.org/). Here is an [example](http://www.geeksforgeeks.org/graph-data-structure-and-algorithms/) of a good post on graph algorithms.
* Look at some interview questions posted on [CareerCup](https://www.careercup.com/) and try and understand how other users solved the questions. Like [this example](https://www.careercup.com/question?id=5641027330244608).
* Aside from coding challenge sites, try and solve common coding interview questions you find online [such as the ones on this list](https://techiedelight.quora.com/500-Data-Structures-and-Algorithms-practice-problems-and-their-solutions?srid=dV6r).
**Dynamic Programming**
This a *very* [important concept](https://en.wikipedia.org/wiki/Dynamic_programming) you will need to understand if you want to get better at algorithms, which is the reason I separated this topic from the rest. The description from Wikipedia for it is (bolding is mine):
> A method for solving a complex problem by **breaking it down** into a collection of simpler **subproblems**, solving each of those subproblems just once, and storing their solutions. The next time the same subproblem occurs, instead of recomputing its solution, one simply **looks up** the previously computed solution, thereby saving computation time.
I have seen dynamic programming show up in several coding interviews I’ve had. I’ve also seen problems that require a dynamic programming solution on challenge sites like [LeetCode](https://leetcode.com/problems/longest-palindromic-subsequence/description/), [Google Code Jam](https://code.google.com/codejam/contest/10224486/dashboard), and several challenges on [Google Foo Bar](http://www.geeksforgeeks.org/google-foo-bar-challenge/) required a DP solution.
I’d recommend to try and solve as many [problems on this list](http://www.geeksforgeeks.org/dynamic-programming/) as you can. There is also a good tutorial on TopCoder titled: [Dynamic Programming — From Novice to Advanced](https://community.topcoder.com/tc?module=Static\&d1=features\&d2=040104). A lot of DP problems have the same structure and patterns so if you solve 3 DP problems everyday for 2 weeks or so, after a while you’ll be able to spot and solve a DP problem no problem.
**Advanced Resources in Algorithms (optional)**
* [Advanced Data Structures](http://courses.csail.mit.edu/6.851/fall17/lectures/) Lectures by [Erik Demaine](http://erikdemaine.org/)
* [Algorithmic Lower Bounds: Fun with Hardness Proofs](http://courses.csail.mit.edu/6.890/fall14/lectures/) by Erik Demaine
* [Competitive Programmer’s Handbook](https://cses.fi/book.html)
* [The Hitchhiker’s Guide to the Programming Contests](http://comscigate.com/Books/contests/icpc.pdf)
* [AlgoWiki](https://github.com/AlgoWiki/AlgoWiki): A wiki dedicated to competitive programming
* [Computational Geometry](https://en.wikipedia.org/wiki/Computational_geometry) problems and algorithms ([cool](https://en.wikipedia.org/wiki/Voronoi_diagram) and [fun](https://en.wikipedia.org/wiki/Delaunay_triangulation), but can get quite difficult)
* [List of NP-complete problems](https://en.wikipedia.org/wiki/List_of_NP-complete_problems)
* [Open Data Structures Book](http://opendatastructures.org/): implementation and analysis of data structures for sequences, queues, priority queues, unordered dictionaries, ordered dictionaries, and graphs
I hope you enjoyed this list of resources. Feel free to practice coding on [Coderbyte](https://www.coderbyte.com/), and comment below with any other resources you think are helpful.