CS 261 FINAL
Perfect Full Binary Tree
1. All leaves are at the same depth and all internal nodes have two children 2. height of h will have 2^h leaves 3. height of h will have 2^(h+1)-1 nodes
Open Address Hashing (adding and linear probing)
1. All values are stored in an array 2. if hashed value is already filled use linear probing to find next empty spot 3. If probing reaches end of the array wrap around to the front of the array
Adding nodes to heap (process)
Add from left to right, or at the end of the array and percolate up maintaining the max or min heap property
Edges
An edge between two vertices indicates they have some sort of relationship/connected
Binary Tree Application
Animal game/20 Questions
Binary Search tree vs. Binary Tree
Binary search tree = ADT Binary Tree = Data Structure
Data structure used to implement a knowledge base as in the "guess the animal game"
Binary tree(not BST) order doesn't matter
HeapSort Time Complexity
Build heap = O(nlogn) HeapSort = O(nlogn) total: O(nlogn)
Binary search algorithm Psuedocode
Check middle index if its not value split array according to if value is bigger (right) or smaller (left)
Best data structure to represent Priority queue ADT
Heap b/c items are constantly being added or removed so overall time will be saved when using heap
AVL Trees, height difference, time complexity for operations
Height Balanced Trees 1. For each node, the height difference between the left and right subtrees is at most one 2. O(logn) for bag operations
Traversal that produces elements of an AVL tree in sorted order.
In-order
Tree Traversal that goes in parenthesis added order
In-order
Searching time for a reasonably full (well balanced) tree
O(logn)
Time complexity for Binary Search
O(logn) b/c splitting array in two everytime
Average time of add() for a SortedArray
O(n)
Tree traversal time complexity
O(n)
Worst-case search time for a binary search tree
O(n) potentially a linked list
edge list space complexity
O(v+e)
Adjacency Matrix space complexity
O(v^2)
How can search be sped up with arrays
Order them
Parent and children nodes
Parent nodes are nodes that point to other nodes, and those other nodes are children. Every node has at least one parent
Node's depth
Path length from the root to that node
Tree traversal that goes in polish notation
Pre-order
Three common tree traversals (Depth-first traversals)
Pre-order (Node, left children, right children) in-order (Left children, node, right children) post-order(Left children, right children, node)
Best table sizes
Prime Numbers
Type of Rotations and How to rotate depending on type of rotation
RR (Left rotation around root), RL (right rotation around child, then left rotation around root) LL(right rotation around the root) LR(Left rotation around child, then right rotation around root)
Removing nodes from heap (process)
Remove first node and return it at the end. put last filled node at the start and remove it from the end or decrement size. Then percolate down
descendants
consists of a node's children and their children and so on. All nodes in a tree are descendants of the root node (except the root node)
Subtree
consists of the root node (root of that subtree) and all of its descendants
Finding children at index i in heap
left child of a node at index i = 2i+1 right child of a node at index i = 2i+2
Node's height
max path length from that node to a leaf node. Height of a tree is the height of the root node
To find the index of a children's parent node
parent of a node at index i = (i-1)/2
Tree traversal that goes in reverse polish notation
post-Order
ADT used when implementing an in-order tree traversal iterator
stack
Inserting into an AVL tree with n nodes requires looking at O(log n) nodes
true, because AVL trees are balanced
Priority Queue and operations
- ADT -Associates a priority with each element -First element has the highest priority (lowest value for prio) -Ex: to do lists, graph searching -Operations: add(), getmin(), and removemin()
Breadth-First Search
- BFS like a wave flowing through a maze - May not find it as quickly, but will always find a solution -BFS is guaranteed to find a path containing the least steps from start to goal
Bucket/Chain
- Collections in table entries
Depth-First Search
- DFS is like a single person working a maze -May take a certain route and have to backtrack a long way -Can get lucky and find solution very quickly -in an infinite path maze can get stuck in the infinite path
Types of graphs
- Directed or undirected - weighted or unweighted
Hash Function Goals
- Fast(constant time) -Produce uniformly distributed indices -repeatable (same key always results in same index)
Chaining HashTable
- Maintain a collection at each table entry (Linked List)
Graphs
- Represent relationships or connections -Each node may have many predecessors -May have loops or cycles
Heap Description
-Data structure used to to implement priority queues -Complete binary tree -Usually represented as an array
AVL Tree Balance Factor
-Determine if double rotation is needed -Height(right subtree) - height (left subtree)
Rotation right pseudocode
-New top node is the current top node's left child -New top's right child is the current node -Current node's new left child is the new top node's right child
Rotation left Pseudocode
-New top node is the current top node's right child -New top's left child is the current node -Current node's new right child is the new top node's left child
Edge List
-Unweighted: Linked lists that stores only the edges -More space efficient for sparse graphs (few edges) -weighted: stores edges and weights
Removing from Open Address HashTable and benefits
-Use TOMBSTONE to mark that a node has been deleted -TOMBSTONE marks deleted entry, can be replaced when adding a new entry, doesn't halt search during contains or remove
Vertices
-nodes that represent something, each vertex is unique
Hash Tables Description about value and indices
1. Elements can be indexed by values other than integers using a hash function 2. Multiple values may share an index
Complete Binary tree
1. Full except for the bottom level which is filled from left to right 2. Longest path is ceiling(logn) for n nodes Ex: heap and priority queue implmentation
Minimally perfect hash functions
1. No collisions 2. Table size = # of elements
Perfect Hash function
1. No collisions 2. Table size >= # of elements
Two approaches to resolving collisions
1. Open address hashing: if a spot is full, probe for next empty spot 2. Chaining (or buckets); keep a collection at each table entry (LinkedList)
Requirements for a binary tree
1. Parent's have to have unique children, can't point to the same children 2. Can't have loops in tree
Requirements for performing a binary search (array)
1. Random access to elements 2. Elements are already in sorted order
Basic Mod operations
5 mod 6 = 5 8 mod 6 = 2 (remainder when dividing 8/6)
Shifting
<< 1 ->Multiply by 2 >> 1 ->divide by 2
Heap Time complexities for general heap operations
Add = logn getMin = 1 removeMin = logn
Binary Search (contains, insert) time complexity
Contains: O(logN) Insert: O(N) -> Need to adjust array
Casts
Convert a numeric type into an integer (turning a string into a number)
Full Binary Tree
Every node is either a leaf or has exactly 2 children
Min heap
Every node's value is less than or equal to the value of its children
Max heap
Every node's value is more than or equal to the value of its children
What can a BST produce in terms of ADT?
Faster bag implementations
Dijkstra's Algorithm
Finds the shortest/lowest cost path from a specified vertex in a graph to all other reachable vertices in the graph (weighted graph) -> priority queue -Cost-first search
Hash Table basic steps
Give a hash function a key and it turns it into an index value, and places the key value in the hash table
Does every key in a hash table need to be unique?
Yes, that is the entire point of storing key/value pairs.
Folding
Key partitioned into parts when are then combined using basic math operations
Load factor (Chaining)
Lambda = number of elements/size of the table -Represents the average number of elements in each bucket (can be more than 1) - If this reaches a certain MAX_LOAD_FACTOR(8) then resize
Load Factor (Open-address
Lambda = number of elements/size of the table -portion of the tables that is filled (between 0 and 1) -if this reaches a certain MAX_LOAD_FACTOR then we need to resize and rehash the table
Mapping
Map (a part of) the key into an integer
Does each key in the hash table need to hash to a unique value?
No, but we should use a hash function with as few collisions as possible
Binary Search Tree requirements
Node values are less than the parent in the left subtree and greater than the parent in the right subtree
Siblings
Nodes that have the same parent
Interior Nodes
Nodes with children
Leaf Nodes
Nodes with no children
Path's length
Number of arcs traversed
Average case to add for an unsorted dynArray
O(1)
Hash table bag operation time complexity
O(1) time for bag operations if uniformly distributed so no collisions occur
Average case to remove from an AVL tree
O(Logn)
Space complexity for BFS and DFS
O(V) -In practice BFS will take more space because it stores all the paths
Dijkstra's Algorithm Space Complexity
O(V+ElogE)
Root Node
Single node usually drawn at the top of the tree and has no parent
Singly Source Reachability
Stack -> Depth-First-Search
Issue with representing a heap when it is not complete or unbalanced
The dynarray will be filled with holes because several indices will have NULL values
Adjacency matrix (weighted and unweighted)
Unweighted: 2d array that stores a value of 1 if it has an edge with another vertex (x and y are both cities). Weighted: stores the weight instead of the number 1
Root or first element of a heap
Value with the highest priority indicated either with the highest priority value (max heap) or the lowest priority value (min heap)
Euler Tour
Walks around the tree's perimeter without crossing edges. 1st visit: left side of node (preorder) 2nd visit: bottom side of the node (inorder) 3rd visit: right side of node (postorder)
Worst case and Best case Open Address Hashing and chaining
Worst Case -> all values have the same position O(n) Best Case -> Uniformly distributes O(1)
Time complexity for Binary Search Tree (AVL Tree) bag operations (add, contains, remove)
add = logn contains = logn remove = logn
Time complexity for Ordered Array bag operations (add, contains, remove)
add = n contains = logn remove = n
What kind of data structure is binary search effective on
arrays or trees
Directed arcs
arrows pointing to children
The height of any binary tree with n nodes is always O(log n)
false, due to unbalanced trees that have height n
This tree is efficiently stored in an array.
heap
Does the hash table performance increase or decrease as the number of buckets increases?
increase, less collisions
To get an index value from a hashed value
int idx = hashfunction(data) % ht->capacity(size of table)
