CSCI 251 Ch. 6 Trees
Consider the following tree. Each question starts from the original tree. Use this text notation for the tree: (20 (12 (11, -), 23 (21, 30))). The - means the child does not exist. What is the tree after removing 12? (20 (- (11, -), 23 (21, 30))) (20 (11, 23 (21, 30)))
(20 (11, 23 (21, 30)))
Consider the following tree. Each question starts from the original tree. Use this text notation for the tree: (20 (12 (11, -), 23 (21, 30))). The - means the child does not exist. What is the tree after removing 21? (20 (12 (11, -), 23 (-, 30))) (20 (12 (11, -), 23))
(20 (12 (11, -), 23 (-, 30)))
Consider the following tree. Each question starts from the original tree. Use this text notation for the tree: (20 (12 (11, -), 23 (21, 30))). The - means the child does not exist. What is the tree after removing 20? (21 (12 (11, -), 23 (-, 30))) (23 (12 (11, -), 30 (21, -)))
(21 (12 (11, -), 23 (-, 30)))
A tree with just one node has height _____
0
Assume a trie is built by executing the following code. trieRoot = new TrieNode() TrieInsert(trieRoot, "cat") TrieInsert(trieRoot, "cow") TrieInsert(trieRoot, "crow") If TrieInsert(trieRoot, "cow") is called a second time, _____ new nodes are created. 0 1 4
0
The root node thus has depth ____
0
A new BST is built by inserting nodes in this order: 6 2 8 What is the tree height? (Remember, the root is at height 0)
1
Searching a BST in the worst case requires H + ____ comparisons, meaning O(H) comparisons, where H is the tree height.
1
The following operations are executed on the above tree: BSTInsert(tree, node 70) BSTInsert(tree, node 56) BSTRemove(tree, 67) How many times is BSTRemoveNode called when removing node 67? 1 2 3
1
In searching for 145, what node is visited second?
100
What node is printed first?
11
Where will a new node 11 be inserted? (So two nodes of 11 will exist). 11's left child 11's right child
11's right child
Where will a new node 18 be inserted? 12's right child 11's right child
12's right child
In searching for 145, what node is visited third?
145
Determine cur's next assignment given the key and current node. key = 6, cur = 47 6 19 48
19
A new BST is built by inserting nodes in this order: 20 12 23 18 30 What is the tree height?
2
The following operations are executed on the above tree: BSTInsert(tree, node 70) BSTInsert(tree, node 56) BSTRemove(tree, 67) How many times is BSTInsertRecursive called when inserting node 56? 2 3 5
2
The following operations are executed on the above tree: BSTInsert(tree, node 70) BSTInsert(tree, node 56) BSTRemove(tree, 67) What is the maximum number of calls to BSTRemoveNode when removing one of the tree's nodes? 2 4 5
2 BSTRemoveNode is always called once by BSTRemove. BSTRemoveNode makes at most 1 recursive call in the case of removing an internal node with 2 children. That recursive call is guaranteed not to make additional recursive calls, so the maximum number of times BSTRemoveNode is called is 2.
When searching for key 21, what node is visited first? 20 21
20
When searching for key 21, what node is visited third? 21 30
21
When searching for key 21, what node is visited second? 12 23
23
A new BST is built by inserting 255 nodes in sorted order. What is the tree height?
254 The tree basically becomes a list, with every node having just one child.
When inserting a new node with key 35, what node is visited third?
28
How many calls to BSTSearchRecursive are made by calling BSTSearch(tree, 71)? 2 3 4
3
What is the depth of the "Mountains.jpg" file node? 3 4
3
What is the height of this tree? 3 4 14
3
What is the maximum loop iterations for a perfect binary tree with 7 nodes, if a node matches? 3 7
3
What is the worst case (largest) number of nodes visited when searching for a key?
3
What is the maximum loop iterations for a perfect binary tree with 7 nodes, if a node matches? 3 7
3 The tree has 3 levels. Iteration 1 checks the first level, 2 the second, 3 the third (which assigns current with null because a leaf has no children). Iteration 4 never occurs because the current node is null.
Assume a perfect 7-node BST. How many algorithm loop iterations will occur for an insert? 3 7
3 The tree has 3 levels. Iteration 1 visits the first level. Iteration 2 visits the second level. Iteration 3 visits the third level, whose node has no children, and inserts the new node as that node's child.
In searching for 145, what node is visited first?
300
Complete the tree traversal after node 300's left subtree has been printed. 11 25 100 201
300, 750, 775, 925
Which nodes would be visited when searching for 900? Write nodes in order visited, as: 5, 10
300, 900
Which nodes would be visited when searching for 800? Write nodes in order visited, as: 5, 10, 15
300, 900, 750
When searching for key 45, what node is visited second?
33
Determine cur's next assignment given the key and current node. key = 40, cur = 27 27 21 39
39
A new BST is built by inserting nodes in this order: 30 11 23 21 20 What is the tree height?
4
A new BST is built by inserting nodes in this order: 30 23 21 20 18 What is the tree height?
4
Assume a trie is built by executing the following code. trieRoot = new TrieNode() TrieInsert(trieRoot, "cat") TrieInsert(trieRoot, "cow") TrieInsert(trieRoot, "crow") When inserting "cat", _____ new nodes are created. 1 3 4
4
Assume a trie is built by executing the following code. trieRoot = new TrieNode() TrieInsert(trieRoot, "cat") TrieInsert(trieRoot, "cow") TrieInsert(trieRoot, "crow") When inserting "crow", _____ new nodes are created. 1 4 5
4
How many calls to BSTSearchRecursive are made by calling BSTSearch(tree, 49)? 3 4 5
4
How many internal nodes does the tree have?
4
What is the maximum possible number of calls to BSTSearchRecursive when searching the tree? 4 5
5
What is the worst case (largest) number of comparisons given a BST with N nodes?
5
What is the worst case (largest) number of comparisons given a BST with N nodes? Perfect BST with N = 31 31 4 5
5
When searching for key 45, what node is visited first?
52
When inserting a new node with key 35, what node is visited second?
64
A new BST is built by inserting 255 nodes in random order. What is the minimum possible tree height?
7
When inserting a new node with key 35, what node is visited first?
7
How many nodes are visited?
8
Assume a perfect 255-node BST. How many algorithm loop iterations will occur for an insert? 8 255
8 The tree has 8 levels. Each iteration visits a level, descending left or right depending on the new and current nodes' keys. A main benefit of a BST is that inserts require only O(logN) iterations to find the proper insert location in a nearly-full N-node tree.
What is the maximum loop iterations for a perfect binary tree with 255 nodes? 8 255
8 The tree has 8 levels. Each iteration visits one level.
TrieSearch will visit at most _____ nodes in a single search. 7 9 41
9
Determine cur's next assignment given the key and current node. key 91, cur = 99 86 91 124
91
BST insert complexity
A BST with N nodes has at least log2N levels and at most N levels. Therefore, the runtime complexity of insertion is best case O(logN) and worst case O(N).
BST remove complexity
A BST with N nodes has at least log2N levels and at most N levels. Therefore, the runtime complexity of removal is best case O(logN) and worst case O(N).
Which operation would increase the height of the tree? Adding a new file into the user1 directory Adding a new directory into the "Image files" directory Adding a new directory into the "Research" directory
Adding a new directory into the "Research" directory
A binary tree used to store information for binary space partitioning
BSP tree
Starting from the root, the BST inorder traversal algorithm recursively prints the left subtree, the current node, and the right subtree.
BSTPrintInorder(node) { if (node is null) return BSTPrintInorder(node⇢left) Print node BSTPrintInorder(node⇢right) }
BST search algorithm
BSTSearch(tree, key) { cur = tree⇢root while (cur is not null) { if (key == cur⇢key) { return cur // Found } else if (key < cur⇢key) { cur = cur⇢left } else { cur = cur⇢right } } return null // Not found }
A technique of repeatedly separating a region of space into 2 parts and cataloging objects contained within the regions
Binary space partitioning (BSP)
The tree has four leaf nodes: Kumar, Lee, Gong, and _____.
Carvey
Trie insert rules
For each character C: 1. A new child node is added only if the current node does not have a child for C. 2. The current node pointer is assigned with the current node's child for C. 3. After all characters are processed, a terminal node is added and returned.
BST GetHeight rules
Given a node representing a BST subtree, the height can be computed as follows: 1. If the node is null, return -1. 2. Otherwise recursively compute the left and right child subtree heights, and return 1 plus the greater of the 2 child subtrees' heights.
Root node: _____
Jones
Smith's left child: ____
Kumar
The maximum N-node binary tree height is _____ (the - 1 is because the root is at height 0).
N - 1
The following operations are executed on the above tree: BSTInsert(tree, node 70) BSTInsert(tree, node 56) BSTRemove(tree, 67) Where is node 70 inserted? Node 67's left child Node 71's left child Node 71's right child
Node 71's left child
Consider the following tree. Each question starts from the original tree. Use this text notation for the tree: (20 (12 (11, -), 23 (21, 30))). The - means the child does not exist. Removing a node from an N-node nearly-full BST has what computational complexity? O(logN) O(N)
O(logN)
Determine cur's next assignment given the key and current node. key 350, cur = 400 Search terminates and returns null. 400 500
Search terminates and returns null.
What is the parent of the "Text files" node? The "user2" directory node The "Image files" directory node The "Sample1.txt" file node.
The "user2" directory node
If the child to be visited is null, when does the algorithm return null? Immediately Upon exiting the loop
Upon exiting the loop
A node's _______ include the node's parent, the parent's parent, etc., up to the tree's root.
ancestors
An especially useful form of binary tree is a ________ (BST), which has an ordering property that any node's left subtree keys ≤ the node's key, and the right subtree's keys ≥ the node's key. That property enables fast searching for an item
binary search tree
In a _______, each node has up to two children, known as a left child and a right child.
binary tree
A binary tree is ________ if all levels, except possibly the last level, contain all possible nodes and all nodes in the last level are as far left as possible.
complete
Determine the insertion algorithm's next step given the new node's key and the current node. key = 7, currentNode = 29 currentNode⇢left = node currentNode = currentNode⇢right currentNode = currentNode⇢left
currentNode = currentNode⇢left
Determine the insertion algorithm's next step given the new node's key and the current node. key = 600, currentNode = 400 currentNode⇢left = node currentNode = currentNode⇢right currentNode⇢right = node
currentNode = currentNode⇢right
Determine the insertion algorithm's next step given the new node's key and the current node. key = 53, currentNode = 76 currentNode⇢left = node currentNode⇢right = node tree⇢root = node
currentNode⇢left = node
Determine the insertion algorithm's next step given the new node's key and the current node. key = 18, currentNode = 12 currentNode⇢left = node currentNode⇢right = node currentNode = currentNode⇢right
currentNode⇢right = node
The number of edges on the path from the root to the node
depth
The link from a node to a child
edge
A directory in a file system tree is always an internal node. True False
false
A's depth is 1. True False
false
Adding the string "balance" would create a new branch off the root node. True False
false
BSTGetParent always returns a non-null node when searching for a null node. True False
false
BSTInsert will not work if the tree's root is null. True False
false
BSTRemoveNode uses BSTRemoveKey. True False
false
BSTRemoveNode will not work to remove the last node in a tree. True False
false
D, F, and H form level 2. True False
false
The terminal nodes can be removed, and instead the last character of a string can be a leaf. True False
false
950's successor is 150. True False
false 950 is the largest BST item, so has no successor. The BST's largest item is the root's rightmost child: Follow right children until reaching a node with no right child (may be the root itself).
The worst-case time complexity for BSTGetHeight is O(log N), where N is the number of nodes in the tree. True False
false BSTGetHeight is called for every node in the tree, so the time complexity is O(N), not O(log N).
500's successor is 850. True False
false The next larger item is 750. For a node with a right subtree, the successor is the leftmost child of the right subtree.
When traversing down a BSP tree, half the objects are eliminated each level. True False
false The partitioning of space doesn't necessarily put half the objects in each half region. Ex: In the animation, C and D are the two halves split from the world's right half, but C contains 5 of the 7 objects and D the other 2.
Adding the string "balance" would create a new branch off the root node.
false The root already has a child for the character b and the character a is a child of b. The node for character a will be reused if "balance" is inserted.
The terminal nodes can be removed, and instead the last character of a string can be a leaf.
false Without the terminal nodes, knowing that both "cat" and "cats" are two separate strings in the same tree is not possible.
BSTRemoveKey will not properly update parent pointers when a non-root node is being removed. True False
false All cases properly update parent pointers. When removing a non-root node, BSTReplaceChild properly updates parent pointers.
A binary tree is _____ if every node contains 0 or 2 children
full
Identifying special types of binary trees. (full, complete, perfect) Tree 3:
full, complete, perfect
Identifying special types of binary trees (full, complete, perfect) Tree 1:
full, not complete, not perfect
A tree's _______ is the largest depth of any node
height
Recall that a tree's ______ is the maximum edges from the root to any leaf.
height
Trees are commonly used to represent ________ data
hierarchical
Searching a BST algorithm
if (currentNode⇢key == desiredKey) { return currentNode; // The desired node was found } else if (desiredKey < currentNode⇢key) { // Visit left child, repeat } else if (desiredKey > currentNode⇢key) { // Visit right child, repeat }
If the current node matches the key, when does the algorithm return the node? Immediately Upon exiting the loop
immediately
An ________ visits all nodes in a BST from smallest to largest, which is useful for example to print the tree's nodes in sorted order.
inorder traversal
Given a new node, a BST ______ operation inserts the new node in a proper location obeying the BST ordering property.
insert
Given a string, a trie _____ operation creates a path from the root to a terminal node that visits all the string's characters in sequence.
insert
Suppose node 23 was instead 21, meaning two 21 nodes exist (which is allowed in a BST). When searching for 21, which node will be returned? Leaf Internal
internal
A node with at least one child
internal node
A tree node with no children
leaf
In a BST, if desired key equals current node's key, return found. If less, descend to _____ child. If greater, descend to _____ child.
left, right
BST ordering property: For three nodes, left child is ______-than-or-equal-to parent, parent is _____-than-or-equal-to right child. For more nodes, all keys in subtrees must satisfy the property, for every node.
less
All nodes with the same depth form a tree _______
level
A binary tree's height can be minimized by keeping all levels full, except possibly the last level. Such an "all-but-last-level-full" binary tree's height is H=⌊______⌋.
log2N
The minimum N-node binary tree height is h=⌊______⌋, achieved when each level is full except possibly the last.
log2N
A major BST benefit is that an N-node binary tree's height may be as small as O(_____), yielding extremely fast searches. Ex: A 10,000 node list may require 10,000 comparisons, but a 10,000 node BST may require only 14 comparisons.
logN
In a BTS, inserting items in nearly-sorted order leads to a nearly-________ tree height.
maximum
Searching a BST is fast if the tree's height is near the ______. Inserting items in random order naturally keeps a BST's height near the _______.
minimum
Does node 200 and the node's subtrees obey the BST ordering property? Yes No
no 201 is in 200's left subtree, but is not ≤ 200.
Does node 750 and the node's subtrees obey the BST ordering property? Yes No
no 800 is in 750's left subtree but is not ≤ 750
Is the tree a binary search tree? Yes No
no Each node and the node's subtrees must obey the BST ordering property.
Identifying special types of binary trees. (full, complete, perfect) Tree 4:
not full, complete, not perfect
Identifying special types of binary trees (full, complete, perfect) Tree 2:
not full, not complete, not perfect
BSTRemoveKey will not work if the key is not in the tree. True False
null
TrieSearch(root, "PINEAPPLE") returns _____. the trie's root node the terminal node for "APPLE" null
null
When searching for key 45, what node is visited third?
null
A node with a child
parent
A binary tree is ________, if all internal nodes have 2 children and all leaf nodes are at the same level.
perfect
A BST node's ________ is the node that comes before in the BST ordering
predecessor
Given a key, a BST ______ operation removes the first-found matching node, restructuring the tree to preserve the BST ordering property.
remove
Given a string, a trie _______ operation removes the string's corresponding terminal node and all non-root ancestors with 0 children.
remove
Where is the new node inserted? Type: left or right
right
Using left, current, and right, what ordering will print the BST from largest to smallest? Ex: An inorder traversal uses left current right.
right, current, left
A node inserted into an empty tree will become the tree's _____
root
The one tree node with no parent (the "top" node)
root
Given a key, a ______ algorithm returns the first node found matching that key, or returns null if a matching node is not found.
search
Given a string, a trie _______ operation returns the terminal node corresponding to that string, or null if the string is not in the trie.
search
BST GetHeight algorithm
see image
BST get parent algorithm
see image
BST insert algorithm
see image
BST remove algorithm
see image
BSTInsert algorithm for BSTs with nodes containing parent pointers
see image
BSTRemoveKey and BSTRemoveNode algorithms for BSTs with nodes containing parent pointers
see image
BSTReplaceChild algorithm
see image
BTS Search recursive algorithm
see image
Recursive BST insertion
see image
Recursive BST removal
see image
Trie insert algorithm
see image
Trie remove algorithm
see image
Trie search algorithm
see image
A BST node's ________ is the node that comes after in the BST ordering
successor
A ________ is a node that represents a terminating character, which is the end of a string in the trie.
terminal node
When searching for "PLUM", _____ visited. only the root node is the root and the root's 'P' child node are all nodes in the root's 'P' child subtree are
the root and the root's 'P' child node are
A _______ algorithm visits all nodes in the tree once and performs an operation on each node.
tree traversal
Determine the insertion algorithm's next step given the new node's key and the current node. key = 87, currentNode = null, tree⇢root = null (empty tree) tree⇢root = node currentNode⇢right = node currentNode⇢left = node
tree⇢root = node
A _____ (or prefix tree) is a tree representing a set of strings. Each node represents a single character and has at most one child per distinct alphabet character.
trie
950's predecessor is 900. True False
true
A BST implementation often includes a parent pointer inside each node. True False
true
A file in a file system tree is always a leaf node. True False
true
A tree with just one node has height 0. True False
true
All calls to BSTRemoveNode to remove a non-root node will result in a call to BSTReplaceChild. True False
true
B and C form level 1. True False
true
BST search can be implemented using recursion True False
true
BSTGetHeight returns 0 for a tree with a single node. True False
true
BSTGetParent returns null when the node argument is the tree's root. True False
true
BSTRemoveKey uses BSTRemoveNode. True False
true
BSTRemoveNode may use recursion. True False
true
BSTReplaceChild will not work if the parent pointer is null. True False
true
Certain binary tree structures can affect the speed of operations on the tree True False
true
E's depth is 2. True False
true
In a BST without parent pointers, a search for a node's parent can be implemented recursively. True False
true
The base case for BSTGetParentRecursive is when subtreeRoot is null or is node's parent. True False
true
The tree's height is 4. True False
true
Using a tree data structure to implement a file system requires that each directory node support a variable number of children. True False
true
The first node in the BST ordering is 150. True False
true 150 is the smallest item in the BST. The BST's first node is the leftmost child of the root: Follow left children until reaching a node with no left child (may be the root itself).
150's successor is 250. True False
true 250 is the next-larger item. If a node has a right subtree, the successor is the leftmost child of that subtree.
250's successor is 300. True False
true If a node has no right child, the successor will be the first ancestor having this node in a left subtree. A node's successor need not involve a direct link.
A BSP implementation could choose to split regions in arbitrary locations, instead of right down the middle. True False
true In practice, most BSP implementations partition according to how objects exist in the world. Regions are not always split down the middle, nor are the splits always horizontal or vertical.
Inserting a string that doesn't already exist in the trie requires allocation of at least 1 new node.
true The inserted string may be a prefix of another string in the trie, thus sharing existing nodes for each character, but a terminal node is still required for the new string.
BSTGetHeight would also work if the recursive call on the right child was made before the recursive call on the left child. True False
true The order of the two recursive calls does not matter. As long as the 2 recursive calls are made and the greater of the 2 returned heights is used, BSTGetHeight will properly determine the tree height.
In the animation, if the parts of the screen were in 2 different regions, then all objects from the 2 regions would have to be analyzed when rendering. True False
true The screen isn't guaranteed to be contained within a single BSP region, so analyzing objects from multiple regions may be required.
The base case for BSTGetHeight is when the node argument is null. True False
true When the node argument is null, BSTGetHeight returns -1 and does not make any recursive calls.
BSP can be used in 3-D graphics as well as 2-D. True False
true When used for 3-D rendering, each node still represents a region of space and the objects contained within. 3-D regions can be split in 2 using a plane. One child represents content on one side of the plane and the other child represents content on the other side.
Inserting a string that doesn't already exist in the trie requires allocation of at least 1 new node. True False
true a terminal node is required for the new string
The tree has an internal node, Gupta, with only one child rather than two. Is the tree still a binary tree? Type yes or no.
yes
Does node 150 and the node's subtrees obey the BST ordering property? Yes No
yes 150 ≤ 201. 150 has no left subtree, which is OK.
Would inserting 300 as the right child of 200 obey the BST ordering property (considering only nodes 300, 200, and 500)? Yes No
yes 200 ≤ 300. 200 and 300 are both ≤ 500.
Does node 900 and the node's subtrees obey the BST ordering property? Yes No
yes 850 ≤ 900, and 900 ≤ 950
Is the tree a binary tree? Yes No
yes Each binary tree node may each have up to two children; no ordering is required.
What is the worst case (largest) number of comparisons given a BST with N nodes? Perfect BST with N = 7 ⌊log2N⌋ ⌊log2N⌋+1 N
⌊log2N⌋+1