Linked List:

Introduction
The term “list” refers to a linear collection of data items. It contains a first element, second
element … and a last element. Data processing frequently involves storing and processing data
organized into lists. One way to store such data is by means of arrays. The disadvantage of array
is it is relatively expensive to insert and delete elements in an array. Also, since an array usually
copies a block of memory space, one cannot simply double or triple the size of an array when
additional space is required. For this reason, arrays are called dense lists and are said to be static
data structures.
Another way of storing a list in memory is to have each element in the list contain a field called a
link or pointer, which contains the address of the next element in the list. Thus successive
elements in the list need not occupy adjacent space in the memory. This will make it easier to
insert and delete elements in the list.
A linked list is a sequence of data structures, which are connected together via links. This is a
sequence of links which contains items. Each link contains a connection to another link. Linked
list is the second most-used data structure after array. The linked list or one-way list is a linear
set of data elements which is also termed as nodes. Here, the linear order is specified using
pointers. That is each node is divided into two parts: the first part contains the information of the
element and the second part called the link field or next pointer field contains the address of the
next node in the list.
The following figure shows a diagrammatic representation of linked list with 4 nodes. Each node
is pictured with two parts. The left part represents the information part of the node, which may
contain an entire record of data items (NAME, ADDRESS etc.,). The right part represents the
next pointer field of the node, and there is an arrow drawn from it to the next node in the list. The
pointer of the last node contains a special value called NULL pointer, which is invalid address.
NAME
or X
START
Next pointer field of third node
Information field of third node

In actual practice, 0 or a negative number is used for the null pointer. This is denoted by x in the
above diagram, which marks the end of the list. The linked list also contains a list pointer
variable called START or NAME – which contains the address of the first node in the list. This
is denoted by drawing an arrow from START to the first node. We need only this address in
START to trace through the list. A special case is the list that has no nodes. Such a list is called
a null list or empty list and is denoted by the null pointer in the variable START.
The important terms to understand the concept of Linked List.
 Link − Each link of a linked list can store a data called an element.
 Next − Each link of a linked list contains a link to the next link called Next.
 LinkedList − A Linked List contains the connection link to the first link called First.

1
Linked List as ADT
Linked list is one of the basic structures used to implement an ADT list. This can be used to
create linear and non-linear structures. All the elements in a list have either zero, one or more
successors.
When compared to an array, linked lists have a major advantage of easy insertion and deletion of
data. There is no need for shifting the elements present in the linked list to accommodate a new
element or to delete an element. On the other hand, since there is no physical sequence for the
elements, we are restricted to use sequential searches instead of using binary search.
Figure (A) given below, shows a linked list implementation of linear list. Every element has a
link except the last which point to its only neighbor. The link present in the last element has a
NULL pointer which indicates the end of the list. Figure (B) shows a linked list implementation
of a non-linear list. Every element present in a non-linear list can have two or more links. There
are two links for every element – one for each successor. Figure (C) shows empty list which can
be either linear or non-linear. An empty list can be called as NULL list pointer.

REPRESENTATION OF LINKED LISTS IN MEMORY

Let LIST be a Linked List. The LIST will be maintained in the memory, unless otherwise
specified or implied as follows: First of all, LIST requires two linear arrays – we will call them
here as INFO and LINK – such that INFO[K] and LINK [K] contains respectively, the
information part and the next-pointer field of a node of LIST. As noted above, LIST also
requires a variable name – such as START – which contains the location of the beginning of the
list and a next-pointer sentinel – denoted by NULL – which indicates the end of the List. Since
the subscripts of the arrays INFO ad LINK usually be positive, we will choose NULL = 0,
unless otherwise stated.

2
 Above figure shows a linked list. It shows that the node of a list need not occupy adjacent
