ADTs,, Arrays, Linked Lists

Transcription

1 1 ADTs,, Arrays, Linked Lists Outline and Required Reading: ADTs ( 2.1.2) Arrays ( 1.5) Linked Lists ( 4.3.1, 4.3.2) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

2 Abstract Data Type (ADT) 2 abstract implementation details are not specified! Abstract Data Type entity that consists of: 1) data structure (DS) 2) set of operation supported on the DS 3) error conditions ADT Data Structure Interface add() remove() find() request result Basic Data Structures array (used in advanced ADT) linked list

3 Abstract Data Type (ADT) (cont.) 3 Data Structure Interface add() remove() find() request result Designer s responsibility: choice of data structure implementation of operations User s requirements: correct performance efficient performance The interior mechanisms of an implemented ADT should be hidden and inaccessible to the user! (Remember encapsulation, i.e. information hiding, OO-programming principle!)

4 Abstract Data Type (ADT) (cont.) 4 Standard ADTs Stacks, Queues, Vectors, Lists, Trees, Why should we know standard ADTs? standard ADTs are great reusable components - can be effectively used in solving many real world problems we may be required to adapt algorithms which use some of the standard ADTs What should we know about standard ADTs? (1) what operations they support (2) complexity of supported operations (3) memory cost of operations

5 ADT Taxonomy 5 Linear ADTs - we call an ADT linear, if the following is true: (1) there is a unique first element (2) there is a unique last element (3) every element has a unique predecessor (except 1 st ) (4) every element has a unique successor (except last) A1 A2 Non-linear ADTs - if one or more of the above is not true, the ADT is non-linear A1 A2 A3 A1

6 Abstract Data Type (ADT) (cont.) 6 Example 1 [ selecting an ADT ] (a) If organizing a tour route, where we have to add/delete a city - use Linked List. (c) If managing a telephone directory that should provide short search times - use Sorted Tree.

7 Array 7 Array sequence of indexed components, with the following general properties: array size is fixed at the time of array s construction int numbers = new numbers [10]; any array component can be efficiently inspected or updated using its index, in O(1) time randomnumber = numbers[5]; numbers[2] = 100; Index = Element at position 5 Array of length 8 Major Limitation size fixed, and must be known in advance

8 Properties of Java Arrays 8 (1) for an array of length n, the index bounds are 0 and (n-1) (2) array elements are stored in side by side memory locations (3) every array is homogeneous - all its components must be of the same type (4) an array is itself an object it is allocated dynamically by means of new it is automatically deallocated when no longer referred to

9 Linked List 9 Linked List sequence of nodes arranged one after another, with each node connected to the next by a link (like a chain) each node is an object containing: 1) a single element - stored object or value 2) links - reference to one or both neighbouring nodes each node (except the last one) has a successor, and each node (except the first one) has a predecessor node A1 head node A2 An tail node element link NOTE: neighbouring nodes can be far away physically!

10 Properties of Linked Lists 10 (1) linked list can be of any length, i.e. it can contain any number of elements, and it can grow (2) the element in any node can be accessed, however we must hold a link to that node (3) nodes can be inserted and deleted ordering of nodes can be changed in minimal running time (4) there are two different types of linked lists Singly Linked List (each node is linked to one of its neighbours) Doubly Linked List (each node is linked to both of its neighbours)

11 Object Reference 11 Reference Variable contains the location (address) of an object when we declare a reference variable, it does not reference anything, i.e. it is initialized to null if we attempt to use a reference variable before initiating an object for it, NullPointerException will be thrown Integer intref; intref = new Integer(5); Reference intref Reference intref null 5 Integer Object

12 Object Reference (cont.) 12 Declaring Reference Variables Integer p, q; p q Allocating an Object p = new Integer(5); p 5 Allocating Another Object p = new Integer(6); 5 p marked for garbage collection 6 Assigning a Reference q = p; p q 6

13 Object Reference (cont.) 13 Allocating an Object q = new Integer(9); p q 6 9 Assigning null to a Reference Variable p = null; p q marked for garbage collection 6 9 Assigning a Reference with a null Value q = p; p q null 9 marked for garbage collection

14 Singly Linked List 14 Singly Linked List each node contains a data-element together with a link to its successor A1 head node A2 An tail node SLLNode public class SLLNode { Object element; SLLNode next; public SLLNode(Object elem, SLLNode succ) { } this.element = elem; this.next = succ; } Reference variables!

