Data Structures and Algorithms

Objectives

In this session, you will learn to:

Identify the features of linked lists Implement a singly-linked list

Ver. 1.0

Session 7

Data Structures and Algorithms

Linked List

Suppose you have to write an algorithm to generate and store all prime numbers between 1 and 10,00,000 and display them. How will you solve this problem?

Ver. 1.0

Session 7

Data Structures and Algorithms

Linked List (Contd.)

Consider the following algorithm, which uses an array to solve this problem:
1. Set I = 0 2. Repeat step 3 varying N from 2 to 1000000 3. If N is a prime number
a. Set A[I] = N b. I = I + 1 // If N is prime store it in an array

4. Repeat step 5 varying J from 0 to I-1 5. Display A[J] // Display the prime numbers
// stored in the array

Ver. 1.0

Session 7

Data Structures and Algorithms

Linked List (Contd.)

What is the problem in this algorithm?

The number of prime numbers between 1 and 10,00,000 is not known. Since you are using an array to store the prime numbers, you need to declare an array of arbitrarily large size to store the prime numbers. Disadvantages of this approach, suppose you declare an array of size N: If the number of prime numbers between 1 and 10,00,000 is more than N then all the prime numbers cannot be stored. If the number of prime numbers is much less than N, a lot of memory space is wasted.

Ver. 1.0

Session 7

Data Structures and Algorithms

Linked List (Contd.)

Thus, you cannot use an array to store a set of elements if you do not know the total number of elements in advance. How do you solve this problem?
By having some way in which you can allocate memory as and when it is required.

Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation

If you knowdeclare an array, a contiguous block of array you When you the address of the first element in the memory can calculate the address of any other elements as shown: is allocated. Let Address of theyou declare an(size of of size 10 to store first us suppose first element + array the element index of the element) 10 prime numbers.

0 1 2 3 4 5 6 7 8 9

1000 1002 1004 1006 1008 1010 1012 1014 1016 1018

One contiguous block of memory allocated for the array to store 10 elements.

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

When memory is allocated dynamically, a block of memory is assigned arbitrarily from any location in the memory. Therefore, unlike arrays, these blocks may not be contiguous and may be spread randomly in the memory.

0 1 2 3 4 5 6 7 8 9

1000 1002 1004 1006 1008 1010 1012 1014 1016 1018

One contiguous block of memory allocated for the array to store 10 elements.

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Let us see how this happens by allocating memory dynamically for the prime numbers.

Allocate memory for 2

1002

Memory allocated for 2

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Let us see how this happens.

Allocate memory for 3

1002

Memory allocated for 3

1036

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Let us see how this happens.

Allocate memory for 5

1002

2 5

Memory allocated for 5

1008

1036

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Let us see how this happens.

Allocate memory for 7

1002

2 5

Memory allocated for 7

1008

1020

1036

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Let us see how this happens.

Allocate memory for 11

1002

2 5

Memory allocated for 11

1008

1020

7 11 3

1030

1036

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

To access know the address of the know its address. Now, if youany element, you need to first element, you cannot calculate the address of the rest of the elements. This is because, all the elements are spread at random locations in the memory.
1002

2 5

1008

1020

7 11 3

1030

1036

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

Therefore, it would be good if every allocated block of memory contains the address of the next block in sequence. This gives the list a linked structure where each block is linked to the next block in sequence.
1002

2 5

1036 1020

1008

1020

7 11 3

1030

1030

1036

1008

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Dynamic Memory Allocation (Contd.)

An can declare data structure that that stores this concept Youexample of a a variable, START, implementsthe address is the first list. of a linked block. You can now begin at START and move through the list by following the links.
START
1002

2 5

1036 1020

1008

1020

7 11 3

1030

1030

1036

1008

Memory representation
Ver. 1.0

Session 7

Data Structures and Algorithms

Defining Linked Lists

Linked list:
Is a dynamic data structure. Allows memory to be allocated as and when it is required. Consists of a chain of elements, in which each element is referred to as a node.

Ver. 1.0

Session 7

Data Structures and Algorithms

Defining Linked Lists (Contd.)

A node is the basic building block of a linked list. A node consists of two parts:
Data: Refers to the information held by the node Link: Holds the address of the next node in the list

Data

Link

Node

Ver. 1.0

Session 7

Data Structures and Algorithms

Defining Linked Lists (Contd.)

The last node in a linked list does not point to any other All the nodes in a linked list are present at arbitrary memory node. Therefore, it points to NULL. locations. Therefore, every node in a linked list has link field that stores the address of the next node in sequence.
NULL

