Lists Chapters Linked Lists Abstract Implementations Storage Leaks Ordered Lists

Transcription

1 Lists Chapters 8-11 Linked Lists Abstract Implementations Storage Leaks Ordered Lists

2 Data Storage Organisation Three basic implementation techniques for linear data collections Files Arrays Linked Lists properties length direct access append insert update persistent file flexible array fixed linked list flexible schmiedecke 07 Inf2-6-Testing 2

3 Data Structures A data structure is a data storage organisation defined and used by the same class. If there are rules to obey, the data structure must be made private. Example: Sorted list of Strings used as an index table into a list of lists, in this case a lookup construct for first name ocurrences. public class BirthRegister { private BirthEntry [] births = new BirthEntry[10000]; private String[] names = new String[5000]; private BirthEntry[][] refs = new BirthEntry[5000][100]; public void enter(birthentry birth) { births[nextentry] = birth; nextentry++; int index = names.locate(birth.firstname); int ii; for (ii=0; ii<100; ii++) if (refs[index][ii]==null) break; refs[index][ii]=birth; schmiedecke 07 Inf2-6-Testing 3

4 Abstract Data Types Implementation of functionality, Data structure is hidden (encapsulated) and exchangeable, General or generic element Type. Contains a private data structure. Exports access and modification methods for the data structure, Usually defined by an interface Examples Typical data structure: Stack, Queue, Set, Bag Linear List Symbol Table Map Lookup Tables Sorted List Hierarchical Structures Tree Arbitrary Structure Graph, Matrix Text Linear List, Tree Binary Tree Tree, Matrix, List,... schmiedecke 07 Inf2-6-Testing 4

5 Flexible Lists Very often, the required size of a list cannot be foreseen. So we need to start with an initial size and provide an extension mechanism, hidden or visible. Normally, extension is done implicitly. schmiedecke 07 Inf2-6-Testing 5

6 Flexible Arrays Flexible Arrays have an initial size - usualy set by a constructor parameter and an increment - either fixed - or adaptive to the array growth (e.g. doubling its size) If a data entry is no longer possible, a new array is defined and the array content is copied. We have seen that doubling the size is the most efficient way of adapting the array size. schmiedecke 07 Inf2-6-Testing 6

7 Implement a Flexible Array with Insertion public class FlexibleArray implements BasicList { private Object [] list; private int count = 0; public FlexibleArray() { this(100); public FlexibleArray(int initialcapacity) { list = new Object[initialCapacity]; public Object get(int index) { return list[index]; public void set(int index, Object value) { list[index] = value; public void add(object value) { ensurecapacity(count+1); list[count] = value; count++; schmiedecke 07 Inf2-6-Testing 7

8 public void add(int index, Object value) { ensurecapacity(count+1); for (int i=count; i>index; i--) list[i] = list[i-1]; list[index] = value; count++; public Object remove(int index) { Object result = list[index]; count--; for (int i=index; i<count; i++) list[i] = list[i+1]; public int size() { return count; schmiedecke 07 Inf2-6-Testing 8

9 Capacity Increment private int capacityincrement; // set in constructor! public void ensurecapacity (int mincapacity) { if (list.length >= mincapacity) return; int newlength = list.length; while (newlength < mincapacity) newlength += capacityincrement; Object[] newlist = new Object[newLength]; for (int i=0; i<count; i++) newlist[i] = list[i]; list = newlist; There are more eleborate strategies for the increment, e.g. doubling the size every time... schmiedecke 07 Inf2-6-Testing 9

10 Dynamic Lists Flexible Arrays adapt their size to the requirements - requires data copying - works only in lumps - insertion and removal require copying, too. Linked Lists adapt thier size immediately - no copying required. schmiedecke 07 Inf2-6-Testing 10

11 Linked Lists Info1 Info2 Info4 Info5 null Basic operations: addafter removeafter getnext get/setvalue Info3 schmiedecke 07 Inf2-6-Testing 11

12 Type Node public class Node { private Node next; private Element info; public Node() { public Node(Node next, Element info) { this.next = next; this.info = info; public node getnext() { return this.next(); public void addafter(element info) { this.next = new Node(this.next, info); public Element removeafter() { Element info = this.next.info; // NullPointerException! this.next = this.next.next; return info; schmiedecke 07 Inf2-6-Testing 12

13 Linked Stack top null public class Stack { private Node top; public void push(element info) { top = new Node(top, info); public Element pop() throws EmptyException { try { Element info = top.getinfo(); top = top.next(); return info; catch (NullPointerException e) { throw new EmptyException(); schmiedecke 07 Inf2-6-Testing 13

14 first Linked Queue last null null public class Queue { private Node first, last; public void add(element info) { if (last==null) first = last = new Node(null, info); else { last.addafter(info); last = last.getnext(); public Element remove() throws EmptyException { try { Element info = first.getinfo(); first = first.getnext(); if (first==null) last = null; return info; catch (NullPointerException e) { throw new EmptyException(); schmiedecke 07 Inf2-6-Testing 14

15 Anchor Nodes First element requires extra treatment: - predecessor is not a node, but a variable - inserting and removing means changing the variable rather than the predecessors "next" attribute - so addafter and removeafter cannot be applied to it Simplify situation by creating an "artificial" predecessor - call it "anchor node" anchor node will never be removed null schmiedecke 07 Inf2-6-Testing 15

16 top Linked Stack with Anchor Node null public class Stack { private Node top = new Node(null, null); // Anchor node public void push(element info) { top.addafter(info); public Element pop() throws EmptyException { try { return top.removeafter() catch (NullPointerException e) { throw new EmptyException(); schmiedecke 07 Inf2-6-Testing 16

17 Linked Queue with Anchor Node first last null null public class Queue { private Node first=new Node(null,null), last; public Queue() { last = first; // start at anchor node public void add(element info) { last.addafter(info); last = last.getnext(); public Element remove() throws EmptyException { try { return first.removeafter(); catch (NullPointerException e) { throw new EmptyException(); schmiedecke 07 Inf2-6-Testing 17

18 Doubly Linked List info info info info Basic Operations: info addbefore / addafter removebefore / removeafter getnext / get Previous get/setinfo Free navigation, anchor node still useful. schmiedecke 07 Inf2-6-Testing 18

19 Implement List using a Linked List large interface: isempty(), getfirst(), getlast(), addfirst(), addlast(), removefirst(),..., contains(), indexof(),... many conveniance methods all can be mapped to the following basic set of methods: - int size() - void add(int index, Object value) - Object remove(int index) - Object get(int index) schmiedecke 07 Inf2-6-Testing 19

20 Start with an Abstract Implementation public abstract class AbstractList extends List { // size, add, remove, get are left abstract public boolean isempty() { return size()==0; public void addfirst(object value) { add(0, value); public void addlast(object value) { add(size()-1, value); public Object getfirst() { return get(0); public Object getlast() { return get(size()-1); public Object removefirst() { return remove(0); public Object removelast() { return remove(size()-1); public void add(object value) { addlast(value); public Object remove() { return removelast(); public Object get() { return getlast(); public boolean contains(object value) { return indexof(value)!= -1; public int indexof(object value) { for (int i=0; i<size()-1; i++) if (get(i)==value) return i; return 1; schmiedecke 07 Inf2-6-Testing 20

21 Implement a Basic Linked List public class BasicLinkedList { private Node anchor = new Node(null, null); private int size = 0; private Node getnode(int index) { if (index>size-1) throw new IndexOutOfBoundsException(); Node current = anchor; for(int i=0; i<=index; i++) current = current.next; return current; public Object get(int index) { return getnode(index).value; public void add (int index, Object value) { getnode(index-1).addafter(value); size++; public Object remove(int index) { Object result = getnode(index-1).removeafter(); size--; return result; schmiedecke 07 Inf2-6-Testing 21

22 public int indexof(object value) { if (size==0) throw new EmptyException(); Node current = start.next; for (int i=0; i<size; i++) { if (current.info==value) return i; current = current.next; return 1; // more efficient than method in abstract class // required for iterators public Node getanchor() { return anchor; schmiedecke 07 Inf2-6-Testing 22

23 Implement a LinkedList public class LinkedList extends AbstractList { private BasicLinkedList list = new BasicLinkedList(); public Object get(int index) { if (index >= size()) throw new IndexOutOfBoundsException(); return list.get(index); public void add(int index, Object value) { list.add(index,value); public Object remove(int index) { return list.remove(index); public int size() { return size; public int indexof(object value) { return list.indexof(value); // use more efficient method public Node getanchor() { list.getanchor(); schmiedecke 07 Inf2-6-Testing 23

24 Add an Iterator public class IterableLinkedList extends LinkedList{ public Iterator iterator() { return new LLIterator(); // define iterator as inner class class LLIterator implements Iterator { private Node current = getanchor(); public boolean hasnext() { return current!= null && current.next!= null; public Object next() { if (!hasnext()) throw new InvalidIteratorError(); current = current.next; return current.info; schmiedecke 07 Inf2-6-Testing 24

25 ListIterator??? A ListIterator can move forward and backwards. So, it is really only appropriate for doubly linked lists! public interface ListIterator <T> { public boolean hasnext(); public boolean hasprevious(); public T next(); public int nextindex(); public T previous(); public int previousindex(); public void add(t element); public void remove(); // remove current public void set(t element); // replace current Usually, linked lists are doubly linked lists! schmiedecke 07 Inf2-6-Testing 25

26 When to Use Linked Lists? Space: - Linked lists don't keep spare space. - Shrink when list shrinks! - But linking requires some extra space. Efficient, if space requirements are not predictable or vary over time. Time: - No random access, always traversal. - But direct insertion/deletion without moving data Efficient for frequent data insertion or deletion. Inefficient for frequent search operations. schmiedecke 07 Inf2-6-Testing 26

27 Beware of Memory Leaks! 24/7 services need to be restarted regularly. Why? They tend to run out of memory. In "older" languages, you cannot simply "create an object", rather - you must explicitly allocate memory to that object - you must explicitly free that memory when the object is discarded. Forgetting to free object space costs memory on the long run schmiedecke 07 Inf2-6-Testing 27

28 But Java is Different In order to avoid memory leaks, Java objects are freed implicitly by a garbage collector. Simple rule: object has no more references discard. object cannot be freed schmiedecke 07 Inf2-6-Testing 28

29 Linked Structures Always present a danger of memory leaks. even in Java... Be very careful! Delete references manually, if you are not sure that they "disappear" automatically. schmiedecke 07 Inf2-6-Testing 29

30 Local Objects...will "survive" their context if passed to a lasting reference. private int[] temp; public void m1(int[] x) { x = new int[100]; temp = x; call by: m1(myarray); m1(new int[50]); public int[] m2() { int[] local = new int[200]; return local; schmiedecke 07 Inf2-6-Testing 30

31 Example: Look for "Petersen" Enumeration Strategies: Stack vs. Queue Meier Jessen Petersen Hansen Krüger Nielsen Ulldall Clausen Traverse by levels: Add root to queue Klausen Lehmann Müller while queue not empty and target not found: remove node, add subnodes to queue Peters Sanders Traverse by subtrees: Add node to stack; if (target found) return; if (hasleft subtree)traverse left subtree; if (hasright subtree) traverse right subtree; schmiedecke pop; 07 Inf2-6-Testing 31

32 The Coins Game Five Coins of different sizes, ordered upward on the left end of a 5 square board. Aim: move coins to the right end, reversing their order. Use minimum number of moves. Coins may move 1 step in either direction.. Coins may be stacked, but only smaller on bigger ones. Only top of stack coin can move Queue minimum number of moves. WHY? While not finished: Add config to queue; remove config from queue; Add all legal subsequent configs to queue. schmiedecke 07 Inf2-6-Testing 32

33 Ordered Lists Primitive type elements are sorted according to the greater operator > Object elements are sorted using compareto, provided by - the element type, if it implements Comparable - a Comparator object passed to the sorting operation or provided by the List type instance. Two main tasks - sorting a list - keeping a list sorted under modification schmiedecke 07 Inf2-6-Testing 33

34 Implementation Choices: Array List Sorting: - Array provides direct access - use any one of the sorting algorithms Inserting - find insertion point using binary search - possibly extend the array - move down bottom part of the array - insert new value Deleting - possibly, find element using binary search - move up bottom part of the array schmiedecke 07 Inf2-6-Testing 34

35 Implementation Choices Linked List Sorting: - sort by traversing an increasing portion in order to insert current element (insertion sort) - directly insert element Inserting - traverse until position is found - directly insert element Deleting - possibly, traverse to locate element - directly remove element. schmiedecke 07 Inf2-6-Testing 35

36 Implementation Choices Index Tables Organisation: - main list with complex entries - may be multi-dimensional or multiple lists Sorting - Instead of sorting the main list - create an int array of identical length with entries 0..n: an index table - sort the index table according to main list entries - You can hold multiple independant index tables for multiple criteria. Inserting - Add new entry to the end of the main list - resort or invalidate index tables Deleting - set main list entry invalid - compactify main list before the next index table update schmiedecke 07 Inf2-6-Testing 36

37 Index Lookup "Find all patients named "Schmiedecke". Key sorting is not helpful, because we are looking for a record field! For a list - create an index (table) for the name field of the PatientRecord - and keep it sorted - You can create independant indexes for all other record fields! Patient Schmiedecke Patient Jeffers sort Patient Andresen Patient Schmiedecke so the only data moved during sorting are small integers index for "name" schmiedecke 07 Inf2-6-Testing 37

38 Working with an index: In order to enter a record "Schmiedecke" find entry point for "Schmiedecke" in nameindex: private int nameentrypoint(string name) { for (int i=0; i<nameindex.length; i++) { if (table[nameindex[i]] == null) traverse table (table[nameindex[i]].name.greater(name) guided by { return i; nameindex return nameindex.length; // watch out, table is full! // rather use binsearch for efficient lookup!!! Note: the "Schmiedecke" record can be entered in any place in table, e.g. at index 238. This reference index, 238, will be stored innameindex[i], after moving subsequent entries down thenameindex table. schmiedecke 07 Inf2-6-Testing 38

39 Notice on Key Sorting To avoid moving full PatientRecords in order to keep the table key-sorted, you can create an additional sorted index for the key! Note: This technique is standard in database implementations. In relational databases, the user can decide on additional indexes for frequent search criteria. schmiedecke 07 Inf2-6-Testing 39

40 Improving Data Access PatientRecord is a nice application type. But accessing data requires time due to indirection: - it is a reference type containing references - e.g. a name is accessed as table[i].name Column operations like - initializing a column - deleting a column - updating a column require iterating through all PatientRecords. Organize table as array or list of columns rather than a list of records schmiedecke 07 Inf2-6-Testing 40

41 Table as List of Columns TKK /02/1986 Sandmann Sepp 01/05/2007 BKK /06/1999 Schneemann Jutta 12/07/2005 BEK /12/1944 Wassermann Horst 01/06/2007 Table implemented as list of columns. Each column has its data type. Each column may have a name. A PatientRecord is a set of column values with identical index. If you have looked up a column entry, e.g. "Schneemann", its index gives access to the entire PatientRecord. schmiedecke 07 Inf2-6-Testing 41

42 Implementation public class PatientTable { Vector<String> insuranceno = new Vector<String>(); Vector<Date> dateofbirth = new Vector<Date>(); Vector <String> name = new Vector<String>(); Vector<String> firstname = new Vector<String>(); Vector<BloodGroup> bloodgroup = new Vector<BloodGroup>(); Vector<Date> insurancecardread = new Vector<Date>(); Vector[] table = {insuranceno, dateofbirth, name, firstname, bloodgroup, insurancecardread ; schmiedecke 07 Inf2-6-Testing 42

43 Implementation public PatientRecord getpatient(string insurancenumber) { int index = lookupkey(insurancenumber); // using keyindex if (index<0)return null; // not found return new PatientRecord(insuranceNo.get(index), dateofbirth.get(index), name.get(index), firstname.get(index), bloodgroup.get(index), insurancecardread.get(index)); private int lookupkey(string key){ // returns -1 as code for "not found" for (int i=0; i<insuranceno.size(); i++) { if (insuranceno.get(keyindex[i]).equals(key)) return i; if (insuranceno.get(keyindex[i]).greater(key)) return -1; // lookupname, lookupbloodgroup, etc. similar // but use Binsearch instead of linear search!! schmiedecke 07 Inf2-6-Testing 43

44 So, these were the simple, linear data structures. There are some more interesting ones to come, e.g. trees