Chapter 11

Linked Data Structures: Linked

Lists
1 Analogy
When you are waiting in line for a movie or at a bank, the ordering of the line is maintained by
physical contiguity. That is, you know where you are in the overall ordering by your physical
position in the queue. When a person in front of you leaves the line, you move up physically, and if
someone breaks into the line ahead of you, you may have to step back. Thus changes in the line
affect not only where you are in line, but your physical location as well.
The waiting line at an (admittedly idealized) barbershop is very different. A customer enters the
shop, picks up an old copy of Field and Stream, and sits down in an empty chair. The location of
the seat has nothing to do with the ordering. When the barber is ready for the next customer, only
that one person moves. And while the order of the waiting line is completely and unambiguously
maintained, no individual in the shop may know the entire ordering. How does this work?
For simplicity, lets assume a shop with only one barber. The shop opens and the first customer, say
Joe, enters. Since no one is waiting, Joe immediately sits in the barber chair and begins to get his
hair cut. Then a new customer, Sue, enters. Joe notes that Sue is to be next. Sue sits and begins to
read, but keeps an eye on the door. To maintain the proper waiting order, she wants to make sure
that she gets served before whoever enters the shop next. Then Bill arrives. Sue notes that Bill
follows her. She can now devote her entire attention to the magazine while Bill sits down and
watches the door. Next, Alice enters. Bill notes that Alice is next; Alice watches the door. Finally,
Pat enters. Alice notes that Pat is next; Pat now assumes the door watch. This all can be shown
graphically as follows.

Joe

Sue

Bill

Alice

2001 Donald F. Stanat and Stephen F. Weiss

Pat

door

Chapter 11

Linked Lists

Page 2

When Joe finishes with his haircut, he gets up and tells Sue to take his place in the chair. Note that
only Sue has to move; none of the other customers needs to change seats in order to maintain the
ordering. If all customers follow this discipline, the correct ordering will be maintained even
though no one person knows the complete ordering. For example, Alice knows that Pat follows
her, and that Sue and Bill were in the shop before she arrived, but she does not know the ordering
of Sue and Bill.

2 Linked Lists
A sequence whose structure is maintained as a collection of items, each of which contains a pointer
to the next item, is called a linked list. The most common form of a linked list has three important
features:
1. There is a provision for finding the first entry of the list. In the barbershop, the first entry
in the current list is the one in the barber chair. Anyone entering the shop would know very
little about the complete ordering of customers, but would know that the person in the
chair is at the head of the list.
2. Each entry in the list keeps track explicitly of its successor. Thus, some local information
about the structure of the list is kept with each entry of the list. The information specifying
a successor is called a pointer or a link.
3. The last entry of the list has no successor. This is represented by a special pointer value
-- a pointer value that doesn't point to anything.
Each element of a linked list is called a node, and each node contains at least two kinds of data: an
entry of the data sequence (e.g., the customers in a queue) and the structure information that
specifies (for each entry of the data sequence) which node comes next. The global structure of the
list need not be (and generally is not) stored anywhere, it is distributed throughout the list and
consists of the collection of local information in the form of pointers.
The distribution of the list structure information through the list has some advantages and
disadvantages. For example, getting to the tenth element of an array is easy because we can access
it directly using the array index. But getting to the tenth element of a linked list requires that we
start at the beginning and trudge down ten entries, following the link at each one. On the other
hand, insertion into the middle of a list stored in an array requires that we shift some of the array
entries, while an insertion into the middle of a linked list requires only changes to adjacent entries
in the list. In this chapter, we will look at various forms of linked lists, at their implementations,
and at the algorithms to maintain and manipulate them.
Arrays are structures that give immediate access to any component. Thus, to access any entry of an
array, one needs only know the address of the array, the description of its structure (the number of
dimensions, and the number of index values along each dimension) and the size of each entry. This
information is all specified in the definition of an array, and is used to provide (1) access to each
entry of the array. Arrays are called implicit data structures because the structure of an array (that
is, how to access its component parts) is specified by the array definition; no structure information
appears in the array itself. Implicit data structures have the advantage of providing quick access to
the parts of a data structure, but the disadvantage that the structure is fixed.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 3

