CSI 1340 Introduction to Computer Science II

1
CSI 1340Introduction to Computer Science II

• Chapter 3
• ADTs Unsorted List and Sorted List

2
Self-test

• Create a class called SalesPerson that includes 2
  public member functions
• void SetSales(int month, float amount)
• float GetSales(int month) const
• And 1 private member variable
• float sales12

3

• // FILE salesperson.h
• // CLASS PROVIDED SalesPerson (an ADT for a
  SalesPerson)
• // Modification member function
• // void SetSales(int month, float amount)
• // Precondition 1 lt month lt 12 amount has
  been
• // assigned a floating point value.
• // Postcondition The sales figure for the month
  indicated
• // by month has been assigned amount.
• // Constant member function
• // float GetSales(int month) const
• // Precondition 1 lt month lt 12
• // Postcondition The sales figure for the month
  indicated
• // by month has been returned.
• // Private member variable
• // float sales12

4
C Class - salesperson.h

• class SalesPerson
• public
• void SetSales(int month, float amount)
• float GetSales(int month) const
• private
• float sales12

5
Create a correct C implementation file (.cpp)
for the SalesPerson class
6
C Implementation - salesperson.cpp

• include salesperson.h
• void SalesPersonSetSales(int month, float
  amount)
• salesmonth - 1 amount
• float SalesPersonGetSales(int month) const
• return salesmonth - 1

7
Show how the SalesPerson class can be utilized in
a program (Main.cpp) to (1) set the sales
figure for month 1 to 1500.00 (2) set the sales
figure for month 2 to 1000.00 (3) display the
following Sales for month 1 1500.00
8
C Program- main.cpp

• include ltiostreamgt
• include salesperson.h
• using namespace std
• int main( )
• SalesPerson s
• s.SetSales(1, 1500.00)
• s.SetSales(2, 1000.00)
• cout ltlt Sales for month 1 ltlt s.GetSales(1)
  
• ltlt endl
• return 0

9
Class Constructors
10
Rules for Constructors

• You may declare as many constructors as you
  like--one for each different way of initializing
  an object.
• Each constructor must have a distinct parameter
  list so that the compiler can tell them apart.
• Only one default constructor is allowed.

11
Do we still need a public member function that
assigns values to the private member variables if
we include a constructor?
12
Yes!!

• Public member functions can be called at any time
  by the user.
• A constructor (either the default or an
  alternative) is utilized only once, when an
  object is declared. It cannot be called by the
  user.

13
Show the implementation for a default constructor
for the SalesPerson class
14
Default Constructor for SalesPerson

• SalesPersonSalesPerson( )
• for (i 0 i lt 12 i)
• salesi 0.0

15
Overloading

• Function Overloading Creating several variants
  of the same function, distinguishing only by
  parameter types
• Operator Overloading Gives a new definition for
  an existing operator (i.e., , , , , . . .)
• Often used to define new meanings for operators
  of a class.

16
Determining Class Value

• Determines how values are copied from one object
  to another.
• Consists of two operators
• Assignment operator
• Copy constructor

17
Assignment Operator

• y x copies the value of x to y.
• For a class, assignment should be carried out by
  copying the value of each private member variable
  from class x to class y.

18
Copy Constructor

• Initializes a new object as an exact copy of an
  existing object.
• The copy constructor is a constructor with
  exactly one parameter, and the data type of the
  parameter is the same as the constructor class,
  e.g., Time(const Time w)
• Examples of its use
• Time y(x)
• Time y x // Not assignment because y is
  created
• Time y Time(x)

19
Assignment vs. Copy Constructor

• Assignment operator
• Assigns the values of one object to another
  object.
• Copy Constructor
• Used whenever a new object is created and
  initialized to an existing object of the same
  type.

20
Assignment Operator Copy Constructor in C

• C provides an automatic assignment operator and
  an automatic copy constructor.
• For some classes, the automatic versions fail and
  programmers must either write their own or
  indicate that the value semantics are not safe to
  use.

21
Testing the Copy Constructor
22
Testing the Copy Constructor

• include ltiostreamgt
• include time.h
• using namespace std
• int main( )
• Time t
• t.setTime(13,37,6)
• Time s(t) // May generate a fatal error
• t.printStandard( )
• s.printStandard( )
• return 0

23
Creating Your Own Copy Constructor
24
Copy Constructor Header File (time.h)

