Post Software Engineering Bootcamp Study Guide

After graduating from Flatiron I knew the learning journey was far from over. Although exciting it was challenging to know what to focus on especially with so much information, and so many resources so easily available.

After almost three months dedicated to sifting through resources, and lots of learning, I came up with a breakdown of resources and information which I found most useful.

If the key study guide had to be broken down it would be the above & Big O

Data Structures

1. *Arrays: store multiple elements in a single variable. Array’s are usually used when order matters. Each element is denoted by an index, starting at zero. Here is an article with a some of JS useful array methods.
2. *Objects: store multiple elements as a key value pair. Best choice when order does not matter, and you need fast access/insertion.
3. **Linked List: is a linear data structure, in which the elements are not stored at contiguous memory locations. Therefore have No index, and cannot be randomly access, however they are good for insertion and deletion. The elements in a linked list are linked using pointers (next & previous). There are tow types of linked lists Singly Linked List (each element only has a next pointer), and Doubly Linked List (each element has a next and previous pointer). Both have a head, tail, and length property.
4. **Stacks: is a linear data structure in which addition or removal of element follows Last In First Out (LIFO).This is most efficient when done with stacks however is often used with arrays ((using .push() & .pop() or .shift() & .unshift() (using shift and unshift is not constant time therefore not as efficient)) Ex. Manage function invocation, Undo/Redo, Browser History
5. **Queues: is a linear data structure in which addition or removal of element follows First in First Out (FIFO). Similar to singly linked list, we have two options add to end and remove from beginning.We usually use the key words enqueue (add) & qequeues (remove) when building the class.Ex. Joining a game, printer queue
6. **Trees: data structures that consist of nodes with a parent, child or sibling relationships (linked lists off a linked list). Every node is moving away from root node (leaf is a node with no children, edge is the connection) Binary Search Trees: sorted in an order (each node has two children or less, used for comparative data) InOrder (starts at smallest node lowest to highest), PreOrder (start at root goes left then right), PostOrder (start at smallest)
7. Graphs: a tree with cycles (up/down/left/right) can also think of this as a matrix. I recommend going through these three articles or completing these Leetcode problems in the following order. 1572 & 1380, 867 & 766 , and 695
8. Heaps: data structure where element has a priority associated with it. Min Heap (parent nodes are always larger than the children (right or left, sibling order, does-not matter) Max Heap parent nodes are always smaller than the children (right or left does-not matter)

*should already be very familiar however if you are not comfortable with them you will be once you start leetcoding (Udemy course goes over them quickly)

** Have not had too much exposure to these as a data structure. The Udemy course mentioned below goes over in detail how to implements them as their own class.

Algorithms

1. Binary Search: here’s a great video simple breakdown and an article that quickly goes over the simple search algorithms
2. Depth First Search(start at one place and go deep in that directions) The common question Area of an Island is a great use case.
3. Breadth First Search(build out one ring at a time). We visit every sibling node before we go to child (horizontal).
4. Merge Sort & Quick Sort are a less intuitive a here is a great video resource I also have an article that walks through them step by step
5. Two Pointer & Sliding Window: start at two different points in the array and move/compare them based on a condition (in sliding window you will generally want a solution of a specific length, in two pointer you are generally more concerned with comparing the two elements.(the Udemy course mentioned below does a great job at going over these two approaches)
6. Recursion: function calling itself. Taking one problem and doing it on a smaller piece, (Ex. JSON.parse(), JSON.stringify). Recursion will always have three parts. call stack (pushing the functions to), base case (conditional statement, where recursion stops) inputs (different data in the recursion call)
7. Dynamic Programing: solving a problem once and using memoization to prevent from recomputing the problem. A great use case for this is Coin Change of the common Fibonacci Example which uses recursion as well

Big-O

There are lots of good resources out there. I personally found it useful to break it down using real life examples outlined here. This Big-O Cheat Sheet is also a great reference.

Resources I Have Found Most Helpful:

1. JavaScript Algorithms and Data Structures Masterclass Udemy: great place to start, gives a good breakdown of common problem solving approaches, and the most common algorithms.
2. Leetcode: here is a pretty good list of problems to go through. I found it useful to take my time and really try to solve the problem on my own. the first few times it might take a while to solve a Medium/Hard problem. However it is a lot more useful to spend 2–3 hours fully understanding one problem than going through 2–5 problems in an 2–3hours. Once you go through a few you will quickly see patterns emerge.
3. Cracking the Coding Interview: 189 Programming Questions and Solutions: haven’t gone through all of it, however I have a few sections that I have gone over in detail
4. CS50: incredibly well put together Harvard Course (highly recommend if you have extra time however the first two resources have been the most helpful for me)

There is a lot more that I have not covered however I hope this list helps. Here are some additional concepts/vocab you should be comfortable with: CPU vs RAM, Object Oriented Programing, Class Oriented Programing, Virtual DOM (React), MVC framework, Hooks (Functional Components), Class Components, Async, Event Loop, Concurrent (multi threaded), Sequential (single thread), and Parallel Programing (context switching), Callback, Promise, Hoisting, Class Inheritance….