Data Structures Exam4

20 12 23 11 21 30 What is the tree after removing 12?

(20 (11, 23 (21, 30)))

20 12 23 11 21 30 What is the tree after removing 21?

(20 (12 (11, -), 23 (-, 30)))

20 12 23 11 21 30 What is the tree after removing 20?

(21 (12 (11, -), 23 (-, 30)))

Determine cur's next assignment given the key and current node. key = 6, cur = 47 47 19 48 6 51 62

19

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?

Internal

Search for insert location:

: If the left (or right) child is not 0, the algorithm assigns the current node with that child and continues searching for a proper insert location.

950's successor is 150 500 300 800 150 750 900 250 850 950

Fasle

Remove a leaf node:

If X has a parent (so X is not the root), the parent's left or right child (whichever points to X) is assigned with 0. Else, if X was the root, the root pointer is assigned with 0, and the BST is now empty.

Remove an internal node with single child

If X has a parent (so X is not the root), the parent's left or right child (whichever points to X) is assigned with X's single child. Else, if X was the root, the root pointer is assigned with X's single child.

Insert as right child:

If the new node's key is greater than the current node, and the current node's right child is 0, 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 0, the algorithm assigns that node's left child with the new node.

The first node in the BST ordering is 150. 500 300 800 150 750 900 250 850 950

True

The recursive DFS algorithm is run on the following graph. Assume D is the starting vertex. B D A | \ | \ | \ | C == E DFS begins with the function call RecursiveDFS(D).

True

The recursive DFS algorithm is run on the following graph. Assume D is the starting vertex. B D A | \ | \ | \ | C == E If B is not yet visited, RecursiveDFS(B) will make subsequent calls to RecursiveDFS(C) and RecursiveDFS(E).

True

If the child to be visited is 0, when does the algorithm return 0

Upon exiting the loop

Consider the following tree: 20 12 23 11 21 30 Assume a full 255-node BST. How many algorithm loop iterations will occur for an insert?

8

What is the maximum loop iterations for a full binary tree with 255 nodes?

8

Determine cur's next assignment given the key and current node. key 91, cur = 99 86 37 99 51 91 124

91

In searching for 145, what node is visited third? 300 100 900 25 145 750 925

145

Consider the following tree: 20 12 23 11 21 30 Where will a new node 18 be inserted?

12's right child

Consider the following tree. If node does not exists, enter 0. 52 33 67 14 60 81 When searching for key 45, what node is visited third?

0

A new BST is built by inserting nodes in this order: 6 2 8 6 2 8 What is the tree height?

1 6 2 8

In searching for 145, what node is visited second? 300 100 900 25 145 750 925

100

Consider the following tree. 300 100 775 25 201 750 925 11 What node is printed first?

11

A new BST is built by inserting nodes in this order: 20 12 23 18 30 What is the tree height?

2 20 12 23 16 30

When searching for key 21, what node is visited first? 20 12 23 11 18 21 30

20

When searching for key 21, what node is visited third?' 20 12 23 11 18 21 30

21

When searching for key 21, what node is visited second? 20 12 23 11 18 21 30

23

A new BST is built by inserting 255 nodes in sorted order. What is the tree height?

254

Consider the following tree. 7 1 64 28 77 When inserting a new node with key 35, what node is visited third?

28

Consider the following tree: 20 12 23 11 21 30 Assume a full 7-node BST. How many algorithm loop iterations will occur for an insert?

3

What is the maximum loop iterations for a full binary tree with 7 nodes, if a node matches?

3

What is the maximum loop iterations for a full binary tree with 7 nodes, if no node matches?

3

What is the worst case (largest) number of nodes visited when searching for a key? 300 100 900 25 145 750 925

3

In searching for 145, what node is visited first? 300 100 900 25 145 750 925

300

Consider the following tree. 300 100 775 25 201 750 925 11 Complete the tree traversal after node 300's left subtree has been printed

300 750 775 925

