Chapter 23, 24, 25 Study Guide

* Node is defined as an inner class inside BST. * Node is defined as a static inner class inside BST because it does not reference any instance data fields in BST. * Node has a property named left that links to the left subtree and a property named right that links to the right subtree and a property named right. * BST contains a property named root. If tree is empty, root is null.

*In the implementation of BST, which of the following are true?* * Node is defined as an inner class inside BST. * Node is defined as a static inner class inside BST because it does not reference any instance data fields in BST. * Node has a property named left that links to the left subtree and a property named right that links to the right subtree and a property named right. * BST contains a property named root. If tree is empty, root is null.

* size indicates the number of elements in the list. * capacity is the length of the array used to store the elements in the list. * size is reduced by 1 if an element is deleted from the list. *Explanation:* (C) is not correct because capacity may equal to size.

*In the implementation of MyArrayList, which of the following are true?* * size indicates the number of elements in the list. * capacity is the length of the array used to store the elements in the list. * capacity is always greater than size. * size is reduced by 1 if an element is deleted from the list. * capacity is reduced by 1 if an element is deleted from the list.

* capacity never reduces. * Inside MyArrayList, a regular array is used to store elements. * size is not declared in MyArrayList, but declared in MyAbstractList as protected. * If the current capacity equals to size, capacity is doubled when a new element is added to MyArrayList

*In the implementation of MyArrayList, which of the following are true?* * size never reduces. * capacity never reduces. * Inside MyArrayList, a regular array is used to store elements. * size is not declared in MyArrayList, but declared in MyAbstractList as protected. * If the current capacity equals to size, capacity is doubled when a new element is added to MyArrayList

* MyLinkedList contains all the methods defined in MyList. Additionally, MyLinkedList defines several new methods that are appropriate for processing a linked list. * MyArrayList does not introduce new methods. All the methods in MyArrayList are defined in MyList. * You can use a linked list to improve efficiency for adding and removing an element anywhere in a list. * You should use an array list if your application does not require adding and removing an element anywhere in a list.

*In the implementation of MyLinkedList, which of the following are true?* * MyLinkedList contains all the methods defined in MyList. Additionally, MyLinkedList defines several new methods that are appropriate for processing a linked list. * MyArrayList does not introduce new methods. All the methods in MyArrayList are defined in MyList. * You can use a linked list to improve efficiency for adding and removing an element anywhere in a list. * You should use an array list if your application does not require adding and removing an element anywhere in a list.

* MyLinkedList has the properties named first and last to point to the nodes in a linked list. * If a linked list is empty, first is null and last is null. * last.next is always null. *Explanation:* (D) is partially wrong, last and first points to the same node if a linked list contains one node.

*In the implementation of MyLinkedList, which of the following are true?* * MyLinkedList has a capacity property. * MyLinkedList has the properties named first and last to point to the nodes in a linked list. * If a linked list is empty, first is null and last is null. * If a linked list contains one element, first points to the node and last is null. * last.next is always null.

* Node is defined as an inner class inside MyLinkedList. * Node is defined as a static inner class inside MyLinkedList because it does not reference any instance data fields in MyLinkedList. * Node has a property named next that links to the node after this node. * Node has a property named element that stores an element.

*In the implementation of MyLinkedList, which of the following are true?* * Node is defined as an inner class inside MyLinkedList. * Node is defined as a static inner class inside MyLinkedList because it does not reference any instance data fields in MyLinkedList. * Node has a property named next that links to the node after this node. * Node has a property named element that stores an element.

* MyStack contains all the methods defined in MyArrayList. * MyQueue contains all the methods defined in MyLinkedList. * MyStack contains an array list for storing elements. * MyQueue contains a linked list for storing elements.

*In the implementation of MyStack and MyQueue, which of the following are true?* * MyStack contains all the methods defined in MyArrayList. * MyQueue contains all the methods defined in MyLinkedList. * MyStack contains an array list for storing elements. * MyQueue contains a linked list for storing elements.

* A pivot can be chosen arbitrarily. * A pivot divides a list into two sublists, the elements in the first list are no larger than the pivot and the elements in the second list are larger than the pivot.

