linked list simple

Data Structures Using C I Year II Semester BCA
Introduction to the theory of Data Structures
Data Type:
Data type is way to classify various types of data such as integer, string
etc. which determines the values that can be used with the corresponding
type of data, the type of operations that can be performed on the
corresponding type of data. Data type of two types
• Built-in Data Type

• Derived Data Type
Built-in Data Type:
Those data types for which a language has built-in support are known as
Built-in Data types. For example, most of the languages provides following
built-in data types.
• Integers
• Boolean (true, false)
• Floating (Decimal numbers)
• Character and Strings
Derived Data Type:

Those data types which are implementation independent as they can be
implemented in one or other way are known as derived data types. These
data types are normally built by combination of primary or built-in data
types and associated operations on them.
✓ CREATE
✓ DESTROY
✓ SELECT
✓ UPDATE
Data Structure:
Data Structure is a way of collecting and organizing data in such a way
that we can perform operations on these data in an effective way. Data
Structures is about rendering data elements in terms of some relationship,
for better organization and storage.
Department of Computer Applications 1 A.S.N. Degree College, Tenali

Classification of Data Structures:
Primitive Data Structures: Data structures that normally are directly

operated upon by machine-level instructions are known as primitive data
structures. The integers, real, logical data, character data, pointer and
reference are primitive data structures.
Non-primitive Data Structures: These are more complex data structures.

These data structures are derived from the primitive data structures. They
stress on formation of sets of homogeneous and heterogeneous data
elements. The different operations that are to be carried out on data are
nothing but designing of data structures. The various operations that can be
performed on data structures
These data structures can be divided into two categories.
1. Linear data structures.

2. Non-linear data structures.
1. Linear data structures: In linear data structures, data is stored in
linear form.
Ex:
o Array
o Linked List
o Stack
o Queue.
2. Non-linear data structures: In non-linear data structures, data is

stored in non-linear form.

o Trees
o Graphs
o
Abstract Data Type:
Abstract data types or ADTs are a mathematical specification of a set

of data and the set of operations that can be performed on the data. They
are abstract in the sense that the focus is on the definitions of the
constructor that returns an abstract handle that represents the data, and the
various operations with their arguments. The actual implementation is not
defined, and does not affect the use of the ADT. An ADT consists of two
parts:
➢ Declaration of Data
➢ Declaration of Operations
For example, students of a college can be characterized with

many properties such as,
(1) Roll Number

(2) Student Name
(3) Marks in different subjects
(4) Sex
(5) Age and so on.
There may be different possible operations which can be performed on

these properties of the students. For example we can display the
information, edit the information, print the sheet of the students and so on.
So the ADT “Student” is defined as follows

ADT Student
Data :
Roll_Number;
Student_Name;
Marks_in_different_subjects;
Sex;
Age;
Operations:
Read_information();
Display_information();
Print_mark_Sheet();
When realized in a computer program, the ADT shields a corresponding

implementation. Users of an ADT are concerned with the interface, but not
the implementation, as the implementation can change in the future.
Algorithm properties
An algorithm is a finite set of instructions or logic, written in order, to

accomplish a certain predefined task. Algorithm is not the complete code or
program, it is just the core logic(solution) of a problem, which can be
expressed either as an informal high level description as pseudo code or
using a flowchart.
Every Algorithm must satisfy the following properties:
1. Input- There should be 0 or more inputs supplied externally to the

algorithm.
2. Output- There should be at least 1 output obtained.

3. Definiteness- Every step of the algorithm should be clear and well

defined.
4. Finiteness- The algorithm should have finite number of steps.
5. Correctness- Every step of the algorithm must generate a correct
output.
An algorithm is said to be efficient and fast, if it takes less time to execute

and consumes less memory space. The performance of an algorithm is
measured on the basis of following properties :
1. Time Complexity
2. Space Complexity
Space Complexity
Its the amount of memory space required by the algorithm, during the
course of its execution. Space complexity must be taken seriously for multi-
user systems and in situations where limited memory is available.
An algorithm generally requires space for following components :
• Instruction Space: Its the space required to store the executable

version of the program. This space is fixed, but varies depending upon
the number of lines of code in the program.
• Data Space: Its the space required to store all the constants and
variables(including temporary variables) value.
• Environment Space: Its the space required to store the environment
information needed to resume the suspended function.
Time Complexity
Time Complexity is a way to represent the amount of time required by the