Which nodes would be visited when searching for 900? Write nodes in order visited, as: 5, 10 300 100 900 25 145 750 925

300, 900

Which nodes would be visited when searching for 800? Write nodes in order visited, as: 5, 10, 15 300 100 900 25 145 750 925

300, 900, 750

Consider the following tree. If node does not exists, enter 0. 52 33 67 14 60 81 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 30 11 23 21 20

A new BST is built by inserting nodes in this order: 30 23 21 20 18 What is the tree height?

4 30 23 21 20 16

What is the worst case (largest) number of comparisons given a full BST with n nodes? Given the following tree. 0 0 0 0 0 0 0

5

Consider the following tree. If node does not exists, enter 0. 52 33 67 14 60 81 When searching for key 45, what node is visited first?

52

Consider the following tree. 7 1 64 28 77 When inserting a new node with key 35, what node is visited second?

64

A new BST is built by inserting 255 nodes in sorted order. What is the tree height?

7

Consider the following tree. 7 1 64 28 77 When inserting a new node with key 35, what node is visited first?

7

Consider the following tree. 300 100 775 25 201 750 925 11 How many nodes are visited?

8

Parent

A node with a child is said to be that child's parent.

Internal node

A node with at least one child

Leaf

A tree node with no children

tree level.

All nodes with the same depth form

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E Which vertices are in the stack after the first iteration of the while loop?

B, E

AVL TREEE private BinaryNode rotateRight(BinaryNode nodeN) { /* your code goes here */ }

BinaryNode nodeC = nodeN.getLeftChild(); nodeN.setLeftChild(nodeC.getRightChild()); nodeC.setRightChild(nodeN); return nodeC;

Perform a depth-first search of the graph below. Assume the starting vertex is E. A - B - C | \ | D - E - F Assume DFS traverses the following vertices: E, A, B, C. Which vertex is visited next?

D

If the current node matches the key, when does the algorithm return the node.

Immediately

Perform a depth-first search of the graph below. Assume the starting vertex is E. A - B - C | \ | D - E - F Which vertex is visited first?

E

500's successor is 850. 500 300 800 150 750 900 250 850 950

FALSE

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E DFS terminates once all vertices are added to visitedSet.

False

The recursive DFS algorithm is run on the following graph. Assume D is the starting vertex. B D A | \ | \ | \ | C == E The recursive DFS algorithm uses a queue to determine which vertices to visit

False

