This is my technical interview cheat sheet that I forked from TSiege. Please comment if you would like to have me edit, or send me a link from your fork. Probably a lot left to add and correct here, so take everything with a grain of salt. This list is meant to be both a quick guide and reference for further research into these topics. It's basically a summary of that comp sci course you never took or forgot about, so there's no way it can cover everything in depth. It also will be available as a gist on Github for everyone to edit and add to.
- Stores data elements based on a sequential index, most commonly 0 based.
- Based on tuples from set theory.
- They are one of the oldest, most commonly used data structures.
- Optimal for indexing; bad at searching, inserting, and deleting (except at the end).
- Linear arrays, or one dimensional arrays, are the most basic.
- Are static in size, meaning that they are declared with a fixed size.
- Dynamic arrays are like one dimensional arrays, but have reserved space for additional elements.
- If a dynamic array is full, it copies it's contents to a larger array.
- Two dimensional arrays have x and y indices like a grid or nested arrays. It is a multidimensional array with two dimensions.
- Multidimensional arrays are arrays composed of elements that are arrays themselves. These can be extended to have as many dimensions as needed. PHP example here
- Jagged arrays are multidimensional arrays composed of arrays that may vary in length. Javascript example here.
- Indexing: Linear array: O(1), Dynamic array: O(1)
- Search: Linear array: O(n), Dynamic array: O(n)
- Optimized Search (Binary Search): Linear array: O(log n), Dynamic array: O(log n)
- Insertion: Linear array: O(n), Dynamic array: O(n)
Note: You cannot add more space at the end of a linear array, but you can insert a new element provided there is sufficient unused space within the existing array. To do so would require shifting every element from the desired insertion position to the last used position in the array by one towards the end. This would give a Big O complexity of O(n)
- Stores data with nodes that point to other nodes.
- A node, at its most basic, has one datum and one reference (another node).
- A linked list chains nodes together by pointing one node's reference towards another node.
- Designed to optimize insertion and deletion, slow at indexing and searching.
- Doubly linked list has pointers that reference the previous node in addition to the next node.
- Circularly linked list is simple linked list whose tail, the last node, references the head, the first node.
- Stack, commonly implemented with linked lists but can be made from arrays too.
- Stacks are last in, first out (LIFO) data structures.
- Made with a linked list by having the head be the only place for insertion and removal.
- Queues, too can be implemented with a linked list or an array.
- Queues are a first in, first out (FIFO) data structure.
- Made with a doubly linked list that only removes nodes from the head and adds nodes to the tail.
- Indexing: Linked Lists: O(n)
- Search: Linked Lists: O(n)
- Optimized Search: Linked Lists: O(n)
- Insertion: Linked Lists: O(1)
- Stores data with key value pairs.
- Hash functions accept a key of arbitrary size and return an output of fixed size that correlates to the specific key.
- This is known as hashing, which is the concept that an input and an output have a one-to-one correspondence to map information.
- Designed to optimize searching, insertion, and deletion.
- Hash collisions are when a hash function returns the same output for two distinct inputs.
- All hash functions have this problem.
- This is often accommodated for by having the hash tables be very large.
- Hashes are important for associative arrays and database indexing.
- Indexing: Hash Tables: O(1)
- Search: Hash Tables: O(n)
- Insertion: Hash Tables: O(1)
- Is a tree like data structure where every node has at most two children.
- There is one left and right child node.
- Designed to optimize searching and sorting.
- A degenerate tree is an unbalanced tree, which if entirely one-sided is a essentially a linked list.
- They are comparably simple to implement than other data structures.
- Used to make binary search trees.
- A binary tree that uses comparable keys to assign which direction a child is.
- Left child has a key smaller than it's parent node.
- Right child has a key greater than it's parent node.
- There can be no duplicate node.
- Because of the above it is more likely to be used as a data structure than a binary tree.
- Indexing: Binary Search Tree: O(log n)
- Search: Binary Search Tree: O(log n)
- Insertion: Binary Search Tree: O(log n)
- An algorithm that searches a tree (or graph) by searching levels of the tree first, starting at the root.
- It finds every node on the same level, most often moving left to right.
- While doing this it tracks the children nodes of the nodes on the current level.
- When finished examining a level it moves to the left most node on the next level.
- The bottom-right most node is evaluated last (the node that is deepest and is farthest right of it's level).
- Optimal for searching a tree that is wider than it is deep.
- Uses a queue to store information about the tree while it traverses a tree.
- Because it uses a queue it is more memory intensive than depth first search.
- The queue uses more memory because it needs to stores pointers
- Search: Breadth First Search: O(|E| + |V|)
- |E| is the size of the set of all edges
- |V| is the size of the set of all vertices
- An algorithm that searches a tree (or graph) by searching depth of the tree first, starting at the root.
- It traverses left down a tree until it cannot go further.
- Once it reaches the end of a branch it traverses back up trying the right child of nodes on that branch, and if possible left from the right children.
- When finished examining a branch it moves to the node right of the root then tries to go left on all it's children until it reaches the bottom.
- The right most node is evaluated last (the node that is right of all it's ancestors).
- Optimal for searching a tree that is deeper than it is wide.
- Uses a stack to push nodes onto.
- Because a stack is LIFO it does not need to keep track of the nodes pointers and is therefore less memory intensive than breadth first search.
- Once it cannot go further left it begins evaluating the stack.
- Search: Depth First Search: O(|E| + |V|)
- |E| is the size of the set of all edges
- |V| is the size of the set of all vertices
- The simple answer to this question is that it depends on where the items you are searching for are located
- If the items searched for tend to be found higher in the tree (not far from the root), then a Breadth First Search is preferable
- If the items searched for tend to be found deeper in the tree (farther from the root), then a Depth First Search is preferable
- Because BFS uses queues to store information about the nodes and its children, it could use more memory than is available on your computer. (In the real world, this often is not an issue. However, this should always be considered in an interview.)
- If using a DFS on a tree that is very deep you might go unnecessarily deep in the search. See xkcd for more information.
- Iterative deepening is a method of combating such an issue.
- Breadth First Search tends to be a looping algorithm.
- Depth First Search tends to be a recursive algorithm.
- A comparison based sorting algorithm
- Divides entire dataset into groups of at most two.
- Compares each number one at a time, moving the smallest number to left of the pair.
- Once all pairs sorted it then compares left most elements of the two leftmost pairs creating a sorted group of four with the smallest numbers on the left and the largest ones on the right.
- This process is repeated until there is only one set.
- This is one of the most basic sorting algorithms.
- Know that it divides all the data into as small possible sets then compares them.
- Best Case Merge Sort: O(n)
- Average Case Merge Sort: O(n log n)
- Worst Case Merge Sort: O(n log n)
- A comparison based sorting algorithm
- Divides entire dataset in half by selecting a random element as a pivot and putting all smaller elements to the left of the pivot. The pivot is usually selected by random (i.e.: Pick three elements randomly, select the median element as the pivot).
- It repeats this process on the left side until it is comparing only two elements at which point the left side is sorted.
- When the left side is finished sorting it performs the same operation on the right side.
- Computer architecture favors the quicksort process.
- While it has the same Big O as (or worse in some cases) many other sorting algorithms it is often faster in practice than many other sorting algorithms, such as merge sort.
- Know that it halves the data set by the average continuously until all the information is sorted.
- Best Case Quick Sort: O(n)
- Average Case Quick Sort: O(n log n)
- Worst Case Quick Sort: O(n^2)
- A comparison based sorting algorithm
- It iterates left to right comparing every couplet, moving the smaller element to the left.
- It repeats this process until it no longer moves an element to the left.
- While it is very simple to implement, it is the least efficient of these three sorting methods.
- Know that it moves one space to the right comparing two elements at a time and moving the smaller on to left.
- Best Case Bubble Sort: O(n)
- Average Case Bubble Sort: O(n^2)
- Worst Case Bubble Sort: O(n^2)
- Quicksort is likely faster in practice. Both have a complexity of O(n * log n), but Quicksort's constant factor is ususually better.
- Merge Sort divides the set into the smallest possible groups immediately then reconstructs the set incrementally as it sorts the groupings.
- Quicksort continually divides the set by the average, until the set is recursively sorted.
- An algorithm that calls itself in its definition.
- Recursive case a conditional statement that is used to trigger the recursion.
- Base case a conditional statement that is used to break the recursion.
- Stack level too deep and stack overflow.
- If you've seen either of these from a recursive algorithm, you messed up.
- It means that your base case was never triggered because it was faulty or the problem was so massive you ran out of space on the stack before reaching it.
- Knowing whether or not you will reach a base case is integral to correctly using recursion.
- Often used in Depth First Search
- An algorithm that is called repeatedly but for a finite number of times, each time being a single iteration.
- Often used to move incrementally through a data set.
- Generally you will see iteration as for loops, while loops, and until statements.
- Think of iteration as moving one at a time through a set.
- Often used to move through an array.
- The differences between recursion and iteration can be confusing to distinguish since both can be used to implement the other. But know that,
- Recursion is, usually, more expressive and easier to implement.
- Iteration uses less memory.
- Functional languages tend to use recursion. (i.e. Haskell)
- Imperative languages tend to use iteration. (i.e. Ruby)
- Check out this Stack Overflow post for more info.
Recursion | Iteration
----------------------------------|----------------------------------
recursive method (array, n) | iterative method (array)
if array[n] is not nil | for n from 0 to size of array
print array[n] | print(array[n])
recursive method(array, n+1) |
else |
exit loop |
- An algorithm that, while executing, selects only the information that meets a certain criteria.
- The general five components, taken from Wikipedia:
- A candidate set, from which a solution is created.
- A selection function, which chooses the best candidate to be added to the solution.
- A feasibility function, that is used to determine if a candidate can be used to contribute to a solution.
- An objective function, which assigns a value to a solution, or a partial solution.
- A solution function, which will indicate when we have discovered a complete solution.
- Used to find the optimal solution for a given problem if the optimal solution is a result of optimally solving the sub-problems.
- Generally used on sets of data where only a small proportion of the information evaluated meets the desired result.
- Often a greedy algorithm can help reduce the Big O of an algorithm.
greedy algorithm (array)
var largest difference = 0
var new difference = find next difference (array[n], array[n+1])
largest difference = new difference if new difference is > largest difference
repeat above two steps until all differences have been found
return largest difference
This algorithm never needed to compare all the differences to one another, saving it an entire iteration.
(I'm not paid to list these or anything, just found them helpful in my experience)