Discussion Questions

Questions for Wednesday of First Week:

Be prepared to define the terms in the following list:
- class
- interface
- constructor
- method
- method invocation
- method signature
- return type
- parameter type
- formal parameter
- actual parameter
- class variable
- instance variable
- local variable
- scope
- access modifier
Read through the class documentation for the String class.
- What does the output from the statement System.out.println(hw) look like?
- What does the output from the statement System.out.println(n.substring(0,4)) look like?
- What does the expression h.matches("hello") evaluate to?
- How can the previous expression be modified so that it evaluates to true?
- How can we use the string n to get another string containing just Pam's name?
Read through the Indexing Substrings programming project. Bring questions to class.
Compare and contrast arrays and ArrayLists.
Write out the code to print out all elements of an array and an ArrayList.
Write out the code to search for a particular element in an array and an ArrayList.
Come up with at least one situation where you would use each of these data structures.

Questions for Friday of First Week:

Ex 2.1, 2.2, 2.4, 2.5
Try to finish stage one of the Indexing Substrings project. Come to class with questions.

Questions for Monday of Second Week:

Questions for Wednesday of Third Week:

Be prepared to discuss the Big-O analysis of the different List implementations.

Questions for Friday of Third Week:

According to Figures 6.15 and 6.16, what methods do java.util.ArrayList and java.util.LinkedList have in common? What methods would you specify in a common java.util.List interface? Might any of these methods have the same implementation? If so, would it make sense to have a java.util.AbstractList class?
Think about an appropriate set of tests for the following two list methods:
- addAtEnd(T element)
- getElement(int index) //returns element without altering list.

Questions for Monday of Fourth Week:

Questions for Friday of Sixth Week:

Re-read the books description of selection sort, insertion sort, Quicksort, and merge sort.
In class, we worked through an analysis of the number of comparisons performed by selection sort. Perform a similar analysis for insertion sort. Does the original ordering of the items impact the number of comparisons made by insertion sort? selection sort?

Questions for Wednesday of Seventh Week:

A stable sort is defined as a sorting algorithm that preserves the original order of duplicate objects. Which of the sorting algorithms that we studied are stable sorts?

Questions for Friday of Seventh Week:

Analysis questions ("Inside or Outside?") from the Binary Tree Lab.
For the depth-first tree traversals discussed in class (pre-order, in-order, and post-order), the order that the nodes are visited arises naturally from the sequence of recursive calls. This makes it challenging to provide corresponding iterators; hasNext and next will not be called recursively. How does the code in the textbook overcome this difficulty?

Questions for Wednesday of Tenth Week:

Test the following code segment to determine what gets printed:
Change the code above to use a HashMap instead of a TreeMap. What output do you get? How can you explain the difference between the output of the different Maps?
Think about the Data Structures we have studied so far. Since the HashMap allows us to add, remove and search for objects in constant time, why would or wouldn't this be our "ultimate" data structure? Would there be other times/reasons we would want to use other structures? Some examples?