Module 3 Dara structure notes

CONTENTS
 Definition
 Representation of linked lists in Memory
 Linked list operations
 Traversing
 Searching
 Insertion
 Deletion
 Doubly Linked lists
 Circular linked lists
 Header linked lists
 Linked Stacks and Queues
 Applications of Linked lists
 Polynomials
 Sparse matrix representation

INTRODUCTION
 One way by which we can store a list of items is using arrays,
in which every item is stored in consecutive memory locations.
 However, the disadvantage of arrays is operations like
insertion and deletion are expensive to perform.
 Also changing the size of an array is not a straightforward task.
 An alternate way of storing a list of items in the memory is by
considering each item as an individual entity and storing it.
 Also every item will have a field called link, that contains the
address of the next item in the list.

INTRODUCTION
 This means, we need not store successive items of the list in
successive memory locations.
 Such an arrangement also makes insertion and deletion of items
very easy. This is accomplished using a data structure called Linked
List.
“A Linked List or One-Way List is a linear collection of data
elements, called nodes, where the linear order is given by means of
pointers.”
 Hence, for a given list of items, if array is used to store the items,
then the sequence of items in the array must be same as the
sequence mentioned in the list.
 However, with linked list, the sequence need not be the same as
mentioned.

INTRODUCTION
 Each node in a linked list is divided into two parts:
 info - contains the information about the element
 link – contains the address of the next node in the list
 A linked list of 6 nodes is diagrammatically presented below.
X
STAR
T info link
 The info part of a node can either contain a single data item or a
group of data items.
 The link part holds the address of the next node in the list.
 The linked list also has a list pointer, called START, that points to the
first node of the list. START indicates the beginning of the list.

REPRESENTATION OF LINKED LISTS IN MEMORY
 Since a simple linked list is made up of two parts(info and link), a
linked list is maintained using two linear arrays in the memory.
 One array is called the INFO array and it contains the information of
all linked list nodes.
 The second array is called the LINK array and it contains the
addresses of next nodes in the linked list.
 The index positions in the array correspond to the list nodes.
 For an index position k, INFO[k] and LINK[k] will contain the data in
node k and address of next node to k respectively.
 The list also requires a variable, called START, that points to the first
node of the list.

 Consider the following linked list.
N O E X I
STAR
T T X
 The memory representation of the above list is,
1
2
3
4
5
6
7
8
9
10
11
INFO LINK
E
N
_
T
O
I
X
10
8
1
0
5
6
9
STAR
T 3

 Array representation of two lists
88 74 93 82 X
AL
G
84 62 74 99 74 78 X
GEO
M
1
2
3
4
5
6
7
8
9
10
11
INFO LINK
93
88
82
74
7
10
0
2
ALG
6
99
93
62
74
88
82
74
78
74
84
4
7
8
9
10
0
1
0
2
3
GEO
M11

 Array representation of multiple lists
Gran
t
Scott Vit
o
Kat
z
X
BOND
Hunte
r
McBrid
e
Evan
s
X
KELL
Y
HALL
X
Telle
r
Jone
s
Adam
s
NELSO
N Roger
s
Westo
n
X

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Student Link
1
2
3
4
Faculty Link
BOND
KELLY
HALL
NELSON
Vito
Katz
Grant
Scott
4
0
16
1
12
Vito
Hunter
Katz
Evans
Grant
McBride
Scott
4
14
0
0
16
6
1
12
3
12
3
0
Vito
Hunter
Katz
Evans
Rogers
Teller
Jones
Grant
McBride
Weston
Scott
Adams
4
14
0
0
15
10
17
16
6
0
1
8
12
3
0
9

 Representation of lists with multiple data items in each node.
Brow
n
178521065 Femal
e
14700
STAR
T Cohe
n
177444557 Male 19000
Davis 192387282 Femal
e
22800 Evan
s
168568113 Male 34200 X
1
2
3
4
5
6
7
Evans
Cohen
Davis
Brown
168568113
177444557
192387282
178521065
Male
Male
Female
Female
34200
19000
22800
14700
0
4
1
2
Name SSN Sex Salary Link
STAR
T
6