program to run till its completion. It is a good practice to try to keep the
time required minimum, so that our algorithm completes its execution in the
minimum time possible.
Generally, the running time of an algorithm depends upon the following...
• Whether it is running on Single processor machine or Multi processor

machine.
• Whether it is a 32 bit machine or 64 bit machine.
• Read and Write speed of the machine.

• The amount of time required by an algorithm to perform Arithmetic

operations, logical operations, return value and assignment operations
etc.,
• Input data
Refinement stages
The best approach to solve a complex problem is to divide it into

smaller parts such that each part becomes an independent module
which is easy to manage. An example of this approach is the System
Development Life Cycle (SDLC) methodology.
This helps in understanding the problem, analyzing solutions,

and handling the problems efficiently. The principle underlying writing
large programs is the top-down refinement. The application or the
nature of problem determines the number of refinement stages
required in the specification process. Different problems have different
number of refinement stages, but in general, there are four levels of
refinement processes:
Conceptual Level
At this level we decide how the data is related to each other, and what
operations are needed.
Details about how to store data and how various operations are performed
on that data are not decided at this level
Algorithmic or Data Structure Level
At data structure level we decide about the operations on the data as

needed by our problem.
For example, we decide what kind of data structure will be required to solve
the problem
Programming or Implementation Level
At implementation level, we decide the details of how the data structures will
be represented in the computer memory.
Application Level

This level settles all details required for particular application such as names
for variables or special requirements for the operations imposed by
applications
Linear Lists - ADT:
Linear ordering of atoms/terms is the essential property of linear list.

List nothing more than a set of terms organized sequentially. Hence a list is
a sequence of zero or more elements of a given type, the form of list is,
L=(a1,a2,a3,……an) (n≥0). Linear list is a data object whose instances

are of the form (a1,a2,a3,……an) where, ai is element of list.
n denotes number of elements in the list
a1 is the first element of the list
an is the last element of the list
n=0 means empty list.
Elements can be linearly ordered according to their position in the list. We

say ai precedes ai+1 ( ai+1 follows ai ) and ai is at position i.
An array is an example of list. In an array, the sequential organization

is provided implicitly by its index.
Examples:
(1) Student names order by their alphabets.

(2) A list of exam scores sorted by descending order.
Days of Week = (S, M, T, W, Th, F, Sa)
Months = (Jan, Feb, Mar, Apr, …, Nov, Dec)
We can implement linear list in two ways
❖ Array
❖ Linked List

Linear List implementation using Arrays:
We can implement a list using simple arrays concept. We can store any data
in the list. we create the array with relevant type of data, which is storing
in it. For Example, List of Students that are having their total percentage
above 70. For this we have to maintain their names so we need to declare
String array in this context.
Creation of linear list
We need to declare an array with desired size and read the elements
in that array. This task will create a list with given size and it also assigns
the items to that list also.
Adding an item at given index in the linear list
Insertion refers to adding the other element to the array. Insertion can
be easily done at end of the array. This can be done when there is an
additional space in the array. If we are intended to place new element at
middle the elements must movie forward to the new locations to
accommodate the new element.
Deleting item from the list at given index
Deleting element means removing the element from the existing array
by specifying its index.
Retrieving item at the given index
To retrieve the item at the given index means searching element

from the array. This task will get the item at the given location in the array.
Advantages:
✓ Array stores items in consecutive memory locations.

✓ Arrays have better cache locality which increases the
performance.
Disadvantages:
o Array size is fixed once we declared.

o Inserting and deleting operations are very expensive due to
elements shifting in both the cases.

Linked Lists
A list is a set of similar data components. A list whose components
are linked together by means of a pointer (reference) is referred to as linked
list. In linked list, each individual component within the list includes a
pointer which indicates the address of the next component in the list.
Therefore, the relative order of the components can easily be changed by
simply altering the pointers. Individual components can easily be added to
(or) deleted from the list by altering the pointers.
Linked Lists are used in the construction of compilers, operating

system, and data base management systems etc. Linked list can be
constructed in different forms.
1. Single Linked List (or) Linear Linked List.

2. Double Linked List.
3. Circular Linked List.
Single Linked List
Single linked list is a sequence of elements in which every element has

