Introduction to ADTs

Transcription

1 Data Structure Introduction to ADTs A particular way of storing and organizing data in a computer so that it can be used efficiently *from Wikipedia A set of data values and associated operations that are precisely specified independent of any particular implementation. *from A data type having - A specific, physical or logical representation of the data - Operations over its data A concrete and logical description May be implemented in various ways - Implementation-dependent Data abstraction refers to, providing only essential information to the outside world and hiding their background details, i.e., to represent the needed information in program without presenting the details. Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation. Options in designing a program that requires new ADT In the course of designing a program and discovering that a new data type is needed, the options are : Use an existing type Build our ADT from scratch by declaring a new class Inherit from an existing class and make slight modifications Fall 2018 Husain Gholoom Lecturer in Computer Science Page 1

2 Example Let's take one real life example of a TV, which you can turn on and off, change the channel, adjust the volume, and add external components such as speakers, VCRs, and DVD players, BUT you do not know its internal details, that is, you do not know how it receives signals over the air or through a cable, how it translates them, and finally displays them on the screen. Thus, we can say a television clearly separates its internal implementation from its external interface and you can play with its interfaces like the power button, channel changer, and volume control without having zero knowledge of its internals. Example Your program can make a call to the sort() function without knowing what algorithm the function actually uses to sort the given values. In fact, the underlying implementation of the sorting functionality could change between releases of the library, and as long as the interface stays the same, your function call will still work. In C++, we use classes to define our own abstract data types (ADT). You can use the cout object of class iostream to stream data to standard output like this: #include <iostream> using namespace std; int main( ) cout << "Hello C++" <<endl; return 0; Here, you don't need to understand how cout displays the text on the user's screen. You need to only know the public interface and the underlying implementation of cout is free to change. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 2

3 Access Labels Enforce Abstraction: In C++, we use access labels to define the abstract interface to the class. A class may contain zero or more access labels: Members defined with a public label are accessible to all parts of the program. The data-abstraction view of a type is defined by its public members. Members defined with a private label are not accessible to code that uses the class. The private sections hide the implementation from code that uses the type Data Abstraction Example: Any C++ program where you implement a class with public and private members is an example of data abstraction. Consider the following example: #include <iostream> using namespace std; class Adder public: // constructor Adder(int i = 0) total = i; ; // interface to outside world void addnum(int number) total += number; // interface to outside world int gettotal() return total; ; private: // hidden data from outside world int total; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 3

4 int main( ) Adder a; a.addnum(10); a.addnum(20); a.addnum(30); cout << "Total " << a.gettotal() <<endl; return 0; When the above code is compiled and executed, it produces the following result: Total 60 Above class adds numbers together, and returns the sum. The public members addnum and gettotal are the interfaces to the outside world and a user needs to know them to use the class. The private member total is something that the user doesn't need to know about, but is needed for the class to operate properly. Benefits of ADT's. ADTs have several benefits: o o o o o o Simplicity: Client programmer does not have to be concerned with details that underlie the implementation of the ADT (eg keeping track of the front and back of a queue) Modularity - Reliability: Dividing a system into components or modules, each of which can be designed, implemented, tested, reasoned about, and reused separately from the rest of the system. Abstractions : Omitting or hiding low-level details with a simpler ideas Encapsulation: Building walls around a module (a hard shell or capsule) so that the module is responsible for its own internal behavior, and bugs in other parts of the system can t damage its integrity. Flexibility for client programmer: can choose from among several implementations of an ADT Example: array stack for efficient time and space Or linked stack for flexibility Independence: ADT programmer can change implementations of ADT without forcing client to change. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 4

