Big O
Worst
Best
Sort
Selection
𝑂(𝑛2 )
𝑂(𝑛2 )
Inplace?
No
extra
space
Y
Stable
?
Same
key
value
N
Given array of n items
1. Find largest item
2. Swap it with item in the first index
3. Increase index by 1 and move down
array
Insertion
𝑂(𝑛2 )
𝑂(𝑛)
Y
Y
Insert an item into a properly sorted array
Bubble
w/o flag
𝑂(𝑛2 )
𝑂(𝑛2 )
Y
Y
Compare ith and (i+1)th item.
Bubble down the array
Add a Boolean to improve best case to 𝑂(𝑛)
Merge
𝑂(𝑛 log 𝑛)
𝑂(𝑛 log 𝑛)
N
Y
Divide-and-conquer method solves problem by
three steps:
Divide Step: divide larger problem
into smaller problems
(Recursively) solve the smaller
problems
- Conquer Step: combine results of
smaller problems to produce result of
larger problem
Additional space complexity of O(n)
Radix
Quick
𝑂(𝑛)
𝑂(𝑛)
N
Y
Treats each data to be sorted as a
character string. Organise the data into
groups according to the next character in
each data.
𝑂(𝑛 log 𝑛)
Y
N
𝑂(𝑛2 )
Use a partition and split the array into two
regions, a[i] >= p AND a[i] < p
Implementation
public static void selectionSort(int[] a) {
for (int i = 0; i < a.length; i++) {
int index = i;
for (int j = i+1; j < a.length; j++) {
if (a[j] > a[index])
index = j;
}
int temp = a[index];
a[index] = a[i];
a[i] = temp;
}
}
public static void insertionSort(int[] a) {
for (int i=1;i<a.length;i++) {
int next = a[i];
int j;
for (j=i-1; j>=0 && a[j]>next; j--)
a[j+1] = a[j];
a[j+1] = next;
}
}
public static void bubbleSort(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = 0; j < a.length - i; j++) {
if (a[j] > a[j+1]) {
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
public static void mergeSort(int[] a, int i, int j) {
if (i < j) {
int mid = (i+j)/2; // divide
mergeSort(a, i, mid); // recursion
mergeSort(a, mid+1, j);
merge(a,i,mid,j); //conquer: merge a[i..mid] and
//a[mid+1..j] back into a[i..j]
}
}
public static void merge(int[] a, int i, int mid, int j) {
// Merges 2 sorted sub-arrays a[i..mid] and a[mid+1..j] into one sorted sub-array a[i..j]
int[] temp = new int[j-i+1]; // temp storage
int left = i, right = mid+1, it = 0;
// it = next index to store merged item in temp[]
while (left<=mid && right<=j) { // output the smaller
if (a[left] <= a[right])
temp[it++] = a[left++];
else
temp[it++] = a[right++];
// Copy the remaining elements into temp.
while (left<=mid) temp[it++] = a[left++];
while (right<=j) temp[it++] = a[right++];
for (int k = 0; k < temp.length; k++)
a[i+k] = temp[k];
}
radixSort(int[] array, int n, int d) {
// Sorts n d-digit numeric strings in the array.
for (j = d down to 1) { // for digits in last position to 1st position
initialize 10 groups (queues) to empty
for (i=0 through n-1) {
k = jth digit of array[i]
place array[i] at the end of group k
}
Replace array with all items in group 0, followed by all items
group 1, and so on.
}
}
... quickSort(int[] a, int i, int j) {
if (i < j) { // Q: What if i >= j?
int pivotIdx = partition(a, i, j);
quickSort(a, i, pivotIdx-1);
quickSort(a, pivotIdx+1, j);
}
}
... partition(int[] a, int i, int j) {
// partition data items in a[i..j]
int p = a[i]; // p is the pivot, the ith item
int m = i;
// Initially S1 and S2 are empty
for (int k=i+1; k<=j; k++) { //process unknown region
if (a[k] < p) { // case 2: put a[k] to S1
m++;
swap(a,k,m);
} else {
// case 1: put a[k] to S2. Do nothing!
}
in
}
swap(a,i,m); // put the pivot at the right place
return m; // m is the pivot final position
}
O(1) < O(log 𝑛) < O(𝑛𝑐 ) < O(𝑛) < O(𝑛 log 𝑛) < O(𝑛2 ) < O(𝑛3 ) < O(𝑛!)O(2𝑛 ) log10 𝑛 =
log2 𝑛
log2 10
 Basically just count the number of statements executed.
 If there are only a small number of simple statements in a program
– O(1)
 If there is a ‘for’ loop dictated by a loop index that goes up to n
– O(n)
 If there is a nested ‘for’ loop with outer one controlled by n and the inner one controlled by m
– O(n*m)
 For a loop with a range of values n, and each iteration reduces the range by a fixed fraction (usually it is 0.5, i.e., half)
– O(log n)
 For a recursive method, each call is usually O(1). So
 if n calls are made – O(n)
 if n log n calls are made – O(n log n)
𝑆𝑢𝑚 𝑜𝑓 𝐴𝑃 =
𝑛
(2𝑎 + (𝑛 − 1)𝑑)
2
𝑆𝑢𝑚 𝑜𝑓 𝐺𝑃 =
Modifier
class
public
protected
No
modifier
private
𝑎(1 − 𝑟 𝑛 )
1−𝑟
Subclas
s
✔
✔
✘
World
✔
✔
✔
packag
e
✔
✔
✔
✔
✘
✘
✘
Division
Multiplication
String
Abstract class
Describes similar functionality & data for classes that
extend it
Can have implemented methods and attributes
Can have non-final data fields
Classes can only extend a single abstract class
Classes that extend an abstract class need not provide
implementation. They will be in turn abstract classes
class Planet extends Ball {
✔
✘
✘
ℎ𝑎𝑠ℎ(𝑘) = 𝑘%𝑚
ℎ𝑎𝑠ℎ(𝑘) = ⌊𝑚(𝑘𝑨 − [𝑘𝑨])⌋
𝑠𝑢𝑚 = 𝑠𝑢𝑚 ∗ 31 + 𝑐
Separate Chaining
Use a linked-list to connect collided
keys
Linear Probing
Move down until you find an empty
slot
Move down every quadratic per probe
Use a second hash function for probing
Quadratic Probing
Double Hashing
Interface
Describes similar functionality for all classes that
implements it
Only has method signatures and are only public
All data attributes must be final
Classes can implement multiple interfaces
classes that implement interface must provide
implementation for all methods defined in interface
class ComplexPolar implements Complex {
𝛼=
𝑛
, 𝑛 = 𝑛𝑢𝑚𝑏𝑒𝑟 𝑜𝑓 𝑘𝑒𝑦𝑠
𝑚
𝑚 = ℎ𝑎𝑠ℎ 𝑡𝑎𝑏𝑙𝑒 𝑠𝑖𝑧𝑒 − 𝑛𝑜 𝑜𝑓 𝑠𝑙𝑜𝑡𝑠
𝛼 = 𝑙𝑜𝑎𝑑 𝑓𝑎𝑐𝑡𝑜𝑟
(ℎ𝑎𝑠ℎ(𝑘𝑒𝑦) + 1 ∗ 𝑑) % 𝑚
(ℎ𝑎𝑠ℎ(𝑘𝑒𝑦) + 𝑘 2 ) % 𝑚
(ℎ𝑎𝑠ℎ2 (𝑘𝑒𝑦) = 5 − (𝑘𝑒𝑦 % 5)
public void reverse() {
// Special case when head is null
if (head == null)
return;
ListNode<E> curr = head;
ListNode<E> next = null; // This will be correctly set later
ListNode<E> prev = null;
// While there is still more nodes
while (curr != null) {
// Remember the next node
next = curr.getNext();
// Reverse pointer for current node
curr.setNext(prev);
// Move on to the next node
prev = curr;
curr = next;
}
// Set the new head
head = prev;
}
public static void PowerSet(String finalString, String startString) {
// Base case. When there is only one character left in
// the starting string, print the finalString with and
// without that character.
if(startString.length() <= 1) {
System.out.println(finalString+startString);
System.out.println(finalString);
} else {
// Takes the first character out from the original
// string (startString), and recurse with cases
// where that character is both added and not
// added to the final string.
PowerSet(finalString + startString.charAt(0),
startString.substring(1));
PowerSet(finalString, startString.substring(1));
}
}
public static void PowerSet(String input) {
PowerSet("", input);
}
public static void main(String args[]) {
PowerSet("abc");
}
}
Hashtable
Hashmap
Hashtable(int initialCapacity) HashMap(int initialCapacity)
Hashtable(int intCapacity,
HashMap(int intCapacity,
float loadFactor)
float loadFactor)
put(K key, V value)
get(Object key)
isEmpty()
remove(Object key)
containsKey(Object key)
containsValue(Object value)
clear()
size()
clone()