Self-referential Structures

and
Linked List

1
 Linked List :: Basic Concepts

• A list refers to a set of items organized

sequentially.
– An array is an example of a list.
• The array index is used for accessing and
manipulating array elements.
– Problems with array:
• The array size has to be specified at the
beginning.
• Deleting an element or inserting an element
may require shifting of elements in the array.
2
 Contd.

• A completely different way to represent a

list:
– Make each item in the list part of a structure.
– The structure also contains a pointer or link to
the structure containing the next item.
– This type of list is called a linked list.

Structure 1 Structure 2 Structure 3

item item item

3
 Contd.
• Each structure of the list is called a node,
and consists of two fields:
– One containing the data item(s).
– The other containing the address of the next
item in the list (that is, a pointer).

• The data items comprising a linked list

need not be contiguous in memory.
– They are ordered by logical links that are
stored as part of the data in the structure itself.
– The link is a pointer to another structure of the
same type.
4
 Contd.

• Such a structure can be represented as:

struct node
{
int item;
struct node *next;
} node

item next

• Such structures which contain a member

field pointing to the same structure type
are called self-referential structures.
5
 Contd.

• In general, a node may be represented as

follows:

struct node_name
{
type member1;
type member2;
………
struct node_name *next;
}

6
 Illustration

• Consider the structure:

struct stud
{
int roll;
char name[30];
int age;
struct stud *next;
}

• Also assume that the list consists of three

nodes n1, n2 and n3.
struct stud n1, n2, n3;
7
 Contd.

• To create the links between nodes, we can

write:
[Link] = &n2;
[Link] = &n3;
[Link] = NULL; /* No more nodes follow */
• Now the list looks like:

roll
name
age
next

n1 n2 n3
8
• Some important observations:
– The NULL pointer is used to indicate that no
more nodes follow, that is, it is the end of the
list.
– To use a linked list, we only need a pointer to
the first element of the list.
– Following the chain of pointers, the successive
elements of the list can be accessed by
traversing the list.

9
 Example: without using function
#include<stdio.h>
struct stud
{
int roll;
char name[30];
int age;
struct stud *next;
}

main()
{
struct stud n1, n2, n3;
struct stud *p;

scanf (”%d %s %d”, &[Link], [Link], &[Link]);

scanf (”%d %s %d”, &[Link], [Link], &[Link]);
scanf (”%d %s %d”, &[Link], [Link], &[Link]);
10
 [Link] = &n2;
[Link] = &n3;
[Link] = NULL;

/* Now traverse the list and print the elements */

p = &n1; /* point to 1st element */

while (p != NULL)
{
printf (”\n %d %s %d”, p->roll, p->name, p->age);
p = p->next;
}
}

11
 A function to carry out traversal
#include<stdio.h>
struct stud
{
int roll;
char name[30];
int age;
struct stud *next;
}

void traverse (struct stud *head)

{
while (head != NULL)
{
printf (”\n %d %s %d”, head->roll, head->name,
head->age);
head = head->next;
}
} 12
 The corresponding main() function

main()
{
struct stud n1, n2, n3, *p;

scanf (”%d %s %d”, &[Link], [Link], &[Link]);

scanf (”%d %s %d”, &[Link], [Link], &[Link]);
scanf (”%d %s %d”, &[Link], [Link], &[Link]);

[Link] = &n2;
[Link] = &n3;
[Link] = NULL;

p = &n1;
traverse (p);
}

13
 Alternative and More General Way

• Dynamically allocate space for the nodes.

– Use malloc() or calloc() for allocating
space for every individual nodes.
– No need for allocating additional space
unnecessarily like in an array.

14
Linked List in more detail

15
 Introduction

• A linked list is a data structure which can

change during execution.
– Successive elements are connected by pointers.
– Last element points to NULL.
– It can grow or shrink in size during execution of
a program.
– It can be made just as long as required.
head
– It does not waste memory space.

A B C

16
• Keeping track of a linked list:
– Must know the pointer to the first element of
the list (called start, head, etc.).

• Linked lists provide flexibility in allowing

the items to be rearranged efficiently.
– Insert an element.
– Delete an element.

17
 Illustration: Insertion
head

A B C

Item to be
X inserted
head

A B C

18
 Illustration: Deletion
head
Item to be deleted
A B C

head

A B C

19
 In essence ...

• For insertion:
– A record is created holding the new item.
– The next pointer of the new record is set to link it
to the item which is to follow it in the list.
– The next pointer of the item which is to precede it
must be modified to point to the new item.