5 Data Structures Again The term data structures is often extended to include both concrete AND logical descriptions of complicated data types. A list of data structures could include ADTs - arrays - linked lists - stacks - queues - vectors or lists ADTs and Program Design ADTs are an important part of bottom up program design In practice, programs are built using a combination of top down and bottom up approaches: o Top down: Decompose problem into subproblems, then decompose subproblems. Repeat until subproblems are simple Structure charts are a common design tool o Bottom up Design a set of tools and use them to build a solution the problem The tools are the values and operations of ADTs Designing ADTs is an essential part of bottom up design ADT Operations Categories Declare a variable of the type o ( ie using a type defined in the package ) Allocate a variable of the type o May be done by a declaration o Or may require a special operation ( eg new or constructor-like call ) Fall 2018 Husain Gholoom Lecturer in Computer Science Page 5

6 Operations on values ( ie procedures and functions that have values of the type as parameters ): o Query a property of the value or the status of a value or a component of a value o Modify a value (ie through an in/out parameter) o Combining two or more values and return a new value (of the same or different type) o Comparing two or more values o Convert a value to a string o Input/output of values Iterate through subcomponents Commonly used ADTs The purpose of many commonly used ADTs is to: - Store a collection of objects - Potentially organize the objects in a specific way - Provide potentially limited access to the objects These ADTs are often called - Containers - Collections - Container classes The ADT Basic Collections are : There are three basic collections. The basic collection is often called a bag. It stores objects with no ordering of the objects and no restrictions on them. Another unstructured collection is a set where repeated objects are not permitted: it holds at most one copy of each item. A set is often from a predefined universe. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 6

7 A collection where there is an ordering is often called a list. Specific examples include an array, a vector and a sequence. These have the same idea, but vary as to the methods they provide and the efficiency of those methods. Other Examples : A List ADT - Stack and Queue - Tree - Map (or dictionary) Values: ordered (1st, 2nd, etc) set of objects Operations: - constructor: creates an empty list - isempty: is the list empty - size: returns the number of elements - add an element to the end of the list - add an element at any position of the list. - remove an element i from the list - remove the first occurrence of any element from a non-empty list. - return the element at position i - replace an element at any position by another element. A Set ADT Values: collection of unique objects Operations: - constructor: creates an empty set - isempty: is the set empty - size: returns the number of elements - add an element to the set (if not there) - remove an element from the set (if it is there) - iselement(x): true if x is in the set - union: combine two sets into one Fall 2018 Husain Gholoom Lecturer in Computer Science Page 7

8 A Map ADT A collection of unique keys and a collection of values where each key is associated with a single value. Keys have one type, values another. Operations may include: constructor: creates an empty map isempty: returns true if map has no key-value pairs size: returns the number of key-value pairs in the map get(k): returns value associated with key k (if any) put(k,v): associates value v with key k (adds a pair) keyset: returns a set of all the keys in the map A Bag (multi-set) ADT A bag is an ADT or abstract data type defines a way of storing data: it specifies only how the ADT can be used and says nothing about the implementation of the structure. The bag values are unordered collection of objects (may include duplicates) The Bag ADT might have: accessor methods such as size, count Occurrence, possibly an iterator (which steps through all the elements). modifier methods such as add, remove, and addall. A union method which combines two bags to produce a third. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 8

9 The Bag ADT Operations : Inside the bag are some elements, values, or numbers. When you first begin to use a bag, the bag will be empty ( called initial state ) Numbers may be inserted into a bag. The bag can hold many numbers We can even insert the same numbers more than once We may ask about the contents of the bag. We may remove a numbers from a bag. But we remove only one number at a time. We can determine how many numbers are in a bag. Summary of the Bag Operations: - constructor: creates an empty bag - isempty: is the bag empty - size: returns the number of elements - add an element to the bag - remove an element from the bag (if it is there) - removes all copies of an element from the bag - occurrences(x): how many times x is in the bag Implementing an ADT Interface : Implementation : - class declaration - prototypes for the operations - data members for the actual representation - ( *.h ) - function definitions for the operations - depends on data members (their representation) - ( *.cpp ) Fall 2018 Husain Gholoom Lecturer in Computer Science Page 9