elements in the array INFO and LINK.
Traversing a Linked List
Traversing refers to visiting each node of the list once in order to perform some operation on
that. We know that it is a linear data structure that needs to be traversed starting from the head
node until the end of the list. Unlike arrays, where random access is possible, linked list requires
access to its nodes through sequential traversal. Traversing a linked list is important in many
applications. For example, we may want to print a list or search for a specific node in the list. Or
we may want to perform an advanced operation on the list as we traverse the list.

The traversing process in a list includes the following steps:

a. Start with the head of the list. Access the content of the head node if it is not null.
b. Then go to the next node (if exists) and access the node information
c. Continue until no more nodes (that is, you have reached the last node)
Let us take LIST as a linked List, stored in memory as a linear
arrays INFO and LINK with START pointing to the first element
and NULL at the end of the LIST indicating there are no more
nodes in the LIST. Pointer variable PTR is used to point the
currently processed node. Accordingly, LINK[PTR] points to the
next node to be processed. Thus the statement
PTR=LINK[PTR] moves the pointer to the next node in the list.
Algorithm: (Traversing Linked List). Let LIST be a linked list in memory.
A PROCESS operation is applied to each element of LIST. The variable PTR points to the node
currently being processed.
1. Set PTR = START.
2. Repeat Steps 3 and 4 while PTR != NULL
3. Apply PROCESS to INFO[PTR]
4. Set PTR = LINK[PTR] (i.e. PTR is now pointing to the next node)
End of Step 2
5. Exit
Explanation of the Algorithm:
Initialize PTR to START. Then process INFO[PTR]. (i.e. information at the first node). Update
PTR by the assignment PTR = LINK[PTR], so that PTR points to the second node. Now again
process the INFO[PTR] – i.e. process the information of the second node. Again update PTR by
the assignment PTR = LINK[PTR] and then process INFO[PTR] to get the information at the
third node. Like this the process continues till the end of the list. i.e. when PTR = NULL.

3
Searching a Linked List
Let LIST be a linked list in memory. Suppose a specific ITEM of information is given for
finding the location LOC of the node where ITEM first appears in the LIST. If ITEM is actually
a key value and we are searching through a file for the record containing ITEM, then ITEM can
appear only once in LIST.
Here we discuss about searching the ITEM in an unsorted LIST. We search for ITEM in the
unsorted LIST by traversing through the list using a pointer variable PTR, and comparing with
the contents INFO[PTR] of each node, one by one in the LIST. Before we update the pointer
PTR by using the statement - PTR = LINK[PTR]
For this purpose, we need to perform two tests.
1. Check to see whether we have reached the end of the list. i.e. we need to check whether PTR =
NULL. If not, then
2. Check to see whether INFO[PTR] = ITEM
The above two tests cannot be performed at the same time, since INFO[PTR] is not defined
when PTR = NULL. So, use the first test to control the execution of a loop, and let the second
test take place inside the loop. The corresponding algorithm is given below:
Algorithm: SEARCH (INFO, LINK, START, ITEM, LOC)
LIST is a linked list in memory. This algorithm finds the location LOC of the node,
where ITEM first appears in the LIST. Otherwise, we set LOC as NULL.
1. Set PTR = START
2. Repeat step 3 while PTR != NULL
3. IF ITEM = INFO[PTR], then
Set LOC = PTR and goto Step 5
else
Set PTR = LINK[PTR] (now PTR points to next node)
[End of IF]
[End of Step 2 loop]
4. Set LOC = NULL (when search is unsuccessful)
5. EXIT

Memory Allocation
The maintenance of linked lists in memory assumes the possibility of inserting new nodes into
the list and hence requires some mechanism which provides unused memory space for the new
nodes. Mechanism is required whereby the memory space of deleted nodes becomes available
for future use.
Together with the linked list in memory, a special list is maintained which consists of unused
memory cells. This list, which has its own pointer, is called the list of available space or the
free-storage list or the free pool.
Whenever a new node is created, memory is allocated by the system. This memory is taken from
list of those memory locations which are free i.e. not allocated. This list is called AVAIL List.