Defining a linked list node
 From the discussion so far, we can conclude that a node in a
list can have any type of data.
 Along with the data, there is a link part that contains the
address/index of the next node.
 The link part will only have integer values as it holds an
address or index, both of which are integers.
 Hence, to define a linked list node, we need to have a facility
by which we can group data belonging to different data types.
 This can be accomplished using Structures.

 Structures are used to define a linked list node.
 The nodes are then created using dynamic memory allocation
functions.
Defining a node using structures
Consider the following structure definition,
typedef struct node{
char info;
node* link;
};
 The above structure definition results in a node that holds
character data and pointer to another node.

Node creation using malloc()
 With the node definition ready, we can now create a linked list
node.
 For this, we first declare a pointer variable as follows,
node* ptr;
 We then use dynamic memory allocation functions to create a
node.
ptr = (node*)malloc(sizeof(node));
1000 1001 1002 1003 1004 1005 1006
Info link
1000 1001 1002 1003 1004 1005 1006
1002
ptr

Assigning values to a node
 Once a node has been created, we next need to fill the node
with appropriate values.
 The node that we have created can hold a character in the info
field and address in the link field.
 Here the info and link fields are members of a structure.
 Hence, to assign values to info and link fields, we need to
access these structure members.
 We know that a structure member can be accessed using a
structure variable and the DOT operator.

 However, the node that we have created is not represented by
a normal structure variable.
 It is represented by a pointer.
node* ptr;
ptr = (node*)malloc(sizeof(node));
1000 1001 1002 1003 1004 1005 1006
Info link
1000 1001 1002 1003 1004 1005 1006
1002
ptr
 The DOT operator cannot be used by a pointer variable to
access structure members.
 Instead, a special operator, , is used by pointers for this
purpose.

 The use of DOT and  is illustrated below. Consider the
structure,
typedef struct sample{
int a;
};
sample var, *ptr;
var . a = 10;
ptr  a = 20;
 We now see how we assign values for the linked list node
using the pointer ptr.
ptr  info = ‘A’;
ptr  link = NULL;

 This will result in,
ptr
A 0
1002
 We now see how to create a linked list of two nodes.
node* create2(){
node *first, *second;
} first
1002
node* create2(){
first = (node *) malloc(sizeof(node));
}
node* create2(){
second = (node *)
malloc(sizeof(node));
}
secon
d
2002
node* create2(){
second = (node *)
first  info = ‘A’;
second  info = ‘B’;
}
A
B
node* create2(){
second = (node *)
first  link = second;
}
A 2002
node* create2(){
second = (node *)
first  link = second;
second  link = NULL;
return first;
B 0

LINKED LIST OPERATIONS
Traversing
Traversing a list involves visiting all the linked list nodes.
A 78 B 32 C 19 D 66 E 21 F 0
STAR
T
05
PTR
Algorithm: (Traversing a Linked List) This algorithm visits all nodes of a
linked list, applying an operation PROCESS on each node of the 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 PTR  info.
4. Set PTR := PTR  link.
[End of Step 2 loop.]
5. Exit
PTR PTR
05 78 32 19 66 21
PTR PTR PTR

Algorithm: PRINT(START) This algorithm prints the information at each node
of the list.
3. Write : PTR  info.
5. Exit
Algorithm: COUNT(START, NUM) This algorithm finds the number of
elements in the list.
1. Set NUM := 0.
4. Set NUM := NUM + 1.
5. Exit

Searching
Here we will see how a search for an item can be performed in an
ordered and unordered list.
Algorithm: SEARCH(START, ITEM, LOC) This algorithm finds the location
LOC of the node where ITEM first appears in an unordered linked list, or
sets LOC = NULL.
2.Repeat steps 3 and 4 while PTR ≠ NULL:
3. If ITEM = PTR  info, then:
Set LOC := PTR and Exit.
Else
Set PTR := PTR  link.
[End of If structure.]
4. Set LOC := NULL.
5. Exit

Algorithm: SEARCH(START, ITEM, LOC) This algorithm finds the location
LOC of the node where ITEM first appears in an ordered linked list, or sets
LOC = NULL. The list elements are arranged in descending order.
2.Repeat step 3 while PTR ≠ NULL:
3. If ITEM < PTR  info, then:
Set PTR := PTR  link.
Else if ITEM = PTR  info, then:
Set LOC := PTR and Exit.
Else
Set LOC := NULL, and Exit.
[End of If structure.]
4. Set LOC := NULL.
5. Exit

Insertion
 Different ways of inserting a node in a linked list are:
 Insert at the beginning of the list
 Insert after a specified node
 Insert at the end of the list
Insert at the beginning
This operation is illustrated as follows
A 2000 B 0
1000
STAR
T
1000 2000
STEP 1 – Create a new node
A 2000 B 0
1000
STAR
T
1000 2000
C 0
3000
NEW
3000
STEP 2 – Make the new
node point to the current
first node.
A 2000 B 0
1000
STAR
T
C 1000
3000
NEW
3000
1000 2000 STEP 1 – Create a new node
STEP 2 – Make the new
node point to the current
first node.
STEP 3 - Make START point
to the new node
A 2000 B 0
3000
STAR
T
C 1000
3000
NEW
3000
1000 2000
C 1000 A 2000 B 0
3000
START
3000 1000 2000

Function to insert a node at the beginning of a list
3000
STAR
T
A 2000 B 0
1000 2000
3000
NEW
C 1000
3000
node* insertBeg(node* START, char data){
}
node* NEW;
NEW = (node*)malloc(sizeof(node));
NEW  info = data;
}
node* NEW;
NEW  link = START;
}
node* NEW;
NEW  link = START;
START = NEW;
return START;
}

