DATA STRUCTURE AND ALGORITHM with linked list

Data Structures is about how data can be stored in different structures.
Algorithms is about how to solve different problems, often by searching through and
manipulating data structures.
Theory about Data Structures and Algorithms (DSA) helps us to use large amounts of data to
solve problems efficiently.
We structure data in different ways depending on what data we have, and what we want to do
with it.

DATA STRUCTURE & ALGORITHM
WHAT IS DSA?
Data Structures and Algorithms (DSA) refer to the study of methods for organizing and storing data and the design of
procedures (algorithms) for solving problems, which operate on these data structures.

DATA
STRUCTURES
PRIMARY DATA
STRUCTURES
SECONDARY DATA
STRUCTURES
INT, CHAR,FLOAT
DOUBLE
LINEAR
DATA
STRUCTURE
S
NON LINEAR
DATA
STRUCTURES
LIST
S
ARRAY
S
STACK
S
QUEUE
S
TREE
S
GRAPH
S
CLASSIFICATION OF DATA STRUCTURE:
Primitive data
type Non- primitive or
Abstract data type

Primary Data Strucutres/Primitive Data Structures:
Primitive data structures include all the fundamental data structures that can be directly manipulated by machine-level
instructions. Some of the common primitive data structures include integer, character, real, boolean etc
Secondary Data Structures/Non Primitive Data Structures:
Non primitive data structures, refer to all those data structures that are derived from one or more primitive data structures.
The objective of creating non-primitive data structures is to form sets of homogeneous or heterogeneous data elements.
Linear Data Structures:
Linear data structures are data strucutres in which, all the data elements are arranged in i, linear or sequential fashion.
Examples of data structures include arrays, stacks, queues, linked lists, etc.
Non Linear Structures:
In non-linear data strucutres, there is definite order or sequence in which data elements are arranged. For instance, a non-
linear data structures could arrange data elements in a hierarchical fashion. Examples of non-linear data structures are trees
and graphs.

Static and dynamic data structure:
Static data structure:
If a data structure is created using static memory allocation, ie. data structure formed when the number of
data items are known in advance ,it is known as static data static data structure or fixed size data structure.
Dynamic data structure:
If the data structure is created using dynamic memory allocation i.e data structure formed when the number
of data items are not known in advance is known as dynamic data structure or variable size data structure.

Array
Array is a linear data structure that stores a collection of elements of the same data type. Elements are
allocated contiguous memory, allowing for constant-time access. Each element has a unique index
number.
Operations on Array:
Traversal: Iterating through the elements of an array.
Insertion: Adding an element to the array at a specific index.
Deletion: Removing an element from the array at a specific index.
Searching: Finding an element in the array by its value or index.
Types of Arrays:
One-dimensional array: A simple array with a single dimension.
Multidimensional array: An array with multiple dimensions, such as a matrix.
Applications of Array:
Storing data in a sequential manner
Implementing queues, stacks, and other data structures
Representing matrices and tables

Array Implementation of list:
Array is a collection of specific number of same type of data stored in consecutive memory locations.
Array is a static data structure i.e., the memory should be allocated in advance and the size is fixed. This
will waste the memory space when used space is less than the allocated space.
Insertion and Deletion operation are expensive as it requires more data movements Find and Print list
operations takes constant time.
The basic operations performed on a list of elements are
a. Creation of List.
b. Insertion of data in the List

c.Deletion of data from the List
d.Display all data s in the List
‟
e.Searching for a data in the list
Declaration of Array:
#define maxsize 10 int list[maxsize], n ; Create Operation:
Create operation is used to create the list with „ n „ number of elements .If „ n „ exceeds the array s maxsize, then
‟
elements cannot be inserted into the list. Otherwise the array elements are stored in the consecutive array locations
(i.e.) list [0], list [1] and so on.
void Create ( )
{
int i;
printf("nEnter the number of elements to be added in the list:t"); scanf("%d",&n);
printf("nEnter the array elements:t"); for(i=0;i<n;i++)
scanf("%d",&list[i]);
}
If n=6, the output of creation is as follows:
list[6]

Insert Operation:
Insert operation is used to insert an element at particular position in the existing list. Inserting the element in
the last position of an array is easy. But inserting the element at a particular position in an array is quite
difficult since it involves all the subsequent elements to be shifted one position to the right.
Routine to insert an element in the array:
void Insert( )
{
int i,data,pos;
printf("nEnter the data to be inserted:t"); scanf("%d",&data);
printf("nEnter the position at which element to be inserted:t"); scanf("%d",&pos);
if (pos==n)
printf (“Array overflow”); for(i = n-1 ; i >= pos-1 ; i--)
list[i+1] = list[i]; list[pos-1] = data; n=n+1;
Display();}
Consider an array with 5 elements [ max elements = 10 ]
10 20 30 40 50