*What is correct about a pivot?* * A pivot divides a list into two sublists of equal size. * A pivot can be chosen arbitrarily. * A pivot divides a list into two sublists, the elements in the first list are no larger than the pivot and the elements in the second list are larger than the pivot. * You should always choose a pivot that divides the list evenly.

* A stack can be viewed as a special type of list, where the elements are accessed, inserted, and deleted only from the end, called the top, of the stack. * A queue represents a waiting list. A queue can be viewed as a special type of list, where the elements are inserted into the end (tail) of the queue, and are accessed and deleted from the beginning (head) of the queue. * Since the insertion and deletion operations on a stack are made only at the end of the stack, you can use either an ArrayList or a LinkedList. However, ArrayList has less overhead than LinkedList. * Since deletions are made at the beginning of the list, it is more efficient to implement a queue using a LinkedList than an ArrayList.

*Which of the following are true?* * A stack can be viewed as a special type of list, where the elements are accessed, inserted, and deleted only from the end, called the top, of the stack. * A queue represents a waiting list. A queue can be viewed as a special type of list, where the elements are inserted into the end (tail) of the queue, and are accessed and deleted from the beginning (head) of the queue. * Since the insertion and deletion operations on a stack are made only at the end of the stack, you can use either an ArrayList or a LinkedList. However, ArrayList has less overhead than LinkedList. * Since deletions are made at the beginning of the list, it is more efficient to implement a queue using a LinkedList than an ArrayList.

* Retrieve an element from this list. * Insert a new element to this list. * Delete an element from this list. * Find how many elements are in this list. * Find whether an element is in this list.

*Which of the following operations are supported by a list?* * Retrieve an element from this list. * Insert a new element to this list. * Delete an element from this list. * Find how many elements are in this list. * Find whether an element is in this list.

* A heap is a complete binary tree. * Each node is greater than or equal to any of its children. * A binary tree is complete if every level of the tree is full except that the last level may not be full and all the leaves on the last level are placed left-most.

*Which of the following statements are true?* * A heap is a complete binary tree. * Each node is greater than or equal to any of its children. * A binary tree is complete if every level of the tree is full except that the last level may not be full and all the leaves on the last level are placed left-most. * A heap is a full binary tree.

* MyArrayList and MyLinkedList are two concrete implementations of MyList. * MyArrayList is implemented using an array. The array is dynamically created. If the capacity of the array is exceeded, create a new larger array and copy all the elements from the current array to the new array. * MyLinkedList is implemented using a linked structure. * A linked structure consists of nodes. Each node is dynamically created to hold an element. All the nodes are linked together to form a list. * MyAbstractList partially implements MyList.

*Which of the following statements are true?* * MyArrayList and MyLinkedList are two concrete implementations of MyList. * MyArrayList is implemented using an array. The array is dynamically created. If the capacity of the array is exceeded, create a new larger array and copy all the elements from the current array to the new array. * MyLinkedList is implemented using a linked structure. * A linked structure consists of nodes. Each node is dynamically created to hold an element. All the nodes are linked together to form a list. * MyAbstractList partially implements MyList.

greedy

A Huffman tree is constructed using the ____________ algorithm.

heap

A ________ can be stored in an ArrayList or an array if the heap size is known in advance.

binary search tree

A __________ (with no duplicate elements) has the property that for every node in the tree the value of any node in its left subtree is less than the value of the node and the value of any node in its right subtree is greater than the value of the node.

quick sort

A _______________ works as follows: The algorithm selects an element, called the pivot, in the array. It divides the array into two parts, so that all the elements in the first part are less than or equal to the pivot and all the elements in the second part are greater than the pivot. The sort algorithm is then recursively applied to the first part and then the second part.

heap sort

A ___________uses a binary heap. It first adds all the elements to a heap and then removes the largest elements successively to obtain a sorted list

linked

A binary search tree can be implemented using a __________ structure.

No

A heap is represented using an array. Is the array {1 2 4 5 9 3} a heap?

Yes

A heap is represented using an array. Is the array {64 42 59 32 39 44} a heap?

True

A new element is always inserted into a leaf node.

external sort

A variation of the merge sort—called an _______________________—can be applied to sort large amounts of data from external files.

True

After the first node is inserted in the list, head and tail point to this node.

Both MyArrayList and MyLinkedList are used to store a list of objects. Why do we need two? MyLinkedList is more efficient for deletion and insertion at the beginning of the list. MyArrayList is more efficient for all other operations.