4
Similarly, whenever a node is deleted, the deleted space becomes reusable and is added to the
list of unused space i.e. to AVAIL List. This unused space can be used in future for memory
allocation. Hence the free storage list will also be called the AVAIL list. Such a data structure
will frequently be denoted by writing:
LIST (INFO, LINK, START, AVAIL)

Memory allocation is of two types- 1. Static Memory Allocation

2. Dynamic Memory Allocation
1. Static Memory Allocation:
When memory is allocated during compilation time, it is called ‘Static Memory Allocation’. It is
fixed and cannot be increased or decreased after allocation. Allocating excess memory results in
wastage of memory. Allocating insufficient memory results in unsuccessful execution of the
program. Therefore exact memory requirements must be known in advance.
2. Dynamic Memory Allocation:
When memory is allocated during run/execution time, it is called ‘Dynamic Memory
Allocation’. This memory is not fixed and is allocated according to our requirements. Here
memory is utilized properly. There is no need to know exact memory requirements in advance
Garbage Collection
Whenever a node is deleted, some memory space becomes reusable. This memory space should
be available for future use. One way to do this is to immediately insert the free space into
availability list. This is what usually we do when linked list is implemented by means of liner
arrays. But this method may be time consuming for the operating system.
So another method is used which is called ‘Garbage Collection’. In this method the OS collects
the deleted space time to time onto the availability list. This process happens in two steps.
 Initially OS goes through all the lists and tags all those cells which are currently being used.
 Later OS goes through all the lists again and collects untagged space and adds this collected
space to availability list.
The garbage collection may occur when small amount of free space is left in the system or no
free space is left in the system or when CPU is idle and has time to do the garbage collection.
Generally speaking, the garbage collection is invisible to the programmer.
Overflow & Underflow
Overflow happens at the time of insertion. If we have to insert new space into the data structure,
but there is no free space i.e. availability list is empty, then this situation is called ‘Overflow’.
The programmer can handle this situation by printing the message of OVERFLOW. In this case,
the programmer may then modify the program by adding space to the underlying arrays.
Overflow will occur with our linked list when AVAIL = NULL and there is an insertion.
Underflow happens at the time of deletion. If we have to delete data from the data structure, but
there is no data in the data structure i.e. data structure is empty, then this situation is called
‘Underflow’. The programmer can handle this situation by printing the message of
5
UNDERFLOW. Underflow will occur with our linked list when START = NULL and there is a
deletion.
Insertion into a Linked List
Let LIST be a linked list with successive nodes A and B. Suppose a node N is to be inserted into
the list between nodes A and B. The corresponding diagram is shown in the picture. That is node
A now points to the new node N and node N points to node B, to which A previously pointed.

After insertion
.
Inserting Algorithms
Algorithms which insert nodes into linked lists come
up in various situations. They are:
1. Inserting a node at the beginning of the list.
2. Inserting a new node after the node with a
given location
3. Inserting a node in a sorted List.

Inserting at the beginning of a List

Algorithm : INFIRST(INFO, LINK, START, ITEM)
This algorithm inserts ITEM as the first node in the list.
1. Start
2. Set NEW=addressof(NEWNODE)
3. Set INFO[NEW] = ITEM [Copies new data into new node]
4. Set LINK[NEW] = START. [New node now points to original first node]
5. Set START = NEW [Changes START so it points to the new node]
6. Exit
The schematic diagram of Steps 2 and 3 is shown in the diagram given above. Diagram for steps
4 and 5 are shown below.

6
Inserting after a given node
The following is the algorithm which inserts ITEM into LIST so that ITEM follows node A (the
previous node) or when LOC = NULL, so that that the ITEM is the first node.
Let N denote the new node (whose location is NEW). If LOC= NULL, then N is inserted as the
first node in LIST. Otherwise, let node N point to node B (which is originally followed node of
A) by the assignment
LINK [NEW] = LINK[LOC]
And we let node A point to the new node N by the assignment
LINK[LOC] = NEW

