CE204 Data Structures and Algorithms Part 1

Transcription

1 CE204 Data Structures and Algorithms Part 1 11/01/2018 CE204 Part 1 1

2 Recommended Reading The most useful book for much of the material in this module is Data Structures and Algorithm Analysis in Java (2nd ed.), M.A. Weiss (Pearson, 2007) This book does not, however, cover in detail all of the Java programming material. Hence a recent Java programming text will be useful as additional reading, e.g. Java How To Program (7th ed.), H.M. Deitel & P.J. Deitel (Prentice Hall, 2007) There are many alternative programming texts if you select a different one you should ensure that it covers Java 5. 11/01/2018 CE204 Part 1 2

3 Assessment Two hour exam in May/June (70% of the module credit) Assignment 1 (10% of the module credit); to be handed out in week 17, for submission by Tuesday of week 20 Assignment 2 (10% of the module credit); to be handed out in week 22, for submission by Tuesday of week 25 Multiple-choice test (10% of the module credit) on Thursday of week 21 11/01/2018 CE204 Part 1 3

4 Linked Lists 1 A recursive data structure is a type that contains a reference or pointer to another object of the same type. The simplest example is a linked list in which each object contains a data item and a reference to the next object in the list. (The last item in the list will hold a null reference, indicating there is no next object.) 11/01/2018 CE204 Part 1 4

5 Linked Lists 2 The traditional operations associated with linked lists are cons, which takes a list and a data item and constructs a new list by adding the item to the front of the list head, which returns the item at the front of the list tail, which returns the list comprising everything but the head. 11/01/2018 CE204 Part 1 5

6 Linked Lists in Java 1 In Java we can declare a class ListCell whose members are a data item and a reference to the next element of the list. It is preferable to write head and tail as methods of the class and use a constructor instead of the cons function. On the next slide we present a class for a linked list of data items of type int. The instance variables could be made private a decision should be made based on needs of the application for which the class will be used. For example, if it is going to be necessary to change data in some of the cells the data member will need to be public, but if it is necessary to ensure that contents cannot be changed once added to the list the members should be private. 11/01/2018 CE204 Part 1 6

