Linked List. ape hen dog cat fox. tail. head. count 5

Transcription

1 Linked Lists

2 Linked List L tail head count 5 ape hen dog cat fox Collection of nodes with a linear ordering Has pointers to the beginning and end nodes Each node points to the next node Final node points to null Can only traverse list in one direction

3 ListNode An instance of the ListNode class represents a single node in a linked list. A node consists of the item field for a data item and the next field that links to the next node in the list. class ListNode { private E item; private ListNode next; } public ListNode(E item) { this.item = item; this.next = null; }

4 Java NPSList ADT /** * This interface defines the List ADT */ public interface NPSList<E> { } public void add(e item); public void add(int index, E item) throws IndexOutOfBoundsException; public void clear( ); public boolean contains(e item); public E get(int index) throws IndexOutOfBoundsException; public int indexof(e item); public boolean isempty( ); public E remove(int index) throws IndexOutOfBoundsException; public boolean remove(e item); public E set(int index, E item) throws IndexOutOfBoundsException; public int size( );

5 Java NPSLinkedList Class public class NPSLinkedList<E> implements NPSList<E> { /** Flag for not finding the specified element */ public static final int NOT_FOUND = -1; /** The pointer to the first node in the list */ private ListNode head; /** The pointer to the last node in the list */ private ListNode tail; /** The number of elements in the list */ private int count;...

6 Appending an Element tail cat fox ant

7 Appending an Element tail cat fox ant

8 Appending an Element tail cat fox ant

9 Appending an Element tail cat fox ant

10 List add(e item) /** * Adds an item to end of the list. * item an item to add. */ public void add( E item ) { //creates a new ListNode ListNode newnode = new ListNode(item); } if (isempty()) { head = tail = newnode; } else { tail.next = newnode; tail = newnode; } count++;

11 Deleting the First Element L tail head count 5 ape hen dog cat fox

12 Deleting the First Element head ape hen dog cat fox

13 Deleting the First Element head ape hen dog cat fox

14 List remove() public Object remove(int index) throws IndexOutOfBoundsException { ListNode deletenode; ListNode ptr = head; if (index == 0) { //removing the first node deletenode = ptr; head = head.next; if (head == null) { //removed first node is the only node tail = null; } } else {... // more stuff here... } } count--; return deletenode.item;

15 Deleting the 3rd Element L tail head count 5 ape hen dog cat fox

16 Deleting the 3rd Element ptr head ape hen dog cat fox

17 Deleting the 3rd Element ptr head ape hen dog cat fox

18 Deleting the 3rd Element ptr head ape hen dog cat fox

19 Deleting the 3rd Element ptr deletenode head ape hen dog cat fox

20 Deleting the 3rd Element ptr deletenode head ape hen dog cat fox

21 List remove() public Object remove(int index) throws IndexOutOfBoundsException { ListNode deletenode; ListNode ptr = head; if (index == 0) {... // other stuff here... } else { for (int i = 1; i < index; i++) { ptr = ptr.next; } deletenode = ptr.next; ptr.next = deletenode.next; } if (ptr.next == null) { //very last node was removed tail = ptr; //we have a new last node } } count--; return deletenode.item;

22 Performance Most operations are O(n) because their cost is bounded by the length of the list Array Linked add(i, obj) remove(obj) contains(obj) O(1) O(n) O(n) O(n) O(n) find location update search update search O(n) O(1) O(n) O(1) O(n) find location update search update search get(i) O(1) find location O(n) find location

23 Doubly Linked List L tail head count 5 ape hen dog cat fox Has pointers in both directions prev & next Added complexity to code but added flexibility in use Can traverse the list in either direction and change directions using next or previous pointers

24 Circularly Linked List L tail head count 5 ape hen dog cat fox How do you know when you have been through the list? Use the pointer to the current node and check to see if it is pointing to the head again OR, keep some count of how many elements are in the list total and how many have been traversed