View
215
Download
2
Category
Preview:
Citation preview
Graphs, Trees, Objects
UC Santa CruzCMPS 10 –
Introduction to Computer Sciencewww.soe.ucsc.edu/classes/cmps010/Spring11ejw@cs.ucsc.edu8 April 2011
UC SANTA CRUZ
Class website
http://www.soe.ucsc.edu/classes/cmps010/Spring11/
Please write this down, and bookmark it
Holds:
Syllabus (including homework due dates)
Homework assignment descriptions
Description of course readings
Links to class lecture notes
The final exam is scheduled for Tuesday, June 7, 8am-11am
This class will have a final exam. Please plan on this.
UC SANTA CRUZ
Tutoring available
Learning Support Services (LSS)
Has tutoring available for students in CMPS 10
Students meet in small groups, led by a tutor
Students are eligible for up to one-hour of tutoring per week per course, and may sign-up for tutoring at https://eop.sa.ucsc.edu/OTSS/tutorsignup/
beginning April 5th at 10:00am.
Brett Care -
bcare@ucsc.edu
is the tutor for CMPS 10 that LSS has hired
UC SANTA CRUZ
Abstraction and Models
Converting the real world into data:
Create a model
of the real world
Represent
that model in data
How do you model the real world?
Involves a process called abstraction
Abstraction
Prerequisite: know your problem or application
Focus
on aspects of the real world that are important to the problem
Add those elements to your model
Omit
elements of the real world that aren’t relevant
Implies: the same real world scenario can be modeled in many ways, depending on the problem at hand
physical world
model
data (inside
computer)
abstraction
representation
UC SANTA CRUZ
Representing models as data
Most models can be represented using:
Basic data types
Integers
Floating point
Boolean
Characters
Strings
Basic data structures
Arrays
Lists
Stacks/Queues
Trees
Graphs
Clusters of data
Modeling data as classes
UC SANTA CRUZ
Modeling a music collection
Consider your music collection
There are many songs
Each song belongs to an album
OK, OK, I know there are a lot of loose singles these days, but work with me here…
Each album has a dominant musical style (pop, rock, classical, etc.)
Say we want to organize this musical collection
By style, then album, then song
All music
rock/pop classical bluegrass
The Fame Thriller 25 Bach Favorites Best Loved Bluegrass
Tocatta AlegroJust Dance Poker Face Beat It White House Blues Train 45
UC SANTA CRUZ
Modeling a music collection (cont’d)
This is a hierarchical structure
Occurs frequently: organizational charts, evolutionary tree in biology, work breakdown structure in project management,
databases, filesystems, programming languages
Hierarchical structures are represented using trees
Elements of a tree can be of any type. Tree of strings, tree of integers, tree of floats, etc.
For the music collection, the hierarchical structure can be represented as a tree of strings
Music_collection
is tree
of string
All music
rock/pop classical bluegrass
The Fame Thriller 25 Bach Favorites Best Loved Bluegrass
Tocatta AlegroJust Dance Poker Face Beat It White House Blues Train 45
UC SANTA CRUZ
Tree terminology
There are some special terms that are used to describe trees
The elements of a tree are called nodes
The topmost element is called the root
An element can have one or more child
nodes
Node “classical”
is a child of node “All music”
Node “Thriller”
is a child of node “rock/pop”
An element with no children is a leaf
node
Every node, except the root, has a parent
node
Node “rock/pop”
is the parent of node “Thriller”
All music
rock/pop classical bluegrass
The Fame Thriller 25 Bach Favorites Best Loved Bluegrass
Tocatta AlegroJust Dance Poker Face Beat It White House Blues Train 45
root node
One of 7 leaf nodes
UC SANTA CRUZ
Tree operations
Trees typically support the following operations
Insert_child(given_node, contents)
Adds a new node with contents as a child of given_node
Example: Insert_child(Node:The
Fame, “Paparazzi”)
Creates a new node, under “The Fame”, with contents “Paparazzi”
Parent(given_node)
Provides the parent node for given_node
Example: Parent(Node:Poker
Face) is Node:The
Fame
Leftmost_child(given_node)
Provides the leftmost child of the given_node
Example: Leftmost_child(Node:The
Fame) is “Just Dance”
Right_sibling(given_node)
Provides the next sibling to the right, or null if there is none
Example: Right_sibling(Node:Poker
Face) is Node:Paparazzi
Example: Right_sibling(Node:Paparazzi) is null
Delete(given_node)
Deletes the given node and all children
Delete(Node:Poker
Face) deletes just Poker Face
Delete(Node:The
Fame) deletes The Fame, Just Dance, Poker Face, and Paparazzi
The Fame
Just Dance Poker Face Paparazzi
The Fame
Just Dance Poker Face PaparazziLe
ftmos
t_ch
ild
Right_sibling Right_sibling
Can navigate through a tree using leftmost_child, right_sibling, and parent!
Parent
UC SANTA CRUZ
Graph
The physical world contains many networks
Towns connected by (rail)roads
Cities connected by airline flights
Pumping stations connected by water pipes
Houses and businesses connected to power stations by electrical wires
A portion of United Airline’s Flight Route Network
content.united.com/ual/asset/UAL_NA_Map.pdf
UC SANTA CRUZ
Graph
A graph is a set of nodes (vertices)
connected by edges (arcs)
Often (but not always) two nodes can be connected by only one edge
An undirected
graph is one where the edges have no directionality (i.e., no arrows)
Can represent situations like a road, where cars can go in either direction
A directed
graph (or digraph) is one where the edges are directional (have edges)
Can represent situations like a water pipe network, where water typically flows in one direction
A node can be any type (string, integer, float, etc.)
Edges are often labeled with data as well (string, integer, etc.)
An undirected graph with 6 nodes and 7 edges
en.wikipedia.org/wiki/Graph_(mathematics)A directed graph with 3 nodes and 3 edges
en.wikipedia.org/wiki/Graph_(mathematics)
UC SANTA CRUZ
Graphs in Computer Science
Graphs are broadly useful in computer science
Represent internal dependency structure inside software programs
I.e., which functions/methods call which other ones?
Represent network information
How elements of the Internet are connected
Represent relationships among items
Dog is-a-kind-of mammal, dog is-a-kind-of pet, humans like pets, etc.
Fragment of the Concept Net network
csc.media.mit.edu/conceptnet
ConceptNet
is a network of common sense knowledge about the world. Can be used by software to reason about items in the world. Open source (freely available)
csc.media.mit.edu/conceptnet
UC SANTA CRUZ
Grouping data together, treating it as one
So far, we have focused on real world situations that can be modeled using combinations of one single basic data type
Temperature, which is represented using a float
Song title, represented using a string
More typical are situations where multiple data items are needed
for a complete representation
Temperature
Value: float
Units: Fahreheit
or Celsius or Kelvin
Time: time & date (when measurement was taken)
Song
Title: string
Artist: string
Year: integer
Ideally want to clump these together and deal with them as a whole
UC SANTA CRUZ
Grouping data together: objects
There are several ways of grouping data together
Two that will be discussed in this class
Tables in a database
More on this when we consider databases
Object modeling
Example of a database table
www.dwreview.com/Data_mining/DM_models.html
UC SANTA CRUZ
Class & object modeling
Group a series of related data items together
Package these up into a class
A class contains a series of related data items
A container for data
Each data item is either a data structure or a basic data type
A data structure contains a series of basic data types
A specific example of a class is called an object
An object
is an instance of a class
Use a class box
to visually
depict a class
This is part of the unified modeling
language (UML), a common way of
visually depicting software
designs…
Class name
Data item 1: data type
Data item 2: data structure of data type
Data item 3: data type
…Operations
These are operations that work on the data in the class. They are super important for object oriented programming, but we’re not going to talk about them now…
UC SANTA CRUZ
Class & object modeling example
Consider again a song
Song
Title: string
Artist: string
Year: integer
Its class box is
Song is a class
It is what a lot of different individual songs look like
It represents the set of all songs
Instances of song are song objects
Any individual, specific song will have all of the data items filled in
It has been “instantiated”
(an instance of it has been made)
Song
Title: String
Artist: String
Year: Integer
Title: Video Killed the Radio Star
Artist: The Buggles
Year: 1979
Title: Poker Face
Artist: Lady Gaga
Year: 2008
Two instances of song –
song
objects
UC SANTA CRUZ
Relationships among classes
Is-a relationship
Sometimes you have situations where there is a general class of item, and then there are multiple distinct subclasses
Example
The term “clothing”
covers a wide range of items that people wear.
Might want to also model pants, shirts, skirts, dresses, belts, socks, etc.
Each of these has specific measurements and hence would need to be modeled differently
Use a to visually depict the is-a relationship
Also known as subclass relationship
Also: parent-child
relationship
Clothing
Brand name: string
Price: float
Color: string
Fabric: string
Pants
Waist: integer
Inseam: integer
Socks
Size_min: integer
Size_max: integer
Pants is-a Clothing
Socks is-a Clothing
parent
child child
UC SANTA CRUZ
Children inherit data fields
The children of a subclass relationship inherit the data fields of all parents
In the example
Pants has
Waist: integer
Inseam: integer
And also
Brand name: string
Price: float
Color: string
Fabric: string
Socks has
Size_min: integer
Size_max: integer
And also
Brand name: string
Price: float
Color: string
Fabric: string
Clothing only has
Brand name: string
Price: float
Color: string
Fabric: string
Clothing
Brand name: string
Price: float
Color: string
Fabric: string
Pants
Waist: integer
Inseam: integer
Socks
Size_min: integer
Size_max: integer
Pants is-a Clothing
Socks is-a Clothing
parent
child child
UC SANTA CRUZ
In-class exercise: answer
There are several ways to approach this modeling problem
Here’s one
Let’s assume we’re modeling vegetables for a supermarket checkout point of sale use
In this case, we care about:
Description of vegetable (for the register receipt)
Price per pound
Pepper
Description: string
Price: floatSome instances:
Description: “Green pepper”
Price: 1.59
Description: “Red pepper”
Price: 2.39
Description: “Yellow pepper”
Price: 3.19
Could also just model this as “Vegetable”
–
there is nothing particularly pepper-related here
UC SANTA CRUZ
In-class exercise: answer #2
Here’s another modeling approach
Let’s assume we’re modeling peppers for a cooking application
In this case, we care about:
Pepper type (red pepper, green pepper, etc.)
Color (for presentation)
Heat (is it a hot pepper?)
Pepper
Type: string
Color: string
Hot: booleanSome instances:
Type: “Green pepper”
Color: “Green”
Hot: false
Description: “Red pepper”
Color: “Red”
Hot: true
Type: “Yellow pepper”
Color: “Yellow”
Hot: true
Another common basic data type is an enumeration. Using an enumeration, you can list all of the possible values a variable can take. In this case, could model type as a Pepper_type
enumeration, with possible values of Red, Green, Yellow. (A similar approach could be used for colors, using a Color_type
enumeration, with Red, Green, and Yellow values). Instead, for this example, we use a string
to hold the values “Red”, “Green”, “Yellow”.
UC SANTA CRUZ
In-class exercise: answer #3
Here’s another modeling approach
Let’s assume we’re modeling peppers for a cooking application
But, we also have other vegetables we’re interested in modeling
In this case, we care about:
What is specific about peppers that is different from other vegetables
All vegetables have a type, and a color
Only peppers have a heatVegetable
Type: string
Color: string
Some Pepper instances:
Type: “Green pepper”
Color: “Green”
Hot: false
Type: “Eggplant”
Color: “Purple”
Type: “Yellow pepper”
Color: “Yellow”
Hot: true
Pepper
Hot: boolean
Some Vegetable instances:
Type: “Carrot”
Color: “Orange”
UC SANTA CRUZ
New exercise
Model the following as a class
Assume it’s for a graphic design application, so we want to model the length, whether it is sharp, and color
Flickr: stevendepolo
UC SANTA CRUZ
In-class exercise: answer
Represent:
Length as a float (since the length could be a fraction of an inch, or centimeter)
Color as a string
Could also be an enumeration
Sharp as a boolean
True means sharp
Pencil
Length: float
Color: string
Sharp: boolean
Some instances:
Length: 5.25
Color: “pink”
Sharp: true
Length: 4.75
Color: “yellow”
Sharp: true
Length: 3.125
Color: “sky blue”
Sharp: false
UC SANTA CRUZ
New exercise
Model the following situation using classes
Assume this is also for a graphic design use, so we’re interested in pencil vs
pen vs
highlighter, color, sharpness, and type of tip (ball, chisel)
Flickr: calliope
UC SANTA CRUZ
In-class exercise
For this situation, need to use multiple classes, and inheritance
One class to model “drawing device”
Used for common qualities, such as color
Subclasses for specific qualities
Pencil: sharpness
Pen: tip type
Highlighter: tip type
Drawing Device
Color: string
Pencil instance:Color: “grey”
Sharp: true
Color: “red”
Tip: “ball”
Pencil
Sharp: boolean
Pen
Tip: string
Highlighter
Tip: stringPen instance:
Highlighter instance:Color: “yellow”
Tip: “chisel”
Recommended