1. Introduction to Data Structures
Lecture 1: Introduction
Lecture 1: Introduction

2. Lecture 1: Introduction
Course Web Sites
Blackboard too
Lecture 1: Introduction

3. Structure of the Course
Lectures / class participation
Projects (programming)
Recitations (lab work, quizzes, and project discussions)
Midterm examination
Final examination
Lecture 1: Introduction

4. Lecture 1: Introduction
Readings
Readings from the required text are assigned for each lecture -- read them in advance
The book contains self-test exercises in each section
Work these exercises (especially if you are new to the material)
Lecture 1: Introduction

5. Lecture 1: Introduction
Grading
Homework (5 or 6) 50%
Recitation %
Midterm Exam 20%
Final Exam 20%
Lecture 1: Introduction

6. Lecture 1: Introduction
Waitlist maintenance
Please see me as soon as possible if you are on the waitlist.
It is essential that you have programming experience prior to taking this class.
Lecture 1: Introduction

7. Lecture 1: Introduction
Definitions
A data structure is an organized collection of data with specific aggregate properties
An algorithm is a sequence of program instructions designed to compute a particular result
Lecture 1: Introduction

8. Five Steps per Datatype
Understand it Abstractly
Write a Specification
Write Applications
Select an existing, or Design and Implement our own
Analyze the Implementation in terms of performance
Lecture 1: Introduction

9. Lecture 1: Introduction
Abstract vs. Concrete
An abstract data type (ADT) specifies behavior, but not implementation
An implementation uses a particular low-level datatype to implement the desired behavior
Lecture 1: Introduction

10. Lecture 1: Introduction
Quick Example
A stack is an abstract data type (ADT).
We push and pop from the top.
Consider three implementations:
(1) Every push causes all elements in an array to shift
down 1 before the insertion at s[0].
(2) We add at stackTop and then add one to stackTop.
(3) A linked list use where the top is always at the list’s
front end.
Each implementation can be written correctly.
Implementation (1) runs in Θ(n).
Implementations (2) and (3) run in Θ(1).
Lecture 1: Introduction

11. Lecture 1: Introduction
Step 1: Understanding
Grasp the datatype at the level of concepts and pictures e.g., visualize a stack and the operations of pushing / popping
Understand simple applications
Simulate by hand e.g., use a stack to reverse the order of letters in a word
Lecture 1: Introduction

12. Lecture 1: Introduction
Step 2: Specification
Write a specification for a Java class that could implement the datatype (Javadoc generates HTML)
Headings for constructor, public methods, public features
Includes precondition / postcondition for each method
Independent of implementation!
Lecture 1: Introduction

13. Lecture 1: Introduction
Step 3: Application
Based on the specification, write small applications to illustrate the use of the datatype
“Test the specification” prior to implementation
Code not yet compiled / run
Lecture 1: Introduction

14. Lecture 1: Introduction
Step 4: Implementation
Select appropriate data structure
Implement as private class vars
Write rules relating instance variables to abstract specification: the invariant of the ADT
Each method knows the invariant is true when it starts
Each method upholds the invariant
Lecture 1: Introduction

15. Lecture 1: Introduction
Step 5: Analysis
Correctness
Flexibility
When possible, compare different implementations of the same ADT
Time Analysis
number of operations
big-O notation, e.g.,
Lecture 1: Introduction

16. Phases of Software Development
Specification of the Task
Design of a Solution
Implementation of the Solution
Running Time Analysis
Testing and Debugging
Maintenance and Evolution
Obsolescence
Lecture 1: Introduction

17. Lecture 1: Introduction
Java
Conceived in 1991 at Sun
Has Similarities to C++
Is simpler than C++
Object-Oriented Programming (OOP)
information hiding
component re-use
programs (methods) and data are grouped together into classes
Unless assigned, we will not be using the collection classes
Lecture 1: Introduction

18. What You Should Pick up Soon
A Java development environment (Netbeans, Eclispse, command line java, javac, javadoc)
How to write, compile, and run short Java programs
Java primitive types (number types, char, boolean) and arrays
Complete this week’s lab as soon as possible
Lecture 1: Introduction

19. Specifying a Java Method
Specification: what a method does not how it does it
A form of information hiding called procedural abstraction
Method signature public static double celsiusToFahrenheit(double c)
Method call double fahrenheit = celsiusToFahrenheit(celsius);
Lecture 1: Introduction

20. Elements of Specification
Short Introduction
Parameter Description
Returns
Specify the meaning of return value
Throws list
error conditions (exceptions) “thrown” by this method
Precondition and Postcondition
Lecture 1: Introduction

21. Lecture 1: Introduction
Preconditions
A precondition is a statement giving the condition that should be true when the method is called
The method is not guaranteed to perform as it should unless the precondition is true.
If violated, ignore (like c) or throw an exception (like Java).
Lecture 1: Introduction

22. Lecture 1: Introduction
Postconditions
A postcondition is a statement describing what will be true when a method call completes
If the method is correct and precondition was met, then the method will complete, and the postcondition will be true when it does
Use Java assert statement for post-condition checks during debugging. Not
during deployment.
Lecture 1: Introduction

23. Example Specification
celsiusToFahrenheit public static double celsiusToFahrenheit(double c)
convert a temperature from Celsius degrees to Fahrenheit degrees
Parameters: c - a temperature in Celsius degrees
Precondition: c>=
Returns: temperature c in Fahrenheit
Throws: IllegalArgument Exception
Lecture 1: Introduction

24. More on Pre/Postconditions
Slides from Main’s Lectures
Lecture 1: Introduction