15 Singly Linked List (cont.) 15 SLLNode Complying with Requirements hidden and inaccessible public class SLLNode { private Object element; private SLLNode next; public SLLNode(Object elem, SLLNode succ) { this.element = elem; this.next = succ; } public Object getelement() { return element; } public SLLNode getnext() { return next; } public void setelement(object newelement){ element = newelement; } public void setnext(sllnode newnext){ next = newnext; } }

16 Singly Linked List (cont.) 16 Creating and Linking Two SLLNodes SLLNode n = new SLLNode(new Integer(5), null); n 5 SLLNode first = new SLLNode(NewInteger(9), n) n first 5 9 SLLNode n = new SLLNode(NewInteger(9), n) n 5 9 Should, in the 2 nd case, the first node be collected by the garbage collection!?

17 Singly Linked List (cont.) 17 SLL A1 A2 An-1 An head tail public class SLL { private SLLNode head; private SLLNode tail; public SLL() { this.head = null; this.tail = null; } Constructs an empty linked list! It is a good practice to maintain direct references to head and tail; with them: 1) easy to delete or insert new node at the front of SLL; 2) easy to insert new node at the rear. But, it is still costly to delete the end node. Why?!

18 Singly Linked List (cont.) 18 Adding New Node at the Rear of SLL with Reference to Head Only! A1 A2 An head curr public class SLL { } private SLLNode head;... public void addlast(sllnode newnode){ SLLNode curr; if (head==null) head=newnode; else { } for (curr = head; curr.getnext()!= null; curr=curr.getnext()){ }; curr.setnext=newnode; }

19 Singly Linked List (cont) 19 Example 1 [ SLL traversal ] public void traversesll() { for (SLLNode curr = head; curr!= null; curr = curr.getnext()) { System.out.print(curr.element + ); } } Example 2 [ deletion of 1 st SLL node ] public void deletefirst() {... head = head.next; } A1 A2 head

20 Singly Linked List (cont) 20 Example 3 [ deletion of 1 st SLL node, with memory management ] public void deletefirst() {... } curr = head; head = head.next; curr.setnext(null); curr = null; A1 A2 marked for garbage collection head

21 Singly Linked List (cont) 21 Example 4 [ deletion of SLL node after node referenced by prev ] public void delete(sllnode prev) {... } SLLNode curr = prev.getnext(); prev.setnext(curr.getnext()); curr.setnext(null); curr = null; A1 Ak Ak+1 head prev marked for garbage collection Ak+2

22 Singly Linked List (cont) 22 Example 5 [ insertion of SLL node after node referenced by prev ] public void insert(object element) {... } SLLNode curr = prev.getnext(); SLLNode newnode = new SLLNode(element, curr); prev.setnext(newnode); Ak+1 A1 Ak Ak+1 head prev

23 Doubly Linked List 23 Doubly Linked List each node contains an element together with a link to its predecessor and a link to its successor A1 A2 An DLLNode public class DLLNode { private Object element; private DLLNode prev, next; public DLLNode(Object elem, SLLNode pred, DLLNode succ) { this.element = elem; this.prev = pred; this.next = succ; } }

24 Arrays vs. Single- and Double- Linked Lists 24 Guidelines for Choosing Between an Array and a Linked List ADT Requirement frequent random access operations add/remove at a cursor add/remove at a two-way cursor frequent capacity changes Suggested Implementation Use an array. Use a singly linked list. Use a doubly linked list. Use a linked list.

25 Questions 25 Q.1 Suppose, in your program, you have been using a collection of numbers, which has been stored in an array of size 1000, named intcollection. (int intcollection = new int[1000];) However, you do not need this collection any longer, and you want to free the memory. What should you do? Q.2 Examine the following code, and determine how the corresponding SLL (the sequence of SLL s elements) looks like. SLLNode c = new SLLNode( not to be, null); SLL phrase = SLL(); phrase.head = new SLLNode( to be, new SLLNode( or, c) ); Q.3 Repeat Examples 1 to 5 for Doubly Linked List. Q.4 Write a short program that swaps the 1 st and 2 nd node of a) a singly linked list (SLL) b) a doubly linked list (DLL)