Presentation is loading. Please wait.

Presentation is loading. Please wait.

Chapter 22 Implementing lists: linked implementations.

Similar presentations


Presentation on theme: "Chapter 22 Implementing lists: linked implementations."— Presentation transcript:

1 Chapter 22 Implementing lists: linked implementations

2 This chapter discusses n Linked lists u lists built through object references. u dynamic lists. u linked implementations of structures more complex than a simple sequence.

3 A linked list implementation n If the list is not empty u there is a first element u there is a last element u every element (except the last) has a successor u every element (except the first) has a predecessor

4 A linked list implementation (cont.) n An array structure is built by creating a reference to the collection of list elements which are stored sequentially in memory. n A linked list is built by creating a reference to a node of the list that, in turn contains a reference to another node of the list, etc.

5 LinkedList class public abstract class LinkedList implements Cloneable { … private class Node { /** * Create a Node containing specified element. * / public Node (Object element) { this.element = element; this.next = null; } Object element; Node next; }

6 LinkedList class (cont.) public abstract class LinkedList implements Cloneable { /** * Create a Node containing specified element. * / protected LinkedList () { size = 0; first = null; } … private int size; private Node first; }

7 LinkedList class (cont.)

8 The component next of the last Node always has a value of null. For the empty list, the LinkedList component first is null.

9 LinkedList methods: get public Object get (int i) { Node p = first; int pos = 0; while (pos < i) { p = p.next; pos = pos + 1; } return p.element; }

10 LinkedList methods: get (cont.) The variable p is initialized with a reference to the 0-th Node of the list.

11 LinkedList methods: get (cont.) Each iteration of the loop assigns p a reference to the next element of the list and increments pos.

12 LinkedList methods: get (Cont). Loop invariant: p references the Node containing the element with index pos. n At loop termination pos == i p references the Node we are looking for.

13 LinkedList methods: append n First, find the last element of list

14 LinkedList methods: append (cont.) n Create a new Node containing the element to be appended n Set the old last Nodes next component to reference the new Node. public void append (Object obj) { if (this.isEmpty()) first = new Node(obj); else { Node p = first; while (p.next != null); p = p.next; p.next = new Node(obj); } size = size + 1; }

15 LinkedList methods: remove n First, find the Node in front of the one we want to delete.

16 LinkedList methods: remove (cont.) Take next of the Node before the one to be deleted and reference it the same as the next field of the Node to be deleted.

17 LinkedList methods: remove (cont.) Since p.next is the Node to be deleted, p.next cannot be null. n Removing the first element of the list is a special case.

18 LinkedList methods: remove (cont.) public void remove (int i) { if (i == 0) { first = first.next; else { Node p = first; int pos = 0; while (pos < i-1) { p = p.next; pos = pos + 1; } p.next = p.next.next; } size = size - 1; }

19 LinkedList methods: add

20 LinkedList methods: add (cont.) public add (int i, Object obj) { Node newElement = new Node(obj); if (i == 0) { newElement.next = first; first = newElement; } else { Node p = first; int pos = 0; while (pos < i-1) { p = p.next; pos = pos + 1; } newElement.next = p.next; p.next = newElement; } size = size + 1; }

21 LinkedList methods: get, append, remove, and add all require linear time on average. n Deleting the first element and inserting a new first element, are constant time operations. n We must be particularly careful of boundary cases: cases involving u the empty list u a list with one element u the first or last element of a list These may well require explicit handling.

22 LinkedList variations A simple change will make append a constant time operation. We keep a reference to both the first and last elements in the list.

23 LinkedList variations (cont.) public append (Object obj) { Node newElement = new Node(obj); if (this.isEmpty()) first = newElement; else last.next = newElement; last = newElement; size = size + 1; }

24 LinkedList variations (cont.) remove must now check explicitly for the case in which the last element is deleted. public void remove (int i) { if (size == 1) { // remove the only element first = null; last = null; } else if (i == 0) { // remove the first element first = first.next; }

25 LinkedList variations (cont.) else { Node p = first; int pos = 0; while (pos < i-1) { p = p.next pos = pos + 1; } p.next = p.next.next; if (i == size-1) //last element removed last = p; } size = size - 1; }

26 Header nodes n One way to eliminate special cases is to employ a header node. It contains no element, but is always present at the front of the list. i.e. it is referenced by first.

27 Header nodes (cont.) private class Header extends Node { public Header () { this.element = null; this.next = null; } The LinkedList constructor creates the header. protected LinkedList () { size = 0; first = new Header(); last = first; }

28 Header nodes (cont.) n The method append, need not check explicitly for the empty list. public append (Object obj) { Node newElement = new Node(obj); last.next = newElement; last = newElement; size = size + 1; }

29 Circular lists n In a circular list, the last node references the first. n A circular list may or may not have a header. n We can traverse the entire list starting from any node. n Care must be taken to avoid infinite iterations or recursions.

30 Doubly-linked lists n Each node contains references to the preceding as well as to the following node.

31 Doubly-linked lists (cont.) n Three components: u the list elements u references to its two neighboring nodes. public abstract class DoublyLinkedList implements Cloneable {… private int size; private Node header; private class Node { public Node (Object element) { this.element = element; this.next = null; this.previous = null; } Object element; Node next; Node previous; }

32 Doubly-linked lists (cont.) protected DoublyLinkedList () { size = 0; header = new Header(); header.next = header; header.previous = header; }

33 Doubly-linked lists (cont.) n Operations are a bit more complicated since we have two references in each node, but the combination of a circular structure and a header eliminates the need for handling most boundary cases explicitly.

34 DoublyLinkedList : append n Set previous of the new node to reference the old last node. n Set next of the new node to reference the header. n Set previous of the header to reference the new node. n Set next component of the old last node to reference the new node.

35 DoublyLinkedList : append (cont.) public void append (Object obj) { Node newElement = new Node(obj); Node last = header.previous; newElement.next = header; newElement.previous = last; last.next = newElement; header.previous = newElement; size = size + 1; }

36 Linked list limitations n Accessing elements by index is a linear time operation. The get operation is linear. Therefore, any operation using the get method will be slower than in an array-based implementation. public boolean contains (List list, Object obj) { int n = list.size(); int i = 0; while (i < n && !obj.equals(list.get(i)) i = i + 1; } return i < n; }

37 Linked list limitations (cont.) This method can be implemented without get. public boolean contains (LinkedList list, Object obj) { Node p = list.first; while (p != null && !obj.equals(p.element)) p = p.next; } return p != null; }

38 Dynamic storage allocation n automatic allocation: memory space for automatic variables is allocated when the method is invoked, and reclaimed (deallocated) when the method completes. n Memory space for array elements is allocated when the array is created. n For a linked implementation, space required for a node is allocated when the node is created.

39 Garbage collection n Dynamically allocated space that can no longer be accessed is termed garbage. n If we create an object and then loose all references to the object, the memory space occupied by the object becomes garbage.

40 Garbage collection (cont.) n The Java run-time system or interpreter continuously looks for garbage and reclaims the space (garbage collection). n Many programming languages do not include garbage collection as part of their run-time systems. n They require programs to deallocate explicitly dynamically allocated space. n In an object-oriented environment, it is often difficult to know when an object no longer is accessible.

41 Garbage collection (cont.) n Dangling references are references to space that has been reclaimed mistakenly. n Such references result in errors that often are extremely difficult to track down.

42 Weve covered n Linked structures u nodes u headers n Doubly-linked lists n Circular lists n Time complexities n Dynamic storage allocation u garbage collection

43 Glossary

44 Glossary (cont.)


Download ppt "Chapter 22 Implementing lists: linked implementations."

Similar presentations


Ads by Google