Linked Lists

Based on D.S. Malik, Java Programming: Program Design Including Data Structures

Linked Lists
Linked list
List of items, called nodes The order of the nodes is determined by the address, called the link, stored in each node

Every node (except the last node) contains the address of the next node Components of a node
data/info: stores the relevant information link: stores the address of the next node

Linked Lists
head or first
Holds the address of the first node in the list

The info part on the node can be either a value of a primitive type or a reference to an object Class Node
Represents nodes on a list It has two instance variables
info (of type int, but it can be any other type) link (of type Node)

Linked Lists
Class Node
public class Node { public int info; public Node link; }

Notice that instance variables of the class Node are declared as public

Linked List: Some Properties

Consider the following linked list

Linked List: Some Properties

Now consider the statement
current = head;

Linked List: Some Properties

Now consider the statement
current = current.link;

Linked List: Some Properties

Traversing a Linked List

Basic operations of a linked list that require the link to be traversed
Search the list for an item Insert an item in the list Delete an item from the list

You cannot use head to traverse the list

Why? You would lose the nodes of the list. Use another reference variable of the same type as head: current

Traversing a Linked List

The following code traverses the list
current = head; while (current != null){ //Do something - process current current = current.link; }

Example: The following code outputs the data /in each node
current = head; while (current != null){ System.out.println(current.info + ); current = current.link; }

10

Item Insertion and Deletion

Consider the following definition of a node
public class Node { public int info; public Node link; }

And the following variable declaration

Node head, p, q, newNode;

11

Insertion
Consider the following linked list

We want to create a new node with info 50 and insert it after p

12

Insertion
The following statements create and store 50 in the info field of a new node
newNode = new Node(); newNode.info = 50; //create newNode //store 50 in the new node

13

Insertion (continued)
The following statements insert the node in the linked list at the required place
newNode.link = p.link; p.link = newNode;

The sequence of statements to insert the node is very important

If you reverse the sequence of the statements, you will not get the desired result

14

Insertion
newNode.link = p.link; p.link = newNode;

List after the statement newNode.link = p.link; executes

List after the statement p.link = newNode; executes

15

Insertion
Using two reference variables, we can simplify the code somewhat Consider the following

List with reference variables p and q

16

Insertion
The following statements insert newNode between p and q
newNode.link = q; p.link = newNode;

or
p.link = newNode; newNode.link = q;

The order in which these statements execute does not matter

17

Insertion
p.link = newNode; newNode.link = q;

List after the statement p.link = newNode; executes

List after the statement newNode.link = q; executes

18

Deletion
Consider the following linked list

We want to delete node with info 34

19

Deletion

The following statement removes the node from the list

p.link = p.link.link

List after the statement p.link = p.link.link; executes

20

Deletion
Previous statement removed the node
However, the memory may still be occupied by this node

Systems automatic garbage collector reclaims memory occupied by unreferenced nodes Could use System.gc(); to manually run the garbage collector

21

Deletion
Using two reference variables, you can simplify the code somewhat Consider the following statements
q = p.link; p.link = q.link; q = null; System.gc();

22

Deletion (continued)
q = p.link; p.link = q.link;

List after the statement q = p.link; executes

List after the statement p.link = q.link; executes

23

Building a Linked List

You can build a list in two ways: forward or backward Forward manner
A new node is always inserted at the end of the linked list

Backward manner
A new node is always inserted at the beginning of the linked list

24

Building a Linked List Forward

A new node is always inserted at the end of the linked list You need three reference variables
One to point to the front of the list
Cannot be moved without destroying the list

One to point to the last node of the list One to create the new node

25

Building a Linked List Forward

Node buildListForward(){ Node first, newNode, last; int num; System.out.println(Enter integers (999 to stop):); num = input.nextInt(); //priming read first = null; while (num != 999) { newNode = new Node(); newNode.info = num; newNode.link = null; if (first == null) { //empty list first = newNode; last = newNode; } else { last.link = newNode; last = newNode; } num = input.nextInt(); //next read } return first; }

26

Building a Linked List Backward

A new node is always inserted at the beginning of the linked list You only need two reference variables
One to point to the front of the list
Changes each time a new node is inserted

One to create the new node

27

Building a Linked List Backward

Node buildListBackward(){ Node first, newNode; int num; System.out.println (Enter integers (999 to stop):); num = input.nextInt(); //priming read first = null; while (num != 999) { newNode = new Node(); //create a node newNode.info = num; //store the data in newNode newNode.link = first; //put newNode at the beginning first = newNode; //update the head of the list num = input.nextInt();//next read } return first; }

28

Linked List as an ADT

UML class diagram of the interface LinkedListADT

29

Linked List as an ADT

There are two types of linked lists: sorted (ordered) and unsorted (unordered) The algorithms to implement some of the operations differ for sorted and unsorted lists Therefore, define the LinkedListClass as an abstract class LinkedListClass has two derived classes
UnorderedLinkedList OrderedLinkedList

30

Structure of Linked List Nodes

Each node of a linked list must keep track of the data as well as the next node in the list The node has two instance variables The class LinkedListNode is defined as an inner class of LinkedListClass
Simplify operations such as insert and delete

LinkedListNode is defined as protected and generic

31

Structure of Linked List Nodes

UML class diagram of the class LinkedListNode and the outer-inner class relationship

32

Instance Variables of the Class LinkedListClass

Instance variables
protected LinkedListNode<T> first; //variable to store the address of the first node protected LinkedListNode<T> last; //variable to store the address of the last node protected int count; //variable to store the number of nodes in the list

33

Linked List Iterators

UML class diagram of the class LinkedListIterator and the outer-inner class relationship NOTE: An iterator is an object that produces each element of a

collection one element at a time

34

class LinkedListClass

UML class diagram of the class LinkedListClass

35

class LinkedListClass
Definition of the class LinkedListClass
public abstract class LinkedListClass<T> implements LinkedListADT<T> {
//Place //Place //Place //Place //Place the definition of the class LinkedListNode<T> here. the definition of the class LinkedListIterator<T> here. instance variables here the definition of the nonabstract methods here the definition of the abstract methods here.

36

Unordered Linked List

UML class diagram of the class UnorderedLinkedList and the inheritance hierarchy

37

Ordered Linked Lists

UML class diagram of the class OrderedLinkedList and the inheritance hierarchy

38

Double Linked Lists

Linked list in which every node has a next pointer and a back pointer A double linked list can be traversed in either direction
public class DoubleLinkedListNode<T> implements Cloneable{ T info; DoubleLinkedListNode<T> next; DoubleLinkedListNode<T> back; ... }

39

Circular Linked Lists

A linked list in which the last node points to the first node It is convenient to make first point to the last node

Circular linked list with more than one node

40