1
0
2
0
3
0
4
0
5
0
If data 15 is to be inserted in the 2nd
position then 50 has to be moved to next index position, 40 has to be
moved to 50 position, 30 has to be moved to 40 position and 20 has to be moved to 30 position.
1
0
2
0
3
0
4
0
5
0
1
0
2
0
3
0
4
0
5
0
After this four data movement, 15 is inserted in the 2nd
position of the array.
1
0
1
5
2
0
3
0
4
0
5
0

Deletion Operation:
Deletion is the process of removing an element from the array at any position.
Deleting an element from the end is easy. If an element is to be deleted from any particular
position ,it requires all subsequent element from that position is shifted one position towards left.
Routine to delete an element in the array:
void Delete( )
{
int i, pos ;
printf("nEnter the position of the data to be deleted:t"); scanf("%d",&pos);
printf("nThe data deleted is:t %d", list[pos-1]); for(i=pos-1;i<n-1;i++)
list[i]=list[i+1]; n=n-1;
Display();
}

Consider an array with 5 elements [ max elements = 10 ]
1
0
2
0
3
0
4
0
5
0
If data 20 is to be deleted from the array, then 30 has to be moved to data 20 position, 40 has to
be moved to data 30 position and 50 has to be moved to data 40 position.
1
0
2
0
3
0
4
0
5
0
After this 3 data movements, data 20 is deleted from the 2nd
position of the array.
1
0
3
0
4
0
5
0

Display Operation/Traversing a list
Traversal is the process of visiting the elements in a array.
Display( ) operation is used to display all the elements stored in the list. The elements are stored from the
index 0 to n - 1. Using a for loop, the elements in the list are viewed
Routine to traverse/display elements of the array:
void display( )
{
int i;
printf("n**********Elements in the array**********n"); for(i=0;i<n;i++)
printf("%dt",list[i]);
}

Search Operation:
Search( ) operation is used to determine whether a particular element is present in the list or not. Input
the search element to be checked in the list.
Routine to search an element in the array:
void Search( )
{
int search,i,count = 0;
printf("nEnter the element to be searched:t"); scanf("%d",&search);
for(i=0;i<n;i++)
{
if(search == list[i]) count++;
}
if(count==0)
printf("nElement not present in the list"); else
printf("nElement present in the list");
}

Linked Lists:
A linked list is a linear data structure that stores data in nodes, which are connected by pointers. Unlike arrays,
linked lists are not stored in contiguous memory locations.
Characteristics of Linked List:
• Dynamic: Linked lists can be easily resized by adding or removing nodes.
• Non-contiguous: Nodes are stored in random memory locations and connected by pointers.
• Sequential access: Nodes can only be accessed sequentially, starting from the head of the list.
Operations on Linked List:
• Creation: Creating a new linked list or adding a new node to an existing list.
• Traversal: Iterating through the list and accessing each node.
• Insertion: Adding a new node at a specific position in the list.
• Deletion: Removing a node from the list.
• Search: Finding a node with a specific value in the list.

Types of Linked List:
Singly Linked List: Each node points to the next node in the list.
Doubly Linked List: Each node points to both the next and previous nodes in the list.
Circular Linked List: The last node points back to the first node, forming a circular loop.
Singly Linked List:
Singly linked list is a linear data structure in which the elements are not stored in contiguous memory
locations and each element is connected only to its next element using a pointer.

Linked List is a linear data structure, in which elements are not stored at a contiguous location,
rather they are linked using pointers. Linked List forms a series of connected nodes, where each
node stores the data and the address of the next node.

Node Structure: A node in a linked list typically consists of two components:
1.Data: It holds the actual value or data associated with the node.
2.Next Pointer or Reference : It stores the memory address (reference) of the next node in the
sequence.
Head and Tail: The linked list is accessed through the head node, which points to the first node in the
list. The last node in the list points to NULL or nullptr, indicating the end of the list. This node is known
as the tail node.
Double-linked list:
In a doubly linked list, each node contains references to both the next and previous nodes. This allows
for traversal in both forward and backward directions, but it requires additional memory for the
backward reference.

Circular linked list:
In a circular linked list, the last node points back to the head node, creating a circular structure.
It can be either singly or doubly linked.

Operations on Linked Lists
1.Insertion: Adding a new node to a linked list involves adjusting the pointers of the existing nodes to
maintain the proper sequence. Insertion can be performed at the beginning, end, or any position within
the list
2.Deletion: Removing a node from a linked list requires adjusting the pointers of the neighboring nodes
to bridge the gap left by the deleted node. Deletion can be performed at the beginning, end, or any
position within the list.
3.Searching: Searching for a specific value in a linked list involves traversing the list from the head
node until the value is found or the end of the list is reached.

DATA STRUCTURE AND ALGORITHM with linked list

Recommended

More Related Content

Similar to DATA STRUCTURE AND ALGORITHM with linked list (20)

Recently uploaded (20)

DATA STRUCTURE AND ALGORITHM with linked list