COMP 2140
What's the two steps of a hash function?
#1 make the key into a hash code #2 make the integer into an array index --> compression map
branch
(edge) a connection between two nodes
What are the only possibilities of a 2-3 tree if h >1?
1) a root with two children 2) a root with three children
What is the height of a full tree?
2 ^ h - 1
among depth-first and breadth-first search, which one finds the shortest path?
Breadth-first
BigO of radix sort
O(d(N+n))
What should you use when traversing a graph
adjacency list
What's the condition for 2-3 tree nodes with two children when the index value is k1?
(keys of the data in TL) <k1 ≤ (keys of the data in TR)
What are the two kinds of collision resolution?
- open addressing: linear probing - separate chaining
What's the condition for 2-3 tree nodes with three children when the index value is k1, k2?
- the keys of data in Tl < k1 - k1 <= the keys of data in Tm < k2 - k2 <= the keys of data in Tr
what is considered a good hash function?
-minimize collisions -fast to compute
If you are at node heap[i], where is the left child, right child, and its parent?
1) Left child: heap[2i+1] if (2i+1) < heapSize 2) Right child: heap[2i +2] if (2i + 2) < heapSize 3) Parent: heap[(i-1)/2] if 0 <= (i-1)/2
What's special about expression trees?
1. parentheses and operator priorities are not needed 2. (in other words) for any arithmetic expression, there is only one corresponding expression tree
What is the height and running time for search, insert, and delete for a 2-3 tree?
2-3 tree containing n keys --> O(logn) for all
Priority Queues
A priority queue stores items with priorities and has operations : Insert & DeleteMax/DeleteMin
What does it mean for a tree to be heap ordered (partially ordered)?
A tree is heap ordered if, for each node v in the tree, the priority of the item contained in v is greater than (or equal to) the priorities of the items in its children
What possible implementations are there for a priority queue?
Array, LL, BST
What's the BigO for DeleteMax and Insert with array or LL implementation (in priority queue) ? How about BST?
DeleteMax : delete from front O(1) Insert : ordered insert O(n) Both O(n) for BST
What is one implementation of a ADT Table that takes O(1) for all insert, delete, and search?
Hash Table
Closed Hashing
Hash table consists of a fixed amount of storage, and every item is placed in a hash table slot in that limited storage (open addressing)
What is a heap?
Heap is a binary tree that is complete and heap ordered // JUST AN ARRAY
What should stack or queue operations never include?
LOOP
Are dummy nodes helpful all the time?
No, like in a circular linked list Queue
What is the height of the shortest tree with n nodes?
O(logn)
What BigO time does binary search take?
O(logn) : because binary search in an array is dividing the number of items left to be searched by two at each step
What is the height of the worst trees?
O(n)
What's the worst-case search time for a BST?
O(n), same as linked lists
BigO of Insertion sort
O(n^2)
BigO of selection sort
O(n^2)
BigO of quickSort
O(n^2) but in average O(nlogn)
BigO of Merge Sort
O(nlogn)
Parent, children, siblings
Parent is connected directly to its children & children of the same parents are siblings
Open Hashing
Storage is dynamically allocated - items are stored outside the table
Can 2-3 tree have height 0?
Yes
Expression Tree
a binary tree that represents an arithmetic expression composed of binary operators
ADT Table Data
a collection of entries, where each entry contains a key (a unique identifier for the entry) and the rest of the entry
What is an ADT (Abstract Data Type)?
a data structure together with a set of operations
What is a good implementation for a priority queue? and why?
a heap (binary tree stored in an array): O(logn) insert & deleteMax
Leaf
a node with no children
binary tree
a tree in which each node has at most two children
What's the worst height for a 2-3 tree with n keys? The insertion? The deletion?
all O(log2n) -> because it is tallest if most interior nodes have two children - that is, it is at worst a full binary tree
Where is the root shored in a heap?
always stored in heap[0], if the tree is not empty
tree traversal
an organized walk that visits every node once
What is 2-3 tree useful for implementing ADT table?
because the trees are always short
Complete Tree
binary tree of height h is complete if it is full to level h-1 and level h is filled from the left with contiguous nodes
What's a problem with Open addressing?
clustering & collisions become more and more likely as more insertions happen --> makes searches expensive!
binary tree == BST
false
BST Property
for each node j, the values stored in the left child tree of j are all less than the value stored in j, which is less than the all values stored in the right child tree of j
minimum value is BST
found by starting at the root and repeatedly moving to the left child until you reach a leaf
maximum value in BST
found by starting at the root and repeatedly moving to the right child until you reach a leaf
Full / Perfect binary tree
h (height) is full if on every level < h, every node has exactly two children
height of a tree
height of its root
Where are operators stored in an expression tree?
in the interior nodes
What are the values in the interior nodes in a 2-3 tree?
index values to guide a search to the correct leaf
Which method of traversal has an output in sorted order?
inorder traversal
Inorder successor of a node n
is the node n(is) containing the next higher value in the tree
Where are constant operands stored in an expression tree?
leaves
height of a node j
length of a longest path from j to one of its leaf descendants
depth of a node n
length of the path from the root of the tree to n
What is the goal of building a better tree?
make the longest path to be short = short tree OR full/perfect or complete trees
Can a search stop at an interior node?
no, a search MUST end at a leaf
descendant of node k
node j if there is a path from j to k that goes up, never down
ancestor of node j
node k if k is on the path from j to the root
interior nodes
nodes that have at least one child
in-degree of a node
number of edges coming in to the node
out-degree of a node
number of edges going out of the node
length of a path from node j to k
number of nodes on the path from j to k, including both j and k
What is the best way to compute node depths in a BST?
preorder traversal because a node's depth is one greater than its parent's depth; computing the depth of a child depends on the result of computing the depth of its parent
three standard ways to traverse a tree
preorder, postorder, and inorder traversal
Depth-first Traversal
searches all the way down a path before packing up to explore alternatives - it is a recursive, stack-based traversal
What kind of a number should you use as a constant when computing a hash code?
small prime number
Root
starting-point node of the data structure
What is special about the adjacency matrix of an undirected graph?
symmetric around the main diagonal
What is the condition of leaves in a 2-3 tree?
the leaves are all on the same level
level of a node
the length of the path from the node to the root
What creates the shape of the tree?
the order items were inserted
Breadth-first Traversal
visits all nearby vertices first before moving farther away - it is a iterative, queue-based traversal
When are graphs used
when complex relationships among data must be represented
When should you use post-order traversal?
when the task you are performing at a node depends on the results of the task performed at its children
When to use preorder traversal
when the tasks performed at the children of a node depend on the results of the task performed at the node itself (their parent)