• For deletion:
– The next pointer of the item immediately preceding
the one to be deleted is altered, and made to point
to the item following the deleted item.

20
 Array versus Linked Lists

• Arrays are suitable for:

– Inserting/deleting an element at the end.
– Randomly accessing any element.
– Searching the list for a particular value.

• Linked lists are suitable for:

– Inserting an element.
– Deleting an element.
– Applications where sequential access is required.
– In situations where the number of elements
cannot be predicted beforehand.
21
 Types of Lists

• Depending on the way in which the links

are used to maintain adjacency, several
different types of linked lists are possible.
– Linear singly-linked list (or simply linear list)
• One we have discussed so far.

head

A B C

22
 – Circular linked list
• The pointer from the last element in the list
points back to the first element.

head

A B C

23
 – Doubly linked list
• Pointers exist between adjacent nodes in
both directions.
• The list can be traversed either forward or
backward.
• Usually two pointers are maintained to keep
head track of the list, head and tail. tail

A B C

24
 Basic Operations on a List

• Creating a list
• Traversing the list
• Inserting an item in the list
• Deleting an item from the list
• Concatenating two lists into one

25
 List is an Abstract Data Type

• What is an abstract data type?

– It is a data type defined by the user.
– Typically more complex than simple data types
like int, float, etc.
• Why abstract?
– Because details of the implementation are
hidden.
– When you do some operation on the list, say
insert an element, you just call a function.
– Details of how the list is implemented or how the
insert function is written is no longer required.
26
 Conceptual Idea

Insert
List
implementation
Delete
and the
related functions
Traverse

27
 Example: Working with linked list
• Consider the structure of a node as
follows:
struct stud {
int roll;
char name[25];
int age;
struct stud *next;
};

/* A user-defined data type called “node” */

typedef struct stud node;
node *head;

28
Creating a List

29
 How to begin?

• To start with, we have to create a node (the

first node), and make head point to it.
head = (node *) malloc(sizeof(node));

head
roll
name next
age

30
 Contd.

• If there are n number of nodes in the initial

linked list:
– Allocate n records, one by one.
– Read in the fields of the records.
– Modify the links of the records so that the
chain is formed.
head

A B C

31
node *create_list()
{
int k, n;
node *p, *head;
printf ("\n How many elements to enter?");
scanf ("%d", &n);
for (k=0; k<n; k++)
{
if (k == 0) {
head = (node *) malloc (sizeof(node));
p = head;
}
else {
p->next = (node *) malloc (sizeof(node));
p = p->next;
}
scanf ("%d %s %d", &p->roll, p->name, &p->age);
}
p->next = NULL;
return (head);
}

32
• To be called from main() function as:

node *head;
………
head = create_list();

33
Traversing the List

34
 What is to be done?

• Once the linked list has been constructed

and head points to the first node of the
list,
– Follow the pointers.
– Display the contents of the nodes as they are
traversed.
– Stop when the next pointer points to NULL.

35
void display (node *head)
{
int count = 1;
node *p;

p = head;
while (p != NULL)
{
printf ("\nNode %d: %d %s %d", count,
p->roll, p->name, p->age);
count++;
p = p->next;
}
printf ("\n");
}

36
• To be called from main() function as:

node *head;
………
display (head);

37
Inserting a Node in a List

38
 How to do?

• The problem is to insert a node before a

specified node.
– Specified means some value is given for the
node (called key).
– In this example, we consider it to be roll.

• Convention followed:
– If the value of roll is given as negative, the
node will be inserted at the end of the list.

39
 Contd.

• When a node is added at the beginning,

– Only one next pointer needs to be modified.
• head is made to point to the new node.
• New node points to the previously first
element.

• When a node is added at the end,

– Two next pointers need to be modified.
• Last node now points to the new node.
• New node points to NULL.

40
• When a node is added in the middle,
– Two next pointers need to be modified.
• Previous node now points to the new node.
• New node points to the next node.

41
void insert (node **head)
{ Why is the argument
int k = 0, rno; a pointer to pointer?
node *p, *q, *new;

new = (node *) malloc (sizeof(node));

printf ("\nEnter data to be inserted: ");

scanf ("%d %s %d", &new->roll, new->name, &new->age);
printf ("\nInsert before roll (-ve for end):");
scanf ("%d", &rno);

p = *head;

if (p->roll == rno) /* At the beginning */

{
new->next = p;
*head = new;
}
42
 else
{
while ((p != NULL) && (p->roll != rno))
{
q = p; The pointers q and p
p = p->next; always point to
} consecutive nodes.
if (p == NULL) /* At the end */
{
q->next = new;
new->next = NULL;
}

else if (p->roll == rno)

/* In the middle */
{
q->next = new;
new->next = p;
}
}
43
}
• To be called from main() function as:

