Linked Lists. It s all connected

Transcription

1 Linked Lists It s all connected

2 Linked list: a data structure used to represent an ordered list Consists of a sequence of nodes A node consists of a data item and a reference to the next node -- the connecting reference is called a link Links keep nodes in sequence Last node s link is assigned null Entire list is accessed via the first node in the list, usually called the head node 2

3 Linked Lists vs. Arrays Arrays: indexed, so random-access relatively difficult to keep data ordered; insertion and deletion relatively costly Linked Lists: access via reference to start; no random access relatively easy to keep ordered; insertion and deletion relatively efficient

4 Node structure public class Node { private int data; private Node link; Data type is for data member declared as int as an example could be any type Node contains a reference to itself -- actual use is as reference to another Node 4

5 Portrait of a linked list List begins with head node keeps track of list front may or may not contain data; if it doesn t, it s a dummy node A list may also have a tail node to keep track of the end of the list could also be a dummy 5

6 Portrait of a linked list Head and tail nodes illustrated here are pointers to the first and last nodes in the list, respectively tail head 10 data 15 data 7 data NULL link link link 6

7 Accessing list members Every node has a link through which it can be accessed this is the link member of the previous node For example, in the list from the previous slide, head.link refers to the second node in the list the data in the first node is head. data head.link.data is a reference to the data in the second node 7

8 Operations on Nodes Constructor: creates Node with specified data and link Accessors & mutators for data and link 8

9 Constructors public Node(int initialdata, Node initiallink) { data = initialdata; link = initiallink; public Node () { data = 0; link = null; 9

10 Accessors & Mutators public int getdata () { return data; public void setdata (int newdata) { data = newdata; public Node getlink() { return link; public void setlink (Node newlink) { link = newlink; 10

11 Operations on Linked Lists Inserting a node at the front at any position other than the front Removing a node from the front from any other position Removing all nodes 11

12 More Operations on Linked Lists Finding the length of a list Finding a target value in a list Finding a value at a specified position in a list Making a copy of a list Making a copy of part of a list 12

13 Inserting a Node a List Front The great advantage of working at the front of the list is: we have a built-in reference here (head pointer) We can simply construct the new node with the data we want to add as the first argument and the existing head pointer as the second argument The next slide illustrates the process

14 Inserting data at front of list Example: adds node containing 4 to front of list: head = new Node(4, head); 4 data link head 10 data 15 data 7 data link link null link

15 Inserting data elsewhere in list If a tail pointer is used, insertion at list end is as simple as at start, but every other position requires a little more work A linked list, unlike an array, does not provide a random access mechanism to data in the middle The easiest way to insert a node in the middle of list is to simply invoke the insert at head routine, recognizing that every node is the head pointer of a list of nodes that follow it (think recursively!) The difficulty comes in getting access to the before node to act as head pointer we ll look at this after illustrating the insertion method

16 Insertion in the middle Example: adds node containing 8 between 10 & 15: before.setlink(new Node(8, before.getlink()); 4 data head link before 10 data 15 data 7 data link link null link

17 But where do we get before? List traversal, that s how Traversing the list means proceeding through the list, starting at the front, and visiting each node in turn This operation is the basis for all of the search functions on a list, including finding the list length We ll look at the length-finding operation first

18 Code for listlength public static int listlength(node head) { Node cursor; int answer; answer = 0; for (cursor = head; cursor!= null; cursor = cursor.getlink()) answer++; return answer; linklist2 18

19 Finding a target value in a list Traverse list, using same strategy as in listlength method If target is found, return its node If target is not found and cursor reaches end of list, return null linklist2 19

20 Code for listsearch public static Node listsearch(node head, int target) { Node cursor = null; for (cursor = head; cursor!= null && target!= cursor.getdata(); cursor = cursor.getlink()); return cursor; linklist2 20

21 Finding value at specific location Traverse list to current position, or until cursor is null Return value of cursor once list has been traversed linklist2 21

22 Code for listposition public static Node listposition(node head, int position) { Node cursor; int i; if (position <= 0) throw new IllegalArgumentException ("position is not positive"); cursor = head; for (i = 1; (i < position) && (cursor!= null); i++) cursor = cursor.getlink(); return cursor; linklist2 22

23 Removing a node Again, this is easiest to do at the front of the list Removal from the middle of a list involves a process similar to the one we used to insert in the middle

24 Removing the Head Node Removal of the first node is easily accomplished with the following instruction: head = head.getlink(); head null 24

25 Removing the Head Node Here s what the linked list looks like after the removal finishes. Automatic garbage collection takes care of removing the node that is no longer part of the list head_ptr null 25

26 Removing a Node from elsewhere in the list If we want to remove a node from somewhere besides the front of the list, the process is a bit more complicated As with list insertion, the key idea is to make sure that we never lose our grip on the rest of the list while we re making changes to a particular node Again, we will assume for the moment that we already have a reference to the node previous to the one we want to remove 26

27 Removing a node that is not at the head As with insertion, we could accomplish this task with an instruction like the following: previous_ptr.setlink (previous_ptr.getlink().getlink()); or by using the method in the Node class: public void removenodeafter( ) { link = link.link; 27

28 Copying a Linked List: How not to do it Because we always have a reference to a head pointer, it s tempting to try copying a list using just the insertion technique we already know: Node newlist = null; for (Node cursor = head; cursor!= null; cursor = cursor.getlink()) newlist = new Node (cursor.getdata(), newlist); linklist2 28

29 A better way The code on the previous slide will traverse the original list (referenced by head) and copy all of the nodes, but they will end up in reverse of their original order A better way involves using a tail pointer for the new list, adding each new node after the last node instead of before the first one The listcopy method is presented on the next slide linklist2 29

30 Code for listcopy public static Node listcopy(node source) { Node copyhead; Node copytail; if (source == null) return null; copyhead = new Node(source.data, null); copytail = copyhead; while (source.link!= null) { source = source.link; copytail.addnodeafter(source.data); copytail = copytail.link; return copyhead; linklist2 30

31 Copying a list with a tail reference As mentioned before, it is sometimes useful to keep track of both the head and tail of a linked list Unfortunately, Java doesn t permit us to have more than one return value from a method or does it? Not really, but kind of we can return an array from the method, and that array can contain multiple values linklist2 31

32 Copying list with tail reference public static Node[ ] listcopywithtail(node source) { Node copyhead; Node copytail; Node[ ] answer = new Node[2]; if (source == null) return answer; copyhead = new Node(source.data, null); copytail = copyhead; while (source.link!= null) { source = source.link; copytail.addnodeafter(source.data); copytail = copytail.link; answer[0] = copyhead; answer[1] = copytail; return answer; linklist2 32

33 Copying part of a linked list Sometimes we only need a portion of a linked list, rather than a copy of the entire list The listpart method, shown on the next slide, handles this situation The two parameters, start and end, are references to the beginning and end of the part of the list we wish to copy linklist2 33

34 listpart method public static Node[ ] listpart(node start, Node end){ Node copyhead; Node copytail; Node cursor; Node[ ] answer = new Node[2]; copyhead = new Node(start.data, null); copytail = copyhead; cursor = start; // continued on next slide linklist2 34

35 listpart continued while (cursor!= end) { cursor = cursor.link; if (cursor == null) throw new IllegalArgumentException ("end node was not found on the list"); copytail.addnodeafter(cursor.data); copytail = copytail.link; answer[0] = copyhead; answer[1] = copytail; return answer; linklist2 35

36 Bag ADT using linked list Invariant: Items are stored in a linked list of Nodes; member variable head refers to the beginning of the list Member variable manynodes stores the current size of the Bag (in # of nodes) linklist2 36

37 List-based Bag vs. Array-based Bag In the list-based version of the Bag, most of the same methods are defined, but with different implementations An exception is the ensurecapacity method; since a linked list can grow and shrink easily (without the need to make a temporary copy of a data array) For this implementation, a new method is added for the heck of it: the grab() method returns a random value from the Bag s contents linklist2 37

38 Bag member methods Default constructor: creates empty bag Code: public Bag ( ) { head=null; manynodes=0; linklist2 38

39 Clone() method Like the array-based bag, the linked list version implements the Cloneable interface, and thus must provide a clone() method Code shown on next slide linklist2 39

40 Clone method public Object clone( ) { Bag answer; try { answer = (Bag) super.clone( ); catch (CloneNotSupportedException e) { throw new RuntimeException ("This class does not implement Cloneable"); answer.head = Node.listCopy(head); return answer; linklist2 40

41 Remove method Strategy is similar to removal of target value from an array With array, we copied the last index s data into the slot occupied by the target value, then decremented used With linked list, we ll copy the head Node s data value into the target Node, then remove the head Node linklist2 41

42 Code for remove method public boolean remove(int target) { Node targetnode; targetnode = Node.listSearch(head, target); if (targetnode == null) return false; else { targetnode.setdata(head.getdata( )); head = head.getlink( ); manynodes--; return true; linklist2 42

43 countoccurrences method Strategy: create local variable (cursor) that refers to a Node use listsearch to find the target value, and assign its return value to cursor If cursor isn t null, count one occurrence Continue process until cursor becomes null linklist2 43

44 Code for countoccurrences public int countoccurrences(int target) { int answer = 0; Node cursor; cursor = Node.listSearch(head, target); while (cursor!= null) { answer++; cursor = cursor.getlink( ); cursor = Node.listSearch(cursor, target); return answer; linklist2 44

45 Add methods Since Bag is unordered ADT, follow path of least resistance and insert all items at front of list We follow this procedure for add(), addmany(), and addall() (next several slides) linklist2 45

46 add method public void add(int element) { head = new Node(element, head); manynodes++; linklist2 46

47 addmany method public void addmany(int... elements) { for (int i : elements) add(i); linklist2 47

48 addall method public void addall(bag addend) { Node[ ] copyinfo; if (addend.manynodes > 0) { copyinfo = Node.listCopyWithTail(addend.head); copyinfo[1].setlink(head); head = copyinfo[0]; manynodes += addend.manynodes; linklist2 48

49 The union method Creates a new Bag that is the union of two other bags Method is static so that it can be applied to any two Bag objects (and has no effect on either one) linklist2 49

50 Code for union public static Bag union(bag b1, Bag b2) { Bag answer = new Bag( ); answer.addall(b1); answer.addall(b2); return answer; linklist2 50

51 But wait, there s more! Doubly-linked lists Singly-linked lists have one major limitation: you can only traverse the list in one direction A variation on the linked list: linking each node to its previous neighbor as well as its next neighbor makes bi-directional list traversal possible linklist2 51

52 Modified class definition for doublylinked list public class Node { private int data; private Node link; // link to next Node private Node back; // link to previous Node linklist2 52

53 Methods that must be modified constructor addnodeafter remove linklist2 53

54 Constructors for doubly-linked list public Node (int d, Node b, Node n) { data = d; back = b; link = n; public Node ( ) { this (0, null, null); linklist2 54

55 addnodeafter method Strategy is similar to singly-linked addnodeafter, but with the additional complication that the node has two links Important thing to remember: make links before you break them! linklist2 55

56 Code for add method public void addnodeafter (Node previous, int entry) { Node n = new Node(entry, previous, null); n.link = previous.getlink(); if (previous.link!= null) previous.link.back = n; previous.link = n; linklist2 56