|
|
Midterm Exam 1 (Thursday, March 8, 5:00 - 7:00 pm)
Location: B10 Ingraham
Students are responsible for material covered in:
Note that, if necessary, a reference will be provided in the exam for a subset of methods for select
Java API classes.
A selection of sample exam questions is available on Learn@UW.
Topics List:
- General
abstract data type (ADT), data structure, Java interfaces (defining, implementing, using an interface as a type), using Java generics, primitive vs. reference types in Java
- Lists
List ADT, List operations, implementing List using an array, implementing List using a linked list
(i.e., a chain of linked nodes), complexities of List operations
for different implementations, using a List
- Iterators
what they are, how to use them, how to implement one for an ADT
when the underlying data structure is an array or a chain of linked nodes
- Java Exceptions
defining new exceptions, checked vs. unchecked, throwing an
exceptions using throw, handling an exception using try-catch, handling an
exception by passing it down the call stack, listing exceptions in a throws
clause
- Complexity
what complexity is, problem size, constant time (O(1)), linear time (O(N)), quadratic time (O(N2)),
big-O notation, worst-case vs. best/average cases, determining complexity of
Java code, limitations of complexity analysis
- Linked Lists (i.e., Chains of Linked Nodes)
list node, linked list operations, head pointer, tail pointer,
dummy header node, singly linked lists, doubly linked lists, circular linked
lists, comparison of linked list variations
- Stacks
Stack ADT, Stack operations, implementing Stack using an array,
implementing Stack using linked list variations, complexities of Stack
operations for different implementations, using a Stack
- Queues
Queue ADT, Queue operations, implementing Queue using array variations,
circular arrays, implementing Queue using linked list variations, complexities
of Queue operations for different implementations, using a Queue
|
|
Midterm Exam 2 (Tuesday, April 17, 5:00 - 7:00 pm)
Location: B10 Ingraham
Students are responsible for material covered in:
- Lectures (through material on priority queues and heaps on Thursday, April 12)
- Readings:
Recursion, Searching, Intro to Trees, Binary Search Trees, Red-Black Trees, Priority Queues
- Homeworks:
5 - 7
(homework solutions are on Learn@UW)
- Programming assignments:
2 (that is, understanding of linked lists - so that you could answer a question
involving recursion or searching using a linked list)
Note that, if necessary, a reference will be provided in the exam for a subset of methods for select
Java API classes and/or ADT interfaces and related classes.
A selection of sample exam questions is available on Learn@UW.
Topics List:
- Recursion
recursive methods, base case, recursion rules, how method calls work (i.e.,
activation records and the call stack), recursion vs. iteration, recursive
data structures, analyzing complexity of recursive methods, recurrence
equations, determining complexity using recurrence relations
- Search
Java interfaces (defining, implementing, using an interface as a type), the
Comparable interface, sequential search, binary search, complexities of search algorithms
- Trees
position-oriented vs. value-oriented ADTs, tree terminology (root, leaf, node,
edge, parent, child, sibling, ancestor, descendant, subtree, path, length of a
path, height of a tree, full tree, complete tree, height-balanced tree), general trees,
binary trees, implementation of trees, writing recursive methods that traverse a
tree, pre-order traversal, post-order traversal, level-order traversal, in-order
traversal
- Binary Search Trees
binary search trees (BSTs), key value, implementing BSTs, algorithms for BST operations (print,
lookup, insert, delete), in-order successor, in-order predecessor,
complexities of BST operations
- Red-Black Trees
balanced search trees, red-black trees, red-black tree properties, root property, red property, black property, algorithms for red-black tree operations (print, lookup, insert)
- Priority queues
Priority Queue ADT, implementing Priority Queue (using a heap, BST, unsorted array, sorted linked
list, etc.) and implications for complexities, heap operations (algorithms & complexities), array implementation of
heaps
|
|
Final Exam (Tuesday, May 15, 7:25 - 9:25 pm)
Location: 105 Psychology
Students are responsible for material covered in:
Note that, if necessary, a reference will be provided in the exam for a subset of methods for select
Java API classes.
A selection of sample exam questions is available on Learn@UW.
Topics List:
- Midterm exam 1 and Midterm exam 2 topics
The final is cumulative although there will be somewhat more emphasis on the topics
covered since midterm 2.
- Hashing
hashing terminology (hash table, hash function, key, load factor, collision,
ideal hashing),
hash table operations (algorithms & complexities), choosing table size,
defining a good hash function, hashing techniques (mod by table size, folding,
extraction, handling non-integer keys), collision handling
strategies, chaining (using different data structures), open addressing (using linear probing), probe sequence
- Graphs
graph terminology (node, vertex, edge, directed, undirected, source,
target, adjacent, successor, degree, in-degree, out-degree, path,
acyclic, cyclic, complete graph, connected graph, weakly-connected graph, strongly-connected graph, weighted
graph, DAG), classifying different kinds of graphs, graph ADT (implementations &
complexities), representing edges using adjacency lists, representing edges using an adjacency matrix, graph traversals (BFS & DFS),
Dijkstra's algorithm, applications of graph traversals (finding paths, topological ordering)
- Sorting
comparison sort, bubble sort, insertion sort, selection sort, merge sort,
quick sort, heap sort, stable sort, radix sort, complexities of sorts (both in terms of time and
space), what input results in the best or worst case complexity
|
|
Last Updated: 5/7/2012 ©2012 Beck Hasti
|