node *head;
………
insert (&head);

44
Deleting a node from the list

45
 What is to be done?

• Here also we are required to delete a

specified node.
– Say, the node whose roll field is given.

• Here also three conditions arise:

– Deleting the first node.
– Deleting the last node.
– Deleting an intermediate node.

46
void delete (node **head)
{
int rno;
node *p, *q;

printf ("\nDelete for roll: ");

scanf ("%d", &rno);

p = *head;
if (p->roll == rno)
/* Delete the first element */
{
*head = p->next;
free (p);
}

47
 else
{
while ((p != NULL) && (p->roll != rno))
{
q = p; The pointers q and p
p = p->next; always point to
} consecutive nodes.

if (p == NULL) /* Element not found */

printf ("\nNo match :: deletion failed");

else if (p->roll == rno)

/* Delete any other element */
{
q->next = p->next;
free (p);
}
}
} 48
 A sample main() function

int main()
{
node *head;

head = create_list();
display(head);

insert(&head);
display(head);

delete(&head);
display(head);
}

49
Abstract Data Types

50
 Definition

• An abstract data type (ADT) is a specification

of a set of data and the set of operations that
can be performed on the data.
• Such data type is abstract in the sense that it
is independent of various concrete
implementations.
• Some examples follow.

51
Example 1 :: Complex numbers
add

sub

mul Complex
Number
div

read

print
52
 Example 1 :: Complex numbers
struct cplx {
float re; Structure
float im;
}
definition
typedef struct cplx complex;

complex *add (complex a, complex b);

complex *sub (complex a, complex b);
complex *mul (complex a, complex b); Function
complex *div (complex a, complex b); prototypes
complex *read();
void print (complex a);

53
 Example 2 :: Set manipulation
union

intersect

minus
Set
insert

delete

size
54
 Example 2 :: Set manipulation
struct node {
int element; Structure
struct node *next;
}
definition
typedef struct node set;

set *union (set a, set b);

set *intersect (set a, set b);
set *minus (set a, set b); Function
void insert (set a, int x); prototypes
void delete (set a, int x);
int size (set a);

55
Example 3 :: Last-In-First-Out STACK
push

pop

create
STACK
isempty

isfull

56
 Visualization of a Stack

In Out

C B A B C

57
 Example 3 :: Last-In-First-Out STACK

Assume:: stack contains integer elements

void push (stack s, int element);
/* Insert an element in the stack */
int pop (stack s);
/* Remove and return the top element */
void create (stack s);
/* Create a new stack */
int isempty (stack s);
/* Check if stack is empty */
int isfull (stack s);
/* Check if stack is full */

58
 Contd.

• We shall later look into two different ways

of implementing stack:
– Using arrays
– Using linked list

59
Example 4 :: First-In-First-Out QUEUE
enqueue

dequeue

create
QUEUE
isempty

size

60
 Visualization of a Queue

In Out

C B A B A

61
Example 4 :: First-In-First-Out QUEUE

Assume:: queue contains integer elements

void enqueue (queue q, int element);
/* Insert an element in the queue */
int dequeue (queue q);
/* Remove an element from the queue */
queue *createq();
/* Create a new queue */
int isempty (queue q);
/* Check if queue is empty */
int size (queue q);
/* Return the no. of elements in queue */

62
 Few Exercises to Try Out
• Write functions to:
1. Concatenate two given lists into one big list.
node *concatenate (node *head1, node *head2);
2. Insert an element in a linked list in sorted order.
The function will be called for every element to
be inserted.
void insert_sorted (node **head, node *element);
3. Always insert elements at one end, and delete
elements from the other end (first-in first-out
QUEUE).
void insert_q (node **head, node*element)
node *delete_q (node **head) /* Return the deleted node */
63
 More Exercises

4. Implement a circular linked list, and write

functions to insert, delete, and traverse nodes
in the list.
5. Represent a polynomial as a linked list, where
every node will represent a term of the
polynomial (anxn), and will contain the values
of ‘n’ and ‘an’. Write a function to add two
given polynomials.

64