• class Time
• public
• Time( )
• Time(int hr,int min,int sec)
• Time(const Time w)
• . . .
• private
• int hour
• int minute
• int second

25
Copy Constructor Implementation File (time.cpp)

• include time.h
• TimeTime(const Time w)
• hour w.hour
• minute w.minute
• second w.second

26
Testing the Assignment Operator ()
27
Assignment Operator () Use in Main.cpp

• include ltiostreamgt
• include time.h
• using namespace std
• int main( )
• Time t
• t.setTime(13,37,6)
• Time s
• s t // May generate a fatal error
• t.printStandard( )
• s.printStandard( )
• return 0

28
Overloading theAssignment Operator ()
29
Assignment Operator () Header File (time.h)

• class Time
• public
• Time( )
• . . .
• void operator(const Time w)
• private
• int hour
• int minute
• int second

30
Assignment Operator () Implementation File
(time.cpp)

• include time.h
• void Timeoperator(const Time w)
• hour w.hour
• minute w.minute
• second w.second

31
What is a List?

• A list is a homogeneous collection of elements,
  with a linear relationship between elements.
• That is, each list element (except the first) has
  a unique predecessor, and each element (except
  the last) has a unique successor.

32
Sorted and Unsorted Lists
UNSORTED LIST Elements are placed into the
list in no particular order.
SORTED LIST List elements are in an order
that is sorted in some way -- either
numerically or alphabetically by the elements
themselves, or by a component of the element
(called a KEY member) .
33
ADT Unsorted List Operations

• Transformers
• MakeEmpty
• InsertItem
• DeleteItem
• Observers
• IsFull
• LengthIs
• RetrieveItem
• Iterators
• ResetList
• GetNextItem

34

• // SPECIFICATION FILE ( unsorted.h )
• include ItemType.h
• class UnsortedType // declares a class data
  type
• public // 8 public member functions
• void MakeEmpty ( )
• bool IsFull ( ) const
• int LengthIs ( ) const
  // returns length of list
• void RetrieveItem ( ItemType item,
  bool found )
• void InsertItem ( ItemType item )
• void DeleteItem ( ItemType item )
• void ResetList ( )
• void GetNextItem ( ItemType item )
  
• private // 3 private data members
• int length

35

Class Interface Diagram
UnsortedType class
MakeEmpty
IsFull
LengthIs
RetrieveItem
InsertItem
DeleteItem
ResetList
GetNextItem
36

• // IMPLEMENTATION FILE ARRAY-BASED LIST (
  unsorted.cpp )
• include itemtype.h
• void UnsortedTypeMakeEmpty ( )
• // Pre None.
• // Post List is empty.
• length 0
• void UnsortedTypeInsertItem ( ItemType item )
• // Pre List has been initialized. List is not
  full. Item is not in list.
• // Post item is in the list.
• infolength item
• length

37
Before Inserting Hsing into anUnsorted List
The item will be placed into the length
location, and length will be incremented.
length 3 info 0
Maxwell 1
Bradley 2 Asad 3
. .
. MAX_ITEMS-1
38
After Inserting Hsing into anUnsorted List
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
39

• void UnsortedTypeLengthIs ( ) const
• // Pre List has been inititalized.
• // Post Function value ( number of elements
  in list ).
• return length
• bool UnsortedTypeIsFull ( ) const
• // Pre List has been initialized.
• // Post Function value ( list is full ).
• return ( length MAX_ITEMS )

40

• void UnsortedTypeRetrieveItem ( ItemType
  item, bool found )
• bool moreToSearch
• int location 0
• found false
• moreToSearch ( location lt length )
• while ( moreToSearch !found )
• switch ( item.ComparedTo( infolocation ) )
• case LESS
• case GREATER location
• moreToSearch ( location lt length )
• break
• case EQUAL found true
• item info location
• break

41
Retrieving Ivan from anUnsorted List
moreToSearch true found
false location 0
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
42
Retrieving Ivan from anUnsorted List
moreToSearch true found
false location 1
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
43
Retrieving Ivan from anUnsorted List
moreToSearch true found
false location 2
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
44
Retrieving Ivan from anUnsorted List
moreToSearch true found
false location 3
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
45
Retrieving Ivan from anUnsorted List
moreToSearch false found
false location 4
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
46

