CSE 2320 - Spring 2014 - Lectures

There is also a compact version of this page, that does not include links to code.

Lecture 1: Mon 01/13 - Introduction
- Book reading: Chapter 1.
- Slides: PDF, PPT.
Lecture 2: Wed 01/15 - Examples of Algorithms
- Book reading: Chapter 1, Chapter 2.6 (Binary Search), Chapter 6.2 (Selection Sort).
- Slides: PDF, PPT.
- Code for the Find-Union problem:
  - find_union1a.c: The first, slow version of find-union, as described in the textbook, modified to print some additional information.
  - find_union1b.c. A modified version of find_union1a.c. We follow the same algorithm, but the code is rewritten, so as to have functions set_union and find defined explicitly.
  - find_union2b.c. This is the first slow-find, fast-union version from the textbook, where the size of the two sets is not considered by function set_union.
  - find_union3b.c. This is the more efficient version of slow-find, fast-union, where function set_union considers the size of the two sets, and changes the ID of the smaller set.
  - find_union4b.c. This is the most efficient version of slow-find, fast-union, where function find flattens the tree that it goes through.
- Code for Binary Search:
  - binary_search.c: This takes two command-line arguments: a filename, containing numbers in sorted order, and a number to search for. For example, if you compile the program into an executable called binary_search, you can run the program as follows:
```
binary_search input2.txt 321492
```
  - input2.txt: An example of a file that you can pass as input to the program.
- Code for Selection Sort:
  - selection_sort.c: This takes two command-line arguments: an input filename, containing numbers, and an output file, where the result is stored. For example, if you compile the program into an executable called selection_sort, you can run the program as follows:
```
selection_sort input3.txt output.txt
```
  - input3.txt: An example of a file that you can pass as input to the program.
Lecture 3: Wed 01/22 - Analysis of Algorithms
- Book reading: Chapter 2.
- Slides: PDF, PPT.
Lecture 4: Mon 01/27 - Analysis of Algorithms, Arrays.
- Book reading: Chapter 3.1, 3.2.
- Slides for analysis of algorithms: PDF, PPT (same as in previous lecture, today we covered slides 65-99).
- Slides for data structures: PDF, PPT (covered up to slide 15).
Lecture 5: Wed 01/29 - Linked Lists.
- Book reading: Chapter 3.3, 3.4.
- Slides: PDF, PPT (same as in previous lecture, today we covered slides 16-69).
- Code for lists:
  - simple_list1a.c: A simple program, that creates a list containing integers 573, 100, 200, and prints out the contents of the list.
  - simple_list1b.c: An improved version of the previous program, that includes functions for creating a new link, and for printing the contents of the list.
  - read_integers1.c: A program that asks the user to enter some integers, and stores those integers in a list.
  - list_interface.h and list_interface.c Files defining lists of integers as an abstract interface. Other C code (see next examples) can use lists only through the functions defined in list_interface.h. The implementation of lists in list_interface.c can change without affecting any code using the functions of list_interface.h. The only thing that is hardcoded here is that lists can only contain integers.
  - read_integers2.c An alternative version of read_integers1.c, that uses lists through the interface defined on list_interface.h. Should be compiled with list_interface.c.
Lecture 6: Mon 02/03 - Review of Chapter 2, for Assignment 2.
- Book reading: Chapter 2.
- Review slides for assignment 2: PDF, PPT.
Lecture 7: Wed 02/05 - Lists, continued.
- Book reading: Chapters 3.
- Slides: PDF, PPT (same as in lecture 5, today we covered slides 70-96).
- More code for lists:
  - insertion_sort.c A program that creates a random list of integers, sorts the list in ascending order, and then reverses the list. Should be compiled with list_interface.c.
  - josephus.c A program that solves the Josephus problem. It takes two command line arguments, N and M (see textbook program 3.9). Should be compiled with list_interface.c.
  - merging.c A program that tests two functions that merge two lists together: a destructive function, and a non-destructive function. The functions themselves are defined at list_interface.c. Should be compiled with list_interface.c.