10 Example ADT: Bag Version 1 ( header file ) #include<iostream> #include <cassert> using namespace std; class Bag public: Bag (); void insert(int element); void remove(int element); int occurrences(int element) const; bool isempty() const; int size() const; static const int CAPACITY = 20; ; private: int data[capacity]; int count; concrete representation Note : #include <cassert> is a header file in the standard library of the C programming. The macro implements an assertion, which can be used to verify assumptions made by the program and print a diagnostic message if this assumption is false. Member variables of a class can be made static by using the static keyword. Static member variables only exist once in a program regardless of how many class objects are defined! Fall 2018 Husain Gholoom Lecturer in Computer Science Page 10

11 Example ADT: Bag Version 1 ( header implementation ) Bag::Bag () count = 0; void Bag::insert(int element) assert (count < CAPACITY); data[count] = element; count++; // what does this do? void Bag::remove(int element) int index = -1; for (int i=0; i<count && index==-1; i++) if (data[i]==element) index = i; if (index!=-1) data[index] = data[count-1]; count--; int Bag::occurrences(int element) const int occurrences=0; for (int i=0; i<count; i++) if (data[i]==element) occurrences++; return occurrences; bool Bag::isEmpty() const return (count==0); int Bag::size() const return count; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 11

12 Bag - driver int main() Bag b; cout << "\nis empty " << b.isempty() << endl ; b.insert(4); b.insert(8); b.insert(4); cout << "is empty " << b.isempty() << endl << endl ; cout << "size " << b.size() << endl ; cout << "how many 4's: " << b.occurrences(4) << endl << endl; b.remove(4); cout << "removed a 4" << endl; cout << "size " << b.size() << endl; cout << "how many 4's: " << b.occurrences(4) << endl << endl; Bag c(b); cout << "copied to c" << endl; cout << "size " << c.size() << endl; cout << "how many 4's: " << c.occurrences(4) << endl << endl; b.insert(10); cout << "added 10 to b" << endl; cout << "b.size " << b.size() << endl; cout << "c.size " << c.size() << endl << endl; cout << "starting insert of 20 items" << endl; for (int i = 0; i < 20; i++) b.insert(33); cout << "inserted 20 more items into b" << endl; return 0; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 12

13 Bag driver : output output of running bagtest is empty 1 is empty 0 size 3 how many 4's: 2 removed a 4 size 2 how many 4's: 1 copied to c size 2 how many 4's: 1 added 10 to b b.size 3 c.size 2 starting insert of 20 items assertion "count < CAPACITY" failed: file "../bagimp.cpp", line 17, function: void Bag::insert(int) 0 [main] L5- Bag 4412 cygwin_exception::open_stackdumpfile: Dumping stack trace to L5- Bag.exe.stackdump One way to resolve is to increase the size of the array Bag Version 1 - Summary Implemented using a fixed size array When adding more elements than fit in the bag, the program exits. One Solution : increase the size of the array in bag.h Better Solution: - use a dynamically allocated array - when its capacity is reached, allocate a new, bigger array. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 13

14 Bag Version -2 : Using Dynamic Memory Allocation ( header file ) class Bag public: Bag (); void insert(int element); void remove(int element); int occurrences(int element) const; bool isempty() const; int size() const; static const int INCREMENT = 20; ; private: int *data; //pointer to bag array // concrete representation int capacity; //size of the array int count; //number of elements currently in array Fall 2018 Husain Gholoom Lecturer in Computer Science Page 14

15 Bag Version 2 ( Header Implementation ) Bag::Bag () count = 0; capacity = INCREMENT; data = new int[capacity]; void Bag::insert(int element) //if count is at the capacity, resize if (count==capacity) capacity += INCREMENT; int *newdata = new int[capacity]; //new array for (int i=0; i<count; i++) //copy values newdata[i] = data[i]; delete [] data; //delete old array data = newdata; //make data point to new data[count] = element; //add new element count++; // no changes to remaining functions! Fall 2018 Husain Gholoom Lecturer in Computer Science Page 15

16 bag driver : output version 2 output of running bagtest is empty 1 is empty 0 size 3 how many 4's: 2 removed a 4 size 2 how many 4's: 1 copied to c size 2 how many 4's: 1 added 10 to b b.size 3 c.size 2 starting insert of 20 items inserted 20 more items into b resizing succeeded! Fall 2018 Husain Gholoom Lecturer in Computer Science Page 16