• void UnsortedTypeDeleteItem ( ItemType item )
• // Pre items key has been inititalized.
• // An element in the list has a key that matches
  items.
• // Post No element in the list has a key that
  matches items.
• int location 0
• while (item.ComparedTo (info location )
  ! EQUAL )
• location
• // move last element into position where item
  was located
• info location info length - 1
• length--

47
Deleting Bradley from anUnsorted List
location 0
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
Key Bradley has not been matched.
48
Deleting Bradley from anUnsorted List
location 1
length 4 info 0
Maxwell 1
Bradley 2 Asad 3 Hsing
. .
. MAX_ITEMS-1
Key Bradley has been matched.
49
Deleting Bradley from anUnsorted List
location 1
length 4 info 0
Maxwell 1 Hsing
2 Asad 3 Hsing
. . .
MAX_ITEMS-1
Placed copy of last list element into the
position where the key Bradley was before.
50
Deleting Bradley from anUnsorted List
location 1
length 3 info 0
Maxwell 1 Hsing
2 Asad 3 Hsing
. . .
MAX_ITEMS-1
Decremented length.
51

• void UnsortedTypeResetList ( )
• // Pre List has been inititalized.
• // Post Current position is prior to first
  element in list.
• currentPos -1
• void UnsortedTypeGetNextItem ( ItemType item
  )
• // Pre List has been initialized. Current
  position is defined.
• // Element at current position is not last in
  list.
• // Post Current position is updated to next
  position.
• // item is a copy of element at current
  position.
• currentPos
• item info currentPos

52
Specifying class ItemType

• // SPECIFICATION FILE ( itemtype.h )
• const int MAX_ITEM 5
• enum RelationType LESS, EQUAL, GREATER
• class ItemType // declares class data type
• public // 3 public member functions
• RelationType ComparedTo ( ItemType ) const
• void Print ( ) const
• void Initialize ( int number )
  
• private // 1 private data member
• int value // could be any
  different type

53

• // IMPLEMENTATION FILE ( itemtype.cpp )
• // Implementation depends on the data type of
  value.
• include itemtype.h
• include ltiostream.hgt
• RelationType ComparedTo ( ItemType otherItem
  ) const
• if ( value lt otherItem.value )
• return LESS
• else if ( value gt otherItem.value )
• return GREATER
• else return EQUAL
• void Print ( ) const
• cout ltlt value ltlt endl

54
ItemType Class Interface Diagram
class ItemType
ComparedTo
Private data value
Print
Initialize
55

SortedType Class Interface Diagram
SortedType class
MakeEmpty
Private data length info 0
1 2
MAX_ITEMS-1 currentPos
IsFull
LengthIs
RetrieveItem
InsertItem
DeleteItem
ResetList
GetNextItem
56
Member functions

• Which member function specifications and
  implementations must change to ensure that any
  instance of the Sorted List ADT remains sorted at
  all times?
• InsertItem
• DeleteItem

57
InsertItem algorithm for SortedList ADT

• Find proper location for the new element in the
  sorted list.
• Create space for the new element by moving down
  all the list elements that will follow it.
• Put the new element in the list.
• Increment length.

58
Implementing SortedType member function
InsertItem

// IMPLEMENTATION FILE
(sorted.cpp) include itemtype.h //
also must appear in client code void SortedType
InsertItem ( ItemType item ) // Pre List
has been initialized. List is not full. item is
not in list. // List is sorted by key member
using function ComparedTo. // Post item is in
the list. List is still sorted. . . .
59

• void SortedType InsertItem ( ItemType item )
• bool moreToSearch
• int location 0
• // find proper location for new element
• moreToSearch ( location lt length )
• while ( moreToSearch )
• switch ( item.ComparedTo( infolocation ) )
• case LESS moreToSearch
  false
• break
• case GREATER location
• moreToSearch ( location lt length
  )
• break
• // make room for new element in
  sorted list
• for ( int index length index gt location
  index-- )
• info index info index - 1
• info location item
• length

60
DeleteItem algorithm for SortedList ADT

• Find the location of the element to be deleted
  from the sorted list.
• Eliminate space occupied by the item being
  deleted by moving up all the list elements that
  follow it.
• Decrement length.

61
Implementing SortedType member function
DeleteItem

