Specifications for the ADT List Ali list provides a way to organize data List of students List of sales List of lists

Transcription

1 Abstract Data Type List

2 ADT List Specifications for the ADT List Ali list provides a way to organize data List of students List of sales List of lists A list has first, last, and in between items (the items has positions) Operations on lists Add new entry at end, or anywhere Remove an item Remove all items Replace an entry Look at any entry Look for an entry of a specific value Count how many entries Check if list is empty, full Display all the entries 2

3 ADT List To specify an ADT list Describe its data Specify the operations ADT list must be considered in general Not necessarily a list of strings 3

4 an interface for the ADT list. After redefine the draft specifications and it is become complete we can starting to build the Java interface for the list ADT as follows: /** an interface for the ADT list. * entries in the list have positions that begin with 0. * / public interface ListInterface { /** Task: adds a new entry to the end of the list.increase i the length by 1 *@ param newentry the object to be added as a new entry *@return true if the addition is successful ( list not full), false otherwise */ public boolean add (Object newentry); /** Task: adds a new entry at a specified position within the list. * The list size increased by 1. *@param newposition an integer that specifies the desired position of the new entry ; *@param newentry the object to be added as a new entry *@return true if the addition is successful (newposition >= 0 and newposition <= * getlength (), and the list not full), or false if not */ public boolean add (int newposition, object newentry); 4

5 an interface for the ADT list. /** Task: removes the entry at a given position from the list. decrease the length by 1 *@param givenposition an integer that indicates the position of the entry to be * removed; *@return either the entry at position givenposition (if the list not empty && the * givenposition >=0 && the givenposition< getlength()), otherwise return null */ public Object remove (int givenposition); /** Task: Removes all entries from the list. */ public void clear(); /** Task: replaces the entry at a given position in the list. *@param givenposition an integer that indicates the position of the entry to be * replaced; *@param newentry the object that t will replace the entry at the position givenposition iti *@return true if the replacement occurs (givenposition >= 0 and givenposition < * getlength() and the list not empty), or false if either the list was empty * or givenposition is invalid */ public boolean replace (int givenposition, Object newentry); 5

6 an interface for the ADT list. /** Task: retrieves the entry at a given position in the list. *@param givenposition an integer that indicates the position of the desired entry; *@return a reference to the indicated list entry, if (the list not empty and * givenposition >= 0 and givenposition < getlength() and the entry found, * otherwise returns null */ public Object getentry (int givenposition); /** Task: determines whether the list contains a given entry. *@param anentry the object that t is the desired d entry *@return true if (the list not empty and the list contains anentry), or false if not */ public boolean contains (Object anentry); /** Task: gets the length of the list. *@return the integer number of entries currently in the list */ public int getlength(); 6

7 an interface for the ADT list. /** Task: determines whether the list is empty. py true if the list is empty, or false if not */ public boolean isempty(); /** Task: determines whether the list is full. true if the list is full, or false if not */ public boolean isfull(); /** Task: displays all entries that are in the list, one per line, in the order in which * they occur in the list. */ public void display(); }// end ListInterface 7

8 LIST Implementations List ADT can be implemented using: a Fixed-Size Array implementation ti Dynamic Array Expansion implementation a Vector implementation Linked-based implementation 8

9 Using Linked based List ADT Implementation Linked list is a linear data structure of objects (items), each item is called a node. Each node contains two fields: a reference to an entry in the list (information field, data portion ) a reference to another node in the chain ( next field that points to the next node, link portion) 9