In contrast, data in which structure information is itself part of the data is called an explicit data
structure. Explicit data structures generally require more storage because of the structure
information they include, but they provide a flexibility that is lacking in the implicit structures.
Explicit data structures are commonly used in combination with dynamic storage allocation,
which provides additional storage on demand during program execution. The combination of
linked structures and dynamic storage allocation makes possible data structures that are not fixed
and, in fact, can grow and change during program execution. An example of such an explicit data
structure is the linked list, in which each entry in a sequence is stored in a node along with
information about which node contains the next sequence entry; thus, the information that
determines the list structure is distributed throughout the data structure.
Linked lists and other linked structures can be implemented in a variety of ways, including with
arrays. But array implementation of linked list is not truly dynamic; the list can grow and shrink,
but only within the bounds of the array. We will focus instead on truly dynamic data structures.
Two programming language features are needed in order to implement linked lists. First is a data
structure that can be dynamically allocated whenever and in whatever quantity needed. And
second is a pointer to link one list node to another. In some programming languages, there are
special dynamically allocated data structures and a special pointer data type, but in Java we use
features that we already know and love: classes and references. Linked list nodes will be objects
of a Node class; pointers will be references to other Node objects. In this chapter, well see how to
build explicit data structures of any description. We'll first describe the simplest of these structures,
the linked list, which itself comes in a variety of forms.

3 Description of a linked list

Good programming requires a familiarity with the tools and materials that can be used to solve
problems. Many problems involve some form of sequence, and in Chapter 8 we saw how arrays
can be used to implement bounded sequences. Sequences can also be implemented using linked
lists. The two implementations have very different properties, and commonly the application at
hand makes one implementation a clear choice over the other. Understanding how to make the
choice requires that we understand the properties of a linked list.1
A linked list is similar in some ways to a treasure hunt: a sequence of clues (nodes) with each clue
indicating the position of the next clue. And like a treasure hunt, we need a couple of additional
items to complete the implementation. First, we need to know where to find the first clue. In the
linked list, this is called the head pointer: a special pointer to the first node in the list. And second,
we need to be able to recognize the end of the list. A treasure hunt ends when we find the treasure,
which we recognize not only because of its value, but also because it has no pointer to another
clue. In a linked list, the last node is distinguished because its associated pointer has a special
pointer value, called null, that is recognizable as pointing nowhere. The figure below represents a
sequence of names implemented as a linked list. When implemented in Java, each node of the list
will occupy a chunk of memory that will contain a string (the name contained in the node) and a
pointer (reference) to the next node. Unlike an array, the physical location of the nodes of the
1 Actually, the linked list is itself an abstraction. There are several other ways to implement linked lists.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 4

linked list is irrelevant to the list of names; the structure of the list is completely determined by the
pointers.
Sue
Joe

head

Alice
Bill
Pat

nul
l

A linked list of names

If the list of names were empty, the value of the pointer variable head would be null.

head

null

The empty linked list of names

In summary, the simplest form of a linked list consists of a head pointer, and a set of zero or more
nodes. Each node has two fields: a data field that contains one element of the sequence being
implemented, and a link field that contains either an explicit pointer to the unique node containing
the successor of the data field, or the distinguished value null, indicating that the node is the last
one of the linked list. Every node but one (the last one) has exactly one successor, and every node
but one (the first one) is the successor of another node. No two nodes have the same successor;
and no node is its own successor.

4 Working with linked lists

In later sections of this chapter we will describe how to create and manipulate linked lists in Java,
but using linked structures is difficult, and we'll spend this section giving an intuitive description of
some basic algorithms to manipulate linked lists.
The basis for most linked structure manipulation is one or more pointers 2 that are used to point to
particular nodes of the structure. We move through the structure by following the pointers of the
nodes. We'll illustrate this by considering the problem of displaying the contents of a sequence
implemented as a linked list. Scanning a linked list from beginning to end uses a pointer (here
called p) that initially points to the first node of the list and works its way through the list, pointing
to each node in turn so that it can be displayed. After pointing to the last node, p will be set to null,
indicating the list has been traversed, and providing our loop exit condition. The body of the loop
consists of
Display the value of the node pointed to by p, and
2 In Java we will implement linked list pointers with references. However, we prefer to use the word "pointer"

when talking about linked lists as an abstraction.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 5

Advance p to point to the next node by assigning p the value of the pointer in the
node it is pointing to.
Pointer p is initially given the value of the list head, called head in the figures above. Thus p is
initially equal to null (in which case the list is empty), or it starts out pointing at the first node. This
completes the algorithm. The complete informal algorithm to display the elements of a linked list is
shown below. As with a sequential scan of an array, scanning a linked list of size n is a (n)
operation.
//Displaythecontentsofthelistpointedtobyhead.
//Pre:true
//Post:Alltheelementsofthelisthavebeendisplayed,inorder.
//Setptopointatfirstnodeifitexists,andnullotherwise.
p=head;
while(true)
{
//Inv:Thelistofvaluesinnodesthatprecedethenode
//pointedtobyphavebeendisplayed.
if(p==null)break;
displaythevalueofthedatafieldofthenodecurrently
pointedtobyp.
//Advanceptopointatthenextnode
p= thevalueinthepointerfieldofthenodecurrently
pointedtobyp
}