Lecture 8: Mon 02/10 - Strings, 2D arrays, Graphs.
- Book reading: Chapters 3.6, 3.7.
- Slides: PDF, PPT.
- Code for strings:
  - basic_strings.h and basic_strings.c Files defining basic functions for using and manipulating strings.
  - basic_testing.c A program testing the functions defined at basic_strings.c. Should be compiled with basic_strings.c.
  - string_search.c A program searching a (presumably long) string A to find all occurrences of a (presumably short) string P. String P is provided as a command-line argument, and string A is provided as user input. Should be compiled with basic_strings.c.
- Code for 2D arrays and matrices:
  - twoD_arrays.h and twoD_arrays.c Files defining some simple functions for 2D arrays, such as memory allocation, memory deallocation, printing a 2D array, creating a random 2D array, and adding two matrices.
  - matrices.c. A simple program that tests the functions defined at twoD_arrays.c. Should be compiled with twoD_arrays.c.
- Code for graphs:
  - graphs.h. This header file defines some simple functions for graphs, such as memory allocation, memory deallocation, adding and removing edges, and printing neighbors of vertices.
  - graphs_matrix.c. A source file implementing the functions declared at graphs.h. In this file, we use a 2D array to keep track of graph edges. Note: file graphs_list.c provides an equivalent but different implementation of the same functions.
  - graphs_list.c. A source file also implementing the functions declared at graphs.h. In this file, we use an array of linked lists to keep track of graph edges. Note: file graphs_matrix.c provides an equivalent but different implementation of the same functions.
  - graphs_main.c. A program that tests the functions declared at graphs.h. Should be compiled with twoD_arrays.c, list_interface.c, and either graphs_matrix.c or graphs_list.c. Actually, one of the key features of this program is that it does not care how graphs are implemented, so we can use either implementation (graphs_matrix.c or graphs_list.c), as long as it complies with the declarations in graphs.h
Lecture 9: Wed 02/12 - Abstract Data Types and Stacks.
- Book reading: Sections 4.2, 4.3, 4.4.
- Slides: PDF, PPT.
- Code for stacks:
  - lists.h and lists.c. A revised interface and implementation of lists. Now each link contains an item of type void*, so a list can store any type of object.
  - stacks.h. This header file defines a public interface for stacks.
  - stacks_lists.c. A source file implementing the functions declared at stacks.h, using lists as the underlying stack representation.
  - stacks_arrays.c. A source file implementing the functions declared at stacks.h, using arrays as the underlying stack representation.
  - tokens.h and tokens.c An interface and implementation of tokens, that can be used for processing arithmetic expressions in infix or postfix notation.
  - infix_main.c. An incomplete main file for a program that evaluates postfix expressions. Completing this implementation will be given as homework.
Lecture 10: Mon 02/17 - Abstract Data Types: Stacks, FIFO Queues.
- Book reading: Section 4.6.
- Slides for stacks (same as in Lecture 9): PDF, PPT.
- Slides for FIFO queues: PDF, PPT.
Lecture 11: Wed 02/19 - FIFO Queues, Recursion, Fibonacci numbers.
- Book reading: Sections 4.6, 5.1, 5.3.
- Slides for FIFO queues: PDF, PPT.
- Slides for recursion and Fibonacci numbers: PDF, PPT (today we covered slides 1-35).
Lecture 12: Mon 02/24 - Review for First Midterm.
Lecture 13: Wed 02/26 - First Midterm.
Lecture 14: Mon 03/03 - Fibonacci numbers, Memoization.
- Book reading: 5.3.
- Slides (same as in lecture 11): PDF, PPT (today we covered up to slide 46).
- Code:
  - fibonacci.c. A program computing Fibonacci numbers using top-down dynamic programming (also called memoization).