10 logical view of linked list NODE External pointer Data Link portion Null pointer portion /next (last node (internal pointer) 10

11 logical view of linked list firstnode (head reference ): is an external reference that points to the first node of the list. Next: is an internal reference that points to the next node The next portion of the last node of the list has a value of null (don t points to any thing). 11

12 Example Two linked nodes with : (a) primitive data; (b) object data 12

13 A Linked Implementation of the ADT List Use a chain of nodes Remember the address of the first node in the chain Record a reference to the first node The head reference The implementation contains the class Node as an inner class 13

14 A Linked Implementation of the ADT List We can use the concept of performing chains, in order to implement our ListInterfase with its all methods. add new entry (new node ) in the list - case 1: at the beginning i - case 2 : at the middle - case 3: at the end 14

15 A Linked Implementation of the ADT List Remove an entry (node) from the List Case 1: at the beginning Case 2: at the middle Case 3: at the end Method replace Method getentry Method contains.and Remaining methods 15

16 add new entry (new node ) in the list Case1 at the beginning need: - new node - first node reference Process: - get new node - store data - connect: - newnode.next=firstnode - firstnode=newnode 2 null 1 16

17 add new entry (new node ) in the list Case2 at the middle need: - new node - previous node reference - after node Process: - get new node - store data - get previous node - previousnode= getnodeat(pos -1) - get after node - afternode= previousnode.next - connect newnode.next=afternode PreviousNode.next=newNode 17

18 add new entry (new node ) in the list Case 3: at the end In this case we can use two approaches: 1. the same process As case Get a reference to the last node as part of the implementation class ( will be explained later on). 1. as case 2: 18

19 Remove an entry (node) from the List Case 1: at the beginning i Process: get data stored in the firstnode Result = firstnode.data reconnect firstnode = firstnode.next. 19

20 Remove an entry (node) from the List Case 2: at the middle Process: get node before the deleted node beforenode=getnodeat(pos-1) get node to be removed nodetoremove=beforenode.next get node after deleted node afternode=nodetoremove.next reconnect beforenode.next=afternode 20

21 Remove an entry (node) from the List Case 2: at the middle 21

22 Remove an entry (node) from the List Case 3: at the end In this case, what we need is to get the reference to the node which is before the last node, so we can use the same process as case 2 to implement this case. 22

23 Replace operation Process: Get a reference to the desired node, where the old data of this node will be replaced by new data. desirednode dn d = getnodeat(position); Store the new data in the data portion of the desired node. desirednode.data = newentry 23

24 Get an entry from the list Process Get a reference to the desired node, where the data of this node will be returned to the user. desirednode = getnodeat(position); Get the data portion of this node result = desirednode.data; ed data; Return the result return result 24

25 Contains operation Process: Get a referance to the firstnode currentnode= firstnode; Using this reference (currentnode) to traverse all nodes of the list with equality comparison While (not found && not reach the end of the list(currentnode!= null )) { compare and If found return true else proceeds to the next node (currentnode = currentnode.next) The above repetition continuing until found or reach the end of the list and not found in this case return false. 25

26 Is full, is empty and get length operations isfull(): always return fall as no limitations on the list size {return false;} isempty(): if the first node has a null value means that the list hasn t any node (the list empty { return firstnode == null;} getlength(): returns the value of the counter that holds the number of nodes in the list { return length;} 26

27 Node Class It is implementation detail of the ADT list that should be hidden from the client: in a package with the implementation class inner private class (the data fields of inner class are accessible directly by the outer class) 27

28 The class Node as an inner class (private Class) private class Node{ private Object data; // data portion private Node next; // link to next node private Node(Object dataportion){ data = dataportion; next = null; } // end constructor t private Node(Object dataportion, node nextnode){ data = dataportion; next = nextnode; } // end constructor } // end node 28

29 the implementation class public class LList implements ListInterface{ private Node firstnode; // reference to first node private int length; // number of entries in list public Llist(){ clear(); } // end default constructor <<private class Node>> // as an Inner class goes here 29

30 implementation continue // private! /** Task: returns a reference to the node at a given position. precondition: list is not empty; 0 <= givenposition < length. */ private Node getnodeat(int givenposition){ node currntnode=firstnode; // traverse the list to locate the desired node for (int i =0 ; i< givenposition ; i++) currentnode=currentnode.next; t d t return currentnode; } // end getnodeat 30

31 implementation continue public boolean isfull() /*always false. no limit. The system can only produce an error*/ { return false; } public int getlength() { return length; } public boolean isempty() //like ArList { return length == 0; } public final void clear() { firstnode = null; length=0; } 31

32 implementation continue public boolean add (Object newentry){ Node newnode = new Node(newEntry); if (isempty()) firstnode = newnode; else { // add to end of nonempty list Node lastnode = getnodeat (length - 1); lastnode.next = newnode; // make last node reference new node } // end if length++; return true; } // end add 32

33 implementation continue public boolean add (int newposition, Object newentry){ boolean issuccessful = true; if ((newposition >= 0) && (newposition <= length)){ Node newnode = new Node(newEntry); if (isempty() (newposition= = 0)) { // case 1 newnode.next = firstnode; firstnode = newnode; } else { // case 2 and 3: newposition >= 1, list is not empty Node prevnode = getnodeat (newposition -1); Node nodeafter = prevnode.next; newnode.next = afternode; prevnode.next= newnode; } // end second if length ++; } // end first if else issuccessful = false; return issuccessful; }// end add 33

34 implementation continue public Object remove (int givenposition){ object result = null; // returned value if (!isempty() && (givenposition >= 0) && (givenposition <length)){ if (givenposition = = 0) { // case 1: remove first entry result = firstnode.data; d // save data of entry before removing firstnode = firstnode.next; } else { // case 2 and 3: givenposition >= 1 Node prevnode = getnodeat (givenposition -1); Node nodetoremove = prevnode.next; Node afternode = nodetoremove.next; prevnode.next = afternode; // disconnect the node to be removed result = nodetoremove.data; // save data of entry before removing } // end second if length --; } // end first if return result; // return data of removed entry, or null if operation fails } // end remove 34

35 implementation continue public boolean replace (int givenposition, Object newentry){ boolean issuccessful = true; if(!isempty() () && (givenposition >= 0) && (givenposition <length)) { Node desirednode = getnodeat (givenposition); desirednode.data = newentry; } else issuccessful = false; return issuccessful; } // end replace 35

36 implementation continue public Object getentry (int givenposition) { Object result = null; // result to return if (!isempty() () && (givenposition>= iti 0) &&( (givenposition iti < length)) result = getnodeat(givenposition).data; return result; } // end getentry public void display() { Node currentnode = firstnode; for( int i = 0; i <length; i++) { System.out.println(currentNode.data); t e t ode data); currentnoden = currentnode.next; } } // end display 36

37 implementation continue public boolean contains(object anentry){ boolean found = false; Node currentnode= firstnode; while (!found && (currentnode!= null)){ if (anentry. equals(currentnode.data)) found = true; else currentnode = currentnode.next; } // end while return found; } // end contains } // end of LList class 37

38 Linked-based implementation of ADT List with Tail References Consider a set of data where we repeatedly add data to the end of the list Each time the getnodeat method must traverse the whole list This is inefficient Solution: maintain a pointer that always keeps track of the end of the chain The tail reference A linked chain with a head and tail reference When adding to an empty list Both head and tail references must point to the new solitary node When adding to a non empty list No more need to traverse to the end of the list lastnode points to it Adjust lastnode.next in new node and lastnode 38

39 Adding a node to the end of a nonempty chain that has a tail reference 39

40 Removing a node from a chain that has both head and dtail references when the chain contains (a) one node; (b) more than one node 40

41 the implementation pe e tato cass class with tail reference e e The code is written only for methods that have been changed. public class LList implements ListInterface{ private Node firstnode; // refrence to first node private node lastnode; private int length; // number of entries in list public Llist(){ clear(); } // end default constructor Note: the underlined text shows the difference at the previous implementation 41

42 implementation continue public Boolean add (Object newentry){ Node newnode = new Node(newEntry); if (isempty()) { firstnode = newnode; } else { // add to end of nonempty list // Node lastnode = getnodeat(length g -1); omitted lastnode.next = newnode; // make last node reference new node } // end if lastnode =newnode; length++; return true; } // end add Note: the underlined text shows the difference at the previous implementation ti 42

43 public Boolean add(int newposition, Object newentry){ boolean issuccessful = true; if ((newposition >= 0) && (newposition <= length)){ Node newnode = new Node(newEntry); If (isempty){ // If (isempty()) (newposition= = 0)) { // case 1 //NewNode.next = firstnode; omitted implementation continue 43 FirstNode = newnode; lastnod=newnode;} Else if(newposition= = 0){ newnode.next=firstnode; firstnode=newnode; } else if (newposition==length){ lastnode.next=newnoe; lastnode=newnode;} else { // case 2: newposition > 0 and <length, list is not empty Node prevnode = getnodeat(newposition-1); Node after = prevnode.next; newnode.next = afternode; prevnode.next= newnode; } // end if length++;} else issuccessful = false; return issuccessful; } // end add Note: the underlined text shows the difference at the previous implementation

44 implementation continue public Object remove(int givenposition){ Object result = null; // returned value if f( (!isempty()&&( (givenposition >= 0) && (givenposition <length)){ if (givenposition = = 0) { // case 1: remove first entry result = firstnode.data; // save entry to be removed firstnode = firstnode.next; if(legth ==1) lastnode=null; // the list become empty } else { // case 2 and 3: givenposition iti > 0 Node prevnode = getnodeat(givenposition-1); Node nodetoremove = prevnode.next; Node afternode = nodetoremove.next; prevnode.next = afternode; // disconnect the node to be removed result = nodetoremove.data; //save entry to be removed if(givenposition== length-1); lastnode = prevnode; Note: the underlined text } // end if shows the difference at the length - -; previous implementation } // end if return result; // return removed entry, or null } // end remove // if operation fails 44

45 Pros and Cons of a Chain for an ADT List The chain (list) can grow as large as necessary (advantage) Can add and remove nodes without shifting existing entries (advantage) But Must traverse a chain to determine where to make addition/deletion (disadvantage) Retrieving an entry requires traversal As opposed to direct access in an array (disadvantage) 45

46 Java Class Library: The Class LinkedList The standard java package java.util contains the class LiknkedList This class implements the interface List Contains additional methods addfirst() addlast() removefirst() removelast() getfirst() getlast() 46