7
Inserting into a Sorted Linked List
Suppose ITEM is to be inserted into a sorted linked LIST. Then ITEM must be inserted between
nodes A and B so that

INFO(A)<ITEM S INFO(B)

The following is a procedure which finds the location LOC of node A. that is, which finds the
location LOC of the last node in LIST whose value is less than TEM.
Traverse the list, using a pointer variable PTR and comparing ITEM with INFO[PTR] at each
node. While traversing, keep track of the location of the preceding node by using a pointer
variable SAVE, as pictured in Fig. 5.21, Thus SAVE and PTR are updated by the assignments

SAVE= PTR and PTR= LINK[PTR]

The traversing continues as long as INFO[PTR]>ITEM. or in other words, the traversing stops as
soon as ITEM<=INFO[PTR] Then PTR points to node B. so SAVE will contain the location of the node A.

The formal statement of our procedure follows. The cases where the list is empty or where
ITEM< INFO[START], so LOC=NULL are treated separately. Since they do not involve the
variable SAVE

Procedure 5.6 FINDA(INFO. LINK, START. ITEM. LOC)

This procedure finds the location LOC of the last node in a sorted fist such
that INFO[LOC]< ITEM, or sets LOC=NULL

1. [List empty ?] If START=NULL then: Set LOC =NULL and Retum.

2. [Special case?] If TEM<INFO[START], then: Set LOC=NULL, and Return
3. Set SAVE =START and PTR=LINK[START] I Initializes pointers)
4. Repeat Steps 5 and 6 while PTR !=NULL
5. If ITEM<INFO[PTR], Then
Set LOC=SAVE and Return.
[End of IF structure]
6. Set SAVE=PTR and PTR=LINK [PTR]. [Updates pointers.]
[END of Step4 loop]
7. Set LOC=SAVE
8. Return

Now we have all the components to present an algorithm which inserts TEM into a linked list.
8
The simplicity of the algorithm comes from using the previous two procedures

Algorithm 5.7 INSERT(INFO, LINK. START,ITEM)

This algorithm inserts ITEM into a sorted linked list

1. [Use Procedure 5.6 to find the location of the node preceding ITEM.]
Call FINDA(INFO, LINK. START, ITEM, LOC)
2. [Use algorithm 5.5 o insert ITEM after the node with location L0C.]
Call INSLOC(INFO. LINK. START,LOC,ITEM)
3 .Exit

Deletion from a Linked List

Let LIST be a linked list with a node N between nodes A and B as shown in the figure (a) given
below. Suppose node N is to be deleted from the linked list. The corresponding diagram of such
a deletion appears in Figure (b). The deletion occurs as soon as the next-pointer field of node A
is changed so that it points to node B. (Accordingly, when performing deletions, we must keep
track of the address of the node which immediately precedes the node that is to be deleted).

There are special cases in deletion. If the deleted node is the first node in the list, then START
will point to node B and if the deleted node N is the last node in the list, then node A will
contain the NULL pointer.
Deletion Algorithm
Algorithms which delete nodes from linked lists come up in various situations. For example,
1. Deleting a node, following a given node.
2. Deleting the node with a given item of information
While deleting a node either the first node or the last node from the list, we must check to see
whether there is a node in the list. If not, then a corresponding message must be printed (eg.
Underflow).
Deleting the Node Following a Given Node
Let LIST be a inked list in memory. Suppose we are given the location LOC of a node N in LIST.
suppose we are given the location LOCP of the node preceding N or, when N is the
first node, we are given LOCP = NULL, The following algorithm deletes N from the list.

