This page presents course-level and module-level outcomes. Outcomes identify what students will know and be able to do if they master the material.
Use and implement abstract data types such as lists, stacks, queues, and trees.
Select the appropriate searching or sorting algorithm based on the algorithm’s behavior.
Develop recursive algorithms and programs.
Use standard libraries or packages as well as advanced object-oriented programming techniques (polymorphism, inheritance, and encapsulation).
Produce robust and secure programs using exception handling and extensive program testing.
Understand the goals, structures, and procedures for learning in ICS 211.
To learn basics of programming with a modern programming language, Java.
To learn and uses the basics of algorithm analysis, including big-O notation.
To learn and understand the array standard data structure. Know the standard interface for an Array.
To learn and implement standard algorithms for sorting arrays.
To understand Java collection classes and the basics of memory management.
To learn and implement the List standard data structure. Know the standard interface for a List.
To learn and implement the Iterator and Iterable. Know the standard interface for an Iterator and Iterable.
To learn and implement the Queue standard data structure. Know the standard interface for a Queue.
To learn and implement the Stack standard data structure. Know the standard interface for a Stack.
To learn and implement the Tree standard data structure.
To learn and implement the Hash Map standard data structure. Know the difference between open addressing and chained maps.
To understand recursion and how to develop recursive algorithms and programs.
To learn and implement standard algorithms for searching.
An ability to apply mathematical foundations, algorithmic principles, and computer science theory to the modeling and design of computer-based systems.
An ability to define the computing requirements of a problem and to design appropriate solutions based on established design principles and with an understanding of the tradeoffs involved in design choices.
An ability to use sound development principles to implement computer-based and software systems of varying complexity, and to evaluate such systems.
An ability to use current techniques, skills, and tools necessary for computing practice.
The student will:
Referencing modules: Midterm Exam 1, Midterm Exam 2, Java Review, Final Exam, Simple Sorting Algorithms
Assessed by: H10: Sort by using a Binary Search Tree, H11: Huffman Tree, Q01: Practice, Midterm 1, Midterm 2, H08: Simulate checkout lanes, Q02: Java Review, H09: Recursive Sudoku Solver, H06: Iterating over Beer Flights, H04: Sortable Beer List (Array implementation), H05: Sortable Beer List (Doubly linked implementation), Final Exam Assessment, Final Grade Assessment, H03: Sorting Arrays, Q05: Big O, Q03: Person Class, Q04: Inheritance and interfaces, H07: Postfix Calculator,
The student will:
Referencing modules: Midterm Exam 1, Midterm Exam 2, Final Exam, Simple Sorting Algorithms, OOP and Class Hierarchies
Assessed by: H10: Sort by using a Binary Search Tree, H11: Huffman Tree, Midterm 1, Midterm 2, H08: Simulate checkout lanes, H09: Recursive Sudoku Solver, H06: Iterating over Beer Flights, H04: Sortable Beer List (Array implementation), H05: Sortable Beer List (Doubly linked implementation), Final Exam Assessment, H03: Sorting Arrays, Q03: Person Class, Q04: Inheritance and interfaces, H07: Postfix Calculator
The student will:
Referencing modules: Midterm Exam 1, Midterm Exam 2, Big-O Notation, Final Exam
Assessed by: Midterm 1, Midterm 2, Q08: ArrayList, Q09: LinkedList, Q12: Iterators, Q07: List ADT, H04: Sortable Beer List (Array implementation), Q10: LinkedList, H05: Sortable Beer List (Doubly linked implementation), Q11: List Iterators, Final Exam Assessment
The student will:
Distinguish between and implement O(n2) sorting algorithms.
Distinguish between and implement O(nlogn) sorting algorithms.
Referencing modules: Midterm Exam 1, Midterm Exam 2, Final Exam, Simple Sorting Algorithms, Complex Sorting Algorithms
Assessed by: Midterm 1, Midterm 2, H04: Sortable Beer List (Array implementation), H05: Sortable Beer List (Doubly linked implementation), Final Exam Assessment, H03: Sorting Arrays, Q05: Big O, Q26: Merge, Q25: Heaps
The student will:
Use Arrays as the underlying data structure for different ADT implementations.
Explain the trade-offs between an array vs. Linked implementation of the ADTs.
Referencing modules: Midterm Exam 1, Midterm Exam 2, Final Exam, Simple Sorting Algorithms, Complex Sorting Algorithms
Assessed by: Midterm 1, Midterm 2, Q08: ArrayList, Q07: List ADT, H04: Sortable Beer List (Array implementation), Final Exam Assessment, H03: Sorting Arrays, Q05: Big O
The student will:
Develop abstract data types.
Use appropriate data encapsulation and information hiding.
Choose, design and develop appropriate tests for their Java code.
Referencing modules: Simple Sorting Algorithms
Assessed by: H10: Sort by using a Binary Search Tree, H11: Huffman Tree, H08: Simulate checkout lanes, H09: Recursive Sudoku Solver, H06: Iterating over Beer Flights, H04: Sortable Beer List (Array implementation), H05: Sortable Beer List (Doubly linked implementation), H03: Sorting Arrays, H07: Postfix Calculator,
The student will:
Understand White and Black box testing.
Choose, design and develop appropriate tests for their Java code.
Referencing modules: Simple Sorting Algorithms
Assessed by: H10: Sort by using a Binary Search Tree, H11: Huffman Tree, H08: Simulate checkout lanes, H09: Recursive Sudoku Solver, H06: Iterating over Beer Flights, H04: Sortable Beer List (Array implementation), H05: Sortable Beer List (Doubly linked implementation), H03: Sorting Arrays, H07: Postfix Calculator,
The student will:
Implement two different versions of the List interface.
Explain the trade-offs between the two different implementations.
Referencing modules: Midterm Exam 1, Midterm Exam 2, Lists, Hash Tables, Final Exam
Assessed by: Midterm 1, Midterm 2, Q08: ArrayList, Q09: LinkedList, Q12: Iterators, H06: Iterating over Beer Flights, Q07: List ADT, H04: Sortable Beer List (Array implementation), Q10: LinkedList, H05: Sortable Beer List (Doubly linked implementation), Q11: List Iterators, Q24: Chaining Hashmap, Final Exam Assessment
The student will:
Describe the different Java collection classes.
Explain and compare the basics of memory management in different implementations.
Referencing modules: Midterm Exam 1, Midterm Exam 2, Lists
The student will:
Implement several different versions of the Iterator interface.
Implement several different versions of the Iterable interface.
Explain the trade-offs between the different implementations.
Referencing modules: Lists
Assessed by: Q09: LinkedList, Q12: Iterators, H06: Iterating over Beer Flights, Q10: LinkedList, Q11: List Iterators
The student will:
Explain standard interface for a Stack.
Implement two different versions of the Stack interface.
Compare the trade-offs between the two different implementations.
Referencing modules: Midterm Exam 2, Final Exam, Stacks
Assessed by: Midterm 2, Final Exam Assessment, H07: Postfix Calculator, Q14: LinkedStack
The student will:
Explain the differences between prefix, infix and postfix notation.
Implement code to process prefix, infix and postfix equations.
Compare the trade-offs between the notations.
Referencing modules: Midterm Exam 2, Final Exam, Stacks
Assessed by: Midterm 2, Final Exam Assessment, H07: Postfix Calculator
The student will:
Implement several different versions of the Queue interface.
Compare the trade-offs between the two different implementations.
Referencing modules: Midterm Exam 2, Queues, Final Exam
Assessed by: Midterm 2, H08: Simulate checkout lanes, Q16: ArrayQueue, Q15: LinkQueue, Final Exam Assessment
The student will:
Use recursive algorithms to solve different problems.
Write correct recursive Java code to solve different problems.
Referencing modules: Trees, Midterm Exam 2, Recursion, Final Exam
Assessed by: Q19: Binary Tree Traversal, Q20: BinarySearchTree, H10: Sort by using a Binary Search Tree, Q21: BinarySearchTree, H11: Huffman Tree, Midterm 2, Q18: Recursion, H09: Recursive Sudoku Solver, Q17: Recursion, Final Exam Assessment
The student will:
Explain the standard structure of a Tree.
Implement binary trees.
Implement binary search trees.
Implement a Heap.
Referencing modules: Trees, Final Exam
Assessed by: Q19: Binary Tree Traversal, Q22: Heaps , Q20: BinarySearchTree, H10: Sort by using a Binary Search Tree, Q21: BinarySearchTree, H11: Huffman Tree, Final Exam Assessment
The student will:
Explain the differences between pre-order, in-order and post-order traversals.
Implement code to conduct pre-order, in-order and post-order traversals of binary trees.
Referencing modules: Trees, Final Exam
Assessed by: Final Exam Assessment
The student will:
Implement two different versions of the Hash Map interface, open addressing and chaining.
Explain the trade-offs between the two different implementations.
Referencing modules: Hash Tables, Final Exam
Assessed by: Q23: Open Address Hashmap, Q24: Chaining Hashmap, Final Exam Assessment
The student will:
Explain and implement the binary and linear search algorithms.
Compare, contrast and implement pre-order, in-order, and post-order binary tree traversal.
Referencing modules: Final Exam
Assessed by: Final Exam Assessment
The student will:
Referencing modules: Welcome to ICS 211
Assessed by: Q01: Practice, Final Grade Assessment