Programming II (CS300)

Transcription

1 1 Programming II (CS300) Chapter 07: Linked Lists MOUNA KACEM Spring 2019

2 Linked Lists 2 Introduction Linked List Abstract Data Type SinglyLinkedList ArrayList Keep in Mind

3 Introduction: General Linked List 3 This chapter introduces how to: Declare the Abstract Data Type (ADT) Linked List Define the most commonly Operations for General Linked Lists Implement a General Linked List The basic Linked List consists of a collection of connected, dynamically allocated nodes or items of the same type linkedlist null item next item next item next

4 Introduction: General Linked List 4 A linked list contains a collection of data items of the same type that are stored in different objects referred as nodes Each node consists of two fields: A data item field : stores or refers to the data value A reference to an object of the same type This reference is used to connect to the next node in the list node linkedlist null item next item next data item Reference to the next node in the list

5 LinkedNode 5 public class LinkedNode<T>{ // Fields private T item; // item data field of any type T private LinkedNode<T> next; // reference to the next node in the list // Constructors... // Methods... } // end generic class LinkedNode node linkedlist null item next item next data item Reference to the next node in the list

6 Linked List Abstract Data Type 6 public interface ListADT<T> { // List of Operations public void add(t newobject); public void add(int index, T newobject); public boolean contains(t findobject); public boolean isempty(); public int size(); public int indexof(t findobject); public T get(int index); public T remove(int index); } // end ListADT generic interface T refers to AnyType

7 7 /** * LinkedList class represents a reference-based implementation of ADT list. <author> */ public class LinkedList<T> implements ListADT<T> { private LinkedNode<T> head; of type<t> public LinkedList<T>() { head = null; } // end default constructor /** // entry point reference to linked list of items * TODO Implementation of the interface ListADT declared methods */ } // end LinkedList class

8 8 public void add(t newobject); // inserts newobject at the end of the linked list 1. Create a NewNode that contains newobject as data field 2. If the list is empty, insert the newnode at the head of the list 3. Otherwise, insert the newnode at the end of the list

9 9 public void add(t newobject); // inserts newobject at the end of the linked list The list is empty 35 newnode: head:

10 10 public void add(t newobject); // inserts newobject at the end of the linked list The list is empty newnode: head: 35

11 11 public void add(t newobject); // inserts newobject at the end of the linked list The list is empty (summary diagram) newnode: 1 3 head: head: 35 2

12 12 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: newobject: 35 runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

13 13 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: 35 runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

14 14 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: 35 runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

15 15 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: 35 runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

16 16 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: 35 runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

17 17 public void add(t newobject); // inserts newobject at the end of the linked list List is not empty newnode: runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

18 18 public void add(t newobject); // inserts newobject at the end of the linked list The list is not empty (summary diagram) newnode: Traverse the list runner: 3 2 head: runner: a pointer of type LinkedNode<T> used to traverse the list

19 19 public void add(int index, T newobject); Precondition: 0 index list.size() If index < 0 or index > size() error (throw an exception or display an error message) Otherwise, create a newnode (instance of LinkedNode) that contains the newobject as item data field If index == 0 insert the newnode at the head of the list If index == size() insert the newnode at the end of the list If index > 0 and index < size() insert newnode in the middle of the list at the index position

20 20 public void add(int index, T newobject); Case3: 0 < index < list.size() Index: 3-3 newnode: runner: inx = 0 inx = 1 indices: head: runner initialized to head : a pointer of type LinkedNode<T> used to traverse the list inx an integer initialized to 0 : the index of the node pointed by runner in the list

21 21 public void add(int index, T newobject); Case3: 0 < index < list.size() Index: 3 newnode: -3 indices: runner: inx = 1 inx = head: runner initialized to head : a pointer of type LinkedNode<T> used to traverse the list inx an integer initialized to 0 : the index of the node pointed by runner in the list

22 22 public void add(int index, T newobject); Case3: 0 < index < list.size() Index: 3 inx == index -1 newnode: -3 indices: runner: inx = head: X runner initialized to head : a pointer of type LinkedNode<T> used to traverse the list inx an integer initialized to 0 : the index of the node pointed by runner in the list

23 public void add(int index, T newobject); Case3: 0 < index < list.size() 23 Summary Diagram newnode: Index: Traverse the list until inx = index runner: 4 3 inx = 2 indices: head: X runner initialized to head : a pointer of type LinkedNode<T> used to traverse the list inx an integer initialized to 0 : the index of the node pointed by runner in the list

24 24 public void add(int index, T newobject); Case3: 0 < index < list.size() Index: 3 newnode: runner: indices: head: runner initialized to head : a pointer of type LinkedNode<T> used to traverse the list inx an integer initialized to 0 : the index of the node pointed by runner in the list

25 25 public boolean contains(t findobject); If the list is empty return false Otherwise (list is not empty) define a runner (a reference to a LinkedNode object) to traverse the list and look for the first node whose data item matches with findobject initialize runner to the head of the list traverse the list looking for a much with findobject while runner!= null && there is no match go to the next node in the list if the findobject is found return true if the list is entirely traversed without finding a match, return false runner: a pointer of type LinkedNode<T> used to traverse the list

26 26 List not empty findobject: 10 is runner.getitem().equals(findobject)? No runner: head: runner: a pointer of type LinkedNode<T> used to traverse the list

27 27 List not empty Example findobject: 10 is runner.getitem().equals(findobject)? runner: Yes return true head: runner: a pointer of type LinkedNode<T> used to traverse the list

28 28 public int indexof(t findobject); Initialize index of type int to -1 if list is empty return index Otherwise define a runner (a reference to a LinkedNode object) to traverse the list and look for the first node whose data item matches with findobject initialize runner to the head of the list and increment index traverse the list looking for a much with findobject while runner!= null && there is no match go to the next node in the list and increment index if the findobject is found return index if the list is entirely traversed without finding a match, return -1 runner: a pointer of type LinkedNode<T> used to traverse the list

29 29 public T get(int index); Precondition: 0 index < list.size() if index < 0 or index >= size() error (throw an exception or return null) Otherwise (list is not empty and index in the range of the list indices) define a runner (a reference to a LinkedNode object) to traverse the list looking for the node of index index initialize runner to the head of the list and inx of type int to 0 while inx < index go to the next node in the list (runner = runner.getnext()) and increment inx return runner.getitem() runner: a pointer of type LinkedNode<T> used to traverse the list

30 30 public T remove(int index); Precondition: 0 index < list.size() if index < 0 or index >= size() error (throw an exception or return null) Otherwise (list is not empty and index in the range of the list indices) We distinguish two cases Case1: index == 0 : return the item at the head of the list, then remove the node at the head Case2: Index > 0 and index <= size() -1 : remove the item stored at index position of the list and return it

31 31 public T remove(int index); Case1: List not empty and index == 0 : remove the node at the head of the list 1 2 remove the node at the head of the list 3 item = head.getitem(); head = head.getnext(); return item 1 item: 18 head: X head:

32 32 public T remove(int index); Case3: List not empty and index > 0 and index <= size -1 : remove a node other than the head To remove a node from the list (at a given index not zero), we need a pointer to its previous node Use a runner to reach the node of index index - 1 Initialize runner to head and inx of type int to 0 While inx < index 1, go to the next node (runner = runner.getnext()) and increment inx item = runner.getnext().getitem(); remove the node at the position index the list: runner.setnext(runner.getnext().getnext()); return item head: runner: a pointer of type LinkedNode<T> used to traverse the list

33 33 public T remove(int index); Case2: (Example) List not empty and index > 0 and index == size -1 : remove the node at the end (tail) of the list Index: 4 1 runner: inx = 0 indices: 2 runner: inx = 1 Traverse the list to reach the node of index index-1 2 runner: inx = 2 2 runner: inx = head: X Get the item at runner.getnext() and Remove runner.getnext() Return item 3 item = runner.getnext().getitem(); item: 35 3 runner: a pointer of type LinkedNode<T> used to traverse the list

34 34 public T remove(int index); Case2 (general case): List not empty and index > 0 and index <= size -1 : remove a node at the middle of the list Index: Traverse the list to reach the node of index index-1 3 Get the item at runner.getnext() // remove runner.getnext() runner.setnext(runner.getnext().getnext()) return item runner: inx = 0 indices: runner: 2 3 item = runner.getnext().getitem(); item: 78 inx = head: 18-5 X runner: a pointer of type LinkedNode<T> used to traverse the list 3

35 Practice Examples 35 Declare the ListADT<T> interface Implement the generic LinkedNode<T> class Implement the linked list of Integers class public class LinkedList implements ListADT<Integer> Test the implementation Implement the generic linked list SinglyLinkedList<T> class public class SinglyLinkedList<T> implements ListADT<T> Test the SinglyLinkedList class implementation considering different types T Implement the generic class ArrayList<T> implements ListADT<T>

36 Doubly Linked Lists 36 The singly linked list does not efficiently support some important operations For instance, it is time consuming to go to the end of the list Singly linked lists cannot implement retreat method which allows one backward move at the time while traversing a list A doubly linked list allows bidirectional traversal by storing two links per node Each node now has two links (next and prev) prev node: -5

37 Doubly linked lists 37 Searching and traversing the list can easily be performed in both directions Doubly linked lists allow to move up just as easily as down in the list to insert after as well as before a node at a given position (index) Insertion (add) and removal (remove) operations involve twice as many link changes as for a singly linked list. head: : tail

38 Circular Linked List 38 In a circularly linked list, the last node s next link references the first one in the list (i.e. the head of the list) The circular list is useful when we want searching to allow wraparound head:

39 Keep in Mind 39 A linked list represents a collection (that may be empty) of connected, dynamically allocated nodes (known as linked nodes) A linked node of a singly linked list must contain a reference to a node of the same type. This reference is used to connect to the next node in the list To add a node at the middle of a singly linked list, we need a reference to the previous node We need a reference to the node at the prior position to the one that we want to insert To remove a node from a singly linked list other than the head of the list, we need a reference to the node prior to the node that we want to remove To remove an item or object that we don t know the index, we can make use of the method indexof which returns the position (index) of an item in the linked list

40 Keep in Mind 40 Doubly linked list allows bidirectional traversal of the list A doubly linked node has two links: a reference to the next node and a reference to the previous node in the list Insertion and deletion operations are more easy with doubly linked lists, but ensure more link changes compared to a singly linked list Common error while implementing linked list operations: NullPointerException! Methods should not be allowed to access fields via a null reference