C343 - Data Structures and Algorithms Final
Two Conditions of Binary Search Trees
1) All nodes in the left subtree of a node must be less than the parent node 2) All nodes in the right subtree of a node must be greater than the parent node
Max Heap Insertion Steps
1. Add new value to Heap, add to end of array. 2. If new value is greater than parent, swap with parent. 3. Do this iteratively until new value reaches correct position.
Building a Huffman Tree
1. Sort the table based on frequency 2. Choose the two smallest numbers - Smaller number goes on the left, larger on the right 3. Merge them and reorder list iteratively until all values are combined.
Heap Removal Steps
1. Swap the first element with the last element 2. Remove Last Element 3. Fix Heap using siftDown() (take θ(long)) Removes max value from a max heap and the min value from a min heap
Properties of Heaps
A complete binary tree, almost always implements as an array for complete binary trees Values stored are partially ordered, there is a relationship between the value of a node and the values of its children.
Complete Binary Tree
A tree where all levels except possibly the last is completely filled
Time Comparison of Array Based List VS Linked List Access
Array Based List: θ(1) Linked List: θ(n) Array Based Lists are faster
Time Comparison of Array Based List VS Linked List Insertion and Deletion
Array Based List: θ(n) Linked List: θ(1) Linked Lists are faster
Time Comparison of Array Based List VS Linked List Search
Array Based List: θ(n) Linked List: θ(n) No Benefit for Either
Heap Sort
Based on Heap data structure Not as fast as Quick Sort in the average case (by constant factor), but still used in some applications such as graphs.
Limitations of Bin Sort
Can't process duplicates Needs an array as large as the largest key Number of comparisons grow with he largest value in array, not by number of values in the array.
Closed Hashing
Collision Resolution goal is to find a free slot in the hash table when the home position is taken. Function p has two parameters: Key k and count i
Insertion Sort
Compares the first two elements, sorts, then adds the variables. Good when data is almost sorted
Merge Sort
Divide and Conquer Breaking the list to be sorted into pieces, process the pieces, and then putting them back together.
Full Binary Tree
Each node is either an internal node with two non-empty children, or a lead. (No node can have just one child)
Max Heap
Every node stores a value that is greater than or equal to that of its children Highest value is the root node Useful from finding the maximum, but not efficient when searching for values.
Min Heap
Every node stores a value that is less than or equal to that of its children. Lowest value is the root node
Hash Binning
Example: Given keys in range 0 - 999, and have a hash table of size 10. In this case, you simply divide the key value by 100. (1000/10) Divide amount of keys by size of table
Properties of Queues
FIFO - First In First Out Front = Pointer to the first element in the queue Rear = Pointer to the last element in the queue
Selection Sort
Finds the largest key in unsorted list, then next largest, and so on. Few record swaps
Decoding a Huffman Tree
For each bit in the Huffman Code: 0 = Left Branch 1 = Right Branch
Pseudo-Random Probing
Given a permutation: a list of integers that tells how many places to skip M = size of table r1 is the i-th value in a random permutation of the numbers from 1 to M-1 Probe sequence: (h(k) + ri) % M Eliminates primary clustering but not secondary clustering.
Properties of a Stack
LIFO - Last In First Out Top Variable = The Accessible Element of the Stack
Postorder Traversal
Left, Right, Root
Inorder Traversal
Left, Root, Right
Merge Sort Algorithm
List mergeSort(List inList) { if(inList.length() <= 1) { return inList; } List L1 = half of the items from inList; List L2 = other half of the items from inList; return merge(mergeSort(L1), mergeSort(L2)); } List merge(List L1, List L2) { List answer = new List(); while(L1 != NULL || L2 != NULL) { if(L2 == NULL) { answer.append(L2); L2 = NULL; } else if(L2 == NULL) { answer.append(L1); L1 = NULL; } else if(L1.value() <= L2.value()) { answer.append(L1.value()); L1 = L1.next(); } else { answer.append(L2.value()); L2 = L2.next(); } } return answer; }
Overall Time Comparison of Array Based List VS Linked List
Overall, Linked Lists are preferred due to insertion and deletion being most dominate.
Shell Sort
Performs insertion on sublists. First on small sublists then increasingly larger sublists.
Binary Tree Overhead
Pointer Size P Data Object Size D Regular Binary Tree: Total Space Taken By Overhead = 2P/(2P+D) Full Binary Tree: Total Space Taken By Overhead = P/(P+D)
Linear Probing
Probe Function: p(k, i) = i If home position is taken, then go to the next available spot (increments by 1) Leads to primary clustering, very bad choice
Preorder Traversal
Root, Left, Right
Open Hashing
Simplest form of open hashing defines each slot in the hash table to be the head of a linked list.
Radix Sort
Sorts based on the base 10 of the number Processes records with k digit keys in k passes, where each pass sorts the records according to the current digit. Efficient when the number of digits is small compared to the number of records if the n records all have unique key values, then at least Ω(long) digits are required, leading to an Ω(blown) sorting algorithm Tends to be much slower than Quick Sort and Merge Sort
Hash Mid-Square Method
Squares the key value, then takes out middle r bits of the result. Works well since most or all bits of the key value contribute to the result (unlike mod or binning)
Linear Probing by Steps
Using linear probing but skipping some slots Probe Function: p(k, i) = ci Constant c must be relatively prime to size of table to visit all slots in the table.
Functions of Queues
enqueue() - Adding variable to the end of the queue and assigning the rear value to it (As long as the queue is not full) dequeue() - Deleting and returning the front (first) element in the queue
Simple Bin Sort Algorithm
for(i = 0; i < A.length; i++) { B[A[i]] = A[i]; }
Selection Sort Algorithm
for(int i = 0; i < A.length-1; i++){ int bigIndex = 0; for(int j = 1; j < A.length-i; j++) { if(A[j].compareTo(A[bigIndex]) > 0) { bigIndex = j; } } Swap.swap(A, bigIndex, A.length-i-1); }
Insertion Sort Algorithm
for(int i = 1; i < A.length; i++){ for(int j = 1; (j > 0) && {A[j].compareTo(A[j-1]) < 0); j--){ Swap.swap(A, j, j-1); } }
Hash Mod Function
int h(int x) { return x % 16; }
Functions of a Stack
pop() - Takes the last item in the stack and returns it push() - Adds the item to the end of stack
BST Insertion Implementation
private BSTNode insert help(BSTNode rt, Comparable e){ if(rt == null){ return new BSTNode(e); } if(rt.value().compareTo(e) >= 0){ rt.setLeft(insert help(rt.left(), e)); } else{ rt.setRight(insert help(rt.right(), e)); } return rt; }
BST Deletion Implementation
private BSTNode removehelp(BSTNode rt, Comparable key){ if(rt == null){ return null; } if(rt.value().compareTo(key) > 0){ rt.setLeft(removehelp(rt.left(), key)); } else if(rt.value().compareTo(key) < 0) { rt.setRight(removehelp(rt.right(), key)); } else { if(rt.left() == null){ return rt.right(); } else if(rt.right() == null){ return rt.left(); } else { BSTNode temp = getmax(rt.left()); rt.setValue(temp.value()); rt.setLeft(deletemax(rt.left())); } } return rt; }
Bubble Sort Algorithm
static <T extends Comparable<T>> void bubble sort(T[ ] A) { for(int i = 0; i < A.length-1; i++) { for(int j = 1; j < A.length-i; j++){ if(A[j-1].compareTo(A[j]) > 0) { Swap.swap(A, j-1, j); } } } }
Quick Sort Algorithm
static int findPivot(Comparable[ ] A, int i, int j) { return (i + j) / 2; } static void quickSort(Comparable[ ] A, int i, int j) { int pivotIndex = findPivot(A, i, j); Swap.swap(A, pivotIndex, j); int k = partition(A, i, j-1, A[j]); Swap.swap(A, k, j); if((k - i) > 1) { quickSort(A, i, k-1); } if((j - k) > 1) { quickSort(A, k+1, j); } static int partition(Comparable[ ] A, int left, int right, Comparable pivot) { while( left <= right) { while(A[left].compareTo(pivot) < 0) { left++; } while((right >= left) && (A[right].compareTo(pivot) >= 0) { right--; } if(right > left) { Swap.swap(A, left, right); } } return left; }
Bin Sort Algorithm Modified to Hold Duplicates
static void binSort(int[ ] A) { List[ ] B = new LinkedList[MaxKeyValue + 1]; int item; for(int i = 0; i <= MaxKeyValue; i++) { B[i] = new LinkedList(); } for(int i = 0; i < A.length; i++) { B[A[i]].append(A[i]); } int pos = 0; for(int i = 0; i < MaxKeyValue; I++) { for(B[I].moveToStart(); (item = B[I].getValue()) != -1; B[I].next()) { A[pos++] = item; } } }
Heap Sort Algorithm
static void heapSort(Comparable[ ] A) { MaxHeap H = new MaxHeap(A, A.length, A.length); for(int i = 0; i < A.length; i++){ H.removemax(); } }
Radix Sort Algorithm
static void radix(Integer[ ] A, int k, int r) { Integer[ ] B = new Integer[A.length]; int[ ] count = new int[r]; int i, j, rtok; for(i = 0; rtok = 1; i < k; i++; rtok *= r) { for(j = 0; j < r; j++) { count[j] = 0; } for(j = 0; j < A.length; j++) { count[(A[j]/rtok)%r]++; } count[0] = count[0] - 1; for(j = 1; j < r; j++) { count[j] = count[j-1] + count[j]; } for(j = A.length-1; j >= 0; j--) { B[count[(A[j]/rtok)%r]] = A[j]; count[(A[j]/rtok)%r] -1; } for(j = 0; j < A.length; j++) { A[j] = B[j]; } } }
Shell Sort Algorithm
static void shell sort(int[ ] A) { for(int i = A.length/2; i > 2; i/=2) { for(int j = 0; j < I; j++) { insSort2(A, j, i); } } insSort2(A, 0, 1); } static void insSort2(int[ ] A, int start, int incr) { for(int i = start + incr; i < A.length; i += incr) { for(int j = I; (j >= incr) && (A[j] < A[j-incr]); j -= incr) { Swap.swap(A, j, j - incr); } } }
Time Complexity of Array Access
θ(1)
Time Complexity of Linked List Deletion
θ(1)
Time Complexity of Linked List Insertion
θ(1)
Time Complexity of Queue Deletion
θ(1)
Time Complexity of Queue Insertion
θ(1)
Time Complexity of Stack Deletion
θ(1)
Time Complexity of Stack Insertion
θ(1)
Best/Average Case of BST Access
θ(log(n))
Best/Average Case of BST Deletion
θ(log(n))
Best/Average Case of BST Insertion
θ(log(n))
Best/Average Case of Searching a BST
θ(log(n))
Worst Case Time Complexity of Heap Insertion
θ(logn)
Worst/Average Case Time Complexity of Heap Removal
θ(logn)
Best Case Time Complexity for Insertion Sort
θ(n)
Time Complexity of Array Deletion
θ(n)
Time Complexity of Array Insertion
θ(n)
Time Complexity of Linked List Access
θ(n)
Time Complexity of Queue Access
θ(n)
Time Complexity of Searching a Linked List
θ(n)
Time Complexity of Searching a Queue
θ(n)
Time Complexity of Searching a Stack
θ(n)
Time Complexity of Searching an Array
θ(n)
Time Complexity of Stack Access
θ(n)
Worst Case of BST Access
θ(n)
Worst Case of BST Deletion
θ(n)
Worst Case of BST Insertion
θ(n)
Worst Case of Searching a BST
θ(n)
Average Case Time Complexity of Bin Sort
θ(n+K)
Best Case Time Complexity of Bin Sort
θ(n+K)
Worst Case Time Complexity of Bin Sort
θ(n+K)
Average Case Time Complexity of Radix Sort
θ(nK)
Best Case Time Complexity of Radix Sort
θ(nK)
Worst Case Time Complexity of Radix Sort
θ(nK)
Average Case Time Complexity of Shell Sort
θ(n^1.5) or θ(n SqRt n)
Average Case Time Complexity for Insertion Sort
θ(n^2)
Average Case Time Complexity of Selection Sort
θ(n^2)
Best case Time Complexity of Selection Sort
θ(n^2)
Bubble Sort Average Case Time Complexity
θ(n^2)
Bubble Sort Best Case Time Complexity
θ(n^2)
Bubble Sort Worse Case Time Complexity
θ(n^2)
Worst Case Time Complexity for Insertion Sort
θ(n^2)
Worst Case Time Complexity of Quick Sort
θ(n^2)
Worst Case Time Complexity of Selection Sort
θ(n^2)
Average Case Time Complexity of Heap Sort
θ(nlogn)
Average Case Time Complexity of Merge Sort
θ(nlogn)
Average Case Time Complexity of Quick Sort
θ(nlogn)
Best Case Time Complexity of Heap Sort
θ(nlogn)
Best Case Time Complexity of Merge Sort
θ(nlogn)
Best Case Time Complexity of Quick Sort
θ(nlogn)
Worst Case Time Complexity of Heap Sort
θ(nlogn)
Worst Case Time Complexity of Merge Sort
θ(nlogn)