Both MyArrayList and MyLinkedList are used to store a list of objects. Why do we need both types of lists?

No. Because MyList is an interface.

Can you create a list using new MyList()?

Yes.

Every internal node in a Huffman tree has two children. Is it true?

True

Heaps are a useful data structure for designing efficient algorithms such as sorting. You learned how to define and implement a heap class, and how to insert and delete elements to/from a heap.

First, add it to the end of the heap and then rebuild the tree as follows: let the last node be the current node while (the current node is greater than it's parent) { Swap the current node with it's parent Now the current node is one level up: }

How do you add a new node to the heap?

Move the last node to replace the root; let the root be the current node; while (the current node has children and the current node is smaller than one of it's children) { Swap the current node with the larger of it's children; Now the current node is one level down; }

How do you remove the root?

return root.weight < t.weight ? 1 : root.weight == t.root.weight ? 0 : -1;

How do you replace lines 94-99 in Listing 25.11 using one line?

The time complexity for enqueue will be O(1) and for dequeue will be O(n).

If LinkedList is replaced by ArrayList in lines 2-3 in Listing 24.6 GenericQueue.java, what will be the time complexity for the enqueue and dequeue methods?

head and tail are null.

If a linked list does not contain any nodes, what are the values in head and tail?

Yes. When the list is empty, head == tail is also true.

If a linked list has only one node, is head == tail true? List all cases in which head == tail is true.

n - 1 times.

If a list is already sorted, how many comparisons will the insertionSort method perform?

Yes, except that you also have to change heap.getSize() to heap.size().

If the Heap class in line 50 in Listing 25.9 is replaced by java.util.PriorityQueue, will the program still work?

(Hint: To find the bug, perform trimToSize() on an empty list, then add a new element to the list.) When an empty array list is trimmed, its size becomes 0. If you create a new array by doubling its size, the new array size is still 0. Adding a new element now would cause an ArrayIndexOutOfBounds exception.

If you change the code in line 33 in Listing 24.2, MyArrayList.java, from E[] newData = (E[])(new Object[size * 2 + 1]); to E[] newData = (E[])(new Object[size * 2]); the program is incorrect. Can you find the reason?

If you have to add or delete the elements anywhere in a list, use MyLinkedList. If most of operations on a list involve retrieving an element at a given index, use MyArrayList.

If you have to add or delete the elements at the beginning of a list, should you use MyArrayList or MyLinkedList? If most of the operations on a list involve retrieving an element at a given index, should you use MyArrayList or MyLinkedList?

@Override /** Returns true if the element is in the tree */ public boolean search(E e) { return search(root, e); } public boolean search(TreeNode<E> root, E e) { if (root == null) return false; else if (e.compareTo(root.element) < 0) return search(root.left, e); else if (e.compareTo(root.element) > 0) return search(root.right, e); else return true; }

Implement the search(element) method using recursion.

node

In a linked list, each element is contained in an object, called the ________. When a new element is added to the list, a node is created to contain it. Each node is linked to its next neighbor

The nodes in the tree are visited in preorder.

In what order are the nodes in the tree visited by the displayTree method: inorder, preorder, or postorder?

MyArrayList is implemented using an array and an array is a fixed-size data structure. But MyArrayList is considered as a dynamic data structure, because its storage size changes behind the scene and hidden from the user.

MyArrayList is implemented using an array, and an array is a fixed-size data structure. Why is MyArrayList considered a dynamic data structure?

Retrieve an element at given the index.

MyArrayList is more efficient than MyLinkedList for the following operations:

Insert/delete an element in the beginning of the list

MyLinkedList is more efficient than MyArrayList for the following operations:

After line 1, list's length is 16. After line 2, list's length is 16. After line 3, list's length is 1. After line 4, list's length is 3. After line 5, list's length is 3. After line 6, list's length is 7.

Show the length of the array in MyArrayList after each of the following statements is executed. 1 MyArrayList<Double> list = new MyArrayList<>(); 2 list.add(1.5); 3 list.trimToSize(); 4 list.add(3.4); 5 list.add(7.4); 6 list.add(17.4);

