Tree
The first node in a tree is called the?
Tree
Pre-order Traversal is a type of Depth First Search, where each ____ is visited in a certain order.
node
In-order Traversal is a type of ____ Search?
Depth First Search,
What makes this traversal "post" is that visiting a node is done "_____" the left and right child nodes are called recursively.
after
A _______ is a Binary Tree where every node's left child has a lower value, and every node's right child has a higher value.
Binary Search Tree
A link connecting one node to another is called an?
edge
This traversal is "pre" order because the node is visited "____" the recursive pre-order traversal of the left and right subtrees.
before
This traversal is mainly used for Binary Search Trees where it returns values in ascending order.
In-order Traversal
Given the code below, what do you think is the missing in line of codes?
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def ______ (node):
if node is None:
return
postOrderTraversal(node.left)
postOrderTraversal(node.right)
print(node.data, end=", ")
root = TreeNode('R')
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
# Traverse
postOrderTraversal(root)
#Python
postOrderTraversal
The ____ of a tree is the number of nodes in it (n�).
size
A node can only have _____?
one parent node
Pre-order Traversal is a type of _____?
Depth First Search
_______ does a recursive In-order Traversal of the left subtree.
In-order Traversal
Given the code below, what do you think is the missing in line of codes?
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def postOrderTraversal(node):
if node is None:
return
postOrderTraversal(node.left)
postOrderTraversal(node.right)
___________
root = TreeNode('R')
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
# Traverse
postOrderTraversal(root)
#Python
print(node.data, end=", ")
The descendants of a node are all the _____ of that node, and all their child nodes, and so on.
child nodes
What is the relationship between node B and nodes E and F?
Node E is B's ____ child node, and node F is B's ___ child node.
left child node, right child node
Pre-order Traversal is done by visiting the ____ node first.
root
Given the code below, what do you think is the missing in line of codes?
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def _______ (node):
if node is None:
return
inOrderTraversal(node.left)
print(node.data, end=", ")
inOrderTraversal(node.right)
root = TreeNode('R')
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
inOrderTraversal(root)
inOrderTraversal
It is used for deleting a tree, post-fix notation of an expression tree, etc.
Post-order Traversal
The node's ____ is the maximum number of edges between that node and a leaf node.
height
What are nodes C, D, E, and G called?
Leaf nodes or Leaves
Given the illustration below, what do you think is the missing code?
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def _________(node):
if node is None:
return
print(node.data, end=", ")
preOrderTraversal(node.left)
preOrderTraversal(node.right)
root = TreeNode('R')
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
preOrderTraversal(root)
preOrderTraversal
Given the code below, what do you think is the missing in line of codes?
class TreeNode:
self.data = data
self.left = None
self.right = None
def inOrderTraversal(node):
if node is None:
return
inOrderTraversal(node.left)
print(node.data, end=", ")
inOrderTraversal(node.right)
root = TreeNode('R')
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
inOrderTraversal(root)
def __init__(self, data):
Given the code below, what do you think is the missing in line of codes?
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def postOrderTraversal(node):
if node is None:
return
postOrderTraversal(node.left)
postOrderTraversal(node.right)
print(node.data, end=", ")
nodeA = TreeNode('A')
nodeB = TreeNode('B')
nodeC = TreeNode('C')
nodeD = TreeNode('D')
nodeE = TreeNode('E')
nodeF = TreeNode('F')
nodeG = TreeNode('G')
root.left = nodeA
root.right = nodeB
nodeA.left = nodeC
nodeA.right = nodeD
nodeB.left = nodeE
nodeB.right = nodeF
nodeF.left = nodeG
# Traverse
postOrderTraversal(root)
#Python
root = TreeNode('R')
A _____ starts with one of the nodes in the tree as a local root, and consists of that node and all its descendants.
subtree