CS2852
Outcomes

This is an old version of this course, from Spring 2014. A newer version is avaliable here.

Software Tips and Tricks

Excel

IntelliJ

Enterprise Architect

Week 1

Interfaces

  • Use the Collection<E> and List<E> interfaces defined in the Java Collection Framework
  • Explain when to use Collection<E> instead of List<E> and vice versa
  • Demonstrate correct use of generics when declaring Collection<E> and List<E> interfaces
  • Describe the implications of an interface extending another interface
  • List two classes that implement the Collection<E> interface
  • List two classes that implement the List<E> interface

Array Based Lists

Week 2

Big-O Notation and Algorithm Efficiency

  • Explain the purpose of Big-O notation
  • Describe the limitations of big-oh notation
  • Be familiar with the formal definition of Big-O
  • Using Big-O notation, determine the asymptotic time complexity of an algorithm with a conditional
  • Using Big-O notation, determine the asymptotic time complexity of an algorithm with a loop
  • Determine the asymptotic time complexity of an algorithm with a nested loop
  • Using Big-O notation, determine the asymptotic time complexity of an algorithm that calls other methods with known asymptotic time complexity
  • Use time complexity analysis to chose between two competing algorithms
  • Describe the meaning of the following symbols: T(n), f(n), and O(f(n))
  • Given T(n) expressed as a polynomial, determine the Big-O notation
  • Determine the asymptotic time complexity of the following methods from the ArrayList<E> class: add(E), add(int, E), clear(), contains(Object), get(int), indexOf(Object), isEmpty(), remove(int), remove(Object), set(int, E), and size()

Linked Lists

  • Describe key differences between an array based list and a linked list
  • Describe advantages and disadvantages of a singly linked list verses a doubly linked list
  • Write an singly linked list implementation of the List<E> interface, including the following methods:
  • Describe key differences between a singly linked list and the LinkedList<E> class
  • Determine the asymptotic time complexity of the following methods from a singly linked list: add(E), add(int, E), clear(), contains(Object), get(int), indexOf(Object), isEmpty(), remove(int), remove(Object), set(int, E), and size()
  • Determine the asymptotic time complexity of the following methods from the LinkedList<E> class: add(E), add(int, E), clear(), contains(Object), get(int), indexOf(Object), isEmpty(), remove(int), remove(Object), set(int, E), and size()
  • Implement small software systems that use one or more LinkedList<E> objects

Week 3

Iterators

  • List the methods declared in the Iterator<E> interface
  • List the methods declared in the Iterable<E> interface
  • Implement the iterator() method in the ArrayList class (returning a fully functional iterator)
  • Implement the iterator() method in the LinkedList class (returning a fully functional iterator)
  • Explain why the enhance for loop only works on classes that implement the Iterable<E> iterface
  • Be familiar with the ListIterator<E> interface

Java Collection Framework and Testing

  • Explain the purpose of the Java Collections Framework
  • Be familiar with class/interface hierarchy for the Java Collections Framework
  • Describe the following levels of testing: unit, integration, system, and acceptance
  • Describe the differences between black-box testing and white-box testing
  • List advantages and disadvantages of black-box testing verses white-box testing
  • Develop tests that test boundary conditions

Week 4

Stacks

  • List the methods that are part of a pure stack interface
  • Define LIFO and explain how it relates to a stack
  • Explain how the Stack<E> class is implemented in the Java Collection Framework
  • Describe the design flaw found in the Stack<E> implementation found in the Java Collection Framework
  • Implement a class that provides an efficient implementation of the pure stack interface using an ArrayList<E>
  • Implement a class that provides an efficient implementation of the pure stack interface using a LinkedList<E>
  • Define the term adapter class
  • Implement small software systems that use one or more stack data structures

Week 5

Queues

  • List the methods that are part of a pure queue interface
  • Define FIFO and explain how it relates to a queue
  • The Queue<E> interface has multiple methods for insertion, removal, and accessing the front element. Describe how these methods differ
  • Describe the design flaw found in the Queue<E> interface found in the Java Collection Framework
  • Implement a class that provides an efficient implementation of the pure queue interface using a LinkedList<E>
  • Explain why an ArrayList<E> is not an appropriate choice when implementing a pure queue interface
  • Explain how a circular queue differs from a standard queue
  • Implement a class that provides an efficient implementation of a circular queue using an array
  • Implement small software systems that use one or more queue data structures

Acknowledgements

Original outcomes by Dr. Taylor