9
Algorithm 5.8: DEL(INFO, LINK, START, LOC, LOCP)
This algorithm deletes the node N with location LOC. LOCP is the location of
the node which precedes N or, when N is the first node, LOCP = NULL.
1. If LOCP = NULL, then
Set START= LINK[START]. [Deletes first node.]
Else
Set LINK[LOCP] = LINK[LOC]. [Deletes node N.]
End of If structure.
2. Exit.

Deleting the Node with a Given ITEM of Information

Let List be a linked list in memory. Suppose we are given an ITEM of information and we want
to delete from the LIST the first node N which contains ITEM. (IF ITEM ss a key value, then only
one node can contain ITEM.) Recall that before we can delete N from the list, we need to know
the location of the node preceding N. Accordingly, first We give a procedure which finds the
location LOC of the node N containing ITEM and the location LOCP of the node preceding node
N. If N is the first node, we set LOCP NULL, and if ITEM does not appear in LIST, we set LOC
= NULL.
Traverse the list, using a pointer variable PTR and comparing ITEM with INFO[PTR] at each
node. While traversing, keep track of the location of the preceding node by using a pointer
variable SAVE, as pictured in Fig. 5.21. Thus SAVE and PTR are updated by the assignments

SAVE= PTR and PTR =LINK[PTR]

The traversing continues as long as INFOĮPTR] # ITEM, or in other words, the traversing stops as
soon as ITEM= INFO[PTR]. Then PTR contains the location LOC of node N and SAVE contains
the location L.OCP of the node preceding N.
The formal statement of our procedure follows. The cases where the list is empty or where
INFO[START] = ITEM (i.e., where node N is the first node) are treated separately, since the

not involve the variable SAVE.

Procedure 5.9: FINDB(INFO, LINK, START. ITEM, LOC, LOCP)

1
0
This procedure finds the location LOC of the first node N which contains
ITEM and the location LOCP of the node preceding N. If ITEM does not
appear in the list, then the procedure sets LOC = NULL, and if ITEM appears
in the first node, then it sets LOCP = NULL.

1. [List empty?] If START = NULL, then

Set LOC= NULL and LOCP= NULL, and Return.
[End of If structure.]
2.[ ITEM in first node?] If INFO[START] = ITEM, then
Set LOC= START and LOCP = NULL, and Return.
[End of If structure.]
3. Set SAVE = START and PTR:= LINK[START]. [Initializes pointers.]
4. Repeat Steps 5 and 6 while PTR # NULL.
5. If INFO[PTR] = ITEM. then
Set LOC := PTR and LOCP := SAVE, and Return

[End of If structure.]
6.Set SAVE := PTR and PTR := LINK|PTR]. [Updates pointers.]
End of Step 4 loop.
7. Set LOC := NULL. [Search unsuccessful.]
8. Returm.
Now we can easily present an algorithm to delete the first node N from a linked list which contains a
given ITEM of information. The simplicity of the algorithm comes from the fact that the task of finding
the location of N and the location of its preceding node has already been done in Procedure 5.9.

Algorithm 5.10: DELETE(INFO, LINK, START, ITEM)

This algorithm deletes from a linked list the first node N which contains
given ITEM of information.
1.[Use Procedure 5.9 to find the location of N and its preceding node]
Call FINDB(INFO, LINK, START, ITEM, LOC, LOCP)
2. If LOC = NULL, then: Write: ITEM not in list, and Exit.
3. [Delete node.]
If LOCP = NULL. then:
Set START= LINK[START]. [Deletes first node]
Else
Set LINK[LOCP] = LINK[LOC]
End of If structure.
4. Exit.

5.9 HEADER LINKED LISTS

A header linked list which always contains a special node, called the header node,at the beginning of the list. The
following are two kinds of widely used header lists:
1. A grounded header list is a header list where the last node contains the null pointer.
2. circular header list is a header list where the last node points back t0 the header node.
Figure 5.30 contains schematic diagrams of these header lists.

