Linked List - Indian Institute of Technology Kharagpurcse.iitkgp.ac.in/~ppd/course/pds/Lect-23-24-Linked-List.pdf · Linked List A completely different way to represent a list Make

Linked ListLinked ListLinked List

1

Linked List

List� A list refers to a sequence of data items

� Example: An array

� The array index is used for accessing and

manipulation of array elements

� Problems with arrays� Problems with arrays

� The array size has to be specified at the

beginning (at least during dynamic allocation)

� realloc can be used to readjust size in middle, but

contiguous chunk of memory may not be available

� Deleting an element or inserting an element may

require shifting of elements

� Wasteful of space

A list refers to a sequence of data items

The array index is used for accessing and

manipulation of array elements

2

The array size has to be specified at the

beginning (at least during dynamic allocation)

can be used to readjust size in middle, but

contiguous chunk of memory may not be available

Deleting an element or inserting an element may

require shifting of elements

Linked List

� A completely different way to represent a list

�Make each data in the list part of a structure

�The structure also contains a pointer or link to �The structure also contains a pointer or link to

the structure (of the same type)

next data

�This type of list is called a linked list

Structure 1 Structure 2

data data

A completely different way to represent a

Make each data in the list part of a structure

The structure also contains a pointer or link to

3

The structure also contains a pointer or link to

(of the same type) containing the

This type of list is called a linked list

Structure 2 Structure 3

data

Forming a linked list

