Topic2 Bags

CS2400 - Data Structures and Advanced Programming
Topic 2: Bags
Hao Ji
Computer Science Department
Cal Poly Pomona
© 2018 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.
The ADT Bag
• Definition
• A finite collection of objects in no particular order
• Can contain duplicate items
Bag
• Possible behaviors
• Get number of items
• Check for empty
• Add and remove objects
2
Using UML Notation to Specify a Class
<<interface>>
Bag
+getCurrentSize(): integer // Get the number of items currently in the bag

+isEmpty(): boolean // See whether the bag is empty
+add(newEntry: T): boolean // Add a given object to the bag
+remove(): T // Remove an unspecified object from the bag
+remove(anEntry: T): boolean // Remove a particular object from the bag, if possible
+clear(): void // Remove all objects from the bag
+getFrequencyOf(anEntry: T): integer // Count the number of times a certain object occurs in the bag
+contains(anEntry: T): boolean // Test whether the bag contains a particular object
+toArray(): T[] // Look at all objects that are in the bag
3
/** An interface that describes the operations of a bag of objects. */
public interface BagInterface<T>
{
/** Gets the current number of entries in this bag.
@return The integer number of entries currently in the bag. */
public int getCurrentSize();
/** Sees whether this bag is empty.
@return True if the bag is empty, or false if not. */
public boolean isEmpty();
/** Adds a new entry to this bag.
@param newEntry The object to be added as a new entry.
@return True if the addition is successful, or false if not. */
public boolean add(T newEntry);
/** Removes one unspecified entry from this bag, if possible.
@return Either the removed entry, if the removal was successful, or null. */
public T remove();
/** Removes one occurrence of a given entry from this bag, if possible.
@param anEntry The entry to be removed.
@return True if the removal was successful, or false if not. */
public boolean remove(T anEntry);
/** Removes all entries from this bag. */
public void clear();
/** Counts the number of times a given entry appears in this bag.
@param anEntry The entry to be counted.
@return The number of times anEntry appears in the bag. */
public int getFrequencyOf(T anEntry);
/** Tests whether this bag contains a given entry.
@param anEntry The entry to find.
@return True if the bag contains anEntry, or false if not. */
public boolean contains(T anEntry);
/** Retrieves all entries that are in this bag.
@return A newly allocated array of all the entries in the bag. Note: If the bag is empty, the returned array is empty. */
public T[] toArray();
4
} // end BagInterface
/** A class that maintains a shopping cart for an online store. */ public class Item
public class OnlineShopper {
{ private String description;
public static void main(String[] args) private int price;
{
Item[] items = {new Item("Bird feeder", 2050),
new Item("Squirrel guard", 1547), public Item(String productDescription, int productPrice)
new Item("Bird bath", 4499), {
new Item("Sunflower seeds", 1295)}; description = productDescription;
price = productPrice;
BagInterface<Item> shoppingCart = new ArrayBag<>(); } // end constructor
int totalCost = 0;
public String getDescription()
// Statements that add selected items to the shopping cart: {
for (int index = 0; index < items.length; index++)
{ return description;
Item nextItem = items[index]; // Simulate getting item from shopper } // end getDescription
shoppingCart.add(nextItem);
totalCost = totalCost + nextItem.getPrice(); public int getPrice()
} // end for {
return price;
// Simulate checkout } // end getPrice
while (!shoppingCart.isEmpty())
System.out.println(shoppingCart.remove()); public String toString()
System.out.println("Total cost: " + "\t$" + totalCost / 100 + "." + totalCost % 100); {
} // end main return description + "\t$" + price / 100 + "." + price % 100;
} // end OnlineShopper } // end toString
} // end Item
5
Implementations of a Bag
6
• Using Fixed-Size Arrays
• Using Array Resizing
• Using Linked Data
7
ArrayBag
• Using Array Resizing -bag: T[]
• Using Linked Data -numberOfEntries: integer
-DEFAULT_CAPACITY: integer
+getCurrentSize(): integer
+isEmpty(): boolean
+add(newEntry: T): boolean
+remove(): T
+remove(anEntry: T): boolean
+clear(): void
+getFrequencyOf(anEntry: T): integer
+contains(anEntry: T): boolean
+toArray(): T[]
–isArrayFull(): boolean
8
Bag Implementations That Use Arrays
• Private Data Fields
• By declaring the array bag as a final data

members of the class ArrayBag, we know
that the reference to the array in the
variable bag cannot change.
9
• Constructors
• Initialize the field numberOfEntries to 0.
• Create the array bag.
• To create the array, the constructor must
specify the array’s length, which is the
bag’s capacity.
10
• Constructors
bag’s capacity.
• Option 1:
• Option 2:
• Option 3:
• Option 4:
11
• Constructors
bag’s capacity.
• Option 1:
You cannot use a generic type when allocating an array
12
• Constructors
bag’s capacity.
• Option 1:
• Option 2:
You cannot assign an array of type Object[] to an array of type T[].
13
• Constructors
bag’s capacity.
• Option 1:
• Option 2:
• Option 3: // warning: ArrayBag.java uses unchecked or unsafe operations.
You can instruct the compiler to ignore the warning by writing the annotation
@SuppressWarnings("unchecked") before the offending statement
14
• Constructors
bag’s capacity.
• Option 1:
• Option 2:
• Option 3: // warning: ArrayBag.java uses unchecked or unsafe operations.
• Option 4: // This instruction to the compiler can only precede a method definition
or a variable declaration.
15
• The method add
• If the bag is full, we cannot add anything to it.
In that case, the method add should return
false
• Otherwise, we simply add newEntry
immediately after the last entry in the array
bag
16
• The method add
false
bag
17
• The method add
false
bag
18
• The method toArray
• Retrieves the entries that are in a bag
• Returns them to the client within a newly
allocated array.
19
allocated array.
20
allocated array.
• Question: Can we use the following?
21
allocated array.
• Question: Can we use the following?
22
• The method isFull()
• A bag is full when it contains as many objects
as the array bag can accommodate.
23
• The method isFull()
• A bag is full when it contains as many objects
as the array bag can accommodate.
24
A Test Program
25
Making the Implementation Secure
• Practice fail-safe programming by including checks for anticipated errors
• Validate input data and arguments to a method
• Refine incomplete implementation of ArrayBag to make code more secure by
adding the following two data fields:
private boolean integrityOK = false;
private static final int MAX_CAPACITY = 10000;
26
ArrayBag
• Revised Constructor -bag: T[]
/** Creates an empty bag having a given capacity. -numberOfEntries: integer
@param desiredCapacity The integer capacity desired. */ -DEFAULT_CAPACITY: integer
public ArrayBag(int desiredCapacity)
{
-integrityOK: Boolean
if (desiredCapacity <= MAX_CAPACITY) -MAX_CAPACITY: integer
{ +getCurrentSize(): integer
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked") +isEmpty(): boolean
T[] tempBag = (T[])new Object[desiredCapacity]; // Unchecked cast +add(newEntry: T): boolean
bag = tempBag;
numberOfEntries = 0; +remove(): T
integrityOK = true; +remove(anEntry: T): boolean
}
else +clear(): void
throw new IllegalStateException("Attempt to create a bag whose" +getFrequencyOf(anEntry: T): integer
+ "capacity exceeds allowed maximum.");
} // end constructor
+toArray(): T[]
–isArrayFull(): boolean 27
ArrayBag
• Method to check initialization -bag: T[]
// Throws an exception if this object is not initialized. -numberOfEntries: integer
private void checkIntegrity() -DEFAULT_CAPACITY: integer
{
if (!integrityOK) -integrityOK: Boolean
throw new SecurityException("ArrayBag object is corrupt."); -MAX_CAPACITY: integer
} // end checkIntegrity
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
ArrayBag
• Revised method add -bag: T[]
-numberOfEntries: integer
@param newEntry The object to be added as a new entry. -DEFAULT_CAPACITY: integer
@return True if the addition is successful, or false if not. */ -integrityOK: Boolean
public boolean add(T newEntry)
{ -MAX_CAPACITY: integer
checkIntegrity(); +getCurrentSize(): integer
boolean result = true;
if (isArrayFull())
+isEmpty(): boolean
{ +add(newEntry: T): boolean
result = false;
+remove(): T
}
else +remove(anEntry: T): boolean
{ // Assertion: result is true here +clear(): void
bag[numberOfEntries] = newEntry;
numberOfEntries++; +getFrequencyOf(anEntry: T): integer
} // end if +contains(anEntry: T): boolean
return result; +toArray(): T[]
} // end add –isArrayFull(): boolean 29
Implementing More Methods
ArrayBag
-bag: T[]
-MAX_CAPACITY: integer
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
ArrayBag
@return True if this bag is empty, or false if not. */
-bag: T[]
public boolean isEmpty() -numberOfEntries: integer
{
return numberOfEntries == 0;
} // end isEmpty -integrityOK: Boolean
/** Gets the current number of entries in this bag. +getCurrentSize(): integer
@return The integer number of entries currently in this bag. */ +isEmpty(): boolean
public int getCurrentSize()
return numberOfEntries; +remove(): T
} // end getCurrentSize
+clear(): void
+toArray(): T[]
ArrayBag
-bag: T[]
/** Counts the number of times a given entry appears in this bag. -DEFAULT_CAPACITY: integer
@return The number of times anEntry appears in this bag. */ -integrityOK: Boolean
public int getFrequencyOf(T anEntry) -MAX_CAPACITY: integer
{
checkIntegrity(); +getCurrentSize(): integer
int counter = 0; +isEmpty(): boolean
for (int index = 0; index < numberOfEntries; index++)
{ +remove(): T
if (anEntry.equals(bag[index]))
{
counter++; +clear(): void
} // end if +getFrequencyOf(anEntry: T): integer
} // end for
} // end getFrequencyOf +contains(anEntry: T): boolean
+toArray(): T[]
ArrayBag
• Removing a given entry -bag: T[]
• Search for the entry -numberOfEntries: integer
• Remove the entry from the bag -DEFAULT_CAPACITY: integer
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
ArrayBag
• Removing a given entry -bag: T[]
• Search for the entry -numberOfEntries: integer
• Remove the entry from the bag -DEFAULT_CAPACITY: integer
/** Removes one occurrence of a given entry from this bag. -MAX_CAPACITY: integer
@param anEntry The entry to be removed. +getCurrentSize(): integer
public boolean remove(T anEntry) +isEmpty(): boolean
checkIntegrity();
int index = getIndexOf(anEntry); +remove(): T
T result = removeEntry(index); +remove(anEntry: T): boolean
return anEntry.equals(result);
} // end remove
+clear(): void
+toArray(): T[]
// Locates a given entry within the array bag.
// Returns the index of the entry, if located, or -1 otherwise.
• Removing a given entry // Precondition: checkIntegrity has been called.
private int getIndexOf(T anEntry)
• Search for the entry {
int where = -1;
• Remove the entry from the bag boolean found = false;
int index = 0;
/** Removes one occurrence of a given entry from this bag. while (!found && (index < numberOfEntries))
@param anEntry The entry to be removed. {
@return True if the removal was successful, or false if not. */ if (anEntry.equals(bag[index]))
public boolean remove(T anEntry) {
{ found = true;
checkIntegrity(); where = index;
int index = getIndexOf(anEntry); } // end if
T result = removeEntry(index); index++;
return anEntry.equals(result); } // end while
} // end remove
// Assertion: If where > -1, anEntry is in the array bag, and it
// equals bag[where]; otherwise, anEntry is not in the array
return where;
} // end getIndexOf 35
• Removing a given entry
• Search for the entry
• Remove the entry from the bag
/** Removes one occurrence of a given entry from this bag.

public boolean remove(T anEntry)
{
checkIntegrity();
int index = getIndexOf(anEntry);
T result = removeEntry(index);
return anEntry.equals(result);
} // end remove
36
Option 1 Option 2
?
37
• Search for the entry
// Removes and returns the entry at a given index within the array bag.
• Remove the entry from the bag // If no such entry exists, returns null.
// Preconditions: 0 <= givenIndex < numberOfEntries;
// checkIntegrity has been called.
/** Removes one occurrence of a given entry from this bag. private T removeEntry(int givenIndex)
@param anEntry The entry to be removed. {
@return True if the removal was successful, or false if not. */ T result = null;
public boolean remove(T anEntry)
{ if (!isEmpty() && (givenIndex >= 0))
checkIntegrity(); {
int index = getIndexOf(anEntry); result = bag[givenIndex]; // Entry to remove
T result = removeEntry(index); bag[givenIndex] = bag[numberOfEntries - 1]; // Replace entry with last entry
return anEntry.equals(result); bag[numberOfEntries - 1] = null; // Remove last entry
} // end remove numberOfEntries--;
} // end if
return result;
} // end removeEntry
38
ArrayBag
• Removing an unspecified entry -bag: T[]
• Simply remove the last entry -numberOfEntries: integer
/** Removes one unspecified entry from this bag, if possible. -MAX_CAPACITY: integer
@return Either the removed entry, if the removal was successful, +getCurrentSize(): integer
or null otherwise. */
public T remove() +isEmpty(): boolean
checkIntegrity();
T result = removeEntry(numberOfEntries - 1); +remove(): T
return result; +remove(anEntry: T): boolean
} // end remove
+clear(): void
+toArray(): T[]
ArrayBag
-bag: T[]
/** Removes all entries from this bag. */ -numberOfEntries: integer
public void clear()
{ -DEFAULT_CAPACITY: integer
while (!isEmpty()) -integrityOK: Boolean
remove();
} // end clear
+isEmpty(): boolean
/** Tests whether this bag contains a given entry. +remove(): T
@param anEntry The entry to locate.
@return True if this bag contains anEntry, or false otherwise. */ +remove(anEntry: T): boolean
public boolean contains(T anEntry) +clear(): void
{
checkIntegrity(); +getFrequencyOf(anEntry: T): integer
return getIndexOf(anEntry) > -1; // or >= 0 +contains(anEntry: T): boolean
} // end contains
+toArray(): T[]
Putting all pieces together to form ArrayBag.java
ArrayBag
-bag: T[]
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
{
public T remove();
@return A newly allocated array of all the entries in the bag. Note: If the bag is empty, the
returned array is empty. */
} // end BagInterface BagInterface.java 42
OnlineShopper.java
/** A class that maintains a shopping cart for an online store. */ public class Item
public class OnlineShopper {
{ Item.java private String description;
public static void main(String[] args) private int price;
{
Item[] items = {new Item("Bird feeder", 2050),
new Item("Squirrel guard", 1547), public Item(String productDescription, int productPrice)
new Item("Bird bath", 4499), {
new Item("Sunflower seeds", 1295)}; description = productDescription;
price = productPrice;
BagInterface<Item> shoppingCart = new ArrayBag<>(); } // end constructor
int totalCost = 0;
public String getDescription()
// Statements that add selected items to the shopping cart: {
for (int index = 0; index < items.length; index++)
{ return description;
Item nextItem = items[index]; // Simulate getting item from shopper } // end getDescription
shoppingCart.add(nextItem);
totalCost = totalCost + nextItem.getPrice(); public int getPrice()
} // end for {
return price;
// Simulate checkout } // end getPrice
while (!shoppingCart.isEmpty())
System.out.println(shoppingCart.remove()); public String toString()
System.out.println("Total cost: " + "\t$" + totalCost / 100 + "." + totalCost % 100); {
} // end main return description + "\t$" + price / 100 + "." + price % 100;
} // end OnlineShopper } // end toString
} // end Item
43
• Using Fixed-Size Arrays Using a fixed-size array to implement the ADT bag,
therefore, limits the size of the bag.
44
Bag Implementations That Use Array
Resizing
• The process of array resizing
45
Resizing
• Doubling the size of an array each time it becomes full is a typical approach
46
Resizing
• Revised method add using array resizing
// Throws an exception if the client requests a capacity that is too large.
/** Adds a new entry to this bag. private void checkCapacity(int capacity)
@param newEntry The object to be added as a new entry. {
@return True. */ if (capacity > MAX_CAPACITY)
public boolean add(T newEntry) throw new IllegalStateException("Attempt to create a bag whose " +
{ "capacity exeeds allowed " +
checkIntegrity(); "maximum of " + MAX_CAPACITY);
boolean result = true; } // end checkCapacity
if (isArrayFull())
{
doubleCapacity();
} // end if // Doubles the size of the array bag.
// Precondition: checkIntegrity has been called.
bag[numberOfEntries] = newEntry; private void doubleCapacity()
numberOfEntries++; {
int newLength = 2 * bag.length;
return true; checkCapacity(newLength);
} // end add bag = Arrays.copyOf(bag, newLength);
} // end doubleCapacity
47
Pros and Cons of Using an Array
• +Adding an entry to the bag is fast
• +Removing an unspecified entry is fast
• -Removing a particular entry requires time to locate the entry