The ADT Sequence operation elem(i) returns the value of the ith entry in the sequence. If a
sequence is implemented as an array, elem(i) is both simple and fast (its a (1) operation).
Accessing the ith element of a linked list neither so easy nor so quick. Since our only entry into a
linked list is through the head, getting to the ith element requires that we start at the head and go
sequentially through the first i-1 elements to get to the ith. The informal algorithm is shown below.
//Displaytheithentryofthelistpointedtobyhead.
//Pre:0<=iandthelisthasatleasti+1entries.
//Post:Theithelementofthelisthasbeendisplayed.
//Setptopointatfirstnode.
p=head;
for(intj=0;j<i;j++)
{
//Advanceptopointatthenextnode.
p=thevalueinthepointerfieldofthenodecurrently
pointedtobyp.
//Inv:ppointstothejthelementofthelist.
}

displaythedatafieldofthenodecurrentlypointedtobyp.

Displaying the contents of the ith node of a linked list with n entries is on average a (n) operation,
hence the elem(i) operation is far less efficient in a linked list than in an array. The situation is
even worse for some other operations because, while moving down a linked list is easy, moving up
(toward the head) is not. Later we'll look at variations of linked lists that make it possible to move
easily in either direction.
Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 6

Insertion and deletion operations are simple for linked lists if the appropriate pointers are readily
available. In the example below, we add a node containing the new value Tom to the list between
Bill and Alice; the changed pointer values are indicated by bold arrows. The simplest way to do
this is to first set Toms pointer to point to Alice, and then change Bills pointer to point to Tom.
Nothing else in the list need be changed; the changes are entirely local. Notice that the order in
which we set these two pointers was critical. If we had changed Bills pointer first, then Alice and
Pat would have been lost.
Sue
Joe

Head

Alice
Bill
Pat

Tom

null
;

New node (Tom) not yet linked into the list

Sue
Joe

Head

Alice
Bill

Tom

Pat

null

New node (Tom) linked into the list

To delete a node from a linked list requires that only one pointer be changed. For example, to
delete Sue, all that need be done is to change Joes pointer to point to Bill rather than Sue. Again,
the altered pointer is shown in bold. Sues node still exists (and occupies storage), but it is
inaccessible (unless a pointer outside the list points to it). Inaccessible nodes are referred to as
garbage. In some languages, such as C++ and Pascal, the programmer is responsible for explicitly
deallocating nodes that are no longer needed. Java, however, performs periodic garbage collection
and reclaims unused storage automatically.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 7

Sue
Joe

Head

Alice
Bill

Tom

Pat

nil

Sues node has been deleted form the list.

Notice that to insert and to delete we needed to access only the nodes that precede and follow the
insertion point. Thus these operations are very fast -- (1) -- if the required pointers are available,
whereas they are both (n) operations (where n is the size of the list) for the array implementation
of a list. Of course the linked list operations are also (n) if the list must be traversed in order to
obtain the required pointers.
The ease with which a linked list can be updated often makes linked lists a good choice for
implementing sequences, but often there is a more important reason for using them. Because linked
lists use dynamic storage allocation, the size of an aggregate data structure need not be static nor
must its maximum size be known in advance. We can allocate storage for nodes as they are needed
and de-allocate nodes when they are no longer needed. In contrast, we must allocate arrays
completely in advance of using them. If we err by allocating too much space, we waste space; if
we err by allocating too little space, the program will crash.

5 Java implementation of a linked list

In this section we show how to implement a linked list in Java. We've seen all the tools already; we
will implement nodes with objects, and pointers with references. Shown below is the definition of
a very simple linked list. List class objects serve as the head pointer indicating the location of the
first node. Later, we will add methods to the List class for keeping track of the list size, inserting a
node, deleting a node, and scanning the list. Node objects each contain some data (a String in this
example) and a reference to the next Node object in the list, or null to indicate the end of the list.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 8

publicclassList
{
privateNodehead;//Referencetofirstnodeonthelist.
List()//Constructor:setheadtonull.
{
head=null;
}
//SetheadtopointtoaNode.
publicvoidsetHead(Noden)
{
head=n
}
}

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 9

publicclassNode
{
privateStringdata;
privateNodenext;
Node()//Constructor:setdatatoempty;nexttonull;
{
data="";
next=null;
}
Node(Strings)//Constructor:setdataasindicated.
{
data=s;
next=null;
}
Node(Strings,Noden)//Constructor:setdata
//andnextasindicated.
{
data=s;
next=n;
}
publicStringgetData()//Reader:returndatavalue
{
returndata;
}
publicNodegetNext()//Reader:returnnextvalue.
{
returnnext;
}
publicvoidsetData(Strings)//Writer:setdatavalue.
{
data=s;
}
publicvoidsetNext(Noden)//Writer:setnextvalue.
{
next=n;
}
}