� Let each structure of the list (lets call it

two fields:

� One containing the data

� The other containing the

structure holding the next data in the liststructure holding the next data in the list

� The structures in the 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

Forming a linked list

Let each structure of the list (lets call it node) have

One containing the data

The other containing the address of the

structure holding the next data in the list

4

structure holding the next data in the list

The structures in the linked list need not be

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

Contd.� struct node

{int data;struct node *next;

}

� The pointer variable nextaddress of the location in memory of the successor list element or the special value defined as 0� NULL is used to denote the end of the list (no successor

element)

� Such structures which contain a member field pointing to the same structure type are called referential structures

data

node

next

5

contains either the address of the location in memory of the successor list element or the special value NULL

is used to denote the end of the list (no successor

Such structures which contain a member field pointing to the same structure type are called self-

Example: nodes of the list

struct node a, b, c;

a.data = 1;

b.data = 2;

c.data = 3;c.data = 3;

a.next = b.next = c.next = NULL;

1 NULL

data next

a

2 NULL

data next

b

Example: nodes of the list

6

a.next = b.next = c.next = NULL;

NULL

next

3 NULL

data next

c

Chaining these together

a.next = &b;

b.next = &c;

a b

1

data next

2

data next

What are the values of :

• a.next->data

• a.next->next->data


c

7

next

3

data next

NULL



a.next = &b;

b.next = &c;

a b

1

data next

2

data next


• a.next->data

• a.next->next->data


c

8

next

3

data next

NULL

What are the values of : 2

3

Linked Lists

� A singly linked list is a data structure consisting of a sequence of nodes

� Each node stores

� data

� link to the next node

datanext

node

9

node

NULL

Contd.

� A head pointer addresses the first element of

the list

� Each element points at a successor element

� The last element has a link value NULL

head

A head pointer addresses the first element of

Each element points at a successor element

The last element has a link value NULL

10

NULL

Contd.

� In general, a node of the linked list may be represented as

struct node_namestruct node_name

{

type member1;

type member2;

………

struct node_name *next;

};

In general, a node of the linked list may be

Name of the type of nodes

11

struct node_name *next;

Data items in each element of the list

Link to the next element in the list

Example: list of student records

� Structure for each node

struct stud

{

int roll;int roll;

char name[30];

int age;

struct stud *next;

};

� Suppose the list has three students’ records

� Declare three nodes n1, n2, and n3

struct stud n1, n2, n3;

Example: list of student records

Structure for each node

12

char name[30];

struct stud *next;

Suppose the list has three students’ records

Declare three nodes n1, n2, and n3


Contd.

� Create the links between the nodes

n1.next = &n2 ;

n2.next = &n3 ;

n3.next = NULL ;n3.next = NULL ; /* No more nodes follow */

� The final list looks like

n1

roll

name

age

next

Create the links between the nodes

13

/* No more nodes follow */

n2 n3

Code for the Example#include <stdio.h>

struct stud

{

int roll;

char name[30];

int age;

struct stud *next;struct stud *next;

};

int main()

{


struct stud *p;

scanf (“%d %s %d”, &n1.roll, n1.name, &n1.age);



Code for the Example

14





n1.next = &n2 ;

n2.next = &n3 ;

n3.next = NULL ;

/* Now traverse the list and print the

elements */

p = &n1 ; /* point to 1

while (p != NULL)

{

printf (“\n %d %s %d”,

p->roll, p->name, p

p = p->next;

}

return 0;

}

n3.next = NULL ;

/* Now traverse the list and print the

151515

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

while (p != NULL)

n %d %s %d”,

>name, p->age);

>next;

Alternative Way

� Instead of statically declaring the structures n1,

n2, n3,

� Dynamically allocate space for the nodes

� Use malloc individually for every node allocated

� This is the usual way to work with linked lists, as

number of elements in the list is usually not

known in advance (if known, we could have

used arrays)

� See examples next

Instead of statically declaring the structures n1,

Dynamically allocate space for the nodes

161616

Use malloc individually for every node allocated

This is the usual way to work with linked lists, as

number of elements in the list is usually not

known in advance (if known, we could have

Example of dynamic node allocation

15 18

Storing a set of elements = {15,18,12,7}

15 18

struct node {

int data ;

struct node * next ;

} ;

struct node *p, *q;

Example of dynamic node allocation

12 7

Storing a set of elements = {15,18,12,7}

17

12 7

NULL

data next

int node *

q = (str

p = (struct node *) malloc(sizeof(struct node));

p

struct node {

int data ;


Adding 15

and 18 only

p

p


} ;

struct node *p, *q;

(struct node *) malloc(sizeof(struct node));

q->data=18; q->next = NULL;


p->data=15;

15

15 18

p

18

NULL

15 18

q

p->next = q;

NULL

15 18

q

Traversing the elements added

struct node {

int data;

struct node * next;

};

int main() {

struct node *p,*q,*r;

p = (struct node *) malloc(sizeof(struct node));p = (struct node *) malloc(sizeof(struct node));

:

r=p;

while(r!=NULL){

printf("Data = %d \n",r->data);

r=r->next;

}

return 0;

}

Traversing the elements added


Output

Data = 15

Data = 18

19

p = (struct node *) malloc(sizeof(struct node)); We could have done anything else other than printing as we traverse each element, like searching for example. Just like traversing an array.

Contd.

� We assumed two elements in the list, so took two pointers p and q

� What if the number of elements are not known?� Precisely the reason we use linked list� Precisely the reason we use linked list

� Solution: � Remember the address of the first element in a

special pointer (the head pointer), make sure to not overwrite it

� Any other pointer can be reused

We assumed two elements in the list, so took

What if the number of elements are not known?Precisely the reason we use linked list

20

Precisely the reason we use linked list

Remember the address of the first element in a special pointer (the head pointer), make sure to not

Any other pointer can be reused

Example: adding n elements read from

keyboardint main() {

int n, i;

struct node *head = NULL, *p, *prev;

scanf(“%d”, &n);

for (i = 0; i < n; ++i) {


scanf(“%d”, &p->data);

p->next = NULL;

if (head == NULL) head = p;

else prev->next = p;

prev = p;

}

return 0;

}

Example: adding n elements read from

head changes only once, when the first element is added

prev remembers

21

p = (struct node *) malloc(sizeof(struct node));prev remembers the pointer to the last element added,

p is linked to its next field

p and prev are reused as many times as needed

Example: printing an arbitrary sized list

int main()

{

int n, i;

struct node *head = NULL, *p;

::

p = head;

while (p != NULL) {

printf(“%d “, p->data);

p = p->next;

}

return 0;

}

Example: printing an arbitrary sized list

Assumed that the list is already created and head points to the first element in the list

p is reused to point

22

p is reused to point to the elements in the list (initially, to the first element)

When p points to the last element, p->next = NULL, so the loop terminates after this iteration

Important to remember

� Store the address of the first element added in a

separate pointer (head in our examples), and

make sure not to change it

� If you lose the start pointer, you cannot access any

element in the list, as elements are only accessible element in the list, as elements are only accessible

from the next pointers in the previous element

� In the print example, we could have reused

(head=head->next instead of

not need to remember the start pointer after

printing the list, but this is considered bad practice,

so we used a separate temporary pointer

Important to remember

Store the address of the first element added in a

in our examples), and

make sure not to change it

If you lose the start pointer, you cannot access any

element in the list, as elements are only accessible

23

element in the list, as elements are only accessible

from the next pointers in the previous element

In the print example, we could have reused head,

instead of p=p->next) as we do

not need to remember the start pointer after

printing the list, but this is considered bad practice,

so we used a separate temporary pointer p

Function to print a list

void display (struct node *r)

{

struct node *p = r;

printf(“List = {”);

while(p != NULL) {

The pointer to the

start of the list while(p != NULL) {

}

printf(“}

}

start of the list

(head pointer) is

passed as

parameter

Function to print a list

void display (struct node *r)

struct node *p = r;

printf(“List = {”);

while(p != NULL) {

24

while(p != NULL) {

printf("%d, ", p->data);

p = p->next;

printf(“}\n”);

Common Operations on Linked

Lists

� Creating a linked list (already seen)

� Printing a linked list (already seen)

� Search for an element in a linked list (can be easily done by traversing)easily done by traversing)

� Inserting an element in a linked list� Insert at front of list

� Insert at end of list

� Insert in sorted order

� Delete an element from a linked list

Common Operations on Linked

Creating a linked list (already seen)

Printing a linked list (already seen)

Search for an element in a linked list (can be easily done by traversing)

25

easily done by traversing)

Inserting an element in a linked list

Delete an element from a linked list

Search for an element

struct node *search (struct node *r, int value)

{

struct node *p;

p = r;

Takes the

head pointer

as parameter

Traverses the

list and

compares while (p!=NULL){

if (p->data == value) return p;

p = p->next;

}

return p;

}

compares

value with

each data

Returns the

node with the

value if

found, NULL

otherwise

Search for an element

struct node *search (struct node *r, int value)

struct node *p;

26

while (p!=NULL){

>data == value) return p;

>next;

Insertion in a list

� To insert a data item into a linked list involves� creating a new node containing the data

� finding the correct place in the list, and

linking in the new node at this place� linking in the new node at this place

� Correct place may vary depending on what is needed�Front of list

�End of list

�Keep the list in sorted order

�…

Insertion in a list

To insert a data item into a linked list

node containing the data

finding the correct place in the list, and

linking in the new node at this place

27

linking in the new node at this place

may vary depending on what

Keep the list in sorted order

Insert in front of list

struct node *insert(struct node *r, int value)

{

struct node *p;

Takes the

head pointer

and the value

to be inserted

(NULL if list is

empty)struct node *p;


p->data = value;

p ->next = r;

return p;

}

Inserts the

value as the

first element of

the list

Returns the

new head

pointer value

Insert in front of list

struct node *insert(struct node *r, int value)

struct node *p;

28

struct node *p;


>data = value;

>next = r;

Contd.

15pp

15 18p

r

18 3

18

r

3 …

…

29

r

18 3 …

Using the Insert Function

void display (struct node *);

struct node * insert(struct node * , int);

int main()

{ struct node *head;

head = NULL;

head = insert(head, 10);head = insert(head, 10);

display(head);

head = insert(head, 11);

display(head);

head = insert(head, 12);

display(head);

return 0;

}

Using the Insert Function


Output

30

List = {10, }

List = {11, 10, }

List = {12, 11, 10, }

Insert at endstruct node *insert_end(struct node *r,

{ struct node *p,*q;


p->data = value;

p ->next = NULL;

Takes the

head pointer

and the value

to be inserted

(NULL if list is

empty)

p ->next = NULL;

if (r==NULL

q=r;

while (q->next!=NULL)

q=q->next; /* find the last element */

q->next =p;

return r;

}

Inserts the

value as the

last element of

the list

Returns the

new head

pointer value

Insert at endstruct node *insert_end(struct node *r,

int value)

{ struct node *p,*q;


>data = value;

>next = NULL;

31

>next = NULL;

LL) return p; /* list passed is empty */

>next!=NULL)

>next; /* find the last element */

Contd.

11

r

11

r

…

15

p

4…

11

r

4…

q NULL

32

15…NULL NULL

15

p

4

NULLq

q

Using the Insert at End Functionvoid display (struct node *);


struct node * insert_end(struct node * , int);

int main()

{

struct node *start;

start = NULL;start = NULL;

start = insert_end(start, 10);

display(start);


display(start);


display(start);

return 0;

}

Using the Insert at End Function


struct node * insert_end(struct node * , int);

Output

33

List = {10, }

List = {10, 11, }

List = {10, 11, 12, }

Output

Insertion in Ascending Order

3 5

first prev

� Create new node for the 7

� Find correct place – when ptr finds the 8 (7 < 8)

� Link in new node with previous (even if last) and ptr nodes

� Also check insertion before first node!

7new

Insertion in Ascending Order

8 12 -

ptr

34

when ptr finds the 8 (7 < 8)

Link in new node with previous (even if last) and ptr

Also check insertion before first node!

7

Insert in ascending order & sortstruct node * insert_asc(struct node * r, int value)

{ struct node *p, *q, *new;

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

new->data = value; new ->next = NULL;

p = r; q = p;

while(p!=NULL) {

if (p->data >= value) { /* insert before */

if (p==r) { new->next =r; /* insert at start */if (p==r) { new->next =r; /* insert at start */

return new; }

new->next = p; /* insert before p */

q->next = new;

return r; }

q = p;

p = p->next; } /* exists loop if > largest */

if (r==NULL) return new; /* first time */

else q->next = new; /* insert at end */

return r; }

Insert in ascending order & sortstruct node * insert_asc(struct node * r, int value)

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

/* insert at start */

int main()

{

struct node *start;

int i,n,value;

start = NULL;

scanf("%d",&n);

for(i=0; i<n; i++) {

printf("Give Data: " );

35

/* insert at start */ printf("Give Data: " );

scanf("%d",&value);

start = insert_asc(start, value);

}

display(start);

return 0;

}

Deletion from a list

� To delete a data item from a linked list

�Find the data item in the list, and if found

�Delink this node from the list

�Free up the malloc’ed node space�Free up the malloc’ed node space

Deletion from a list

To delete a data item from a linked list

Find the data item in the list, and if found

Delink this node from the list

Free up the malloc’ed node space

36

Free up the malloc’ed node space

Example of Deletion

3 5

prevfirst

� When ptr finds the item to be deleted, e.g. 8, we need

the previous node to make the link to the next one

after ptr (i.e. ptr -> next)

� Also check whether first node is to be deleted

Example of Deletion

8 12 -

ptr

37

When ptr finds the item to be deleted, e.g. 8, we need

the previous node to make the link to the next one

Also check whether first node is to be deleted

Deleting an elementstruct node * delete(struct node * r, int value)

{ struct node *p, *q;

p =r;

q = p;

while(p!=NULL) {

if (p->data == value){

if (p==r) r = p->next;

else q->next = p->next;

11…q

else q->next = p->next;

p->next = NULL;

free(p);

return r;

}

else { q = p;

p = p->next;

}

}

return r;

}

11…q

11…q

Deleting an elementstruct node * delete(struct node * r, int value)

154 …q p

delete(r,4)

38

154 …q p NULL

15 …q

Exercises

� Print a list backwards (try a recursive print)

� Count the number of elements in a list (both using and not using recursion)(both using and not using recursion)

� Concatenate two lists

� Reverse a list

Print a list backwards (try a recursive print)

Count the number of elements in a list (both using and not using recursion)

39

(both using and not using recursion)

Concatenate two lists

Documents

Linked List - Indian Institute of Technology Kharagpurcse.iitkgp.ac.in/~ppd/course/pds/Lect-23-24-Linked-List.pdf · Linked List A completely different way to represent a list Make