Chapter 9 Linked Lists Learn about linked lists

  • Slides: 44
Download presentation
Chapter 9: Linked Lists • Learn about linked lists. • Learn about doubly linked

Chapter 9: Linked Lists • Learn about linked lists. • Learn about doubly linked lists. • Get used to thinking about more than one possible implementation of a data structure. • Think about the advantages and disadvantages of different implementations. 3/9/2021

Reading • Bailey Chapter 9 3/9/2021 CS 2007, Dr M. Collinson

Reading • Bailey Chapter 9 3/9/2021 CS 2007, Dr M. Collinson

Linked lists: the idea • A linked list is a set of items where

Linked lists: the idea • A linked list is a set of items where each item is part of a node that may also contain a single link to another node. • Allow one to insert, remove and rearrange lists very efficiently. 3/9/2021 CS 2007, Dr M. Collinson

Linked lists: data structure • A linked list consists of a sequence of nodes

Linked lists: data structure • A linked list consists of a sequence of nodes connected by links, plus a header. • Each node (except the last) has a next node, and each node (except the first) has a predecessor. • Each node contains a single element (object or value), plus links to its next. ant header 3/9/2021 node bat element cat link CS 2007, Dr M. Collinson null link

More about linked lists • The length of a linked list is the number

More about linked lists • The length of a linked list is the number of nodes. • An empty linked list has no nodes. • In a linked list: – We can manipulate the individual elements. – We can manipulate the links, • Thus we can change the structure of the linked list! • This is not possible in an array. 3/9/2021 CS 2007, Dr M. Collinson

Points to Note • Last element may use a special link called the null

Points to Note • Last element may use a special link called the null link. • Different implementations of linked lists. • Different forms: – Circular lists: `last’ item linked to `first’. – Cyclic: `last’ item linked to one of its predecessors. – Acyclic: not cyclic. 14506 – Nodes sometimes drawn: ant 3/9/2021 CS 2007, Dr M. Collinson

3/9/2021

3/9/2021

Linked Lists vs. Arrays • Size of linked list can be variable! – Arrays

Linked Lists vs. Arrays • Size of linked list can be variable! – Arrays have fixed size. • Re-arrangement of items in a linked list is (usually) faster. • Access to elements is slower in a LL. 3/9/2021 CS 2007, Dr M. Collinson

References • Many languages use references or pointers to implement linked lists. • This

References • Many languages use references or pointers to implement linked lists. • This is the case in Java, where references are pointers to objects. See Malik, chapter 3. • A node consists of a variable for the data it carries (which may be done via a reference), and a variable which is a reference to its next. 3/9/2021 CS 2007, Dr M. Collinson

Pitfalls with Pointers • You should be aware that programming with references is very

Pitfalls with Pointers • You should be aware that programming with references is very powerful, but can be tricky. • Aliasing: `If two variables contain references to the same object, the state of the object can be modified using one variable’s reference to the object, and then the altered state can be observed through the reference in the other variable. ’ (Gosling, Joy, Steele, The Java Language Specification). 3/9/2021 CS 2007, Dr M. Collinson

Null • The last node of a linked list is a reference, but it

