Consider the following instance of BinarySearchTree<Integer> T:

What would be the output if we were to add the elements 21, 78, 47 and then proceed to do a In-Order Traversal on T?

Consider the following LinkedBST<Integer, Integer> T:

Suppose a call to T.remove(27) was made, how many nodes (not including itself) do we have to traverse to find its in-order predecessor? Who is it?

Consider a BinaryTree<Character>  that has the following structure (nodes are empty circles) with a size 10. 

What would be the last character printed by a Post-Order traversal be if the In-Order traversal generates the following output: 

• B X A C D M L K W Z

Which node is visited after Ned in a Post-Order Traversal? 

Consider an arbitrary binary tree T that has the following structure:

Assume that an In-Order traversal of its nodes (where each visit just prints out the node's value) produces the following output: 

• A B C D K L M W X Z

Then what would be the output if the traversal is based on Pre-Order?

Consider the following binary tree:

The most efficient way to implement the front() method in a DoublyLinkedQueue implementation would be to access the last element in the LinkedList by traversing from header.getNext() to trailer.getPrev()

If we do the following:

stack1  = {Apu, Jil, Ned, Bob, Ron}

stack2 = { }

while(!stack1.isEmpty())

    stack2.push(stack1.pop());

stack1.push(stack2.pop());

stack2.pop();

stack1.push(stack2.pop());

What is the contents of stack1 and stack2?

All Stack implementations are efficient! Their push() and pop() operations are always O(1)!

Is this statement true?