link to its next element in the sequence. In any single linked list, the
individual element is called as "Node". Every "Node" contains two
fields, data field, and the next field. The data field is used to store
actual value of the node and next field is used to store the address of
next node in the sequence.
The graphical representation of a node in a single linked list is as
follows...
• In a single linked list, the address of the first node is always stored in
a reference node known as "front" (Some times it is also known as
"head").
• Always next part (reference part) of the last node must be NULL.
Example

Operations on Single Linked List:
The following operations are performed on a Single Linked List
• Creation
• Insertion
• Deletion
• Displa
Creation of Single Linked List:
1. Compose the node structure of the Linked List.
Ex: struct node

{
int a;
node next;
};
3. Create first node and keep the address of the first node in separate
variable say root.
3. Create new node and link it to previous node.
4. Repeat step no. 3 until required no. of nodes are linked.
5. Keep address field of last node as NULL.
Insertion
In a single linked list, the insertion operation can be performed in three

ways. They are as follows...
1. Inserting At Beginning of the list

2. Inserting At End of the list
3. Inserting At Specific location in the list

Inserting At Beginning of the list
We can use the following steps to insert a new node at beginning of the
single linked list...
Consider the following existing linked list
r root
10 20 30 40 50 NULL
25 NULL
newnode
root’ is a variable which holds the address of the first element in the
linked list. Each element consists of data and address field.
If a new element with data value 25 is to be inserted at the top.
i) Create a new element and assume new element address is

‘newnode’.
ii) Move the address in root to the address field of new element.
iii) Move the address of new element to root .
newnode-> next = root;
root = newnode;

After insertion the linked list will be as shown below.
(root)
25 10 20 30 40 50 NULL
new element
Inserting At Specific location in the list (After a Node)

Consider the following existing linked list.
(root)
10 20 30 40 50 NULL
35 NULL p
newnode
‘root’ holds the address of first element. To insert an element after element.
i) create a new element and assume new element address is

‘newnode’.
ii) starting from first element process the linked list until desired
element, after which a new element is to be inserted, is found. Say
the address of that element is ‘p’.
Ex: Inserting after element 30 i.e., p has address of element 30.
iii) Move the address of element 40, which is in address field of 30 to

address field of new element.

iv) Move the address of new element ‘newnode’ to address field of

element 30.
newnode->next = p->next;
p->next = newnode;
After insertion linked list will be
(root)
10 20 30 35 40 50 NULL
Inserted element
Inserting an element at last:

Consider the following existing linked list.
(root)
10 20 30 40 NULL
35 NULL
newnode
‘root’ holds the address of first element.
v) create a new element and assume new element address is

‘newnode’.
vi) starting from first element process the linked list until last element
is found. Say the address of that element is ‘p’.
vii) Move the address of element 35, which is in address field of 40.
p->next = newnode;

(root)
10 20 30 40 35 NULL
Deletion
In a single linked list, the deletion operation can be performed in three ways.
They are as follows...
1. delete an element at first

2. delete an element at last
3. Delete a Specific Node
Deleting an element at first
We can use the following steps to delete a node from beginning of the single
linked list...
where root holds address of first element.
i) move the address of the first element to temp variable ‘p’.

ii) move address of 2nd element to root.
p=root;
root=root->next;

Linked List after deletion :
Deleting an element at last:
We can use the following steps to delete a node from end of the single linked
list...
Consider the following linked list.
q p
where root holds address of the first element. ‘p’ holds address of the
element which is to be deleted , ‘q’ holds address of element before p.
i) Find the address of the element to be deleted, by processing the list

from beginning. Say address of the element is ‘p’. And ‘q’ is the
address of the element which is before ‘p’ element.
ii) Remove the address of element ‘40’ from q address field.
q->next =NULL;
Linked List after deletion:
(root)
10 20 30 NULL

Deleting a Specific Node from the list
We can use the following steps to delete a specific node from the single
linked list...
where root holds address of the first element. ‘p’ holds address of the
element which is to be deleted , ‘q’ holds address of element before p.
iii) Find the address of the element to be deleted, by processing the list
from beginning. Say address of the element is ‘p’. And ‘q’ is the
address of the element which is before ‘p’ element.
iv) Move address of element ‘40’ to q address field.
q->next =p->next;
d list after deletion
Double Linked Lists
A Double Linked List is a list in which each component in the linked list have
two pointers which can point to both the next element and the previous
element. The concept of double linked list is as shown in figure below