The code below creates a simple linked list called list1with two elements: "Linda" is first; "Jim"
is second.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 10

//Createlisthead
Listlist1=newList();
//Create"Linda"node.
Noden1=newNode("Linda");
//Create"Jim"node.
Noden2=newNode("Jim");
//SetheadtopointtoLinda.
list1.setHead(n1);
//ConnectLindatoJim.
n1.setNext(n2);

list1

"Jm"

"Linda"

null

If we were to change the head pointer to point to Jim thereby bypassing Linda, then Linda's node
would become garbage (assuming it were not addressed by some other reference) and would be
reclaimed by Java's automatic garbage collection.
//Setheadtopointtothesecondnodeonthelist,
//bypassingthefirst.
list1.setHead(n2);

The following code does the same thing, but without having to have an explicit name ( n2) for Jim's
node. This is a complex statement and dissecting it to understand exactly what it does is
important. First, list1.getHead() returns a reference to the first node object on the list (Linda).
Then we call getNext() in that object to retrieve the reference to the second node (Jim). And
finally, we call the setHead method for list1 to set that list's head pointer.
//Setheadtopointtothesecondnodeonthelist,
//bypassingthefirst.
list1.setHead((list1.getHead()).getNext());

list1

"Linda"

"Jm"

nul
l

5.1 Common pitfalls of linked structures

The simplicity of our drawings, and the conceptual simplicity of moving pointers around is
misleading: programming with pointers is notoriously difficult, and debugging programs with
pointers can be extremely frustrating. The following are the two classic problem syndromes that
occur.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 11

1. 'Losing' an element. In Java, an object is accessible only through a reference, if no reference

points to an object, then that object is garbage and is lost. In updating a linked list, we
must be careful not to lose portions of the list.
2. Pointers that don't point anywhere. This problem, commonly called a dangling pointer,
occurs when a pointer points to an element that has been deallocated. Fortunately, this
cannot happen in Java since deallocation is handled by Java, not the programmer, and since
an object is deallocated only when no reference points to that object .
These problems are common, but they by no means exhaust the range of difficulties that can occur.
Fortunately, all problems are largely avoidable if you follow a simple strategy when writing
programs that manipulate pointers: draw pictures. Tracing your program by going through each
step on a diagram, drawing and erasing arrows when pointers change values, will help enormously.
But don't just do these pictorial traces for the general case. As always, special cases pose special
hazards; inserting into an empty list, and deleting the only remaining element of a list are two
examples, but many more occur. Pictorial traces of program execution will save many hours of
debugging on a keyboard.

6 The ADT List

We now expand the List ADT to include methods for adding to and deleting from the list. This is
designed to parallel the ADT Bounded Sequence developed previously, but, since the
implementation can rely on dynamic storage allocation, there is no need to restrict the length of the
sequences. The List class illustrates that we have, in fact, considerable freedom in how we use
linked lists to implement an ADT. The list representation uses two variables: a pointer, head, that
points to the first element of the list, and an integer, listSize, that contains the current size of the
list. Using listSize can clearly speed up the size operation; without it, we would have to
traverse the list while counting the number of elements. Maintaining the size information makes the
asymptotic time cost of the size function (1) rather than (n). At the same time, it slightly
increases the cost of several operations (e.g., insert and delete and list initialization). This is an
example of the tradeoffs that can be made in the design and implementations of ADTs.
The methods added are:
elem(inti)

return the element in position i in the list (String)

size()

return the current size of the list.

insert(Strings,inti)
delete(inti)

Insert s onto the list making it the ith element.

delete the ith element from the list.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 12