• -Increasing the size of the array requires time to copy its entries
48
• Array has fixed size and may become full.
• Alternatively may have wasted space.
• Resizing is possible but requires overhead of time
49
A Linked Implementation of a Bag
• Node with two data fields
50
51
52
• Organize data by linking it together
53
• Organize data by linking it together
Here we simply place Node

class as private class member
inside LinkedBag class 54
LinkedBag
-firstNode: Node
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
55
• The method add
56
• The method add
• Adding a new node to an empty chain
• Adding a new node to a non-empty chain
57
• The method add
58
• The method add
59
• The method add
@param newEntry The object to be added as a new entry
public boolean add(T newEntry) // OutOfMemoryError possible

{
// Add to beginning of chain:
Node newNode = new Node(newEntry);
newNode.next = firstNode; // Make new node reference rest of chain
// (firstNode is null if chain is empty)
firstNode = newNode; // New node is at beginning of chain

numberOfEntries++;
return true;
} // end add
60
• The method remove
61
• Removing an unspecified entry from a bag
• Removing a given entry from a bag
62
63
64

public T remove()
{
T result = null;
if (firstNode != null)
{
result = firstNode.getData();
firstNode = firstNode.getNextNode(); // Remove first node from chain
numberOfEntries--;
} // end if
return result;
} // end remove
65
66
• Search for the given entry in a bag
• Remove the given entry
67
How can be remove the

