CSCI 2341 Course Outline (may be updated at any time)
Last updated: 2025-05-02 09:57:04

Students are expected to be comfortable with the Java programming language, and its use to write software solutions to various problems, up to the level provided by the CSCI 1226/1228 course sequence here at SMU. Revisiting at least some of this material will be part of the current course as well.

In addition to assignments to be done in the zyBook, students will also write Java programs to solve various problems and submit both their source code and an executable class or jar file and a testing script for evaluation.

Sample Program Files under the "Sample Java Code" Link
The subdirectories in this location contain files and further subdirectories with groups of related files that are the same as or similar to the sample files available on our Linux server. However, since we are now using the Linux server as our main development platform, the files and versions of files on the server may be more complete and/or up to date than the website versions, and it is recommended that, given a choice, you go with the server version(s). A readme.txt file in a subdirectory on the web or the server will suggest the order in which you should study the programs in that subdirectory.

Agenda for the first class (Wednesday, September 3, 2025)

  1. Overview of course and course infrastructure via a tour of the Brightspace page for the course and the "legacy" course website
  2. Introduction to Linux and connecting to a Linux server from your personal computer via ssh, PuTTY, KiTTY or similar software
  3. Introduction to the Vim editor
  4. Introduction to our zyBook online text

Follow-up after the first class

  1. Take some time before the next class to make yourself thoroughly familiar with the "legacy" course website.
  2. Sign up for the zyBook online text and once you have done that you can start working on the first required zyBook assignment (PCLAss1).

Working through the zyBook (our online textbook)

Once we have finished our course orientation, we will begin our discussion of course material using our online zyBook text as the main point of reference. We will also examine many Java code examples that illustrate the various topics under discussion. Some will come from the zyBook itself, and others will be instructor-supplied. Many sample programs will be available by download from the legacy course website, but the most complete and up-to-date versions of sample code files will be the ones on the Linux server.

Given below is a list of the chapters in our zyBook. We will not have time to cover everything in all the chapters listed. The first 6 chapters discuss the main topics of the course (namely, data structures and algorithms), and also provide illustrative Java examples, of course. The last 4 chapters deal specifically with Java-related topics, and Chapters 13 and 14 contain material that should be familiar to any student who is adequately prepared for this course, but you will also be working through those two chapters as further practice to help you consolidate that material. If time permits, we may also cover one or more topics from the remaining zyBook chapters.

  1. Introduction to Data Structures and Algorithms (data structures, algorithms and the relationship between them, ADTs and some typical applications; intro to algorithm efficiency)
  2. Searching and Algorithm Analysis (linear and binary search, with Big O performances)
  3. Sorting Algorithms (selection, insertion, shell, quick, merge, and radix, with Big O performances)
  4. Lists, Stacks, and Queues (mainly linked implementations, but also array-based lists)
  5. Hash Tables (various hash functions, open addressing and chaining, collision resolution, Big O performance)
  6. Trees (binary trees with inorder, preorder and postorder traversal and binary search trees in particular, Big O performance)
  7. Balanced Trees (just one global balancing algorithm)
  8. Heaps and Treaps (brief discussion of heaps)
  9. Sets (not covered)
  10. Graphs (not covered)
  11. Algorithms (not covered)
  12. B-trees (not covered)
  13. Additional Material (BubbleSort, Circular Lists)
  14. Recursion (including arrays and linked lists)
  15. Exceptions (throw, try, catch, finally)
  16. Generics (generic classes and generic methods)
  17. Collections (Java ArrayList and LinkedList; Java ArrayDeque as used for stacks, queues and deques; Java HashSet and TreeSet; Java HashMap and TreeMap; Java lambda functions, streams and pipelines)