10 Data 3352 2403

10 Data 5689 3352

10 Data 1012 5689

10 Data 1012

Ver. 1.0

Session 7

Data Structures and Algorithms

Defining Linked Lists (Contd.)

To keep track of the first node, declare a variable/pointer, START, which always points to the first node. When the list is empty, START contains null.
START 10 Data 3352 2403 10 Data 5689 3352 10 Data 1012 5689 10 Data 1012 NULL

Ver. 1.0

Session 7

Data Structures and Algorithms

Implementing a Singly-Linked List

Let us solve the given problem of storing prime numbers using a linked list.
1. Repeat step 2 varying N from 2 to 1000000. 2. If N is a prime number, insert it in the linked list:
a. Allocate memory for a new node. b. Store the prime number in the new node. c. Attach the new node in the linked list.

3. Display the prime numbers stored in the linked list.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List

Consider the following linked list that stores prime numbers.

START 2

When a new prime number is generated, it should be inserted at the end of the list. Initially, when the list is empty, START contains NULL.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Consider the given algorithm to insert a node in a linked list.

2.

3.

4.

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Consider NULL START = that the list is initially empty. Insert a prime number 2.

2.

3.

4.

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

START = NULL

2.

Insert a prime number 2.

3.

4.

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

START = NULL

2.

3.

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

START = NULL

2.

3.

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

START = NULL

2.

3.

START

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

Insertion complete
5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Insert a prime number 3.

2.

3.

START

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Insert a prime number 3.

2.

3.

START

4.

2 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

Insertion complete

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Insert a prime number 5.

2.

3.

START

4.

2 10
currentNode

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

Insert a prime number 5.

2.

3.

START

4.

2 10

3 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10
currentNode

3 10

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10

5 10

currentNode currentNode

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10
currentNode

5 10

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

3.

START

4.

2 10

3 10
currentNode

5 10

Insertion complete
5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then: a. Make START point to the new node. b. Go to step 6. Locate the last node in the list, and mark it as currentNode. To locate the last node in the list, execute the following steps: a. Mark the first node as currentNode. b. Repeat step c until the successor of currentNode becomes NULL. c. Make currentNode point to the next node in sequence. Make the next field of currentNode point to the new node. Make the next field of the new node point to NULL. Session 7

What is thea better approach is to Therefore, problem with this algorithm? declare a variable, LAST, which will Consider aaddress of the last store the list of 10000 numbers. node in the a number at the end of To insert list. the list, you first need to locate the Hence, you need to maintain two last node in the and variables, START list. LAST, to To reach the last node, you have keep track of the first and last to start from the first node and nodes in the list respectively. visit all the preceding nodes If the list is empty, START node. before you reach the last and LAST point to NULL.
This approach is very time consuming for lengthy lists.

2.

3.

4.

5.

6.

Ver. 1.0

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

Refer to the given algorithm to insert a node at the end of the linked list.

2.

3.

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

START = NULL Consider that the list is initially empty.= NULL LAST Insert a prime number 2.

2.

3.

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

START = NULL LAST = NULL Insert a prime number 2.

2.

3.

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

START = NULL LAST = NULL

2.

3.

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

START = NULL LAST = NULL

2.

3.

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

START = NULL LAST = NULL

2.

3.

START

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

LAST = NULL

3.

START LAST

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

2 10

4.

5.

Insertion complete

6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

Insert a prime number 3.

2.

3.

START LAST

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

Insert a prime number 3.

2.

3.

START LAST

2 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START LAST

LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

2 10

3 10

4.

5.

Insertion complete

6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

Insert a prime number 5.

2.

3.

START

LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

Insert a prime number 5.

2.

3.

START

LAST

2 10

3 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

2 10

3 10

5 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

2 10

3 10

5 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

2 10

3 10

5 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

LAST

2 10

3 10

5 10

4.

5. 6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Allocate memory for the new node. Assign value to the data field of the new node. If START is NULL, then (If the list is empty): a. Make START point to the new node. b. Make LAST point to the new node. c. Go to step 6. Make the next field of LAST point to the new node. Mark the new node as LAST. Make the next field of the new node point to NULL.

3.

START

LAST

2 10

3 10

5 10

4.

5.

Insertion complete

6.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Now consider another problem.

Suppose you have to store the marks of 20 students in the ascending order. How will you solve this problem?

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Consider the following algorithm, which uses an array to solve this problem.
1. Set N = 0 // Number of marks entered 2. Repeat until N = 20 a. Accept marks. b. Locate position I where the marks must be inserted. c. For J = N 1 down to I Move A[J] to A[J+1] // Move elements to make // place for the new element d. Set A[I] = marks e. N = N + 1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks. b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

