CS313E Study Guide: Fall 2011

This is study guide for the CS313E midterm and final. The best strategy to study is to read over the slides and make sure that you understand the code you've written. You can bring one handwritten 8 1/2 by 11 sheet of notes to the test; you can use both sides of the sheet.

Slideset 1: Introduction

  1. Understand basically what a computer is, what the major components are, and how the fetch-execute cycle works.
  2. Understand conceptually how different types of information are represented in a computer.

Slideset 2: Basic Python

  1. You are expected to have facility with basic Python language constructs and be able to write simple programs.
  2. Understand the basic design goals of Python.
  3. Know how to run Python programs.
  4. Understand the primitive Python data types: integers, floats, bools.
  5. Understand how variables work in Python.
  6. Understand the complex data types: strings, lists, and dictionaries.
  7. Know how to use the arithmetic and relational operators.
  8. Understand how to use Python conditionals and loops.
  9. Know how to write and call Python functions.
  10. Know the difference between mutable and immutable data structures.
  11. Understand how to use the function input.

Slideset 3: Turtle Graphics

  1. Understand how the turtles exemplify object oriented programming.
  2. Understand a turtle's state.
  3. Be able to write simple turtle programs.
  4. Understand the scheme for specifying colors (RGB).

Slideset 4: Classes

  1. Understand what a class is.
  2. Know how to write simple classes.
  3. Understand what attributes and methods mean wrt classes.
  4. Understand accessors and mutators.
  5. Understand the "magic methods" like __str__, __len__, __init__, etc.

Slideset 5: Abstract Data Types

  1. Understand what an abstract data type is and how they're used.
  2. Be able to explain why encapsulation is important.
  3. Understand how ADTs are implemented as classes in Python.
  4. Know the details of the Stack class and how to use it.
  5. Understand at an intuitive level the Stack algorithms we discussed. You don't need to be able to write them from scratch.
  6. Understand Python's dictionary type and how it's used.

Slideset 6: Queues

  1. Know the details of the Queue class and how to use it.
  2. Understand the market simulation example.
  3. Understand inheritance (single and multiple), what it means, and how it's done in Python.
  4. Understand the Rectangle/Square example and how it works.
  5. Understand when methods are new, inherited or overridden in a class.
  6. Understand bounded queues and priority queues and how they are implemented in Python.
  7. Understand bounded priority queues and how they are implemented via double inheritance.

Slideset 7: Linked Lists

  1. Know how to use the Python list type.
  2. Understand the List ADT interface.
  3. Understand the two ways to implement lists, contiguous and linked implementation.
  4. Understand when a method is constant-time and when linear-time.
  5. Understand the Node and Unordered List classes.
The following came after the midterm.

Slideset 8: Recursion

  1. Understand what recursion is.
  2. Understand what must be true of recursive routines.
  3. Be able to write simple recursive routines.
  4. Understand the overhead of recursion.

Slideset 9: Efficiency

  1. Understand the concept of algorithm efficiency.
  2. Understand the Big-O concept.
  3. Be able to explain the difference between best, average and worst case efficiency.
  4. Know why worst case is often chosen.
  5. Be able to estimate the efficiency of simple code fragments, particularly nested loops.
  6. Understand the categories: constant, logarithmic, linear, quadratic, and exponential.

Slideset 10: Trees

  1. Understand the vocabulary associated with the Tree ADT.
  2. Understand expression trees.
  3. Know the BinaryTree and TreeNode interfaces.
  4. Understand the implementation in Python of BinaryTrees.
  5. Understand the notion of BinaryTree as a "wrapper" on nodes.
  6. Understand the algorithm for converting a postfix expression to a BinaryTree.
  7. Understand the four tree traversals: postorder, inorder, preorder and level-order.
  8. Know that all of the traversals are linear time.
  9. Understand the algorithm for evaluating an expression tree.
  10. Understand binary search trees and their interface.
  11. Understand why balancing a tree may be necessary.
  12. Understand the TreeSort algorithm and its complexity.

Slideset 11: Language Interpreter

  1. Be able to read and understand code.
  2. Understand basic object oriented design.
  3. Know the Python constructs used in this application such as split and strip.