given entry easily and
efficiently?
68
Option 1:
10
Remove the given entry directly by

updating the reference in the entry
before the given entry
69
Replace the given entry with entry
• The method remove in first node
Option 2:
Remove first node

instead
70
// Locates a given entry within this bag. /** Removes one occurrence of a given entry from this bag,
// Returns a reference to the node containing the // if possible.
entry, if located, or null otherwise. @param anEntry The entry to be removed.
private Node getReferenceTo(T anEntry) @return True if the removal was successful, or false
{ otherwise. */
boolean found = false; public boolean remove(T anEntry)
Node currentNode = firstNode; {
boolean result = false;
while (!found && (currentNode != null)) Node nodeN = getReferenceTo(anEntry);
{
if (anEntry.equals(currentNode.getData())) if (nodeN != null)
found = true; {
else // Replace located entry with entry in first node
currentNode = currentNode.getNextNode(); nodeN.setData(firstNode.getData());
} // end while // Remove first node
firstNode = firstNode.getNextNode();
return currentNode;
} // end getReferenceTo numberOfEntries--;
result = true;
} // end if
return result;
} // end remove

71
• The methods isEmpty, getCurrentSize, and clear
72
• The method getFrequencyOf
73
• The method contains
74
75
Putting all pieces together to form LinkedBag.java
LinkedBag
-firstNode: Node
+isEmpty(): boolean
+remove(): T
+clear(): void
+toArray(): T[]
76
{
public T remove();
@return A newly allocated array of all the entries in the bag. Note: If the bag is empty, the
returned array is empty. */
} // end BagInterface BagInterface.java 77
LinkedBagDemo.java
…
The client program can be found in our blackboard 78