public void breadthFirstTraversal(int start) { AQueue queue = new AQueue(); HashMap reached = new HashMap(); int current; for (int i = 0; i < adjacencyMap.CAPACITY; i++) { if (adjacencyMap.keys[i] != "empty") { reached.put(adjacencyMap.keys[i], false); } } queue.enqueue(start); reached.set(start, true); while (!(queue.isEmpty())) { int to; current = queue.dequeue(); /* your code goes here */ for (int i = 0; i < edgeList.getLength(); i++) { // getEntry is one based to = edgeList.getEntry(i+1); Boolean check = (Boolean) reached.get(to); if (!check) { queue.enqueue(to); reached.set(to, true); } } System.out.println("Vertex: " + current); } }

LList edgeList = (LList)adjacencyMap.get(current);

San Fransico -> Dallas <- ^ |/\ -/| | \/| Los Angles -> Tuscon Tucson is adjacent to _____.

Los Angeles

Does node 200 and the node's subtrees obey the BST ordering property? 500 200 750 150 800 900 201 850 950

NO

Does node 750 and the node's subtrees obey the BST ordering property? 500 200 750 150 800 900 201 850 950

NO

250's successor is 300. 500 300 800 150 750 900 250 850 950

True

950's predecessor is 900. 500 300 800 150 750 900 250 850 950

True

A weighted graph

associates a weight with each edge.

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E Which vertices are in visitedSet after the first iteration of the while loop?

c

BinarySearchTree JAVA private void printInOrder(BinaryNode t) { /* your statements here */ }

if (t != null) { printInOrder(t.left); System.out.println(t.element); printInOrder(t.right); }

A directed graph is cyclic

if the graph contains a cycle, and acyclic if the graph does not contain a cycle.

Perform a depth-first search of the graph below. Assume the starting vertex is E. A - B - C | \ | D - E - F The DFS traversal of a graph is unique. Type: Yes or No

no

A vertex's predecessor pointer

points to the previous vertex along the shortest path from the start vertex.

Searching a BST in the worst case

requires h + 1 comparisons, meaning O(h) comparisons, where h is the tree height.

Consider the following tree. 300 100 775 25 201 750 925 11 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 -> B -> C \ \ | > > > D < - E A directed edge connects vertices A and D. D is the _____ vertex.

terminating

binary search tree (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.

What is the worst case (largest) number of comparisons given a full BST with n nodes?' BST with n = 7

⌊log(n)⌋+1

Consider the following tree: 20 12 23 11 21 30 Where will a new node 11 be inserted? (So two nodes of 11 will exist).

11's right child

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E In the second iteration, currentV = B. Which vertices are in the stack after the second iteration of the while loop?

A, C, D, E, E

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E Which vertices are in the stack before the first iteration of the while loop?

C

DFS is run on the following graph. Assume C is the starting vertex. A - B - C / \ / D - E Which vertices are in visitedSet after the second iteration of the while loop?

C, B

private BinaryNode rotateRight(BinaryNode nodeN){ }

BinaryNode nodeC = nodeN.getLeftChild(); nodeN.setLeftChild(nodeC.getRightChild()); nodeC.setRightChild(nodeN); return nodeC;

private BinaryNode rotateLeftRight(BinaryNode nodeN){ }

BinaryNode nodeC = nodeN.getLeftChild(); nodeN.setLeftChild(rotateLeft(nodeC)); return rotateRight(nodeN);

AVL TREEE private BinaryNode rotateLeft(BinaryNode nodeN) { /* your code goes here */ }

BinaryNode nodeC = nodeN.getRightChild(); nodeN.setLeftChild(nodeC.getLeftChild()); nodeC.setLeftChild(nodeN); return nodeC;

private BinaryNode rotateLeft(BinaryNode nodeN){ }

BinaryNode nodeC = nodeN.getRightChild(); nodeN.setRightChild(nodeC.getLeftChild()); nodeC.setLeftChild(nodeN); return nodeC

private BinaryNode rotateRightLeft(BinaryNode nodeN){ }

BinaryNode nodeC = nodeN.getRightChild(); nodeN.setRightChild(rotateRight(nodeC); return rotateLeft(nodeN);

Perform a depth-first search of the graph below. Assume the starting vertex is E. A - B - C | \ | D - E - F Is the following a valid DFS traversal? Type: Yes or No E, D, F, A, B, C

No

20 12 23 11 21 30 Removing a node from an n-node nearly-full BST has what computational complexity

O(log(n))

edge

The link from a node to a child

Consider the following tree. 7 1 64 28 77 Where is the new node with key 35 inserted? Type: left or right

Right

Determine cur's next assignment given the key and current node. key 350, cur = 400 300 200 400 100 500

Search terminates and returns 0.

Root:

The one tree node with no parent (the "top" node).

A -> B -> C \ \ | > > > D < - E The airline routes graph is a digraph.

True

Remove an internal node with two children

This case is the hardest. First, the algorithm locates X's successor (the leftmost child of X's right subtree), and copies the successor to X. Then, the algorithm recursively removes the successor from the right subtree.

Does node 150 and the node's subtrees obey the BST ordering property? 500 200 750 150 800 900 201 850 950

YES

Does node 900 and the node's subtrees obey the BST ordering property? 500 200 750 150 800 900 201 850 950

YES

Is the tree a binary search tree? 500 200 750 150 800 900 201 850 950

YES

Would inserting 300 as the right child of 200 obey the BST ordering property (considering only nodes 300, 200, and 500)? 500 200 750 150 800 900 201 850 950

YES

Perform a depth-first search of the graph below. Assume the starting vertex is E. A - B - C | \ | D - E - F Is the following a valid DFS traversal? Type: Yes or No E, D, A, B, C, F

Yes

BST ordering: D b g a c f

a b c D f g

Bellman-Ford shortest path algorithm,

created by Richard Bellman and Lester Ford, Jr., determines the shortest path from a start vertex to each vertex in a graph.

Determine the insertion algorithm's next step given the new node's key and the current node 29 13 45 key = 7, cur = 29

cur = cur->left

Determine the insertion algorithm's next step given the new node's key and the current node 300 200 400 100 500 key = 600, cur = 400

cur = cur->right

Determine the insertion algorithm's next step given the new node's key and the current node 15 4 88 76 91 key = 53, cur = 76

cur->left = node

Determine the insertion algorithm's next step given the new node's key and the current node 20 12 23 11 21 30 key = 18, cur = 12

cur->right = node

binary tree's height is

h=⌊log(n)⌋

private boolean search(int x, BinaryNode t) { /* your statement here */ }

if (t == null) return false; if (x < t.element) return search(x,t.left); else if (x > t.element) return search(x, t.right); else return true; // Match

private BinaryNode insert(int x, BinaryNode t) { /* your statements here */ }

if (t == null) return new BinaryNode(x, null, null); if (x < t.element) t.left = insert(x, t.left); else if(x > t.element) t.right = insert(x , t.right); else ; // Duplicate; do nothing return t;

private BinaryNode remove(int x, BinaryNode t) { /* your statements here */ }

if (t == null) return t; // Item not found; do nothing if (x < t.element) t.left = remove(x, t.left); else if (x > t.element) t.right = remove(x, t.right); else if (t.left != null && t.right != null) // Two children { t.element = findMin(t.right).element; t.right = remove(t.element, t.right); } else t = (t.left != null) ? t.left : t.right; return t;

A path

is a sequence of directed edges leading from a source (starting) vertex to a destination (ending) vertex.

depth-first search (DFS)

is a traversal that visits a starting vertex, then visits every vertex along each path starting from that vertex to the path's end before backtracking. is a traversal that visits a starting vertex, then visits every vertex along each path starting from that vertex to the path's end before backtracking.

A cycle

is path that starts and ends at the same vertex.

A tree's height

is the largest depth of any node. A tree with just one node has height 0.

Recall that a tree's height

is the maximum edges from the root to any leaf.

A BST node's successor

is the node that comes after in the BST ordering, so in A B C, A's successor is B, and B's successor is C.

A node's depth

is the number of edges on the path from the root to the node. The root node thus has depth 0.

A vertex's distance

is the shortest path distance from the start vertex

public void breadthFirstTraversal(int start) { AQueue queue = new AQueue(); HashMap reached = new HashMap(); int current; for (int i = 0; i < adjacencyMap.CAPACITY; i++) { if (adjacencyMap.keys[i] != "empty") { reached.put(adjacencyMap.keys[i], false); } } /* enter your code here */ while (!(queue.isEmpty())) { int to; current = queue.dequeue(); LList edgeList = (LList) adjacencyMap.get(current); for (int i = 0; i < edgeList.getLength(); i++) { // getEntry is one based to = edgeList.getEntry(i+1); Boolean check = (Boolean) reached.get(to); if (!check) { queue.enqueue(to); reached.set(to, true); } } System.out.println("Vertex: " + current); } }

queue.enqueue(start); reached.set(start, true);

A BST node's predecessor is

the node that comes before in the BST ordering.

Determine the insertion algorithm's next step given the new node's key and the current node key = 87, cur = 0, tree->root = 0 (empty tree)

tree->root = node

A -> B -> C \ \ | > > > D < - E E is a _____ in the directed graph.

vertex