CSE 2320 - Spring 2014 - Lectures

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

Lecture 1: Tue 07/08 - Introduction, Examples of Algorithms
- Book reading: Chapter 1, Chapter 2.6 (Binary Search), Chapter 6.2 (Selection Sort).
- Slides for Introduction: PDF, PPT.
- Slides for Examples of Algorithms: PDF, PPT. Today we covered up to slide 42.
Lecture 2: Wed 07/09 - Examples of Algorithms (continued), Analysis of Algorithms
- Book reading: Chapter 2.
- Slides for Examples of Algorithms: PDF, PPT. Today we covered from slide 43 to the end.
- Slides for Analysis of Algorithms: PDF, PPT. Today we covered up to slide 46.
- 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 07/09 - More on Analysis of Algorithms.
- Book reading: Chapter 2.
- Slides for Analysis of Algorithms: PDF, PPT. Today we covered from slide 47 to the end.
- Additional slides with methods and examples: PDF, PPT.
Lecture 4: Mon 07/14 - Data Structures: Arrays, Linked Lists.
- Book reading: Chapter 3.1, 3.2, 3.3, 3.4.
- Slides: PDF, PPT. Today we covered up to slide 71.
- 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.
  - 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 5: Tue 07/15 - Linked Lists (continued), Strings, 2D arrays, Graphs.
- Book reading: Chapter 3.1, 3.2, 3.3, 3.4, 3.6, 3.7.
- Slides for lists: PDF, PPT. Today we covered from slide 72 up to the end.
- Slides for strings, 2D arrays, and graphs: 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 6: Wed 07/16 - Abstract Data Types, Stacks, FIFO Queues.
- Book reading for abstract data types and stacks: Sections 4.2, 4.3, 4.4.
- Slides for abstract data types and stacks: PDF, PPT. Today we covered all slides.
- 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_incomplete.c. An incomplete main file for a program that evaluates postfix expressions. You can try to complete this implementation as practice (the solution is the next file).
  - infix_main.c. A complete version of the previous file: a main file for a program that evaluates postfix expressions. You should compile with tokens.c, and either stacks_arrays.c or both stacks_lists.c and lists.c.
- Book reading for FIFO queues: Section 4.6.
- Slides for FIFO queues: PDF, PPT. Today we covered all slides.
Lecture 7: Thu 07/17 - Recursion, Dynamic Programming.
- Book reading: Sections 5.1, 5.3.
- Slides: PDF, PPT (today we covered slides 1-85).
- Code:
  - fibonacci.c. A program computing Fibonacci numbers using top-down dynamic programming (also called memoization).
  - 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 8: Mon 07/21 - Dynamic Programming (continued)
- Book reading: Sections 5.1, 5.3.
- Slides: PDF, PPT (today we covered slides 86-end).
- Code:
  - 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 9: Tue 07/22 - Trees and Graphs.
- Book reading: Sections 5.4, 5.5, 5.6, 5.7, 5.8.
- Slides: PDF, PPT.
Lecture 10: Wed 07/23 - First Midterm.
Lecture 11: Thu 07/24 - Quicksort and Mergesort.
- Book reading for quicksort: Sections 6.1, 7.1, 7.2, 7.5, 7.8.
- Slides for quicksort: PDF, PPT.
- Code for quicksort: quicksort.c. An implementation of quicksort.
- Book reading for mergesort: Sections 8.1, 8.3, 8.6.
- Slides for mergesort: PDF, PPT.
- Code for mergesort: mergesort.c. An implementation of mergesort.
Lecture 12: Mon 07/28 - Heaps
- Book reading: Sections 9.1, 9.2, 9.3, 9.4.
- Slides: PDF, PPT.
Lecture 13: Tue 07/29 - 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 14: Wed 07/30 - Search Trees
- Book reading for search trees: Sections 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 13.3.
- Slides for search trees: PDF, PPT.
Lecture 15: Thu 07/31 - Second Midterm.
Lecture 16: Mon 08/04 - Minimum-Cost Spanning Trees
- Book reading for minimum-cost spanning trees: Sections 20.1, 20.2, 20.3, 20.4.
- Slides for minimum-cost spanning trees: PDF, PPT. Today we did slides 1-39.
Lecture 17: Tue 08/05 - Minimum-Cost Spanning Trees (continued), Shortest Paths
- Book reading for minimum-cost spanning trees: Sections 20.1, 20.2, 20.3, 20.4.
- Slides for minimum-cost spanning trees: PDF, PPT. Today we did slides 40-end.
- Book reading for shortest paths: Sections 21.1, 21.2, 21.3, up to program 21.4 on page 294.
- Slides for shortest paths: PDF, PPT.
Lecture 18: Wed 08/06 - Review
Lecture 19: Thu 08/07 - Review
Final Exam: Mon 08/11

Back to the compact version of this page.

Back to CSE 2320 home page.