1
1
Observe that the list pointer START always points to the header node. Accordingly,LINK[START] = NULL
indicates that a grounded header list is empty, and LINK[START]=START indicates that a circular header list is
empty.
The term "node," by itself, normally refers to an ordinary node, not the header node, when used
with header lists. Thus the first node in a header list is the node following the header node, and the
location of the first node is LINK [START), not START, as with ordinary linked lists.
Algorithm 5.11, which uses a pointer variable PTR to traverse a circular header list which traverses an ordinary
linked list, except that now the algorithm (1) begins with PTR = LINK[START] (not PTR = START) and (2) ends
when PTR = START (not PTR= NULL).
Circular header lists are frequently used instead of ordinary linked lists because many operations
are much easier to state and implement using header lists. This comes from the following two
properties of circular header lists:
1. The null pointer is not used, and hence all pointers contain valid addresses.
2. Every (ordinary) node has a predecessor, so the first node may not require a special case.

Algorithm 5.11: (Traversing a Circular Header List)

Let LIST be a circular header list in memory. This algorithm traverses LIST, applying an operation PROCESS to
each node of LIST.
1. Set PTR= LINK [START]. [Initializes the pointer PTR.]
2 Repeat Steps 3 and 4 while PTR! =START
3. Apply PROCESS to INFO [PTR].
4. Set PTR: = LINK [PTR]. [PTR now points to the next node.]
[End of Step 2 loop.]
5. Exit.

There are two other variations of linked lists which sometimes appear in the literature:
1. A linked list whose last node points back to the first node instead of containing the null
pointer, called a circular list.
2. A linked list which contains both special header node at the beginning of the list and a
special trailer node at the end of the list
Figure 5.32 contains schematic diagrams of these lists.

1
2
Polynomials
Header inked lists are frequently used for maintaining polynomials in memory. The he
node plays an important part in this representation, since it is needed to represent the
polynomial.

Representation of Polynomials Using Linked Lists

We can represent a polynomial using array or a linked list. This is done by simply storing the
Coefficient and exponent of all the terms. The linked list representation is easy for operations like
Polynomial addition or subtraction, and polynomial multiplication. We should also keep in mind
that in a polynomial, all the terms might not be present, especially for polynomials with a higher
order. Look at the following example.

8X13+5X6+2X8+X5+X10+17X
This 13 order polynomial does not have all the 14 terms (including the constant term). Thus, it Is
very easy to represent the polynomial with the help of a linked list structure. Here every node can retain
information pertaining to a single term of the polynomial. All the nodes store three things:
vanable x
exponent
coefficient for each term.
Whatever be the equation, it does not matter if the polynomial is in x or y. This is a very
important informatIon that needs to be kept in mind when performing operations on polynomials.
Thus it is better if we define a node structure which holds 2 integers-exp and coff.

5.36 CIRCULARLY LINKED LISTS

Circularly linked list is a special type of linked list. In a circularly linked list, the link field of the
last node points to the first node of the list. This type of list is mainly used in lists that allow
access to nodes in the middle of the list without starting at the beginning.
Figure 5.33 is a schematic diagram of a circularly linked list with four nodes. Notice that the
last node does not contain a NULL pointer as in a singly linked list. The link field of the last node
is connected to the information part of the first node.

1
3
Insertion into and deletion from a circularly linked list follows the Same pattern used in a singlly
liSt. However, in this case, the last node points to the first node. Therefore, when insenrting the last node we must
also point the link field to the first node.

5.11 TWO-WAY LISTS (OR DOUBLY LINKED LISTS)

A two-way list is a linear collection of data elements, called nodes, where each node N is
divided into three parts:
I. An information field INFO which contains the data of N
2 A pointer field FORW which contains the location of the next node in the list
3. A pointer field BACK which contains the location of the preceding node in the list