17 Bag Implementation Using Vector - Summary of the Operations: - constructor: creates an empty bag - drop : add a number to the bag - pick: erase an element from the bag - get_size : returns the number of elements - get_capacity : returns cap - display : display numbers - is_full : is the bag full - subtract : erase common numbers from 2 bags Fall 2018 Husain Gholoom Lecturer in Computer Science Page 17

18 Vector Bag Implementation - bagvector.h #ifndef BAGVECTOR_H_ #define BAGVECTOR_H_ #include <iostream> #include <vector> using namespace std; class My_Bag private: const static int DS=5; vector<int> b; unsigned int cap; unsigned int size; public: My_Bag(); My_Bag(int); bool drop(int); bool pick(int); int get_size(); int get_capacity(); void display(); bool is_full(); bool subtract(const My_Bag&); ; bool My_Bag::subtract(const My_Bag& q) if (size==0 cap==0) return true; for (int i=0;i<q.b.size();i++) pick(q.b[i]); return true; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 18

19 Vector Bag Implementation ( cont. ) : My_Bag::My_Bag() cap=ds; size=0; My_Bag::My_Bag(int c) if (c<=0) cap=ds; else cap=c; size=0; bool My_Bag::drop(int item) if (size==cap) return false; b.push_back(item); ++size; return true; bool My_Bag::pick(int item) int index=-1; for (unsigned int i=0;i<size;i++) if (b[i]==item) index=i; b.erase(b.begin()+index); --size; return true; return false; int My_Bag::get_size() return size; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 19

20 Vector Bag Implementation ( cont. ) : int My_Bag::get_capacity() return cap; bool My_Bag::is_full() if (size==cap) return true; else return false; void My_Bag::display() cout << "Bag capacity: " << cap << endl; cout << "Current size: " << size << endl; for(unsigned int i=0;i<size;i++) cout << b[i] << ' '; cout << endl; #endif /* BAGVECTOR_H_ */ Fall 2018 Husain Gholoom Lecturer in Computer Science Page 20

21 Vector Bag Implementation ( cont. ) : bagvectordriver.cpp #include <iostream> #include <vector> #include "bagvector.h" using namespace std; int main() My_Bag b1(5); b1.drop(10); b1.drop(10); b1.drop(20); b1.pick(10); b1.drop(20); b1.drop(30); b1.drop(10); b1.pick(20); b1.drop(-100); b1.drop(-100); b1.pick(10); b1.pick(10); b1.pick(30); b1.pick(-1009); b1.drop(20); b1.display(); cout << "==================\n"; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 21

22 bagvectordriver.cpp - ( continued ) My_Bag b2(10); b2.drop(20); b2.drop(20); b2.drop(30); b2.drop(78); b1.subtract(b2); b1.display(); cout << "==================\n"; b2.drop(-100); b2.drop(20); b2.subtract(b1); b2.display(); cout << "==================\n"; b2.drop(10); b1.subtract(b2); b1.display(); cout << "==================\n"; b1.drop(20); b2.subtract(b1); b2.display(); cout << "==================\n"; return 0; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 22

23 Sample Run Bag capacity: 5 Current size: ================== Bag capacity: 5 Current size: ================== Bag capacity: 10 Current size: ================== Bag capacity: 5 Current size: ================== Bag capacity: 10 Current size: ================== Fall 2018 Husain Gholoom Lecturer in Computer Science Page 23

24 ADT - Example -2 : Rolling a Pair of Dice Write a function that rolls a pair of dice until the sum of numbers rolled is a specific number. Also, calculate the number of times the dice are rolled to get the desired sum. Note that the smallest number in each die is 1 and the largest number is 6. So, the smallest sum of the numbers rolled is 2 and the largest sum of the numbers rolled is 12. Use the random number generator to randomly generate a number between 1 and 6 by using the following formula for both die1 and die2 :- die1 = rand() % 6 + 1; die2 = rand() % 6 + 1; sum = die1 + die2; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 24

