Class: CSCI/CMPE 3333.01 Algorithms and Data Structures
Semester: Fall 2009
Instructor: Robert Schweller
Email: schwellerr@gmail.com
Homepage: http://www.cs.panam.edu/~schwellerr
Phone: (956) 381-2667
Office: ENGR. 3.294
OH: MTWRF 10:00am - 11:00am, or by appointment
Classroom: ENGR. 1.290
Class Time: MWF 11:45am - 12:35

Textbook and other materials:

(Required) Data Structures and Algorithm Analysis in C++ (third edition), by Mark A. Weiss, Addison-Wesley

Description:

This course is a continuation of data structures topics covered in CSCI 2380. Content includes theoretical topics in algorithmic efficiency and complexity, along with abstract data types, including graphs, networks, trees, and priority queues. Search topics, including hashing, trees, external search trees (B-trees), and sorting algorithms including external sorting are introduced and compared. Computational complexity topics include the Class P and NP, NP-completeness and Reducibility, NP-completeness Proofs, and NP-complete Problems. Prerequisites: CSCI 2380 and Math 3373.

Prerequisites:

CSCI 2380, MATH 3373

Grading and Policies:

Written Homework (33%)

Projects (33%)
3 Exams (33%)

Your final grade will be based on the following scale:
A: 90-100%, B: 80-89%, C: 70-79%, D: 60-69%, and F: 0-59%

Attendance and Drop Policy:

Students are expected to attend lectures and to study the text in preparation to contribute to discussions. The class web page will provide access to the slides used for each lecture, assignments, tests schedule, resources, etc. Consult it often.

Make-up exams and quizzes will not be given except by prior consent of the instructor. You must notify the instructor within 24 hours after the exam/quiz when it is missed for determination of excuse. Examples of acceptable excuses would be death of an immediate family member, or illness, requiring physician's attention. Depending on the excuse, make-up exams/quizzes will result in a loss of points.

Students who wish to drop the class should request the drop from the instructor no later than November 12th (last day to officially drop or withdraw). No "drops" will be given after that date.

Important Note on Academic Dishonesty:

Students are expected to be familiar with the Department of Computer Science (UTPA) policies on computer usage.
All assignments and exams must be the student's own work. Students are encouraged to help one another and work in groups to understand the materials presented in class and the books, but both giving and receiving major sections of programming code and exam solutions are considered cheating. Cheating will be punished severely. For those who don't want others cheating to cheapen your own hard work and hurt your grade -- send an anonymous cheating reporting to the instructor via email. When cheating is caught, zero marks will be given the cheated work, and the case will be forwarded to the Department chair and beyond if necessary. Students are also encouraged to seek help with identifying syntax and run-time errors from the instructor during office hours.

Learning Outcomes:

Level 3: Synthesis and Evaluation

Level 3 outcomes are those in which the students can apply the materials in new situations. This is the highest level of mastery.

Upon successful completion of this course, students will be able to

• specify data structures and operations associated with abstract data types
• define the signature and pre- and post-conditions for operations of an abstract data type
• Given a scenario, describe the abstract data types that could be created
• identify, implement, and use the following data structures as appropriate for a given problem:
• lists implemented as arrays or linked lists
• stacks
• queues
• binary trees and binary search trees
• simple hashes
• implement binary trees and binary search trees, using pre-, post-, or in-order traversals as appropriate for a given situation
• judge which data model (list, tree, graph, or set) is appropriate for solving a problem
• justify the choice of a data structure to solve a problem based on issues such as time, space, and of the data structure.
• judge which implementations are best suited for an application that requires a list data model: lists, circular lists, circular queues, or generalized list
• judge whether an array or linked implementation is best suited or an application that requires a data model
• judge which graph representations (adjacency list, adjacency matrix, edge list) are appropriate for solving a problem
• develop algorithms that are based on depth- and breadth-first traversals of general trees, binary trees and graphs
• judge which sort algorithms (insertion, selection, mergesort, heapsort, quicksort, radix) is appropriate for solving a problem
• judge which search algorithm and data structure is appropriate for solving a problem
• implement a recursive solution to a problem

Level 2: Application and Analysis

Level 2 outcomes are those in which the students can apply the materials in familiar situations, e.g., can work a problem of familiar structure with minor changes in the details.

Upon successfull completion of this course, students will be able to

• use Big-O notation to express the best-, average-, and worst-case behaviors of an algorithm
• explain the structure and use of activation records
• determine the best-, average- and worst-case behaviors of an algorithm
• assess time and space trade-offs in algorithms
• explain, code, and use quadratic and O(n log n) sorting algorithms
• implement recursive algorithms over natural numbers, lists, and trees
• define and use classes, subclasses, and inheritance
• describe the importance of encapsulation and information hiding
• implement applications and simulations using data structures identified above
• implement simple sequential and binary search algorithms
• implement a set of searching/sorting algorithms
• categorize algorithms based on programming strategy, i.e., divided-and-conquer, greedy, backtracking, and dynamic programming strategies
• analyze iterative and recursive algorithms with respect to time and space
• describe the applications for a dictionary/map ADT, e.g., the application of symbol table
• Give representations for and operations on a binary tree, general tree, threaded tree, heap, binary search tree, B-tree, quadtree, and graph
• determine the order for a B-tree based on memory issues

Level 1: Knowledge and Comprehension

Level 1 outcomes are those in which the students have been exposed to the terms and concepts at a basic level and can apply basic definitions. The materials have been presented only at a superficial level.

Upon successful completion of this course, students will be able to:

• recognize the standard terms associated with particular data structures, e.g., head/tail, push/pop
• understand the big-O, Theta, Omega notations
• understand the concepts of time/space complexity
• understand the basic tree concepts
• understand the basic searching/sorting methods
• recognize the standard terms of graphs

Note to students with disabilities:

If you have a disability which will make it difficult for you to carry out the work as outlined here, or you need special accommodations/assistance due to a disability, please contact the Office of Services for Persons with Disabilities (OSPD), Emilia Schunior Ramirez Hall, Room 1.101 (ph: 316-7005), or the Associate Director at maureen@utpa.edu immediately. Appropriate arrangements/accommodations can be arranged.

Verification of disability and processing of special services required, such as notetakers, extended test time, separate accomodations for testing, will be determined by OSPD. Please do not assume adjustments/accomodations are impossible. Please consult with the Associate Director, OSDP, at extension 7005.