Each component in the double linked list has the following structure.
The main advantage of double linked list is that it permit traversing and
searching of the list in both directions. For a given pointer to any list
element, it is possible to get to any other element in the list. To move to
the end of the list, simply follow the next pointers and to move to the
beginning of the list, simply follow the previous pointers.
When compared to single linked list, the extra pointers in double linked
list occupies additional space and also increases the maintenance of the
insertion and deletion because there are more pointers to adjust.
Creation of Double Linked List :
1. Compose the mode structure of the double linked list.
Ex: struct node

{
int data;
struct node lptr;
struct node rptr;
}
2. Create first node and keep the address of first node in separate variable
say head.
3. Create new node and link new node and previous nodes bidirectional.
4. Repeat step 3, until required no. of nodes are linked. Keep the address of
the last node in a separate variable say tail.

Ex:
head tail
NULL 10 20 30 NULL
5. Keep left pointer of first node and right pointer of last node as NULL.
Inserting an element into Double Linked List :
An element can be inserted into a existing double linked list at any

desired position.
1. To insert element as first element :
head tail
NULL 10 20 30 40 NULL
NULL 5 NULL
newnode
head holds address of first element.

tail holds address of last element.
1. Create a new element and assume ‘newnode’ holds address of new

element.
2. Move address in head to right pointer of new element.
3. Move the address of new element to left pointer of first element.
4. Move address of new element to ‘head’.
n->rptr = head;
head->lptr = newnode;
head = newnode;

Linked list after insertion :

tail
head
NULL 5 10 20 30 40 NULL
inserted element
2. To insert element as last element :
head tail
NULL 10 20 30 NULL
NULL 5 NULL
newnode

element.
2. Move address in ‘tail’ to left pointer of new element.
3. Move address of new element to right pointer of last element.
4. Move address of new element to tail.
n->lptr = tail;
tail->rptr = newnode;
tail = newnode;
Linked List after Insertion

head tail
NULL 10 20 30 5 NULL
inserted element
Inserting element between two elements (or) after a particular

element :

head tail
NULL 10 20 30 NULL
p
NULL 25 NULL
newnode
element.
2. Find address of the element, after which new element is to be inserted.
Ex: after element 20. ‘p’ holds address of element ‘20’.
3. Move address of element ‘20’ to left pointer of new element.
4. Move address of element ‘30’ to right pointer of new element.
5. Move address of new element to left pointer of 30.
6. Move address of new element to right pointer of 20.
p->next=r;
newnode->lptr=p
newnode->rptr=r
r->lptr=newnode
p->next=newnode

Linked list after insertion :

Linked List after Insertion is
head tail
NULL 10 20 25 30 NULL
inserted element
Deleting an element from Double Linked List :
Any element can be deleted from the double linked list by knowing the
address of the element.
1. To delete first element : Consider the following double linked

list
head tail
NULL 10 20 30 NULL
element to be deleted
1. Move address of second element to head.

2. Move NULL to left pointer of new first element.
head = head->rptr;
head->lptr =null;
Linked List after Deletion :
head tail
NULL 20 30 NULL

2. To delete last element : Consider the following linked list

head tail
NULL 10 20 30 NULL
1. Move second last element address to tail.

2. Move NULL to right pointer of new last element.
tail = tail->lptr;
tail->rptr = NULL;
Linked List after deletion :
head tail
NULL 10 20 NULL
3.To delete a particular element :
Consider the following linked list
head tail
NULL 10 20 30 NULL
q p r
1. Find the element to delete by processing list either from head (or) from
tail. Assume ‘p’ holds address of element to be deleted.
Ex: Element to be deleted is ’20’ . ‘p’ holds address of 20.
2. Move address of ‘30’ to right pointer of ‘10’.

3. Move address of ‘10’ to left pointer of ‘30’.
p->rptr=r;
q->rptr=p->rptr
r->lptr=q;

Linked list after deletion :
head tail
NULL 10 30
CIRCULAR LINKED LISTS
In a circular linked list, the last node contains a pointer to the first
node of the list. We can have a circular singly linked list as well as a circular
doubly linked list. While traversing a circular linked list, we can begin at any
node and traverse the list in any direction, forward or backward, until we
reach the same node where we started. Thus, a circular linked list has no
beginning and no ending.
Note that there are no NULL values in the NEXT part of any of the nodes of
list.
Inserting a new node in a circular Linked List