public E removeLast() { if (size <= 1) { return removeFirst(); } else { Node<E> current = head; for (int i = 0; i < size - 2; i++) { current = current.next; } Node<E> temp = tail; tail = current; tail.next = null; size--; return temp.element; } } This new code is simpler and better. It reuses the existing code and makes the code easy to maintain.The time complexity for the new code is O(1), which is the same as before.(Thanks to the UT Dallas students for their contribution. 10/14/2015)

Simplify the code for the removeLast() method by invoking the removeFirst() method when the size is less than or equal to 1. Is the new code more efficient in execution time?

result.append((current != null) ? ", " : "]");

Simplify the following code in Listing 24.5 using a conditional expression. if (current != null) { result.append(", "); // Separate two elements with a comma } else { result.append("]"); // Insert the closing ] in the string }

{103, 55, 100, 23, 33, 81, 92}

Suppose a heap is stored in an array list as follows: {100, 55, 92, 23, 33, 81}. After inserting 103, what is the content of the array list?

92

Suppose a heap is stored in an array list as follows: {100, 55, 92, 23, 33, 81}. The parent of 81 is _______.

2, 5, 4, 8, 1, 9

Suppose a list is {2, 9, 5, 4, 8, 1}. After the first pass of bubble sort, the list becomes

Yes. Because MyList is Iterable.

Suppose list is an instance of MyList, can you get an iterator for list using list.iterator()?

Code fragment A is more efficient that code fragment B.

Suppose list1 is a MyArrayList and list2 is a MyLinkedList. Both contains 1 million double values. *Analyze the following code:* A: for (int i = 0; i < list1.size(); i++) sum += list1.get(i); B: for (int i = 0; i < list2.size(); i++) sum += list2.get(i);

Code fragment B runs faster than code fragment A.

Suppose list1 is a MyArrayList and list2 is a MyLinkedList. Both contains 1 million double values. *Analyze the following code:* A: while (list1.size() > 0) list1.remove(0); B: while (list2.size() > 0) list2.remove(0);

Code fragment A runs as fast as code fragment B.

Suppose list1 is an MyArrayList and list2 is a MyLinkedList. Both contains 1 million double values. *Analyze the following code:* A: for (int i = 0; i < 100000; i++) list1.add(0, i); B: for (int i = 0; i < 100000; i++) list2.add(0, i);

Code fragment A runs faster than code fragment B.

Suppose list1 is an MyArrayList and list2 is a MyLinkedList. Both contains 1 million double values. *Analyze the following code:* A: while (list1.size() > 0) list1.remove(size() - 1); B: while (list2.size() > 0) list2.remove(size() - 1);

3 4 12 21 45 92

Suppose the keys 3, 4, 45, 21, 92, 12 are inserted into a BST in this order. What is the inorder traversal of the elements?

12 21 92 45 4 3

Suppose the keys 3, 4, 45, 21, 92, 12 are inserted into a BST in this order. What is the postorder traversal of the elements?

3 4 21 12 92

Suppose the keys 3, 4, 45, 21, 92, 12 are inserted into a BST in this order. What is the preorder traversal of the elements after deleting 45 from the tree?

3 2 4 45 21 12 92

Suppose the keys 3, 4, 45, 21, 92, 12 are inserted into a BST in this order. What is the preorder traversal of the elements after inserting 2 into the tree?

3 4 45 21 12 92

Suppose the keys 3, 4, 45, 21, 92, 12 are inserted into a BST in this order. What is the preorder traversal of the elements?

Stack

Suppose the rule of the party is that the participants who arrive later will leave earlier. Which data structure is appropriate to store the participants?

4 2 1 3 0 5 8 9 6 7

Suppose you choose the first element as a pivot in the list {5 2 9 3 8 4 0 1 6 7}. Using the partition algorithm in the book, what is the new list after the partition?

No. Since Tree is not iterable now, the foreach loop cannot be used.

Suppose you delete implements Collection<E> from line 3 in Listing 25.3, Tree.java. Will Listing 25.10 still compile?

If the number of elements is fixed in the program, use array is more efficient. If the number of elements changes in the program, you may use MyArrayList or MyLinkedList.

Suppose you need to store a list of elements. If the number of elements in the program is fixed, what data structure should you use? If the number of elements in the program changes, what data structure should you use?

depth

The _______ of a node is the length of the path from the root to the node.

height

The _______ of a nonempty tree is the length of the path from the root node to its furthest leaf + 1.

inorder traversal

The ________ is to visit the left subtree of the current node first, then the current node itself, and finally the right subtree of the current node.

length

The ________ of a path is the number of the edges in the path.

preorder traversal

The _________ is to visit the current node first, then the left subtree of the current node, and finally the right subtree of the current node.

postorder traversal

The _________ is to visit the left subtree of the current node first, then the right subtree of the current node, and finally the current node itself.

breadth-first traversal

The _________ is to visit the nodes level by level. First visit the root, then all children of the root from left to right, then grandchildren of the root from left to right, and so on.

radix sort

The __________ algorithm does not compare keys.

merge sort

The _________________ algorithm can be described recursively as follows: The algorithm divides the array into two halves and applies a sort on each half recursively. After the two halves are sorted, merge them.

insertion-sort

The ___________________ algorithm sorts a list of values by repeatedly inserting a new element into a sorted sublist until the whole list is sorted.

True

The average-case and worst-case complexity for a merge sort is O(n logn). The average time for a quick sort is also O(n logn).

O(nlogn)

The average-time complexity for heap sort is _________

O(nlogn)

The average-time complexity for merge sort is _________.

O(nlogn)

The average-time complexity for quick sort is _________.

O(n)

The best-time complexity for bubble sort is _____________.

O(n)

The best-time complexity for insertion sort is _____________.

list.add(e) invokes list.add(list.size(),e), which will throw an exception, because size is now 0.

The get(index) method invokes the checkIndex(index) method (lines 59-63 in Listing 24.2) to throw an IndexOutOfBoundsException if the index is out of bounds. Suppose the add(index, e) method is implemented as follows: public void add(int index, E e) { checkIndex(index); // Same as lines 23-33 in Listing 24.2 MyArrayList.java } What will happen if you run the following code? MyArrayList<> list = new MyArrayList<>(); list.add("New York");

radix sort

The most efficient algorithm for sorting integer keys is __________.

O(n)

The time complexity for deleing an element into a binary search tree is _______.

O(n)

The time complexity for inserting an element into a binary search tree is _______.

O(n)

The time complexity for searching an element in a binary search tree is _______.

O(n)

The time to merge two sorted lists of size n is _________.

O(n*n)

The worst case complexity for a selection sort, insertion sort, bubble sort, and quick sort is

O(n*n)

The worst-time complexity for bubble sort is _____________.

O(nlogn)

The worst-time complexity for heap sort is _________

O(n*n)

The worst-time complexity for insertion sort is _____________.

O(nlogn)

The worst-time complexity for merge sort is _________.

O(n*n)

The worst-time complexity for quick sort is _________.

the last node in the heap

To add a new node, you need to start a process by first placing it as _______ and move it up to maintain the heap property.

new node The new node is now the tail node, so you should move tail to point to this new node

To append the second node to the list, link the first node with the _____________.

instance You can then apply the methods on the instance to manipulate the data structure, such as inserting an element into the data structure or deleting an element from the data structure.

To create a data structure is to create an _____________from the class.

the last node in the heap

To remove the root, you need to start a process by first placing _______ to the place of the root and move it down to maintain the heap property.

True

True or False? You can traverse the elements in a BST using a for-each loop.

{3, 2, 4, 5, 10, 19, 8}

Using the partition algorithm to partition an array {5, 8, 10, 3, 4, 19, 2} for a quick sort, what is the resulting array after the partition?

True

We use the variable head to refer to the first node in the list, and the variable tail to the last node. If the list is empty, both head and tail are null

An array is a fixed-size data structure. Once an array is created, its size cannot be changed.

What are the limitations of the array data type?

For enqueue and dequeue in a priority queue, the complexity is O(logn). For getSize(), the complexity is O(1).

What are the time complexity of the enqueue, dequeue , and getSize methods in MyProrityQueue?

A binary tree is complete if every level of the tree is full except that the last level may not be full and all the leaves on the last level are placed left-most. A heap is a binary tree with the following properties: 1. It is a complete binary tree. 2. Each node is greater than or equal to any of its children.

What is a complete binary tree? What is a heap? Describe how to remove the root from a heap and how to add a new object to a heap.

A greedy algorithm is often used in solving optimization problems. The algorithm makes the choice that is optimal locally in the hope that this choice will lead to a globally optimal solution.

What is a greedy algorithm? Give an example.

In a priority queue, elements are assigned with priorities. When accessing elements, the element with the highest priority is removed first.

What is a priority queue?

An iterator is an object that provides a uniform way for traversing the elements in a container such as a set, list, binary tree, etc.

What is an iterator?

Being a subtype of Iterable, the elements of the container can be traversed using a for-each loop.

What is the benefit of being a subtype of Iterable<E>?

The return value will be null.

What is the return value from invoking the remove method if the heap is empty?

O(logn) for both insertion and deletion.

What is the time complexity of inserting a new element into a heap and what is the time complexity of deleting an element from a heap?

The time complexity of inserting an element to a binary tree is O(n).

What is the time complexity of inserting an element into a BST?

O(1)

What is the time complexity of the addFirst(e) and removeFirst() methods in MyLinkedList?

If for (int i = 0; i < objects.length; i++) add(objects[i]); are replaced by super(objects); When constructing an ArrayList using new ArrayList(objects), the super class' constructor is invoked first to add element in objects to data. However, data has not been initialized yet. data will be initialized after the body of the superclass' constructor is executed. So you will get a NullPointerException when attempting to add an element to data. See Supplement III.I, "Initialization Block," for reference. If for (int i = 0; i < objects.length; i++) add(objects[i]); are replaced by data = objects; size = objects.length; Then data and objects refer to the same array. This is a security hole. You may change ArrayList by directing changing the array elements through objects.

What is wrong if lines 11-12 in Listing 24.2, MyArrayList.java, for (int i = 0; i < objects.length; i++) add(objects[i]); are replaced by data = objects; size = objects.length;

The iterator() method is defined in the java.lang.Iterable interface.

What method is defined in the java.lang.Iterable<E> interface?

O(n)

What would be the time complexity for the size() method if the size data field is not used in MyLinkedList?

You will see the line that connecting the nodes to be displayed on top of nodes starting from the center of the node, not from the edge of the node, because the line would be displayed after the node.

What would happen if the code in lines 47-52 in BTView.java is moved to line 33?

The index for 44 is 5. The parent index for 44 is 2. The left child index for 44 is 11 and the right child index for 44 is 12.

When a heap in Figure 23.11a is stored in a list, what is index for element 44? What is the index of parent for 44 and what is the index of left and right children of 44?

The head will be changed if the list is empty before the insertion. The tail will always be changed.

When a new node is appended to the end of a linked list, will the head and the tail be changed?

The head will be changed. The tail will also be changed if the list is empty before the insertion.

When a new node is inserted to the head of a linked list, will the head and the tail be changed?

Queue

Which data structure is appropriate to store customers in a clinic for taking flu shots?

Priority Queue

Which data structure is appropriate to store patients in an emergency room?

Line 5 will be wrong, because GenericStack is not a subtype of MyList.

Which lines of the following code are wrong? 1 List<> list = new ArrayList<>(); 2 list.add("Tom"); 3 list = new LinkedList<>(); 4 list.add("Tom"); 5 list = new GenericStack<>(); 6 list.add("Tom");

Lines 1 and 2 are wrong, because Object and Number do not implement Comparable.

Which of the following statements are wrong? 1 Heap<Object> heap1 = new Heap<>(); 2 Heap<Number> heap2 = new Heap<>(); 3 Heap<BigInteger> heap3 = new Heap<>(); 4 Heap<Calendar> heap4 = new Heap<>(); 5 Heap<> heap5 = new Heap<>();

Quick sort does not need to create temporary arrays, while merge sort needs temporary arrays.

Why is quick sort more space efficient than merge sort?

Yes

Will the MyArrayList class have memory leak if the following code in line 41 is deleted? data = (E[])new Object[INITIAL_CAPACITY];

System.out.println("Max elememt in the tree is " + java.util.Collections.max(tree) + " and the min elememt in the tree is " + java.util.Collections.min(tree));

Write one statement that displays the maximum and minimum element in a BST object named tree.

A list

________ is a data structure to store data in sequential order.

Bucket sorts and radix sorts

________________________sorts are specialized sorting algorithms for integer keys. These algorithms sort keys using buckets rather than by comparing keys. They are more efficient than general sorting algorithms.