Data Types. Abstract Data Types. ADTs as Design Tool. Abstract Data Types. Integer ADT. Principle of Abstraction

Transcription

1 bstract ata Types Previous lectures: algorithms and their efficiency analysis. oming lectures: data structures In this lecture: bstract data types Ts as a design tool Examples: integer T, List T ata Types ll programming languages provide basic data types. These have core operations (or methods): For example, int has arithmetic operations +, -, /, * and comparisons <,>,==, etc. lso provide composite (structured) data types (arrays in Java, s in Haskell). bstract ata Types ata type = data + methods bstract data type: Logical domain for data ollection of core operations / methods Ts abstract from implementation des, e.g.: How data domain is built from more basic data types How the core methods actually work Efficiency (complexity) of algorithms for core methods orrectness of algorithms Ts as esign Tool Useful aid in software design process. onsider what kind of data you need to solve the problem. onsider which operations do you need to perform with the data (which arguments the operations take, what is their return type). Essentially, designing a class interface (which methods the class should have). (The idea of Ts predates object oriented programming and is more general.) Principle of bstraction When solving a problem, separate what is to be done, and how it is to be done Integer T Logical domain: integers (whole numbers greater or equal to 0). Methods: Integer add(integer x, Integer y) Postcondition: returns the sum of x and y Integer multiply(integer x,integer y) Postcondition: returns x times y boolean equals(integer x, Integer y) Postcondition: returns true of x equal to y and so on.we don't know how this is going to be implemented - as a 16-bit or a 32-bit number etc. 1

2 List T (Informal) ata (what things are s?): linear collections of items. Methods (what can one do with a?): insert an element delete an element access the of the move to the item from where you are There is no single "true" T; operations depend on what we want to do with s. List T contd. Need T for items in the with methods for assigning items and comparing them. Let s call that T ItemType In Java implementation, ItemType will be assumed to be Object. The example is based on Shaffer s book hapter 4. However Shaffer identifies an T with an interface in Java; this may be confusing because T can be described independently from any programming language. List T methods a method to initialise a (List() in Java syntax) Postcondition: creates an empty void insert(itemtype item) Postcondition: item inserted into (at the ent position). ItemType remove() Postcondition: item at ent position deleted from (and returned). ItemType Value() Postcondition: The item at ent position is returned. List methods contd. boolean isempty() Postcondition: Returns true if is empty, false otherwise. void setfirst() Postcondition: set ent position at the first position in the. void () Postcondition: ent position moves one to the right void prev() Postcondition: ent position moves one to the left etc. (see Shaffer s book). Possible modifications of List T insertion and deletion at a specified position no way to move back (to the previous item) ordered : insertion in order (and different names for methods, obviously...) Implementations of List T ifferent data structures (concrete ways to organise data in computer memory) can be used to implement the List T: Various linked s Recursive s (consisting of and ) n array or vector 2

3 rray implementation of List T lass for an array implementation of a List (List, see Shaffer). Fields: an array of Objects rray to store items; int numinlist to store the actual number of items in the ; int to store the index of the ent position; etc. Insertion at the ent position =0 insert 23 at ent position: Insertion at the ent position Insertion at the ent position =0 insert 23 at ent position =0 insert 23 at ent position Insertion at the ent position Insertion at the ent position =0 insert 23 at ent position =0 insert 23 at ent position 3

4 Insertion at the ent position Insertion at the ent position =0 insert 23 at ent position =0 insert 23 at ent position rray implementation of List T class List { public void insert(object it){ (check that there is space and is a valid index) for(int i=numinlist; i>;i--){ rray[i]=rray[i-1]; rray[]=it; numinlist++; rray implementation of List T remove() method is similar: also involves moving items to close the gap in the array. Note that both insert() and remove() methods in this implementation have O(N) worst case complexity. linked consists of linked nodes: Other Lists linked is not the only way to imagine s: Nil 4

5 with urrent Implementation Each node has a field which says what the item in the is. The has a and fields which refer to the and the last element of the. There is also an indicator for where we are in the : points to the node preceding the ent element (technicality in Shaffer s implementation - does not have to be this way!) LList ent ent lass for elements (nodes) class Link { private Object element; private Link ; Link(Object it, Link val) { element = it; = val; Object element() {return element; Link () {return ; Link setnext(link val) { return = val; Object setelement(object it) { return element = it; lass for a linked class LList { private Link ; private Link ; protected Link ; (constructor etc.) public void insert(object it){ if (!=) {.setnext(new Link(it,.()); if( == ) =.(); else....setnext(new Link(it,.()); insert a new object :.setnext(new Link(it,.()); create a link with : 5

6 .setnext(new Link(it,.()); set this to be the link from :.setnext(.().()); Remove the ent element:.setnext(.().()); Find.():.setNext(.().()); Find.().:.setNext(.().()); Set the link from to be to.().: omparison omplexity of insertion and deletion in linked s: O(1) (faster than in the array implementation) Search for a given element: O(N) in both (given that the is unordered). Static vs dynamic: memory for the List is allocated in advance, for the LList it is allocated as new elements are added. For the former implementation, better to know the size in advance. List is a bit simpler to implement... 6

7 Summary ifferent stages in solving a problem: esigning Ts (e.g. List T) hoosing data structures to implement them (e.g. as linked,or as an array) ctual implementation: only here can you talk about efficiency of methods, but since there are standard ways to implement a linked people refer to complexity of insertion in a linked with ent. Reading Shaffer, Section 1,2 (bstract data Types and data Structures), Section 4.1 (Lists) Other implementations in Java - any textbook on data structures using Java 7