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. 06/09/22
44
Embed
Chapter 9: Linked Lists Learn about linked lists. Learn about doubly linked lists. Get used to thinking about more than one possible implementation of.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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.
04/21/23
Reading
• Bailey Chapter 9
04/21/23 CS2007, Dr M. Collinson
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.
04/21/23 CS2007, Dr M. Collinson
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 bat cat
header null linknode element link
04/21/23 CS2007, Dr M. Collinson
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.
04/21/23 CS2007, Dr M. Collinson
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
04/21/23 CS2007, Dr M. Collinson
04/21/23
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. 04/21/23 CS2007, Dr M. Collinson
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.
04/21/23 CS2007, Dr M. Collinson
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).
04/21/23 CS2007, Dr M. Collinson
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 NullPointerException).
• 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)
04/21/23 CS2007, Dr M. Collinson
A Java Class of Nodes• Nodes for a linked list (of strings).
class SLLNode {String element; // data fieldSLLNode next; // next field
• 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).
04/21/23 CS2007, Dr M. Collinson
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;
}
04/21/23 CS2007, Dr M. Collinson
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 ArrayList to get first element. Slower to get other elements
04/21/23 CS2007, Dr M. Collinson
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).
04/21/23 CS2007, Dr M. Collinson
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.next; } }
04/21/23 CS2007, Dr M. Collinson
How remove works
• start pred at first node• advance pred index-1 times to get to node before
deletion • assign pred.next = pred.next.next
– to bypass the node to delete (44)
– any node with no reference to it is garbage collected04/21/23 CS2007, Dr M. Collinson
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 ArrayList– Faster to remove first element.
04/21/23 CS2007, Dr M. Collinson
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).
04/21/23 CS2007, Dr M. Collinson
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
04/21/23
Adding to Beginning of a List• Adding 11 at index = 0 (the beginning):
– BEFORE
– AFTER:
04/21/23 CS2007, Dr M. Collinson
Pseudocode for Adding to Beginning
• if (index == 0) // add to beginning of list– Create newNode as a new SLLNode with data– Assign newNode.next = first– Assign first = newNode
04/21/23
Adding to Middle/End of List
• Adding 55 at index = 2– Before:
– After
04/21/23
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 newNode as a new SLLNode with data– Assign newNode.next = pred.next– Assign pred.next = newNode
04/21/23
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 newNode = new SLLNode(s, pred.next); // create, link to rest of listpred.next = newNode; } } // link prior to newNode
04/21/23 CS2007, Dr M. Collinson
List implementation: comparison
Array Single LL
Get(index) O(1) O(N)
Get(0) O(1) O(1)
Get(last) O(1) O(N)
Insert/remove O(N) 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 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 ratcat
dog
04/21/23 CS2007, Dr M. Collinson
Doubly-linked List
• Advantages– Fast access to beginning and end of list– Can traverse forwards or backwards
• See Malik for details on algorithms
04/21/23 CS2007, Dr M. Collinson
A Java Class for DLL Nodes
• Java class implementing DLL nodes:
class DLLNode {String data;DLLNode predecessor, next;