The list also requires two list pointer variables: FIRST, which points to the first node in the list,
and LAST, which points to the last node in the list. Figure 5.36 contains a schematic diagram of
such a list. Observe that the null pointer appears in the FORW field of the last node in the list and
also in the BACK field of the first node in the list.
Observe that, using the variable FlRST and the pointer field FORW, we can traverse a two-way
list in the forward direction as before. On the other hand, using the variable LAST and the pointer
field BACK, we can also traverse the list in the backward direction.
Suppose LOCA and LOCB are the locations, respectively, of nodes A and B in a two-way list.
then the way that the pointers FORW and BACK are defined gives us the following:
Pointer property: FORW[LOCA] = LOCB if and only if BACK[LOCB] = LOCA

Two-Way Header Lists

The advantages of a two-way list and a circular header list may be combined into a two-way
circular header list as pictured in Fig, 5.38. The list is Circular because the two end nodes point
back to the header node. Observe that such a two-way 1ist requires only one list pointer variable
START, which points to the header node. This is because the two pointers in the header node point
to the two ends of the list.

1
4
Operations on Two-Way Lists
Deleting
Suppose we are given the location LOC of a node N in LIST, and suppose we want to delete N from
the list. We assume that LIST is a two-way circular header list. Note that BACK[LOC] and FORW[LOC]
are the locations, respectively,of the nodes which precede and follow node Accordingly, as pictured
in Fig. 5.40, N is deleted from the list by changing the following pair of pointers

FORW[BACK[LOC]]= FORW[LOC] and BACK[FORW[LOC]] = BACK[LOC]

The formal statement of the algorithm follows.
Algorithm 5.16: DELTWL(INFO, FORW. BACK. START, AVAIL, LOC)
1. [Delete node.]
Set FORW[BACK[LOC]] = FORWILOC)and
BACK[FORW[LOC]] = BACK[LOC].
2.Exit.

inserting
Suppose we are given the locations L.OCA and LOCB of adjacent nodes A and B LIST,
and suppose we want to insert a given ITEM of information between nodes A and B.
The variable NEW contains the address of NEWNODE and then we copy the data ITEM into the node N;

Now, as pictured in Fig. 5.41, the node N with contents ITEM is inserted into the list by changing
the following four pointers:
FORW[LOCA] := NEW, FORW[NEW] = LOCB
BACK[LOCB] := NEW, BACK[NEW]= LOCA
The formal statement of our algorithm follows.

1
5
Algorithm 5.17: INSTWL(INFO, FORW, BACK, START, LOCA, LOCB, ITEM)

1. start
2. Set NEW=address of (NEWNODE)
3. [ copy new data into node] INFO[NEW]= ITEM.
4. [Insert node into list.]
Set FORW[LOCA] := NEW, FORW[NEW] := LOCB
BACK[LOCB] := NEW, BACK[NEW]= LOCA.
5. Exit.

4.13 DYNAMIC MEMORY MANAGEMENT

In C, there are two ways in which memory can be allocated:

(i) by declaring variables
(ii) by explicitly requesting space from C
There are many functions in C used for allocating and managing memory:
1. Malloc() function may be used to allocate a block of memory. A block of memory with a
particular size is reserved and a pointer is returned which is of type void meaning that this
function can be assigned to any type of pointers.
2. Calloc() function is used when there is a need for multiple blocks of storage, of same size,
and then set all bytes to zero.
3. Realloc() function is used to move a reserved block of memory to another allocation of
different dimensions. When the memory allocated by using calloc or malloc is insufficient
or in excess, the size of the memory which has already been allocated can be changed using
this function.
1
6
 4. Free() is used to release the previously used block of memory. In a block of memory when
there is no further use of the data stored in it and also the same block is not used for the
purpose of storing any other information, using this function the block of memory can be
freed for using in the future.
These functions can be found in the stdlib library.

Insertion sort detailed algorithm

insertionSort(int arr[], int n)
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i - 1;

// Move elements of arr[0..i-1],

// that are greater than key, to one
// position ahead of their
// current position
while (j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

1
7