Let us perform some insert operations in the array by placing the elements at their appropriate positions to get a sorted list.

19

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

Let us perform some insert operations in the array by placing the elements at their appropriate positions to get a sorted list.

10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 10

10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 10

I=0

10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 10

I=0

10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 10

I=0

10 10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=0

10 10 0 1 2 3 4 19

N=0

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=0

10 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 20

I=0

10 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 20

I=0 1

10 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 20

I=1

10 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 20

I=1

10 20 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=1

10 20 10 0 1 2 3 4 19

N=1

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=1

10 20 10 0 1 2 3 4 19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1

10 20 10 0 1 2 3 4 19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1

10 20 10 0 1 2 3 4 19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1
J=1 I

10 20 10 0 1 2 3 4 19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1
J=1 I

10 20 10 0 1 2 3 4 19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1
J=1 I

10 20 10 0 1

20

19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 17

I=1
J=1 I

10 17 10 0 1

20

19

N=2

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=1

10 17 10 0 1

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

10 17 10 0 1

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1

10 17 10 0 1

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=2 I

10 17 10 0 1

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=2 I

10 17 10 0 1

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=2 I

10 17 10 0 1

20

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=1 I

10 17 10 0 1 2

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=1 I

10 17 10 0 1 2

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=1 I

10 17 10 0 1

17

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

marks = 15

I=1
J=1 I

10 15 10 0 1

17

20

19

N=3

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. Set N = 0 Repeat until N = 20 a. Accept marks b. Locate position I where the marks must be inserted c. For J = N-1 down to I Move A[J] to A[J+1] d. Set A[I] = marks e. N=N+1

I=1
J=1 I

10 15 10 0 1

17

20

19

N=4

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

What is the problem in this algorithm? From the preceding example we conclude that insertion and deletion at anyelement atotherposition other thanan arrayof the To insert an position any than the end of the end is list, there is an additional complex and inefficient. overhead of shifting all succeeding elements one position this limitation? How can you overcome forward.
Similarly, to delete an element at any position shifting of data By using a data structure that does not requireother than the end of the list, every insert / delete succeeding elements after you need to shift the operation. elements one position backwards. A linked list offers this flexibility. When the list is very large, this would be very time consuming.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Consider a linked list that stores the marks of students in an ascending order. Insert marks (17). 17 should be inserted after 15.
20 10
1002 1011

START
10 2496 15 1002 20 1020 25 NULL

25 15

1020 2496

Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Allocate memory for 17.

20 10

1002 1011

Memory allocated for 17

17 25

1008

START
10 2496

17
1020 2496

10

15 1002

10

20 1020

10

25 NULL

15

10

Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

In the given list, node 15 contains the address of node 20. To add node 17 after node 15, you need to update the address field of node 15 so that it now contains the address of node 17.
20 10
1002 1011

Memory allocated for 17

17
25

1008

START
10 2496

17
1020 2496

10

15 1002

10

20 1020

10

25 NULL

15

10

Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Update the address field of node 15 to store the address of node 17.

20 10

1002 1011

17

1008

START
10 2496

17 25 15 1002
1020 2496

10

10

17

20 1020

10

25 NULL

10

15

Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Update the address field of node 15 to store the address of node 17.

20 10

1002 1011

17

1008

START
10 2496

25 1008 15 1002

1020 2496

10

10

17

20 1020

10

25 NULL

10

15

Updating the address field Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Store the address of node 20 in the address field of node 17 to make a complete list.

20 10

1002 1011

Node Inserted
START
10 2496

17
25

1008

1020 2496

10

15 1008

17 1002

20 1020

10

25 NULL

10

15

Address updated Memory representation

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Now, let us solve the given problem using a linked list. Suppose the linked list currently contains the following elements.
START 10 15

17

20

The linked list needs to be created in the ascending order of values. Therefore, the position of a new node in the list will be determined by the value contained in the new node.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Write an algorithm to locate the position of the new node to be inserted in a linked list, where the nodes need to be stored in the increasing order of the values contained in them.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

Algorithm for locating the position of a new node in the linked list. After executing this algorithm the variables/pointers previous and current will be placed on the nodes between which the new node is to be inserted.

2. 3.

4. 5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

Insert 16 in the given list.

2. 3.

4. 5.

START 10 15 17 20

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

Insert 16 in the given list.

2. 3.

4. 5.

START 10 10 15 17 20

current

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