Insertion at the
end
A 2000 B 0
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
STEP 2 – Reach the end of the list
A 2000 B 0
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
TEMP
A 2000 B 0
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
TEMP
A 2000 B 0
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
TEMP
STEP 2 – Reach the end of the list
STEP 3 – Make TEMP point to the NEW
node
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
TEMP
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000

Function to insert a node at the end of
a list
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
3000
NEW
TEMP
node* insertEnd(node* START, char
data){
}
data){
node* NEW;
NEW =
(node*)malloc(sizeof(node));
NEW  link = NULL;
}
data){
node* NEW, *TEMP;
NEW =
(node*)malloc(sizeof(node));
TEMP = START;
while(TEMP  link != NULL)
TEMP  link = NEW;
return START;
}

Insertion after a specified
node
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
4000
NEW
TEMP
D 0
4000
STEP 2 – Reach the specified node
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
4000
NEW
TEMP
D 0
4000
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
4000
NEW
TEMP
D 0
4000
STEP 3 – Make the link field of NEW node
point to the last node.
A 2000 B 3000
1000
1000 2000
STAR
T
C 0
3000
4000
NEW
TEMP
D 3000
4000
STEP 3 – Make the link field of NEW node
point to the last node.
STEP 4 – Make the link field of TEMP node
point to the NEW node.
A 2000 B 4000
1000
1000 2000
STAR
T
C 0
3000
4000
NEW
TEMP
D 3000
4000
A 2000 B 4000
1000
1000 2000
STAR
T
C 0
3000
D 3000
4000

Function to insert a node after a specified
node
A 2000 B 4000
1000
1000 2000
STAR
T
C 0
3000
D 3000
4000
TEMP
NEW
4000
NEW  link = TEMP  link;
node* insertAfter(node* START, char data, char
key){
}
key){
node* NEW, *TEMP;
}
key){
node* NEW, *TEMP;
TEMP = START;
while(TEMP != NULL){
if(TEMP  info = = key)
break;
TEMP= TEMP  link;
NEW  link = TEMP  link;
TEMP  link = NEW;
return START;

Deletion
 Different ways of deleting a node from a linked list are:
 Deleting the first node of the list
 Deleting a specified node
 Deleting the last node of the list
Deleting the first node of the list
A 2000 B 3000 C 0
1000
STA
RT
STEP 1 – Set a TEMP
pointer to the first node.
TEM
P
STEP 2 – Make START point
to the second node.
A 2000 B 3000 C 0
2000
STA
RT
TEM
P
STEP 2 – Make START point
to the second node.
STEP 3 – Delete the node
pointed by TEMP
B 3000 C 0
2000
STA
RT

Function to delete the first node of
the list
B 3000 C 0
1000
STAR
T
A 2000
TEMP
node* deletFront(node* start){
}
node* temp;
temp = start;
}
node* temp;
temp = start;
start = start  link;
}
2000
node* temp;
temp = start;
start = start  link;
free(temp);
return start;
}