Null • The last node of a linked list is a reference, but it is the null reference that refers to nothing! • If some operation tries to use the object that the null ref. points to then an exception is raised (in Java Null. Pointer. Exception). • Not always easy to ensure all of these are caught. • `I call it my billion-dollar mistake. It was the invention of the null reference in 1965. … This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years. ’ (Prof. Sir C. A. R. Hoare) 3/9/2021 CS 2007, Dr M. Collinson

A Java Class of Nodes • Nodes for a linked list (of strings). class

A Java Class of Nodes • Nodes for a linked list (of strings). class SLLNode { String element; // data field SLLNode next; // next field // Constructor SLLNode (String elem, SLLNode next. Node) { this. element = elem; this. next = next. Node; } } 3/9/2021 CS 2007, Dr M. Collinson

Java class: linked list with header • Implementing linked list of SLLNodes: class Str.

Java class: linked list with header • Implementing linked list of SLLNodes: class Str. Linked. List { SLLNode first; // Header refers to first node // Constructor for empty list Str. Linked. List () { this. first = null; } } 3/9/2021 CS 2007, Dr M. Collinson

Example of list creation list = new Str. Linked. List(); SLLNode cat. Node =

Example of list creation list = new Str. Linked. List(); SLLNode cat. Node = new SLLNode(“cat”, null); SLLNode bat. Node = new SLLNode(“bat”, cat. Node); SLLNode ant. Node = new SLLNode(“ant”, bat. Node); list. first = ant. Node; ant 3/9/2021 bat CS 2007, Dr M. Collinson cat

What happens? • System. out. println(list. first. data); • System. out. println(list. first. next.

What happens? • System. out. println(list. first. data); • System. out. println(list. first. next. data); • System. out. println( list. first. next. data ); 3/9/2021 CS 2007, Dr M. Collinson

Example of list traversal • Add method (to class Str. Linked. List) to traverse

Example of list traversal • Add method (to class Str. Linked. List) to traverse list. Prints all elements in first-to-last order. • Note clever Boolean condition on while loop. Commonly used trick. Such methods may not always terminate -- for example on lists with cycles. void print. First. To. Last () { SLLNode current = this. first; while (current != null) { System. out. println(current. data); current = current. next; } return; } 3/9/2021 CS 2007, Dr M. Collinson

Array lists: retrieve/get • get(index): return the data at the specified index. • Speed

Array lists: retrieve/get • get(index): return the data at the specified index. • Speed does not depend on the size of the array or the index. Therefore get is O(1). 3/9/2021 CS 2007, Dr M. Collinson

Linked lists: Retrieval • Get item at given position index. String get(int index) {

Linked lists: Retrieval • Get item at given position index. String get(int index) { SLLNode current = this. first; for (int count = 0; count++; count < index) current = current. next return current. data; } 3/9/2021 CS 2007, Dr M. Collinson

Time complexity • Time complexity: takes index+1 steps. – O(1) to get first element

Time complexity • Time complexity: takes index+1 steps. – O(1) to get first element – O(N) to get last element – O(N) to get randomly chosen element. • Same complexity class (= roughly the same speed) as Array. List to get first element. Slower to get other elements 3/9/2021 CS 2007, Dr M. Collinson

Array lists: remove (deletion) • remove(index): remove the element at the index. Shuffle everything

Array lists: remove (deletion) • remove(index): remove the element at the index. Shuffle everything to the right of the index (but not the index itself) back one position. Decrement size (N). • Best case: last element (1 assignment). • Worst case: first element (N+1 assignments). • In general: 1 + N – index assignments. • Average case: O(N). 3/9/2021 CS 2007, Dr M. Collinson

Linked lists: deletion of node. • Idea: Re-wire the picture of linked list, cutting-out

Linked lists: deletion of node. • Idea: Re-wire the picture of linked list, cutting-out X, the node at given position index. • That is, find predecessor of X in the list; call this pred. Then change next of pred to be next of X. (To remove first node, change ref. to first field in header class). void remove(int index) { if (index == 0) first = first. next; else { SLLNode pred = first; for (int count = 0; count < index-1; count++) pred = pred. next; // for-loop ends here pred. next = pred. next; } } 3/9/2021 CS 2007, Dr M. Collinson

How remove works • start pred at first node • advance pred index-1 times

How remove works • start pred at first node • advance pred index-1 times to get to node before deletion • assign pred. next = pred. next – to bypass the node to delete (44) – any node with no reference to it is garbage collected 3/9/2021 CS 2007, Dr M. Collinson

Time Complexity: Linked List Removal • Same speed as retrieval (get) – O(N) on

Time Complexity: Linked List Removal • Same speed as retrieval (get) – O(N) on average, O(1) to remove first element – Most of the time is used to find the predecessor. • Same average speed as Array. List – Faster to remove first element. 3/9/2021 CS 2007, Dr M. Collinson

Arrays lists: Add • Add(index, element): add an element to a list at a

Arrays lists: Add • Add(index, element): add an element to a list at a given index. Add one to the length (size) of the array(N), shuffle everything from the index onward one position to the right. – Best case (index = last element): 2 assignments. – Worst case (first element): N + 2 assignments. – In general, 2+ (N-index) assignments. – Average O(N). 3/9/2021 CS 2007, Dr M. Collinson

Adding to a Linked List • Adding at beginning: O(1) – special case in

Adding to a Linked List • Adding at beginning: O(1) – special case in Add method • Adding at end: O(N) – general case in Add method – uses a pointer variable to traverse list 3/9/2021

Adding to Beginning of a List • Adding 11 at index = 0 (the

Adding to Beginning of a List • Adding 11 at index = 0 (the beginning): – BEFORE – AFTER: 3/9/2021 CS 2007, Dr M. Collinson

Pseudocode for Adding to Beginning • if (index == 0) // add to beginning

Pseudocode for Adding to Beginning • if (index == 0) // add to beginning of list – Create new. Node as a new SLLNode with data – Assign new. Node. next = first – Assign first = new. Node 3/9/2021

Adding to Middle/End of List • Adding 55 at index = 2 – Before:

Adding to Middle/End of List • Adding 55 at index = 2 – Before: – After 3/9/2021

Psuedocode for Adding to Middle/End • • if (index == 0) // add to

Psuedocode for Adding to Middle/End • • if (index == 0) // add to beginning of list. . . // already shown. . . else – assign pred to first node – advance pred through list index-1 times • so it now points to node before insertion point – Create new. Node as a new SLLNode with data – Assign new. Node. next = pred. next – Assign pred. next = new. Node 3/9/2021

Java code for Insertion/Add • Idea: re-wire picture so that predecessor of node N

Java code for Insertion/Add • Idea: re-wire picture so that predecessor of node N at given index points to the new node, and new node points to N. Very similar to remove. • Same speed as get(. . ) for LL: O(N) on average, O(1) to add first element. void add(int index, String s) { if (index == 0) first = new SLLNode(s, first); // Add to beginning else { // Add to middle or end SLLNode pred = first; for (int count = 0; count < index-1; count++) // advance pred to node prior pred = pred. next; SLLNode new. Node = new SLLNode(s, pred. next); // create, link to rest of list pred. next = new. Node; } } // link prior to new. Node 3/9/2021 CS 2007, Dr M. Collinson

List implementation: comparison Array Single LL Get(index) O(1) O(N) Get(0) O(1) Get(last) O(1) O(N)

List implementation: comparison Array Single LL Get(index) O(1) O(N) Get(0) O(1) Get(last) O(1) O(N) Insert/remove O(N) Ins/rem first O(N) O(1) Ins/rem last O(1) O(N)

Doubly-linked lists • A doubly-linked list (DLL) consists of a sequence of nodes, connected

Doubly-linked lists • A doubly-linked list (DLL) consists of a sequence of nodes, connected by links in both directions. • Each DLL node contains a single element, plus links to the node’s next and predecessor (or null link(s)). • The DLL header contains links to the DLL’s first and last nodes (or null links if the DLL is empty). pig dog 3/9/2021 CS 2007, Dr M. Collinson cat rat

Doubly-linked List • Advantages – Fast access to beginning and end of list –

Doubly-linked List • Advantages – Fast access to beginning and end of list – Can traverse forwards or backwards • See Malik for details on algorithms 3/9/2021 CS 2007, Dr M. Collinson

A Java Class for DLL Nodes • Java class implementing DLL nodes: class DLLNode

A Java Class for DLL Nodes • Java class implementing DLL nodes: class DLLNode { String data; DLLNode predecessor, next; // Constructor } DLLNode(String elem, DLLNode pred, DLLNode succ) { this. data = elem; this. next = succ; this. predecessor = pred; } 3/9/2021 CS 2007, Dr M. Collinson

A Java Class for Doubly-linked Lists class DLL { DLLNode first, last; } //

A Java Class for Doubly-linked Lists class DLL { DLLNode first, last; } // Constructor for an empty DLL () { this. first = null; this. last = null; } 3/9/2021 CS 2007, Dr M. Collinson

Example DLL construction // set-up doubly-linked list = new DLL(); DLLNode cat. Node =

Example DLL construction // set-up doubly-linked list = new DLL(); DLLNode cat. Node = new DLLNode("cat", null); DLLNode bat. Node = new DLLNode("bat", null, cat. Node); DLLNode ant. Node = new DLLNode("ant", null, bat. Node); cat. Node. predecessor = bat. Node; bat. Node. predecessor = ant. Node; list. first = ant. Node; list. last = cat. Node; 3/9/2021 CS 2007, Dr M. Collinson

Speed of list implementation Array Single LL Double LL Get(index) O(1) O(N) Get(0) O(1)

Speed of list implementation Array Single LL Double LL Get(index) O(1) O(N) Get(0) O(1) Get(last) O(1) O(N) O(1) Insert/remove O(N) Ins/rem first O(N) O(1) Ins/rem last O(1) O(N) O(1)

Which to use? • Which implementation should we use? • Depends on how we

Which to use? • Which implementation should we use? • Depends on how we are going to use the list – Frequency of get, add, remove. – Usually at beginning or end of list, or can be anywhere? 3/9/2021 CS 2007, Dr M. Collinson

Efficiency of Stack implementations Array Single LL Double LL Get(last) O(1) O(N) O(1) Ins/rem

Efficiency of Stack implementations Array Single LL Double LL Get(last) O(1) O(N) O(1) Ins/rem last O(1) O(N) O(1) • Array or DLL better than SLL. • Array marginally faster than DLL.

Efficiency: Queue/Dequeue Array Single LL Double LL Get(0) O(1) Get(last) O(1) O(N) O(1) Ins/rem

Efficiency: Queue/Dequeue Array Single LL Double LL Get(0) O(1) Get(last) O(1) O(N) O(1) Ins/rem first O(N) O(1) Ins/rem last O(N) O(1) » DLL better for Dequeue » Note: there is a clever array-implementation which is fast: Array. Deque in Java.

(Space) Memory Efficiency • Linked lists need a bit of extra space for the

(Space) Memory Efficiency • Linked lists need a bit of extra space for the links. • Array lists waste space if array bigger than list. • Not a huge difference 3/9/2021 CS 2007, Dr M. Collinson

Implementation Time • Easy to do using Java Collections Framework: – java. util. Linked.

Implementation Time • Easy to do using Java Collections Framework: – java. util. Linked. List. • If implementing directly: – Linked lists generally very easy, just add a “next” field to the objects that hold data. – Array lists more complex, have to deal with copying to bigger array. – Linked list widely used in languages without collection classes (core C, Pascal). 3/9/2021 CS 2007, Dr M. Collinson

Summary • Linked lists are an alternative way of implementing lists to array lists

Summary • Linked lists are an alternative way of implementing lists to array lists • In most cases Array. List (Array. Deque) faster – Although Linked. List better in a few cases • Linked list easier to implement directly. 3/9/2021 CS 2007, Dr M. Collinson

Java Linked. List • List Interface: – http: //download. oracle. com/javase/1. 4. 2/docs/a pi/java/util/List.

Java Linked. List • List Interface: – http: //download. oracle. com/javase/1. 4. 2/docs/a pi/java/util/List. html • Linked. List class – http: //download. oracle. com/javase/1. 4. 2/docs/a pi/java/util/Linked. List. html 3/9/2021 CS 2007, Dr M. Collinson