COP3530 Final Exam Study Guide
Hash Table Worst Search
O(n)
Level Order Tree Traversal complexity
O(n)
Postorder traversal time complexity
O(n)
inorder traversal time complexity
O(n)
preorder traversal complexity
O(n)
Bubble Sort Worst Case
O(n^2)
Insertion Sort Worst Case
O(n^2)
Quick Sort Worst Case
O(n^2)
Selection Sort Worst Case
O(n^2)
Merge Sort Worst Case
O(nlogn)
Quick sort avg case
O(nlogn)
Heap
Ordered Binary Tree
level order traversal
Process all nodes of a tree by depth: first the root, then the children of the root, etc.
Set = red black tree
Same structure as red black tree
Binary Search Tree: search, insert, delete
Search: O(h) / balanced, O(lg n) Insert: O(h) / balanced, O(lg n) Delete: O(h) / balanced, O(lg n)
B-tree
Binary Tree- Structure for storing database indexes, each node in the tree contains a stored list of key values and links that correspond to ranges of key values between the listed values. The point is to allow SQL to make a yes/no decision for each phase of search
Divide and Conquer
Binary search, Quick Sort, Merge Sort
Hash table property
Each key = unique hash, unique keys, hash = key
Knapsack Problem
Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is <= a given limit and the total value is as large as possible -using dynamic programming - Ford Fulkerson Alg.
Map avg time complexity
O log(n)
Hash Table Average Search
O(1)
AVL Tree - Insert
O(log n)
Binary Search Worst Case
O(log n)
Greedy Algorithim examples
The greedy algorithm for the fractional knapsack problem takes a fractional amount of at most one item. Huffman Coding trees Dijikstra's shortest path traveling salesman problem
Separate Chaining
Uses a linked list to handle collisions at a specific point.
Load Factor
in a hash table, the fraction of the table's capacity that is filled.
Postorder Traversal
left subtree, right subtree, root
inorder traversal
left subtree, root, right subtree
Edge List for weighted graph
list of pairs, neighbor name and weight
B+ Tree
1) Maintain a copy of all keys in the leaves of the tree. 2) Create a linked-list out of the leaf nodes of the tree.
AVL Tree
a self-balancing sorted binary tree, in which the heights of subtrees differ by at most 1.
Heap Sort
Non-stable, in place sort which has an order of growth of O(NlogN). Requires only one spot of extra space. Works like an improved version of selection sort. It divides its input into a sorted and unsorted region, and iteratively shrinks the unsorted region by extracting the smallest element and moving it into the sorted region. It will make use of a heap structure instead of a linear time search to find the minimum.
Prim's Algorithm
(Minimum Spanning Trees, O(m + nlogn), where m is number of edges and n is the number of vertices) Starting from a vertex, grow the rest of the tree one edge at a time until all vertices are included. Greedily select the best local option from all available choices without regard to the global structure.
Kruskal's Algorithm
(Minimum Spanning Trees, O(mlogm) with a union find, which is fast for sparse graphs) Builds up connected components of vertices, repeatedly considering the lightest remaining edge and tests whether its two endpoints lie within the same connected component. If not, insert the edge and merge the two components into one.
preorder traversal
root, left subtree, right subtree
Binary Search Tree
A binary tree with the property that for all parent nodes, the left subtree contains only values less than the parent, and the right subtree contains only values greater than the parent.
maxheap
A binary tree with two added properties: It is a complete tree and for each node, the node is greater than or equal to both the left child and the right child.
minheap
A binary tree with two added properties: It is a complete tree, and for each node, the node is less than or equal to both the left child and the right child.
Binary Tree
A data structure that consists of nodes, with one root node at the base of the tree, and two nodes (left child and right child) extending from the root, and from each child node.
Hash Table
A data structure where the calculated value is used to mark the position in the table where the data item should be stored, enabling it to be accessed directly, rather than forcing a sequential search.
adjacency list
A linked list that identifies all the vertices to which a particular vertex is connected; each vertex has its own adjacency list.
Merge Sort
A list is split into individual lists, these are then combined (2 lists at a time).
Brute Force
A method for determining a solution to a problem by sequentially testing all possible solutions.
Collision Resolution Techniques
A method for handling collisions in a hash table, e.g. open addressing with linear probing, open addressing with double hashing, chaining, and buckets.
Selection Sort
A sort algorithm that repeatedly scans for the smallest item in the list and swaps it with the element at the current index. The index is then incremented, and the process repeats until the last two elements are sorted.
Huffman tree
A tree having the nodes representing symbols as the leaves, with more frequent symbols having nodes progressively closer to the root. The most frequent symbols are the closest to the root node. Note that internal nodes cannot represent symbols. The edges connecting children to parents are either 0 or 1. Convention must be established (e.g., left children have 0s, right children have 1s). The code for a symbol is built from 0s and 1s along the path from the root down to the desired symbol. Codes must be prefix free. abc:7 / \ ab:3 c:4 / \ a:1 b:2
Priority Queue: advantage, disadvantage
Advantage: cheap way to sort priorities, sometimes you want to do things first Disadvantage: worse at inserting and searching than BST
Binary Search
An ordered list is divided in 2 with each comparison.
Open Addressing
Any collision resolution scheme that places all the data in the hash table rather than relying on some way of storing some of the data outside the table.
Coin Change Problem
Dynamic Programming Problem, hint: a coin can either be used or not used to make the sum. Consider the scenarios for using it and not using it solution[i][j] = 0 if i=0 = 1 if j=0 = solution[i — 1][j] + solution[i][j — v[i — 1]] if(coin[i]<=j) = solution[i — 1][j]; if(coin[i]>j)
Insertion Sort
Each items is take in turn, compare to the items in a sorted list and placed in the correct position.
Depth First Search
Explore newest unexplored vertices first. Placed discovered vertices in a stack (or used recursion). Partitions edges into two classes: tree edges and back edges. Tree edges discover new vertices; back edges are ancestors.
unordered map
Implemented using hash table, avg cost O(1)
Complete Binary Tree
In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible.
Perfect Binary Tree
It is both full and complete. 2k - 1 nodes where k is the height
Quick Sort Pivot
Place at end, compare larger element than pivot on left half with smaller than pivot on right half, then swap, if left half < right half, swap with pivot
Suppose A is an array containing numbers in increasing order but some numbers occur more than once. When using binary search for the value, what happens
Sometimes it finds first, sometimes last value
Shell Sort
Starts by sorting pairs of elements far apart from each other, then progressively reducing the gap between elements to be compared. Starting with far apart elements can move some out-of-place elements into position faster than a simple nearest neighbor exchange.
Huffman Codes
Used for text compression, or any compression where the input data frequencies are imbalanced, e.g. in english the vowels, r,s, and t are much more common than q and z.
Map tree similarity
Uses bst tree structure
Breadth First Search
Visits the neighbor vertices before visiting the child vertices Often used to find the shortest path from one vertex to another. A queue is usually implemented
Collision Resolution
Ways of handling hashing collisions
Red-Black Tree cases
Worst case height of 2log(n+1). The nodes are either red or black. The root is black. If a node is red, its children MUST BE BLACK. Every path from a node to a leaf must contain the same number of black nodes. New insertions will always be red and always left leaning. Insertions must satisfy the conditions that red nodes have black children and that they have the same number of black nodes in all paths. Time complexity on its operations are O(logN).
Full Binary Tree
a binary tree in which all of the leaves are on the same level and every nonleaf node has two children
Linear Search
a method for finding a target value within a list. It sequentially checks each element of the list for the target value until a match is found or until all the elements have been searched.
Priority Queue
a queue in which the highest-priority elements are removed first; within a priority value, the earliest arrival is removed first.
Adjacency Matrix
a representation of a graph in which a boolean matrix contains a 1 at position (i,j) iff there is an arc from node i to node j.
Red-Black Tree
a self-balancing binary tree in which nodes are "colored" red or black. The longest path from the root to a leaf is no more than twice the length of the shortest path.
Dynamic Programming
an algorithmic paradigm that finds the solution to an optimization problem by recursively breaking down the problem into overlapping subproblems and combining their solutions with the help of a recurrence relation
Iterator
an object containing data and methods to iterate through a collection of data, allowing processing of one data item at a time.
Heapify
assumes part of array is already sorted, similar to create max heap
Create max heap
parent > child, root is largest element in tree, creates max heap in unsorted array, O(n)
disjoint sets
sets that do not have any elements in common