Pros and Cons of Using a Chain
• +Bag can grow and shrink in size as necessary.
• +Remove and recycle nodes that are no longer needed
• +Adding new entry to end of array or to beginning of chain both
relatively simple
• +Similar for removal
• -Removing specific entry requires search of chain

• -Chain requires more memory than array of same length
79
The ADT Set
• A set is a special kind of bag, one that does not allow duplicate entries
<<interface>> <<interface>>
Bag Set
+getCurrentSize(): integer +getCurrentSize(): integer

+isEmpty(): boolean +isEmpty(): boolean
+add(newEntry: T): boolean +add(newEntry: T): boolean
+remove(): T +remove(): T
+remove(anEntry: T): boolean +remove(anEntry: T): boolean
+clear(): void +clear(): void
+contains(anEntry: T): boolean +contains(anEntry: T): boolean
+toArray(): T[] +toArray(): T[]
80
The ADT Set
• A set is a special kind of bag, one that does not allow duplicate entries
/** An interface that describes the operations of a set of objects. */
public interface SetInterface<T> <<interface>>
{ Set
/** Adds a new entry to this set, avoiding duplicates.

@param newEntry The object to be added as a new entry. +getCurrentSize(): integer
@return True if the addition is successful, or
false if the item already is in the set. */
+isEmpty(): boolean
public boolean add(T newEntry); +add(newEntry: T): boolean
+remove(): T
/** Removes a specific entry from this set, if possible. +remove(anEntry: T): boolean
+clear(): void
public T remove(); +toArray(): T[]
} // end SetInterface
81
Java Class Library: The Interface Set
https://www.geeksforgeeks.org/set-in-java/
https://www.programcreek.com/2013/03/hashset-vs-treeset-vs-linkedhashset/ 82
Java Class Library: The Interface Set
https://www.geeksforgeeks.org/set-in-java/ 83
The Interface Set
Readings: https://www.geeksforgeeks.org/set-in-java/
84
Summary
• ADT Bag
• Implementations of a Bag
85
What I Want You to Do
• Review class slides
• Review Chapter 1, Chapter 2, and Chapter 3
• Next Topic
• Efficiency of Algorithms
86

Topic2 Bags

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Topic2 Bags

Uploaded by

Copyright:

Available Formats

CS2400 - Data Structures and Advanced Programming

+getCurrentSize(): integer // Get the number of items currently in the bag

• By declaring the array bag as a final data

• Question: Can we use the following?

• Question: Can we use the following?

/** Removes one occurrence of a given entry from this bag.

• -Removing a particular entry requires time to locate the entry

Here we simply place Node

public boolean add(T newEntry) // OutOfMemoryError possible

firstNode = newNode; // New node is at beginning of chain

/** Removes one unspecified entry from this bag, if possible.

How can be remove the

Remove the given entry directly by

Remove first node

• Removing a given entry from a bag

The client program can be found in our blackboard 78

• -Removing specific entry requires search of chain

+getCurrentSize(): integer +getCurrentSize(): integer

/** Adds a new entry to this set, avoiding duplicates.

You might also like