7 Linked Lists in Java 2 class ListCell { int data; ListCell next; public ListCell(int i, ListCell c) { data = i; next = c; public int head() { return data; public ListCell tail() { return next; 11/01/2018 CE204 Part 1 7

8 Linked Lists in Java 3 An empty list in Java would be represented by null. To create a list containing the elements 1 (at the front), 2 and 3 we could use ListCell l1 = new ListCell(3, null); ListCell l2 = new ListCell(2, l1); ListCell mylist = new ListCell(1, l2); or, more concisely, ListCell mylist = new ListCell(1, new ListCell(2, new ListCell(3, null))); 11/01/2018 CE204 Part 1 8

9 Linked Lists in Java 4 To obtain the third item in a list l we would use ListCell t1 = l.tail(); ListCell t2 = t1.tail(); int answer = t2.head(); or, more concisely, int answer = l.tail().tail().head(); Note that an exception of type NullPointerException will be thrown if the list does not contain three elements, since one of the ListCell objects (l, t1 or t2) will be null and we cannot apply methods to a null reference. 11/01/2018 CE204 Part 1 9

10 Linked Lists in Java 5 We could write a loop to find the nth item in a list l: int i; ListCell c = l; for (i = 1; i<n; i++) c = c.tail(); int answer = c.head(); Code such as this should normally be placed in a try block, with a catch block to handle any exception thrown if the list has less than n elements. 11/01/2018 CE204 Part 1 10

11 Linked Lists in Java 6 If we wish to produce a class similar to the LinkedList class provided in the collections framework, in which an empty list is an object rather than a null reference, and adding an item changes the state of a list object rather than returning a new object, we need to enclose the list cells within another class which contains a reference to the front item in the list. On the next slides we provide such a class for a list of items of type int with a constructor that creates an empty list, methods to add items to the front and to the back and a method that returns the element at location n (assuming locations are numbered starting from 0). 11/01/2018 CE204 Part 1 11

12 Linked Lists in Java 7 // LList.java class ListCell { int data; ListCell next; public ListCell(int i, ListCell c) { data = i; next = c; class ListException extends RuntimeException { 11/01/2018 CE204 Part 1 12

13 Linked Lists in Java 8 // LList.java continued public class LList { private ListCell front; public LList() { front = null; public void addtofront(int i) { front = new ListCell(i, front); 11/01/2018 CE204 Part 1 13

14 Linked Lists in Java 9 // class LList continued public void addtoback(int i) { if (front==null) front = new ListCell(i, null); else { // find back cell ListCell c = front; while (c.next!=null) c = c.next; // add new cell c.next = new ListCell(i, null); 11/01/2018 CE204 Part 1 14

15 Linked Lists in Java 10 // class LList continued public int elementat(int n) { ListCell c = front; if (n<0) throw new ListException(); for (int i = 0; i<n; i++) { if (c == null) throw new ListException(); c = c.next; if (c == null) throw new ListException(); return c.data; 11/01/2018 CE204 Part 1 15

16 Linked Lists in Java 11 If we expect to call the addtoback method frequently it will be more efficient to store in the LList class a reference to the last item in the list. Assuming that this reference is called back we could write the method in the following way. public void addtoback(int i) { if (front == null) front = back = new ListCell(i, null); else { back.next = new ListCell(i, null); back = back.next; 11/01/2018 CE204 Part 1 16

17 Linked Lists in Java 12 If we add a back variable to the LList class we must modify the constructor to initialise it to null. It is also necessary to modify the addtofront method because when an item is added to the front of an empty list it will become both the front and the back item. public void addtofront(int i) { front = new ListCell(i, front); if (back == null) back = front; 11/01/2018 CE204 Part 1 17

18 Doubly-Linked Lists 1 In a doubly-linked list each cell has references to both the next and the previous items. Use of doubly-linked lists allows efficient traversal in both directions and also efficient insertion and removal at both ends, but requires more memory space and more complex code. For example, assuming that the extra reference in the ListCell class is called prev, and that the constructor initialises this to null, a possible addtofront method is shown on the next slide. 11/01/2018 CE204 Part 1 18

19 Doubly-Linked Lists 2 // addtofront method for doubly-linked list public void addtofront(int i) { front = new ListCell(i, front); if (front.next!= null) front.next.prev = front; else back = front; 11/01/2018 CE204 Part 1 19

20 Generic Classes 1 The element type in the linked-list class that we have been developing has been int; if we wished to produce a linked list class with a different element type we could simply replace the occurrences of int with a different type. However, if we wished to use lists of more than one type of element in the same program this would involve producing two almost identical classes with different names. An alternative would be to define a list class with Object as the element type, but this would allow users to mix items of the same type in different lists and we would have to downcast when extracting items. 11/01/2018 CE204 Part 1 20

21 Generic Classes 2 You will have encountered in CE203 the use of parameterised types such as TreeSet<Integer> and Vector<String> TreeSet and Vector are generic classes. To allow the use of linked lists of different types of item it is desirable to produce a generic linked-list class; in order to do this we have to declare the class as LList<T>, where T is a type parameter which can be instantiated with any non-primitive type. Note that the type parameter does not have to be T, although it is conventional to use a single upper-case letter. E would be equal suitable (indicating element type). 11/01/2018 CE204 Part 1 21

22 Generic Classes 3 To make our linked-list class generic we need to replace all occurrences of LList by LList<T> and use the type parameter T wherever the name of the element type is needed. Since the type of the elements stored in the ListCell class will be T it is preferable to also make this class generic (it would be possible to use a ListCell class with elements of type Object, with downcasting used where appropriate). A complete version of a generic linked-list class (with a back reference) is provided on the following slides. Note that the type parameter does not appear after the method name in the declaration of the constructor but it is used when constructors are called. 11/01/2018 CE204 Part 1 22

23 Generic Classes 4 // LList.java generic version class ListCell<T> { T data; ListCell<T> next; public ListCell(T i, ListCell<T> c) { data = i; next = c; class ListException extends RuntimeException { 11/01/2018 CE204 Part 1 23

24 Generic Classes 5 // generic LList.java continued public class LList<T> { private ListCell<T> front, back; public LList() { front = back = null; public void addtofront(t i) { front = new ListCell<T>(i, front); if (back == null) back = front; 11/01/2018 CE204 Part 1 24

25 Generic Classes 6 // class LList<T> continued public void addtoback(t i) { if (front == null) front = back = new ListCell<T>(i, null); else { back.next = new ListCell<T>(i, null); back = back.next; 11/01/2018 CE204 Part 1 25

26 Generic Classes 7 // class LList<T> continued public T elementat(int n) { ListCell<T> c = front; if (n<0) throw new ListException(); for (int i = 0; i<n; i++) { if (c == null) throw new ListException(); c = c.next; if (c == null) throw new ListException(); return c.data; 11/01/2018 CE204 Part 1 26

27 Generic Methods 1 All non-static methods of a generic class can be classed as generic methods since they can be applied to any instance of the class. It is sometimes useful to be able to use generic methods outside of a generic class. Consider as an example the following simple (non-generic) method that adds multiple copies of a string to a list of strings. public static void addcopies(string s, LList<String> ll, int numcopies) { for (int i = 0; i<numcopies; i++) ll.addtoback(s); 11/01/2018 CE204 Part 1 27

28 Generic Methods 2 To allow the same method to be used for adding multiple copies of non-string objects to lists with appropriate types we might wish to make the method generic. If we simply changed the types of the first two arguments to T and LList<T> the compiler would inform us that T has not been declared we must explicitly specify that it is a type parameter by inserting <T> before the return type in the method declaration: public static <T> void addcopies(t s, LList<T> ll, int numcopies) { for (int i = 0; i<numcopies; i++) ll.addtoback(s); 11/01/2018 CE204 Part 1 28