Lecture 15: Wed 03/05 - Dynamic Programming.
- Book reading: 5.3.
- Slides (same as in lecture 11): PDF, PPT (today we covered up to slide 93).
- Code for dynamic programming:
  - knapsack_recursive.c. A program solving the knapsack problem (for hardcoded inputs) using recursion. It has exponential time complexity, becomes too slow for inputs (maximum weights) over 70.
  - knapsack_bottom_up.c. A program solving the knapsack problem (for hardcoded inputs) using bottom-up dynamic programming. It has linear time and space complexity, can easily process maximum weights up to 100 million (or more, if there is sufficient memory).
  - knapsack_top_down.c. A program solving the knapsack problem (for hardcoded inputs) using top-down dynamic programming. It has linear time and space complexity, but cannot process maximum weights over 97,000 (on my machine) due to the cost of recursive function calls.
  - interval_scheduling.c. A program solving the weighted interval scheduling problem using bottom-up dynamic programming. It reads input from files, such as wis1.txt. This program only prints out the best value that can be attained, NOT the set of intervals that achieves that value.
  - interval_scheduling_backtracking.c. A program solving the weighted interval scheduling problem using bottom-up dynamic programming. It reads input from files, such as wis1.txt. This program prints out both the best value that can be attained, AND the set of intervals that achieves that value.
Lecture 16: Mon 03/17 - 2-Dimensional Dynamic Programming.
- Book reading: 5.3.
- Slides (same as in lecture 11): PDF, PPT (today we covered from slide 93 to the end).
- Code for 2D dynamic programming:
  - matrix_multiplication.c. A program finding the optimal order for multiplying a sequence of matrices, using dynamic programming. It reads input from files, such as omm1.txt. This program prints out both the best cost that can be attained, AND the parenthesized expression that shows the order in which matrices should be multiplied.
Lecture 17: Wed 03/19 - Trees and Graphs.
- Book reading: Sections 5.4, 5.5, 5.6, 5.7, 5.8.
- Slides: PDF, PPT.
Lecture 18: Mon 03/24 - Quicksort
- Book reading: Sections 6.1, 7.1, 7.2, 7.5, 7.8.
- Slides: PDF, PPT.
- Code: quicksort.c. An implementation of quicksort.
Lecture 19: Wed 03/26 - Mergesort
- Book reading: Sections 8.1, 8.3, 8.6.
- Slides: PDF, PPT.
- Code: mergesort.c. An implementation of mergesort.
Lecture 20: Mon 03/31 - Heaps
- Book reading: Sections 9.1, 9.2, 9.3, 9.4.
- Slides: PDF, PPT.
Lecture 21: Wed 04/02 - Second Midterm.
Lecture 22: Mon 04/07 - Radix sort
- Book reading: Sections 10.1, 10.3, 10.5, 10.6.
- Slides: PDF, PPT.
- Code: radix_sort.c. Implementations of MSD and LSD radix sort.
Lecture 23: Wed 04/09 - Radix sort
- Book reading: Sections 10.1, 10.3, 10.5, 10.6.
- Slides: PDF, PPT (same as in previous lecture).
Lecture 24: Mon 04/14 - Radix sort, Search Trees
- Book reading: Sections 12.1, 12.2, 12.3, 12.4, 12.5, 12.6.
- Radix Sort slides: PDF, PPT (same as in previous lecture).
- Search Trees slides: PDF, PPT. Today we covered up to slide 29.
Lecture 25: Wed 04/16 - Search Trees
- Book reading: Sections 13.3, 13.4.
- Search Trees slides: PDF, PPT. Same as in previous lecture. Today we covered slides 29-end.
Lecture 26: Mon 04/21 - Minimum-Cost Spanning Trees
- Book reading: Sections 20.1, 20.2, 20.3, 20.4.
- Slides: PDF, PPT.
Lecture 27: Wed 04/23 - Shortest Paths
- Book reading: Sections 21.1, 21.2, 21.3, up to program 21.4 on page 294.
- Slides: PDF, PPT.
Lecture 28: Mon 04/28 - Review
Lecture 29: Wed 04/30 - Review

Back to the compact version of this page.

Back to CSE 2320 home page.