current previous = NULL

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

current previous = NULL

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous current previous = NULL

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous current

current

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous

current

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous previous current

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous current current

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. 2. 3. Make current point to the first node. Make previous point to NULL. Repeat step 4 and step 5 until current.info becomes greater than the newnode.info or current becomes equal to NULL. Make previous point to current. Make current point to the next node in sequence.

4. 5.

START 10 10 15 17 20

previous

current

Node located
Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Once the position of the new node has been determined, the new node can be inserted in the linked list. A new node can be inserted at any of the following positions in the list:
Beginning of the list End of the list Between two nodes in the list

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Write an algorithm to insert a node in the beginning of a linked list.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to the first node in the list. Make START, point to the new node.

Algorithm to insert a node in the beginning of a linked list

2.

3.

START 10 15 17

4.

20

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to the first node in the list. Make START, point to the new node.

Insert 7
newnode

2.

3.

START 10 10 15 17

4.

20

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to the first node in the list. Make START, point to the new node.

Insert 7
newnode

2.

3.

START 10 10 15 17

4.

20

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to the first node in the list. Make START, point to the new node.

2.

newnode

3.

START 10 10 15 17

4.

20

newnode. next = START

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to the first node in the list. Make START, point to the new node.

2.

newnode

3.

START 10 10 15 17

4.

20 Insertion complete

newnode. next = START START = newnode

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)

Write an algorithm to insert a node between two nodes in a linked list.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16 Algorithm to insert a node between two nodes in a linked list.

START 10 15 17 20

2. 3.

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 15 17 20

2. 3.

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 current
2. 3.

15

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 current previous = NULL
2. 3.

15

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 current previous = NULL
2. 3.

15

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 previous current previous = NULL
2. 3.

15

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 previous current 15 current
2. 3.

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 previous 15 current
2. 3.

17

20

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 15 17 20

previous previous current

2. 3.

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 15 17 20

previous currentcurrent
2. 3.

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1. Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Insert 16
START 10 10 15 previous 17 current
2. 3.

20

Nodes located

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1.

newnode

START 10 10 15 previous 17 current

2. 3.

20

Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

Nodes located

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1.

newnode

16
START 10 10 15 previous 17 current
2. 3.

20

Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1.

newnode

16
START 10 10 15 previous 17 current
2. 3.

20

Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

newnode.next = current

4.

5.

Ver. 1.0

Session 7

Data Structures and Algorithms

Inserting a Node in a Singly-Linked List (Contd.)
1.

newnode

16
START 10 10 15 previous 17 current
2. 3.

20

Identify the nodes between which the new node is to be inserted. Mark them as previous and current. To locate previous and current, execute the following steps: a. Make current point to the first node. b. Make previous point to NULL. c. Repeat step d and step e until current.info becomes greater than newnode.info or current becomes equal to NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Allocate memory for the new node. Assign value to the data field of the new node. Make the next field of the new node point to current. Make the next field of previous point to the new node.

newnode.next = current
previous.next = newnode

4.

5.

Insertion complete
Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

Write an algorithm to traverse a list. Algorithm for traversing a linked singly-linked list.
2. 3.

START
4.

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

Refer to the algorithm to display the elements in the linked list.

2.

3.

START
4.

2 10
currentNode

3 10

5 10

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10
currentNode

3 10

5 10

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10
currentNode

3 10

5 10

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10

currentNode currentNode

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10
currentNode

5 10

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10
currentNode

5 10

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10

currentNode currentNode

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10
currentNode

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10
currentNode

7 10

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10

currentNode currentNode

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10
currentNode

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10
currentNode

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10
currentNode currentNode = NULL

Ver. 1.0

Session 7

Data Structures and Algorithms

Traversing a Singly-Linked List (Contd.)
1. Make currentNode point to the first node in the list. Repeat step 3 and 4 until currentNode becomes NULL. Display the information contained in the node marked as currentNode. Make currentNode point to the next node in sequence.

2.

3.

START
4.

2 10

3 10

5 10

7 10
currentNode = NULL

Traversal complete

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node from a Singly-Linked List

Delete operation in a linked list refers to the process of removing a specified node from the list. You can delete a node from the following places in a linked list:
Beginning of the list Between two nodes in the list End of the list

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node From the Beginning of the List

Write an algorithm to delete the first node in a linked list.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node From the Beginning of the List (Contd.)
1. Mark the first node in the list as current. Make START point to the next node in its sequence. Release the memory for the node marked as current.

Algorithm to delete a node from the beginning of a linked list.

