Chapter 5: Binary Trees
Binary search tree(BST) ordering properties
1. left child <= parent 2. right child => parent
What is the maximum number of calls to BSTRemoveNode when removing one of the tree's nodes?
2 maximum number of times - 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.
What is the worst-case (largest) number of comparisons given a BST with N nodes? 2) Perfect BST with N = 31
- 5 - In the worst case, searching a perfect BST requires( height of BST + 1) comparisons so: [log2(31)] + 1 = 5
What is the worst-case (largest) number of comparisons given a BST with N nodes? 1) Perfect BST with N = 7
- [log2N] + 1 - In the worst case, searching a perfect BST requires (height of BST + 1) comparisons so: [log2(7)] + 1 = 3
BSP tree
binary tree used to store information for binary space partitioning. Each node in a BSP tree contains information about a region of space and which objects are contained in the region.
(T/F) The worst-case time complexity for BSTGetHeight is O(log N), where N is the number of nodes in the tree.
false - BSTGetHeight is called for every node in the tree, so the time complexity is O(N), not O(logN).
The minimum N-node binary tree height is
h = [log2N]
Trees are commonly used to represent
hierarchical data ex: a file system is a hierarchy
node's ancestors
include the node's parent, the parent's parent, etc., up to the tree's root
BST In-order traversal
inorder traversal visits all nodes in a BST from smallest to largest. - Starting from the root, the algorithm recursively prints the left subtree, the current node, and the right subtree
BST insert operation
inserts the new node in a proper location obeying the BST ordering property.
Children of a Binary Tree are called.. ?
left child and a right child
depth
A node's depth is the number of edges on the path from the root to the node. The root node thus has a depth 0.
BST GetHeight algorithm
Given a node representing a BST subtree, the height can be computed as follows: - If the node is null, return -1 - Otherwise recursively compute the left and right child subtree heights, and return 1 plus the greater of the child's subtrees' heights
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 height is ______
H = [log2N]
Search for insert location
If the left(or right) child is not null, the algorithm assigns the current node with that child and continues searching for a proper insert location
Insert as right child
If the new node's key is greater than or equal to the current node, and the current node's right child is null, the algorithm assigns the node's right child with the new node
Insert as left child
If the new node's key is less than the current node, and the current node's left child is null, the algorithm assigns that node's left child with the new node
The maximum N-node binary tree height is
N - 1 (the -1 because the root is at height 0).
BST removal space complexity
O(1)
A perfect binary tree search is O(H), so ___
O(logN)
(T/F) Using a tree data structure to implement a file system requires that each directory node support a variable number of children
True - unlike binary trees that have a fixed number of children per node, aa file system tree must support a variable number of children per directory node.
(T/F) BSTGetHeight returns 0 for a tree with a single node.
True -a tree's height is the maximum edges from the root to any leaf. A tree with 1 node has 0 edges and therefore a height of 0.
(T/F) The base case for BSTGetHeight is when the node argument is null.
True, when the node argument is null, BSTGetHeight returns -1 and does not make any recrusive calls.
BST insert algorithm complexity
a BST with N nodes has at least log2N level and at most N levels. Therefore, the runtime complexity of insertion is best case O(logN) and worst case O(N). The space complexity of insertion is O(1) because only a single pointer is used to traverse the tree to find the insertion location.
parent
a node with a child is said to be that child's parent
Binary space partitioning (BSP)
a technique of repeatedly separating a region of space into 2 parts and cataloging objects contained within the regions.
binary tree
a tree in which each node has at most two children.
leaf
a tree node with no children
A binary tree is perfect if ____
all internal nodes have 2 children and all leaf node are at the same level
A binary tree is complete if ___
all levels except possibly the last are completely full, and the last level has all its nodes to the left side
BST removal best and worst case runtime complexity
best: O(logN) worst: O(N)
A binary tree is full if ____
each node is either a leaf (0 children) or has exactly two child nodes.
A BST with N node has at least ____
log2N level and at most N levels
inserting items in random order naturally keeps a BST's height near the ____.
minimum
internal node
node with at least one child
root
one tree node with no parent( the "top node)
BST search can be implemented using
recursion
Searching a BST starts by visiting the ____
root node
A tree's height is ____
the largest depth of any node. A tree with just one node has height 0.
edge
the link from a node to a child
all nodes with the same depth form a _____
tree leve