RESOURCES

LECTURE SLIDES

Preliminaries
  1. Welcome (slides)
  2. grade school algorithms for arithmetic (slides)
  3. log, mod, binary numbers (slides)
Introduction to Java
  1. Java primitive types (slides)
  2. Java programming overview (JVM, JRE, JDE, IDE,...) (slides)
  3. Java arrays (slides)
  4. Java objects & classes 1 (slides)
  5. Java objects & classes 2 (slides)
  6. Java packages, visibility modifiers (slides)
Linear Data Structures 1
  1. array lists (slides)
  2. singly linked lists (slides)
  3. doubly linked lists (slides)
  4. quadratic sorting algorithms (slides)
    bubble, selection, & insertion sort
Object Oriented Design in Java
  1. inheritance (slides)
  2. polymorphism (slides)
  3. interfaces and abstract classes (slides)
  4. Comparable and Iterable (slides)
Linear Data Structures 2 (and ADTs)
  1. stacks (slides)
  2. queues (slides)
Induction and Recursion
  1. mathematical induction (slides)
  2. recursion 1 (slides)
    factorial & Fibonacci, reverse/sort list, Tower of Hanoi; call stack
  3. recursion 2 (slides)
    binary search, mergesort 1
  4. recursion 3 (slides)
    mergesort 2, quicksort
Non-linear Data Structures
  1. rooted trees (slides)
  2. tree traversal (slides)
  3. binary trees e.g. expression trees (slides)
  4. binary search trees (slides)
  5. heaps 1 (slides)
  6. heaps 2 (slides)
  7. maps, hash codes (slides)
  8. hash maps (slides)
  9. graphs (slides)
  10. graph traversal (breadth vs depth first) (slides)
Mathematical Tools for Analysis of Algorithms
  1. recurrences 1 (slides)
  2. recurrences 2 (slides)
  3. big O (slides)
  4. big Omega (slides)
  5. big Theta, best and worst cases (slides)

EXERCISES




Exercises 1: grade school arithmetic, number representations (PDF)











Exercises 3: array lists (PDF)


Exercises 4: linked lists (PDF) (code)

Exercises 5: quadratic sorting (PDF)









Exercises 6: stacks and queues (PDF)






Exercises 7: induction (PDF)


Exercises 8: recursion (PDF)





Exercises 9: trees (PDF)


Exercises 10: heaps (PDF)


Exercises 11: hashing (PDF)


Exercises 12: graphs (PDF)



Exercises 13: recurrences (PDF)

Exercises 14: big O (PDF)