START 10 15 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node From the Beginning of a Linked List (Contd.)
1. Mark the first node in the list as current. Make START point to the next node in its sequence. Release the memory for the node marked as current.

2.

START 10 10 15 17 20

3.

current

current = START

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node From the Beginning of a Linked List (Contd.)
1. Mark the first node in the list as current. Make START point to the next node in its sequence. Release the memory for the node marked as current.

2.

START 10 10

START 15 17 20

3.

current

current = START START = START. next

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node From the Beginning of a Linked List (Contd.)
1. Mark the first node in the list as current. Make START point to the next node in its sequence. Release the memory for the node marked as current.

2.

START 10 15 17 20

3.

current Memory released current = START START = START. next

Delete operation complete

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List

Write an algorithm to delete a node between two nodes in a linked list.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current . e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17 Algorithm to delete a node between two nodes in the list.

START 10 15 17 20
2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 15 17 20
2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous 15 17 20
2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous current 15 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous current 15 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous current 15 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous current 15 current 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous 15 current 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 previous 15 previous current 17 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 15 17 20
2.

previous current current

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 15 previous 17 current 20

2.

3.

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17

START 10 10 15 previous 17 current 20

2.

3.

previous.next = current.next

Ver. 1.0

Session 7

Data Structures and Algorithms

Deleting a Node Between two Nodes in the List (Contd.)
1. Locate the node to be deleted. Mark the node to be deleted as current and its predecessor as previous. To locate current and previous, execute the following steps: a. Set previous = START b. Set current = START c. Repeat step d and e until either the node is found or current becomes NULL. d. Make previous point to current. e. Make current point to the next node in sequence. Make the next field of previous point to the successor of current. Release the memory for the node marked as current.

Delete 17 Delete operation complete

START 10 10 15 previous 17 current 20
2.

3.

previous.next = current.next

Ver. 1.0

Session 7

Data Structures and Algorithms

Group Discussion

Problem Statement
Discuss the advantages and disadvantages of linked lists.

Ver. 1.0

Session 7

Data Structures and Algorithms

Group Discussion (Contd.)

Problem Statement
Discuss the differences between arrays and linked lists.

Ver. 1.0

Session 7

Data Structures and Algorithms

Just a minute

Linked lists allow _________ access to elements.

Answer:
sequential

Ver. 1.0

Session 7

Data Structures and Algorithms

Representing a Singly-Linked List A Linked list is represented in a program by defining two classes:
Node class: This class contains the data members of varying data types, which represent data to be stored in a linked list. It also contains the reference of the class type (Node) to hold the reference of the next node in sequence. // Code in C#:
class Node { public int data; public Node next;

// Variable containing // the address of the // next node in // sequence

Ver. 1.0

Session 7

Data Structures and Algorithms

Representing a Singly-Linked List (Contd.)

// Code in C++
class Node { public: int data; Node *next;

// Pointer to the // next node in // sequence

};

Ver. 1.0

Session 7

Data Structures and Algorithms

Representing a Singly-Linked List (Contd.)

List class: This class consists of a set of operations implemented on a linked list. These operations are insertion, deletion, search, and traversal. It also contains the declaration of a variable/pointer, START that always points to the first node in the list. // Code in C#:
class Node { public int data; public Node next;

// Variable containing // the address of the // next node in // sequence

Ver. 1.0

Session 7

Data Structures and Algorithms

Representing a Singly-Linked List (Contd.)
// Code in C#:
class List { private Node START; List() { START = NULL; } public void addNode(int element){} public bool search(int element, ref Node previous, ref Node current) {} public bool delNode(int element) {} public void traverse() {} }

Ver. 1.0

Session 7

Data Structures and Algorithms

Representing a Singly-Linked List (Contd.)
// Code in C#:
class List { Node * START; public: List() { START = NULL; } void addNode(int element); bool search(int element, Node *previous, Node *current); bool delNode(int element); void traverse(); };

Ver. 1.0

Session 7

Data Structures and Algorithms

Activity: Implementing a Singly-Linked List

Problem Statement: Write a program to implement insert, search, delete, and traverse operations on a singly-linked list that stores the records of the students in a class. Each record holds the following information:
Roll number of the student Name of the student

Ver. 1.0

Session 7

Data Structures and Algorithms

Summary

In this session, you learned that:

In a singly-linked list, each node contains:
The information The address of the next node in the list

Singly-linked list can be traversed only in a single direction. Insertion and deletion in a linked list is fast as compared to arrays. However, accessing elements is faster in arrays as compared to linked lists.

Ver. 1.0

Session 7