Deleting a specified
node
STAR
T
1000
1000
A 2000
2000
B 3000
3000
C 0
STEP 1 – Create two pointers TEMP and PREV.
STEP 2 – Set TEMP to START and PREV to NULL..
TEMP
STEP 3 – Search for the specified node using TEMP. Also
PREV must be one step behind TEMP.
TEMP
PREV
STEP 4 – Make PREV node point to the node next to
TEMP.
A 3000
STEP 4 – Make PREV node point to the node next to
TEMP.
STEP 5 – Delete the node pointed by TEMP.
STAR
T
1000
1000 3000
C 0
A 3000

Function to delete a specified node from
the list
STAR
T
1000
1000 2000
B 3000
3000
C 0
node* deleteSpecific(node* start, char
key){
}
node* deleteSpecific(node *start, char
key){
node *temp, *prev;
temp = start; prev = NULL;
}
TEMP
node* deleteSpecific(node *start, char
key){
node *temp, *prev;
temp = start; prev = NULL;
while(temp != NULL){
if(temp  info == key)
break;
prev = temp;
temp = temp  link;
}
PREV TEMP
A 2000
prev  link = temp  link;
A 3000
free(temp);
free(temp);
return start;
}
STAR
T
1000
1000 3000
C 0
A 3000

Deleting the last node of the
list
B 3000 C 0
STAR
T
A 2000
1000
1000 2000 3000
STEP 1 – Create two pointers TEMP and
PREV
STEP 2 – Set TEMP to START and PREV to
NULL
TEMP
PREV
NULL
STEP 3 – Reach the end of the list using
TEMP. Also PREV must be one
step before TEMP.
B 3000 C 0
STAR
T
A 2000
1000
1000 2000 3000
TEMP
PREV
PREV
NULL
step before TEMP.
PREV
NULL
step before TEMP.
STEP 5 – Set the link field of the node pointed
by PREV to NULL.
B 0
STAR
T
A 2000
1000
1000 2000
B 0

Function to delete the last node from
the list
C 0
STAR
T
1000
1000 2000 3000
node* deleteEnd(node*
start){
}
node* deleteEnd(node* start){
node *temp, *prev;
temp = start; prev =
NULL;
}
TEMP
node *temp, *prev;
NULL;
while(temp  link !=
NULL){
prev = temp;
temp = temp 
link;
}
}
PREV
A 2000
TEMP
B 3000
STAR
T
1000
1000 2000 3000
PREV
A 2000
TEMP
B 3000 C 0
node *temp, *prev;
NULL;
NULL){
prev = temp;
temp = temp 
link;
}
free(temp);
}
node *temp, *prev;
NULL;
NULL){
prev = temp;
temp = temp 
link;
}
free(temp);
prev  link = NULL;
B 0
STAR
T
A 2000
1000
1000 2000
B 0

Displaying contents of a list
B 3000 C 0
STAR
T
A 2000
TEMP
1000
1000 2000 3000
void display(node
*start){
}
void display(node
*start){
node *temp;
temp = start;
}
void display(node *start){
node *temp;
temp = start;
while(temp != NULL){
printf(“%c”,temp 
info);
temp = temp  link;
}
}
B 3000 C 0
STAR
T
A 2000
TEMP
1000
1000 2000 3000
B 3000 C 0
STAR
T
A 2000
TEMP
1000
1000 2000 3000

Module 3 Dara structure notes

Recommended

Recommended

More Related Content

Similar to Module 3 Dara structure notes

Similar to Module 3 Dara structure notes (20)

Recently uploaded

Recently uploaded (20)

Module 3 Dara structure notes