We will take two cases and then see how insertion is done in each case.
Case 1: The new node is inserted at the beginning of the circular linked list.
Case 2: The new node is inserted at the end of the circular linked list.
Inserting a Node at the Beginning of a Circular Linked List
Suppose we want to add a new node with data 9 as the first node of the list.
Then the following changes will be done in the linked list.

Inserting a Node at the End of a Circular Linked List

Suppose we want to add a new node with data 9 as the last node of the list.

deleting a node from a circular Linked List
We will take two cases and then see how deletion is done in each
case. Rest of the cases of deletion are same as that given for singly linked
lists.
Case 1: The first node is deleted.
Case 2: The last node is deleted.
Deleting the First Node from a Circular Linked List
When we want to delete a node from the beginning of the list, then the
following changes will be done in the linked list.
Deleting the Last Node from a Circular Linked List
Suppose we want to delete the last node from the linked list, then the
following changes will be done in the linked list.


linked list simple

Uploaded by

linked list simple

Uploaded by

Data Structures Using C I Year II Semester BCA

Introduction to the theory of Data Structures

• Built-in Data Type

Derived Data Type:

Department of Computer Applications 1 A.S.N. Degree College, Tenali

Classification of Data Structures:

Primitive Data Structures: Data structures that normally are directly

Non-primitive Data Structures: These are more complex data structures.

These data structures can be divided into two categories.

1. Linear data structures.

2. Non-linear data structures: In non-linear data structures, data is

Department of Computer Applications 2 A.S.N. Degree College, Tenali

Abstract Data Type:

Abstract data types or ADTs are a mathematical specification of a set

For example, students of a college can be characterized with

(1) Roll Number

There may be different possible operations which can be performed on

Department of Computer Applications 3 A.S.N. Degree College, Tenali

When realized in a computer program, the ADT shields a corresponding

An algorithm is a finite set of instructions or logic, written in order, to

1. Input- There should be 0 or more inputs supplied externally to the

Department of Computer Applications 4 A.S.N. Degree College, Tenali

3. Definiteness- Every step of the algorithm should be clear and well

An algorithm is said to be efficient and fast, if it takes less time to execute

• Instruction Space: Its the space required to store the executable

Time Complexity is a way to represent the amount of time required by the

• Whether it is running on Single processor machine or Multi processor

Department of Computer Applications 5 A.S.N. Degree College, Tenali

• The amount of time required by an algorithm to perform Arithmetic

The best approach to solve a complex problem is to divide it into

This helps in understanding the problem, analyzing solutions,

At data structure level we decide about the operations on the data as

Department of Computer Applications 6 A.S.N. Degree College, Tenali

Linear Lists - ADT:

Linear ordering of atoms/terms is the essential property of linear list.

L=(a1,a2,a3,……an) (n≥0). Linear list is a data object whose instances

n denotes number of elements in the list

a1 is the first element of the list

an is the last element of the list

n=0 means empty list.

Elements can be linearly ordered according to their position in the list. We

An array is an example of list. In an array, the sequential organization

(1) Student names order by their alphabets.

Months = (Jan, Feb, Mar, Apr, …, Nov, Dec)

We can implement linear list in two ways

Department of Computer Applications 7 A.S.N. Degree College, Tenali

Linear List implementation using Arrays:

Creation of linear list

Adding an item at given index in the linear list

Deleting item from the list at given index

Retrieving item at the given index

To retrieve the item at the given index means searching element

✓ Array stores items in consecutive memory locations.

o Array size is fixed once we declared.

Department of Computer Applications 8 A.S.N. Degree College, Tenali

Linked Lists are used in the construction of compilers, operating

1. Single Linked List (or) Linear Linked List.

Single linked list is a sequence of elements in which every element has

Department of Computer Applications 9 A.S.N. Degree College, Tenali

Operations on Single Linked List:

The following operations are performed on a Single Linked List

Creation of Single Linked List:

1. Compose the node structure of the Linked List.

Ex: struct node

3. Create new node and link it to previous node.

4. Repeat step no. 3 until required no. of nodes are linked.

5. Keep address field of last node as NULL.

In a single linked list, the insertion operation can be performed in three

1. Inserting At Beginning of the list

Department of Computer Applications 10 A.S.N. Degree College, Tenali

Inserting At Beginning of the list

Consider the following existing linked list

If a new element with data value 25 is to be inserted at the top.

i) Create a new element and assume new element address is

Department of Computer Applications 11 A.S.N. Degree College, Tenali

After insertion the linked list will be as shown below.