CS 2420
Total number of possible nodes in a tree
2^height / 2^(height +1) - 1
Min Heap
A complete tree where each root is the smallest of its subtree. Exists to support priority queue
Stable Sorts
A sort that doesn't change the order of identical items. Example B A(1) A(2) sorted would be A(1) A(2) B. Mergesort Insertion sort
Complete Tree
A tree where all levels are filled, except the the bottom row, which is filled left to right. Represented implicitly as an array
Linear Probing
A way of dealing with collisions if hash(key) = H, and the cell at index H is occupied: H + 1 H + 2 H + 3 ... Size of the list must be a prime number to avoid cycles
Quadratic Probing
A way of dealing with collisions and clustering if hash(key) = H, and the cell at index H is occupied: H + 1^2 H+ 2^2 H + 3^2...
Separate Chaining
A way of dealing with collisions and clustering. A table is created with LinkedLists, and if hash(key) = H, and there is an item at index H, then it is added to the end of the LinkedList at that index
Complexity of Binary heaps
Add: O(c) on the average case, O(logN) in the worst case. This is because 75% of the nodes are in the last two rows. delete min: O(logN) on the average find min: O(c)
BST deletion and complexity
After finding the appropriate node (O(logN)): Three cases: 1. delete leaf node - delete node by setting it's parent reference to null. O(c) 2. delete node with one child - reassign it parent's reference to it's grandchild - O(c) 3. delete node with two children - replace item with successor (leftmost item in it's right subtree). Then delete the successor (which will be a leave node) - O(logN) Overall worst complexity is O(N), and best is O(logN).
Binary Search Tree
All items in the left subtree are less than the item in the node all items in the right subtree are greater than or equals to the item in the node
Hexadecimals
Base 16 code, similar to binary
Dijkstra's
Finds the cheapest path keep track of the total path cost from start node to the current node cost of path to next node is total cost so far plus weight of edge to the next node instead of traversing nodes in the order they were encountered, traverse in order of cheapest total cost first
BST insertion and complexity
First must search, and then insert as a leaf node Average: O(logN) worst: O(N) best: O(logN) All depends on how balanced the tree is
Sparse Graph
Graph with few edges More common, E = V (ish)
Dense Graph
Graph with lots of edges Less common, E = V^2 (ish)
Heap Sort
Heap-ify a list using a max heap 'delete' min and put it at the end of the list. Then the heap will repercolate and continue to do this until there is nothing left in the heap. This is an in place sort
Huffman Header
Include the character frequencies to decompress data store the tree using a pre-order traversal first bye is the hex value of the character, the next 8 bytes are the frequency, in hex. After the header is stored in hex, we encode the data in hex You have reached the end of the header when you have all ten 0 bytes
Complete Tree Equations
Left Child: (i*2) + 1 Right Child: (i*2) + 2 Parent: (i-1) / 2
Depth-First Search
Look at the first edge going out of the start node recursively search from the new node upon returning, take the next edge if no more edges, return When visiting a node, mark it as visited so we don't get stuck in a cycle
Adjacency Matrix
Matrix that represents vertices as columns and rows, with entry containing a 1 if an edge exists, and a 0 otherwise used for dense graphs
Complexity of Heap Sort
O(NLogN)
Collisions
Occurs in hash tables. Happens when two different items have the same hash function and go in the same index in an array.
Topological Search
Only works with a graph w/no cycles used for prioritizing tasks (example scheduling) Step through each node in the graph - if any node has in-degree 0, add it to a queue. while the queue is not empty - dequeue the first node, in the queue and add to the sorted list - visit that node's neighbors and decrease their in degree by 1. - if a neighbor's new in-degree is o, add it to the queue.
What was the name of the ethics professor?
Prof. Venkatasubramanian
Add to Min-heap
Put at the end of the heap percolate up, until it satisfies the order property
Constructing a Binary Trie
Put each node into a priority queue where the character with the least occurrences is higher priority. Break ties with the ASCII value of the leftmost node take the first two items out of the queue and construct a trie, with the root being the sum of the character frequencies.Put the trie back in the queue and repeat the first item taken out of the queue is always the left child. Make sure to include a end of file character
Breadth-First Search
Put the starting node in the a queue while the queue is not empty, queue the current node. for each unvisited neighbor of the current node, mark the neighbor as visited and put the neighbor into the queue.
In place sorts
Quicksort Heap sort Selection sort shell sort
Tree Terminology
Root: the start of a tree Parent: a root of a sub tree. A parent can only have two children in a binary tree Children: the nodes of a subtree. In a binary tree, each child can have one parent. Leaf Node: Nodes with no children Nodes: Any leaf of a tree
Red-Black trees
Self balancing tree BST with additional structure property: the longest path from the root to any leaf is no more than twice as long as the shortest path from the root to any other leaf in the tree A node is either red or black the root is black if a node is red, it's children must be black every path from a node to null link must contain the same number of black nodes
AVL trees
Self- balancing tree Adelson, Velskii, and Landis Uses rotations to re-balance the tree
Delete from heap
Switch the root with the last item in the tree and delete that item. Percolate the root down until you satisfy the order property
Load Factor
The fraction of the table that is full. For quadratic probing keep it to .5 to avoid cycles. For separate chaining it is defined as the average length of the Linked Lists If the load factor is reached, the table size is increased and everything is rehashed.
Balanced Tree
The height of the left and right sub-trees of any node can differ by at most 1.
Depth
The number of 'hops' it takes to get back to the root
BFS complexity
Worst Case: O(V+E)
DFS complexity
Worst Case: O(V+E)
Dijkstra's Complexity
Worst Case: O(V+E)*O(logV)
Binary Trie
a binary tree in which a left branch represents a 0 and a right branch represents a 1
Edge
a link between two vertices can be weighted and directional
Graph
a set of vertices connected by edges A tree is a subset of graphs A linked list is a graph
Adjacency List Complexity
confirming the existence of an edge for a vertex is O(E) iterating through all fo the edges is O(E) space complexity is O(V + E)
Adjacency Matrix comlexity
confirming the existence of an edge for a vertex is O(c) iterating through all the edges is O(V^2) space complexity is O(V^2)
Huffman compression
count occurances of each character in a string for each character, create a leaf node to store the character and count place each leaf node into a priority queue construct the binary trie write header with binary trie information compress string using character codes
Height
depth of the deepest node
Adjacency List
each vertex stores an array of adjacent vertex indices, usually as a linked list used for sparse graphs
Min-Max Heap
for any node E at even depth, E is the minimum element in its sub-tree for any node O at odd depth, O is the maximum element in its subtree
BST searching
if it's balanced O(logN), if it's not, O(N).
In-degree
number of edges it has incoming (degree of incoming edges)
Tree traversals
pre-order - will result in the complete replication of a tree (topologically sorted) In-order - prints the nodes in ascending order (for a bst) post-order - (doesn't result in a specific ordering) *remember flags*
AVL double rotation
switch roles of the deepest unbalanced node's child and grandchild. Then switch the roles of the deepest unbalanced node with new child while maintaining order property.
AVL single rotation
switch the roles of the deepest unbalanced node with child while maintaining the order property.
Hash Table
uses a hash function to add something to an index of an array. constant time operations Must be careful of collisions