25 Solution : Rolling a Pair of Dice #include <iostream> #include <cstdlib> #include <ctime> #include "die.h" class die public: die(); //Default constructor //Sets the default number rolled by a die to 1 int roll(); //Function to roll a die. //This function uses a random number generator to randomly //generate a number between 1 and 6, and stores the number //in the instance variable num and returns the number. int getnum() const; //Function to return the number on the top face of the die. //Returns the value of the instance variable num. private: int num; ; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 25

26 die.cpp //Implementation File for the class clocktype using namespace std; die::die() num = 1; srand(time(0)); int die::roll() num = rand() % 6 + 1; return num; int die::getnum() const return num; Fall 2018 Husain Gholoom Lecturer in Computer Science Page 26

27 //The user program that uses the class rolldie int main() die die1; die die2; int sum ; int rollcount = 0; cout << "die1: " << die1.getnum() << endl; cout << "die2: " << die2.getnum() << endl; sum = die1.getnum() + die2.getnum(); cout << "die1 + die2 = " << sum << endl; do cout << "After rolling die1: " << die1.roll() << endl; cout << "After rolling die2: " << die2.roll() << endl; cout << "The sum of the numbers rolled" << " by the dice is: " << die1.getnum() + die2.getnum() << endl; rollcount ++; while ( ( die1.getnum() + die2.getnum() )!= sum); cout << endl; cout << "The number of times the Dice was rolled = " << rollcount<<endl; return 0; //end main Fall 2018 Husain Gholoom Lecturer in Computer Science Page 27

28 Sample Run die1: 1 die2: 1 die1 + die2 = 2 After rolling die1: 5 After rolling die2: 1 The sum of the numbers rolled by the dice is: 6 After rolling die1: 3 After rolling die2: 3 The sum of the numbers rolled by the dice is: 6 After rolling die1: 4 After rolling die2: 3 The sum of the numbers rolled by the dice is: 7 After rolling die1: 1 After rolling die2: 1 The sum of the numbers rolled by the dice is: 2 The number of times the Dice was rolled = 4 Fall 2018 Husain Gholoom Lecturer in Computer Science Page 28

29 C++ Standard Template Library and Standard Library contain components such as : <array> <deque> New in C++11 and TR1. Provides the container class template std::array, a container for a fixed sized array. Provides the container class template std::deque, a double-ended queue. <forward_list> New in C++11 and TR1. Provides the container class template std::forward_list, a singly linked list. <list> <map> <queue> <stack> Provides the container class template std::list, a doubly linked list. Provides the container class templates std::map and std::multimap, sorted associative array and multimap. Provides the container adapter class std::queue, a single-ended queue, and std::priority_queue, a priority queue. Provides the container adapter class std::stack, a stack. <unordered_map> New in C++11 and TR1. Provides the container class template std::unordered_map and std::unordered_multimap, hash tables. <vector> Provides the container class template std::vector, a dynamic array. <algorithm> Provides definitions of many container algorithms such as sorting, searching. <iterator> Provides classes and templates for working with iterators. <string> <regex> Provides the C++ standard string classes and templates. New in C++11. Provides utilities for pattern matching strings using regular expressions. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 29

30 <fstream> Provides facilities for file-based input and output. See fstream. <iomanip> Provides facilities to manipulate output formatting, such as the base used when formatting integers and the precision of floating point values. <istream> Provides the template class std::istream and other supporting classes for input. <ostream> Provides the template class std::ostream and other supporting classes for output. <exception> Provides several types and functions related to exception handling, including std::exception, the base class of all exceptions thrown by the Standard Library. <thread> <mutex> New in C++11. Provide class and namespace for working with threads. New in C This section provides mechanisms for mutual exclusion: ( mutexes, locks, and call once. or exception) from a function that has run in the same thread or another thread. <complex> The header <complex> defines a class template, and numerous functions for representing and manipulating complex numbers. Fall 2018 Husain Gholoom Lecturer in Computer Science Page 30