// IMPLEMENTATION FILE continued
(sorted.cpp) void SortedType DeleteItem (
ItemType item ) // Pre List has been
initialized. Key member of item is
initialized. // Exactly one element in list has a
key matching items key. // List is sorted by
key member using function ComparedTo. // Post
No item in list has key matching items key. //
List is still sorted. . . .
62

• void SortedType DeleteItem ( ItemType item )
• int location 0
• // find location of element to be deleted
• while ( item.ComparedTo ( infolocation ) !
  EQUAL )
• location
• // move up elements that follow deleted item
  in sorted list
• for ( int index location 1 index lt
  location index )
• info index - 1 info index
• length--

63
Improving member function RetrieveItem

• Recall that with the Unsorted List ADT
• we examined each list element beginning
• with info 0 , until we either found a
• matching key, or we had examined all
• the elements in the Unsorted List.
• How can the searching algorithm be improved for
  Sorted List ADT?

64
Retrieving Eliot from aSorted List
The sequential search for Eliot can stop when
Hsing has been examined.
length 4 info 0
Asad 1 Bradley
2 Hsing 3 Maxwell
. .
. MAX_ITEMS-1
65
Binary Seach in a Sorted List

• Examines the element in the middle of the array.
  Is it the sought item? If so, stop searching.
  Is the middle element too small? Then start
  looking in second half of array. Is the middle
  element too large? Then begin looking in first
  half of the array.
• Repeat the process in the half of the list that
  should be examined next.
• Stop when item is found, or when there is nowhere
  else to look and item has not been found.

66

• void SortedTypeRetrieveItem ( ItemType item,
  bool found )
• // Pre Key member of item is initialized.
• // Post If found, items key matches an
  elements key in the list and a copy
• // of that element has been stored in item
  otherwise, item is unchanged.
• int midPoint
• int first 0
• int last length - 1
• bool moreToSearch ( first lt last )
• found false
• while ( moreToSearch !found )
• midPoint ( first last ) / 2 // INDEX
  OF MIDDLE ELEMENT
• switch ( item.ComparedTo( info midPoint ) )
• case LESS . . . // LOOK IN
  FIRST HALF NEXT
• case GREATER . . . // LOOK IN
  SECOND HALF NEXT
• case EQUAL . . . // ITEM HAS
  BEEN FOUND

67
Trace of Binary Search
item 45

15 26 38 57 62 78
84 91 108 119
info0 1 2 3
4 5 6 7
8 9
first
midPoint
last
15 26 38 57 62 78
84 91 108 119
info0 1 2 3
4 5 6 7
8 9
first midPoint last
68
Trace continued
item 45
15 26 38 57 62 78
84 91 108 119

info0 1 2 3
4 5 6 7
8 9
first, last
midPoint
15 26 38 57 62 78
84 91 108 119
info0 1 2 3
4 5 6 7
8 9
first,
midPoint,
last
69
Trace concludes
item 45

15 26 38 57 62 78
84 91 108 119
info0 1 2 3
4 5 6 7
8 9
last first


70

• void SortedTypeRetrieveItem ( ItemType item,
  bool found )
• // ASSUMES info ARRAY SORTED IN ASCENDING ORDER
• int midPoint
• int first 0
• int last length - 1
• bool moreToSearch ( first lt last )
• found false
• while ( moreToSearch !found )
• midPoint ( first last ) / 2
• switch ( item.ComparedTo( info midPoint ) )
• case LESS last
  midPoint - 1
• moreToSearch ( first lt last )
  
• break
• case GREATER first midPoint 1
  
• moreToSearch ( first lt last )
  
• break
• case EQUAL found true
• item info midPoint

71
Order of Magnitude of a Function

• The order of magnitude, or Big-O notation,
• of a function expresses the computing time
• of a problem as the term in a function that
• increases most rapidly relative to the size
• of a problem.

72
Big-O of Two Functions

• for (count 1 count lt n count)
• sum count
• sum ((n 1) 2) / 2

O(N)
O(1)
73
Names of Orders of Magnitude

• O(1) bounded (by a constant) time
• O(log2N) logarithmic time
• O(N) linear time
• O(Nlog2N) Nlog2N time
• O(N2) quadratic time
• O( 2N ) exponential time

74
N log2N Nlog2N N2 2N

5 years supercomputing
75
Comparison of List Operations

OPERATION UnsortedList
SortedList RetrieveItem O(N) O(N)
linear search O(log2N) binary search