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

2. 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

3. 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)

4. 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

5. Linked List: Some Properties
Consider the following linked list

6. Linked List: Some Properties
Now consider the statement
current = head;

7. Linked List: Some Properties
Now consider the statement
current = current.link;

8. Linked List: Some Properties

9. 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

10. 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
System.out.println(current.info + “ “);

11. 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;

12. Insertion Consider the following linked list
We want to create a new node with info 50 and insert it after p

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

14. 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

15. 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

16. Insertion
Using two reference variables, we can simplify the code somewhat
Consider the following
List with reference variables p and q

17. Insertion The following statements insert newNode between p and q or
newNode.link = q;
p.link = newNode; or
The order in which these statements execute does not matter

18. Insertion p.link = newNode; newNode.link = q; List after the statement
p.link = newNode; executes
List after the statement
newNode.link = q; executes

19. Deletion Consider the following linked list
We want to delete node with info 34

20. 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

21. Deletion Previous statement removed the node
However, the memory may still be occupied by this node
System’s automatic garbage collector reclaims memory occupied by unreferenced nodes
Could use System.gc(); to manually run the garbage collector

22. 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();

23. 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

24. 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

25. 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

26. 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;
num = input.nextInt(); //next read
return first;

27. 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

28. 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;

29. Linked List as an ADT
UML class diagram of the interface LinkedListADT

30. 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

31. 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

32. Structure of Linked List Nodes
UML class diagram of the class LinkedListNode
and the outer-inner class relationship

33. Instance Variables of the Class LinkedListClass
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

34. 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

35. class LinkedListClass
UML class diagram of the class LinkedListClass

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

37. Unordered Linked List
UML class diagram of the class UnorderedLinkedList
and the inheritance hierarchy

38. Ordered Linked Lists UML class diagram of the class OrderedLinkedList
and the inheritance hierarchy

39. 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;
... }

40. 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