publicclassList
{
privateNodehead;//Referencetothefirstnodeonthelist.
privateintlistSize=0;//Currentlistsize.
List()//Constructor:setheadtonull.
{
head=null;
}
//Setheadtopointtospecifiednode.
publicvoidsetHead(Noden)
{
head=n;
}
//Returnthecurrentlistsize.
publicintsize()
{
//Pre:true
//Post:currentsizereturned.
returnlistSize;
}
//Returntheithelementofthelist.
publicStringelem(inti)
{
//Pre:0<=i<size()
//Post:Elementinpositionihasbeenreturned.
Nodep=head;
for(intj=0;j<i;j++)
//Moveptothenextnodeinthelist.
p=p.getNext();
//Inv:ppointstothejthelementinthelist.
returnp.getData();
}
//Insertstringsaselementi.
publicvoidinsert(Strings,inti)
{

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 13

//Pre:0<=i<=size()
//Post:shasbeeninsertedaselementi;therestofthe
// listisunchanged.
//Createanewnodewiththedesireddatavalue.
NodenewNode=newNode(s);
//Specialcase:insertasfirstnode.
if(i==0)
{
newNode.setNext(head);
head=newNode;
}
else//Notfirstnode.
{
Nodep=head;
//Locatenodejustbeforeinsertionpoint.
for(intj=0;j<i1;j++)
{
//Advanceptothenextnode.
p.getNext();

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 14

//Inv:ppointstothejthnode.
}
//pnowpointstothenodejustbeforethe
//insertionpoint.
//Insertnewnode.
newNode.setNext(p.getNext());
p.setNext(newNode);
}
//Updatesize.
listSize++;
}//Endofinsert.
//Deletetheithelementformthelist.
publicvoiddelete(inti)
{
//Pre:0<=i<size()
//Post:ithelementhasbeendeleted.Nootherchanges.
//Specialcase:deletethefirstelement.
if(i==0)
{
head=head.getNext();
}
else//i>0
{
//Locatethenodejustbeforetheonetobedeleted.
for(intj=0;j<i1;j++)
//Advanceptothenextnode.
p=p.getNext();
//Inv:ppointstothejthnode.
//pnowpointstothenodejustbeforetheonetobedeleted.
//Bypassthenodetobedeleted.
p.setNext((p.getNext()).getNext())
}
//Updatesize
listSize;
}//Endofdelete.

7 Using copying to simplify insertions and deletions

In this section we present alternative ways to implement two important list operations: insertion
and deletion. We will continue to use a linked list whose nodes are as defined in the previous
section.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 15

7.1 Insertion
Recall from the List implementation code that inserting a new node into a linked list is easy if we
have a pointer to the node that precedes the insertion point. For example, the following code
inserts the new node with data B into the linked list following the node pointed to by p.
NodenewNode=newNode(B);//Createnewnode.
newNode.setNext(p.getNext());//ConnectnewnodetoC(step1)
p.setNext(newNode);
//ConnectAnodetoB(step2)

p
p
A
A

2
newNode

newNode

Before

After
Inserting a list entry after that pointed to by p

Note that the order of the last two instructions is crucial. We've labeled the pointers in the diagram
to indicate the order in which the pointer values must be assigned. Reversing the last two
instructions would make the node containing C (and everything after C) inaccessible.
The preceding code is admirably straightforward, but it requires that we have a pointer to the node
preceding the place of insertion. In many algorithms, when we search for the place of insertion, the
pointer used for the search naturally ends up pointing to the node that should follow the value to
be inserted. For example, if we are inserting a new node into a list that is sorted in ascending order,
we recognize the insertion point only when we have found a data value that is larger than the value
to be inserted. A common solution to this problem is to search using a pair of pointers, one of that
finds the insertion spot, while the second pointer is kept pointing to the node preceding the first.
The second pointer can then be used for the insertion, using the algorithm above. This technique
requires an extra pointer, and about i assignment statements if the insertion is to be made at
position i.
The following code inserts the new entry before the entry stored in the node referenced by p. This
eliminates the need for a second pointer, but at the additional cost of copying the contents of the
node pointed to by p. If the data part of a node is large, this cost can outweigh the cost of the
pointer manipulations it saves, but this is usually not the case.
We begin with a similar situation as before, except that the new value A is to be inserted prior to
the list entry indicated by the pointer p. This strategy works in all cases except that it cannot be
used to insert a new node at the end of a list.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 16

NodenewNode=newNode(p.getData(),p.getNext());//Createnewnode
//copyingdataandpointer.
p.setData(A);
p.setNext(newNode);
p

C
2

newNode

newNode

Before

After

Inserting a list entry prior to that pointed to by p

7.2 Deletion
As with insertion, deleting a node is straightforward if we begin with a pointer to the node
preceding the one to be deleted. This can be done as follows:
p.setNext((p.getNext()).getNext());//Bypassthenodefollowing
//thenodepointedtobyp.
p
p
A
A

Before

After (B is garbage, but not yet collected)

Deletion of the list entry following that pointed to by p

Unfortunately, it is more common to want to delete the node pointed to by p, rather than its
successor. This task is not so straightforward, but this can be done as before by carrying two
pointers, one that finds the node to be deleted, and one that trails one node behind and hence
points to the predecessor of the node to be deleted. Or, in most cases, deletion can be done at the
cost of some copying:

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 17

p.setData((p.getNext()).getData()); //Copydatafromnextnode.
p.setNext((p.getNext()).getNext());//Bypassthenodefollowing
//thenodepointedtobyp.
p
p
B
A

Before

After (Middle node is garbage)

Deletion of the list entry pointed to by p

This deletion technique cannot be performed if p points to the last node of a simple linked list. That
might make this technique seem useless, but in the next section we'll show how to overcome the
problem by modifying the form of a linked list.

8 Variations on the basic linked list

We've mentioned previously that there are many variations on the standard linked list. In this
section, we'll describe three variations that very often result in simpler programs to implement the
necessary operations.

8.1 Eliminating the special cases: dummy head and tail nodes
Its nearly always good programming practice to eliminate or reduce the number of special cases.
In previous sections, we've seen that insertions and deletions at the beginning or end of a standard
linked list must often be treated differently from insertions and deletions elsewhere. How can we
avoid these special case?
One solution is to put dummy first and last nodes on the list. These nodes can be assigned sentinel
values; for example, if the list is sorted in ascending order, we can give the dummy head node a
data value that is less than any legal data value, and similarly, give the dummy last node a data
value that is larger than any legal data value. Then all insertions and deletions must take place in
the interior of the list and there are no special cases. Moreover, by keeping a pointer to the dummy
tail node, we can store sentinel values in its data field, thus simplifying and speeding up searches in
many instances. This additional structure would have its own costs; for example, we would have to
modify the procedure that creates the list so that it initializes the empty list to a list with the two
dummy nodes.
To illustrate the coding rewards of using dummy nodes, below are pairs of insertion and deletion
methods for updating a sorted linked list. The first method in each case assumes a conventional
linked list implementation; the second method is written for an implementation with a dummy tail
node that holds a sentinel value. In each case, the sentinel value could be the value being inserted
or deleted. The sentinel guarantees that insertions and deletions do not occur at the very end of the
list, and hence the copy method for insertions and deletions will always work. Assume that these

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 18

methods are part of a SortedList class in which the variable head points to the first node of the
list and where each node contains a String data field and a next field (a reference to another Node
object or null).
publicvoidinsert(Stringkey)
//Addkeytothesortedlistinitsproperplace.
//Aconventionallinkedlistimplementationisassumed.
//Pre:thelistsissortedby<=.
//Post:keyhasbeeninsertedintos;sissortedby<=.
{

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 19

//Createanewnodeandinsertdata.
NodenewNode=newNode(key);
//Specialcase:listisemptyorkeyislessthanthesmallest
//datavalueonthelist.Newnodegoesfirst.
if(head==null||key.compareTo(head.getData())<0)//SCeval
{
newNode.setNext(head);
head=newNode;
}
else//Newnodegoesfurtherdownthelist.
{
//Setqtopointtotheelement0;ptoelement1.
Nodeq=head;
Nodep=head.getNext();
while(true)
{
//Inv:alllistnodesuptoandincludingthenode
//pointedtobyqhavedatavalueslessthankey.
//Andeitherpisnullandqpointstothelast

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 20

//nodeorppointstothenodethatfollowsq.
if(p==null||key.compareTo(p.getData())<=0)break;//SCeval
//Advancethetwopointers.
q=p;
p=p.getNext();
}
//Newnodegoesafterqandbeforep.
newNode.setNext(p);
q.setNext(newNode);
}
//Updatesize.
listSize++;
}//Endinsert.
publicvoidinsert(Stringkey)
//Addkeytoasortedsequenceinitsproperplace.Alinked
//listimplementationwithadummytailnodeisassumed.
//Asentinelvalueisstoredinthetailnodethatis>=key.
//Pre:listissortedby<=.Lastlistelementis>=key.
//Post:keyhasbeeninsertedintolist;listissortedby<=.
{
//Locateinsertionpoint
Nodep=head; //ppointstofirstdatanodeordummytail
//nodewithsentinelvalue.
while(true)
{
//Inv:alllistnodesprecedingthenodepointedtobyp
//havedatavalueslessthankey.
if(key.compareTo(p.getData())<=0)break;
//Advancepointer.
p=p.getNext();
}
//Insertkeyintolistbeforenodepointedtobyp.
//Createnewnodewithdatavalueofnodepointedtobyp.
NodenewNode=newNode(p.getData(),p.getNext());
//Putnewdatavalueintonodepointedtobyp.
p.setData(key);
//Insertnewnodeintolistafternodepointedtobyp.
p.setNext(newNode);
//Updatesize.
listSize++;
}Endofinsert.

This second method has a number of attractive features when compared to the first:
The basic structure of the first method is a conditional that treats two cases: insert first
and insert somewhere else. This entire structure is unnecessary in the second procedure.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 21

The search loop in the first method uses a compound exit condition and relies on shortcircuit evaluation. In contrast, the loop exit condition of the second procedure is simple.
The difference in complexity of the loop structures is reflected in the loop invariants.
The loop body of the first procedure moves two pointers in tandem; the second procedure
moves a single pointer.
Storage allocation in the first procedure must be done at the top to cover both conditions,
or the allocation statement must be repeated for each case. In the second procedure, the
allocation statement can be naturally grouped with the insertion of the new node.
On the other hand, the second procedure copies the contents of one node into another. If nodes
are very large, this copying may be prohibitively expensive. In that case, the use of the "twopointer walk" might be advisable.
Similar differences hold for the following two deletion methods for sorted linked lists.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

//Deletethefirstelementofthelistwithdatavalue==key.
//Donothingifkeyisnotinthelist.
//Thelinkedlistisstoredasaconventionalsortedlinkedlist.

Printed January 18, 2017 01:40 PM

Page 22

Chapter 11

Linked Lists

Page 23

publicvoiddelete(Stringkey)
{
//Pre:Thelistissortedby<=.
//Post:Thefirstoccurrenceofkeyhasbeendeleted.Ifkeyisnotfound,
//nochangeismade.
if(head!=null&&key.compareTo(head.getData())>=0)//SCeval
//Don'tbothertosearchifthelistisemptyorifkey<firstelement.
{
if(key.compareTo(head.getData())==0)//keyisfirstelement.
{
head=head.getNext(); //Bypassfirstelement.
}
else//Lookfartherdownthelist.
{
Nodeq=head;
//Pointstofirstnode.
Nodep=head.getNext();//Pointstosecondnode.
while(true)
{
//Inv:Allentriesuptoandincludingtheelement

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 24

//pointedtobyqare<key.
if(p==null||
key.compareTo(p.getData())<=0)break;//SCeval
//Advancethe2pointers.
q=p;
p=p.getNext();
}
//Deleteonlyifkeywasfound.
if(p!=null&&key.compareTo(p.getData())==0)//SCeval
{
//Bypassnodepointedtobyp.
q.setNext(p.getNext());
}
}
//Updatesize.
listSize;
}
}//Endofdelete.
//Deletethefirstelementofthelistwithdatavalue==key.
//Donothingifkeyisnotinthelist.
//Thelinkedlisthasadummytailnodewithvalue>=key.
publicvoiddelete(Stringkey)
{
//Pre:Thelistissortedby<=withdummytailnode>=key.
//Post:Thefirstoccurrenceofkeyhasbeendeleted.Ifkeyisnotfound,
//nochangeismade.
Nodep=head;
//Searchforkey.
while(true)
{
//Inv:allnodesprecedingtheonepointedtobyphavedatavalues<key.
if(key.compareTo(p.getData())<=0)break;
//Advancepointer.
p=p.getNext();
}
//Deleteifkeywasfoundanditwasnotthedummy.
if(p.getNext()!=null&&key.compareTo(p.getData())==0)
{
p.setData((p.getNext()).getData());//Copydatafromnextnode.
p.setNext((p.getNext()).getNext());//Bypassnextnode.
}
}//Enddelete.

The second delete method is not only shorter than the first, it also has no special cases, a much
simpler loop exit condition and does not rely on short circuit evaluation. It does require, however,
a dummy tail node containing a sentinel data value that is greater than or equal to the key.
Assigning such a sentinel value may be problematic, but a slightly different approach circumvents
this difficulty. If the list is constructed so that a pointer to the dummy tail node is available, then
each time a search is performed (as is done with insert and delete), the key value can be inserted
into the data field of the dummy tail node to serve as a sentinel.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 25

The use of dummy nodes represents another example of a classic trade-off. We spend a little more
on space (for an extra node or two and a pointer to it) and a little more time in some of the
operations (such as initializing the list) in exchange for substantial simplification of the insert and
delete procedures.

8.2 Circular linked list

Any linked list can be made circular; the figure below shows circular linked lists without dummy
head nodes. The first list is empty; the second list has a single node, and the third list has four
nodes.
list

list

list

null

Circular lists are advantageous in many circumstances, but their advantages are increased if they
are constructed with a dummy head node. The following diagram illustrates this structure for the
same three lists. The nodes with the '?' are the dummy head nodes.

list

list

list

?
?

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 26
C

The circular list with dummy head node provides advantages similar to that of the non-circular list
with a dummy tail node; the head node is readily accessible and can be used to hold sentinel values
for searches.
The circular list requires no more space than the corresponding linear list (with or without a
dummy node). An unsuccessful search will cycle around from the end of the list back to the
beginning, and the programmer must be careful to write loops that terminate. The procedures for
insertion into and deletion from a circular linked list are left as an exercise.

8.3 Doubly Linked Lists

In a standard linked list, it is very easy to go from one node to its successor, but very difficult to go
the other way. A linked list is essentially a one way street. But we can facilitate going in either
direction by using two pointers per node: one to the successor and one to the predecessor. The
figure below shows a two-way linked list of names. To move down, follow the successor pointer
(the first one of the pair); to move up, follow the predecessor pointer (the second one). Once again
we have purchased additional power in this case the ability to go both ways at the cost of
space an additional pointer in each node.
list
head

Tom

nil

Linda

Bill

Barbara nil

Atwowaylinkedlist

8.4 Multiple access

8.4.1 Tail pointers
We mentioned in connection with the algorithms for the list with dummy head and tail nodes that
an additional pointer to the dummy tail node would provide an easy way to use search keys as

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 27

sentinels. Other uses for tail pointers exist. There are certain kinds of lists where changes occur
only at the ends. In a stack, for example, all changes occur at the top. And a standard linked list is
a very efficient way to implement a stack. If the front of a linked list corresponds to the top of the
stack, the stack operations of push, pop and top can all be performed in constant time without any
auxiliary access points. In a queue, however, changes occur at both ends: additions occur at one
end, deletions at the other. If we used a standard linked list to implement a queue with n elements,
one of the two operations would be (1), while the other would be (n). We can make both
operations (1) by providing both a head pointer to the front of the list and a tail pointer to the
back of the list. Adding a new node at the end of the list is now an easy matter of adding a new
successor to the tail node and adjusting the tail pointer, as is shown in the example below.

head

head

Tom

Dick

Dick
head

Tom

tail

Harry

Tom

tail

Harry

Betty

null

Dick

tail

Harry

null

Headandtailpointers

null

Betty

Newnodetobeaddedtoend

Pointersadjusted
Alteredpointersinbold

A circular linked list can also be used to implement a queue with (1) complexity for the principle
operations.
8.4.2 Thumb index
Lets say we had a long sorted linked list of names and were searching for the name LION. We
would have to start at the head and plow through the aardvarks, beavers, cats, dogs, etc. to get to
LION. What would be preferable is if we could enter the linked list somewhere closer to our
destination. One way to do this is to have an array of 26 list references, one for each letter of the
alphabet. Each reference would point to the first entry in the linked list that begins with that letter.
Then to find LION, we would first access the 12 th element of the reference array ('L' is the 12th
letter of the alphabet), which would give us the starting place of the 'L' words. We would still have
to look at lamb, lemur, and limpet, but the overall search would be much quicker. This strategy is
called a thumb index since it resembles the way in which we use a dictionary that has a thumb
index. Here again, we have paid in space and in some additional complexity in creating and
maintaining the list, and received an increase in search speed.
List[]thumbIndex=newList[26];

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 28

thumbIndex[i]wouldbesettopointtothefirstelementofthesorted
linkedlistthatbeginswiththeithletterofthealphabet.

8.5 Summary
The variations on linked lists -- dummy nodes, circular, doubly linked and multiple entry -- can be
used in any combination. There is no clear best choice for all problems; the programmer's best
strategy is to review the requirements of a particular problem and choose the form that appears to
be most appropriate. Additional storage requirements are imposed by using dummy nodes and
two-way linking, but this is not usually a strong factor in the choice, and the advantages brought
by these embellishments often makes them a good choice. The addition of multiple access facilities
is another way of using additional space to save substantial time for some algorithms. In each case,
we add structure to the basic linked list, and maintaining that structure will incur at least a small
cost in the algorithms that use the list. But if the sum of those small costs is outweighed by the
savings in performing other tasks, the result is a win.

9 Non-linear linked structures: trees and graphs

So far, we have dealt with the linked list which is a linear data structure. This linearity is captured
in the following definition
A linked list is a set of nodes with a distinguished node, called the first node, that has no
predecessor; a distinguished node, called the last node, that has no successor, and other
nodes, called interior nodes, each of which has a single predecessor and a single successor.
By relaxing the linearity requirements, we produce some interesting nonlinear data structures.
These nonlinear data structures will be the focus of the next chapter.

Printed January 18, 2017 01:40 PM

Chapter 11

Linked Lists

Page 29

Analogy____________________________________________________________1

LinkedLists_________________________________________________________2

Descriptionofalinkedlist______________________________________________3

Workingwithlinkedlists_______________________________________________4

Javaimplementationofalinkedlist______________________________________7

5.1

Commonpitfallsoflinkedstructures________________________________________9

TheADTList_______________________________________________________10

Usingcopyingtosimplifyinsertionsanddeletions_________________________12

7.1

Insertion_______________________________________________________________12

7.2

Deletion_______________________________________________________________14

Variationsonthebasiclinkedlist_______________________________________15

8.1

Eliminatingthespecialcases:dummyheadandtailnodes_____________________15

8.2

Circularlinkedlist______________________________________________________20

8.3

DoublyLinkedLists_____________________________________________________21

8.4

Multipleaccess_________________________________________________________22

8.4.1
8.4.2

8.5

Tailpointers_______________________________________________________________22
Thumbindex______________________________________________________________23

Summary______________________________________________________________23

Nonlinearlinkedstructures:treesandgraphs____________________________24

Printed January 18, 2017 01:40 PM