Ds Narjjis
Ds Narjjis
Ds Narjjis
Data Structures
(3130702)
Enrolment No
Name
Branch
Academic Term
Institute Name
CERTIFICATE
completed the Practical / Tutorial work for the subject Data structure (3130702)
Place:
Date:
Preface
Main motto of any laboratory/practical/field work is for enhancing required skills as well as
creating ability amongst students to solve real time problem by developing relevant
competencies in psychomotor domain. By keeping in view, GTU has designed competency
focused outcome-based curriculum for engineering degree programs where sufficient weightage
is given to practical work. It shows importance of enhancement of skills amongst the students
and it pays attention to utilize every second of time allotted for practical amongst students,
instructors and faculty members to achieve relevant outcomes by performing the experiments
rather than having merely study type experiments. It is must for effective implementation of
competency focused outcome-based curriculum that every practical is keenly designed to serve
as a tool to develop and enhance relevant competency required by the various industry among
every student. These psychomotor skills are very difficult to develop through traditional chalk
and board content delivery method in the classroom. Accordingly, this lab manual is designed
to focus on the industry defined relevant outcomes, rather than old practice of conducting
practical to prove concept and theory.
By using this lab manual students can go through the relevant theory and procedure in advance
before the actual performance which creates an interest and students can have basic idea prior to
performance. This in turn enhances pre-determined outcomes amongst students. Each
experiment in this manual begins with competency, industry relevant skills, course outcomes as
well as practical outcomes (objectives). The students will also achieve safety and necessary
precautions to be taken while performing practical.
This manual also provides guidelines to faculty members to facilitate student centric lab
activities through each experiment by arranging and managing necessary resources in order that
the students follow the procedures with required safety and necessary precautions to achieve the
outcomes. It also gives an idea that how students will be assessed by providing rubrics.
Data Structures is a core course in all computer science undergraduate curricula. The course is
the basis for understanding several data structures and also algorithms that operate on them. The
course forms the foundation for almost all computer science subjects: compilers, operating
systems, databases, AI and software engineering. The course comes with a lab in most
universities in India. The associated lab in university curricula focuses on implementation of
algorithms operating on the data structures, i.e., coding programs on the data structures and
algorithms.
Data Structure (3130702) Enrollment No
DTE’s Vision
Institute’s Vision
To transform the students into good human beings, employable engineering graduates
and continuous learners by inculcating human values and imparting excellence in technical
education.
Institute’s Mission
To provide education to students from the local and rural areas, so that they become enlightened
individuals and improve the living standards of their families, and their contribution to industry
and society. To foster a learning environment with technology integration and individual
attention, so that the students imbibe quality technical knowledge, skill-development and
character building.
Department’s Vision
To achieve excellence for providing value based education in computer science and Information
Technology through innovation, team work and ethical practices.
Department’s Mission
Have careers in industry, research & academics focusing on the application of the
information technologies and take leadership positions in the industry and also
initiate businesses offering innovative solutions.
Capable of adapting to new technologies and constantly upgrade their skills with
an attitude towards lifelong learning.
Act conscientiously about the potentials and the responsibilities of the
computing profession in the context of science, technology, society and
humanity.
Data Structure (3130702) Enrollment No
Sr. CO CO CO CO CO
Practical Outcome/Title of experiment
No. 1 2 3 4 5
1. Classification of Data Structure and Stack
1.1 Classify various data structures
1.2 Implement a program for stack that performs
following operations using array. (a) PUSH (b)
POP
(c) PEEP (d) CHANGE (e) DISPLAY
1.3 Implement a program to convert infix notation to √ √ √
postfix notation using stack.
1.4 Write a program to implement Tower of Hanoi
problem.
1.5 Identify widely used application which use stack
data structure for implementation of its important
feature.
2. Queue
2.1 Write a program to implement QUEUE using arrays
that performs following operations (a) INSERT (b)
DELETE (c) DISPLAY
2.2 Write a program to implement Circular Queue using
arrays that performs following operations. (a) √ √
INSERT (b) DELETE (c) DISPLAY
2.3 Identify widely used application which use Queue
data structure for implementation of its important
feature.
3. Singly linked list
3.1 Write a menu driven program to implement
√ √
following operations on the singly linked list.
Data Structure (3130702) Enrollment No
6. Tree
6.1 Write a program which create binary search tree.
6.2 Implement recursive tree traversing methods in-
order, pre-order and post-order traversal
√ √
6.3 Identify widely used application which use Tree
data structure for implementation of its important
feature.
7. Graph
7.1 Write a program to perform BFS and DFS on
given graph.
7.2 Identify widely used application which use Graph √ √
data structure for implementation of its important
feature.
Data Structure (3130702) Enrollment No
8. Searching
8.1 Write a program to implement Linear Search.
8.2 Write a program to implement Binary Search.
8.3 Identify widely used application which use √ √
Searching technique for implementation of its
important feature.
9. Sorting
9.1 Write a program to implement Quick Sort
9.2 Write a program to implement Merge Sort
9.3 Write a program to implement Bubble Sort
√ √
9.4 Identify widely used application which use
Sorting technique for implementation of its
important
feature.
10 Hashing and File Structure
The following industry relevant competencies are expected to be developed in the student by
undertaking the practical work of this laboratory.
1. Will be able to classify data structures and identify storage representation of
primitive and non-primitive data structures
2. Will be able to implement various operations on Stack, Queue, Link list, Tree,
Graph, Hashing and File operations.
3. Will be able to understand need of sorting and searching for various applications
4. Will be able to apply various data structure to design real time applications
in efficient manner.
1. Students are expected to carefully listen to all the theory classes delivered by the faculty
members and understand the COs, content of the course, teaching and examination
scheme, skill set to be developed etc.
2. Students will have to perform experiments on computer system on which C/C++ compiler
is installed to execute programs of data structure.
3. Students should develop programs and execute all the programs using C/C++ compiler.
Students have to show output of each program in their practical file.
4. Students are instructed to submit practical list as per given sample list shown on next page.
5. Student should develop a habit of submitting the experimentation work as per the schedule
and s/he should be well prepared for the same.
Data Structure (3130702) Enrollment No
Index
(Progressive Assessment Sheet)
Date
Date of Assessme Sign.
Sr. Page of Remar
Objective(s) of Experiment submiss nt Marks
No. No. perfor ks
ion of
mance
Teacher
with date
6. Tree
6.1 Write a program which create binary
search tree.
6.2 Implement recursive tree traversing
methods in-order, pre-order and post-order
traversal.
6.3 Identify widely used application which use
Tree data structure for implementation of
its important feature.
7. Graph
7.1 Write a program to perform BFS and DFS
on given graph.
Data Structure (3130702) Enrollment No
Theory:
Data Structure
Data structures are a fundamental concept in computer science that enable efficient storage and
manipulation of data. They are used to organize and store data in a manner that allows for optimal
performance of algorithms. The selection of a suitable data structure begins with the choice of an
abstract data type, which defines the operations that can be performed on the data. Well-designed
data structures can perform a wide range of critical operations while using minimal resources such
as execution time and memory space. In essence, data structure introduction refers to the
arrangement of data in a computer's memory in a way that enables rapid access by the processor
for the required calculations.
Stack
A stack is a data structure that follows the last-in first-out (LIFO) principle, meaning that objects
are inserted and removed from the container in a particular order. In pushdown stacks, only two
15
Data Structure (3130702) 220210132022
operations are allowed: pushing an item onto the stack, and popping an item off the top of the
stack. Access to the stack is limited, as elements can only be added and removed from the top.
When an item is pushed onto the stack, it becomes the new top item. Conversely, when an item is
popped off the stack, it is removed from the top.
To illustrate this concept, consider a stack of books. Just as you can only remove the top book,
you can only add a new book to the top of the stack. A stack can also have a limited capacity. If
the stack is already full and there is no space to add a new item, it is said to be in an overflow
state. On the other hand, if the stack is empty and an item is removed, it is in an underflow state,
meaning that no items are present in the stack to be removed.
A stack is an abstract data structure that operates on the LIFO principle, where the last item added
is the first item to be removed. Items can be inserted and deleted at one end called the top,
creating a structure that resembles a closed tube on one side.
(1) PUSH
(2) POP
16
Data Structure (3130702) 220210132022
Structures:
1. Primitive data structures: Primitive data structures are simple data structures
constructed using the standard data types of a computer language. Examples of
primitive data structures include variables, arrays, pointers, structures, unions, and
more. These structures are used to build more complex data structures
Linear data structures are arranged as a continuous set of data elements in the memory
and can be constructed using array data types. In linear data structures, the adjacency
relationship between data elements is maintained.
Add an element
Delete an element
Traverse
Sort the list of elements
Search for a data element
Stack
Queue
Tables
List
Linked Lists.
17
Data Structure (3130702) 220210132022
Non-linear data structures are not arranged in a continuous manner and include data
structures such as trees and graphs. These structures can be used to represent complex
relationships between data elements.
Add elements
Delete elements
Display the elements
Sort the list of elements
Search for a data element
Tree
Decision tree
Graph
Forest
1.2 Implement a program for stack that performs following operations using array.
(a) PUSH (b) POP (c) PEEP (d) CHANGE (e)
DISPLAY Program:
#include<stdio.h>
#define size 5
struct stack
{
int a[size],top;
int temp[size];
}s;
// PUSH Operation
void push()
{
int value;
printf(" Enter value to be pushed:
"); scanf("%d", &value);
s.top = s.top + 1;
s.a[s.top] = value;
18
Data Structure (3130702) 220210132022
}
// POP Operation
void pop()
{
printf(" Popped element is %d\n", s.a[s.top]);
s.top = s.top - 1;
}
// PEEP Operation
void peep()
{
printf(" The value at top position is : %d\n", s.a[s.top]);
}
// DISPLAY Operation
void display()
{
int i;
printf(" The stack contains:
"); for(i=s.top; i>=0; i--)
{
printf("\t%d", s.a[i]);
}
printf("\n");
}
// CHANGE Operation
19
Data Structure (3130702) 220210132022
void main()
{
s.top = -1;
int choice, index,
new_element; do
{
printf("\n STACK IMPLEMENTATION PROGRAM");
printf("\n 1. PUSH 2. POP 3. PEEP 4. CHANGE 5. DISPLAY 0. EXIT\n");
printf("\n Enter your choice:
"); scanf("%d", &choice);
switch(choice)
{
case 1:
if(s.top == size-1)
{
printf("\tSTACK OVERFLOW\n");
}
else
{
push();
}
break
case 2: ;
if(s.top == -1)
{
printf("\tSTACK UNDERFLOW\n");
}
else
{
pop();
}
break
case 3: ;
if(s.top == -1)
{
printf("\tStack is empty.\n");
}
else
{
peep();
}
break
case 4: ;
printf(" Enter index no : ");
scanf("%d",&index);
20
Data Structure (3130702) 220210132022
if(index<0 || index>s.top)
{
printf("\tINVALID INDEX NUMBER\n");
}
else
{
printf(" Enter new element:
"); scanf("%d",
&new_element);
} change(index, new_element);
break
case 5: ;
if(s.top == -1)
{
printf("\t Stack is empty.\n");
}
else
{
display();
}
break
case 0: ;
printf("\tEND OF PROGRAM");
break;
default :
printf("\tINVALID CHOICE\n");
}
} while(choice != 0);
21
Data Structure (3130702) 220210132022
Output:
1.3 Implement a program to convert infix notation to postfix notation using stack.
Program:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include
<string.h> #define
MAX 20
char st[MAX];
int top=-1;
void push(char st[], char);
char pop(char st[]);
void InfixtoPostfix(char source[], char
target[]); int getPriority(char);
int main()
{
char infix[100], postfix[100];
printf("\n Enter any infix expression :
"); scanf("%s",infix);
strcpy(postfix, "");
InfixtoPostfix(infix, postfix);
printf("\n The corresponding postfix expression is : ");
puts(postfix);
22
Data Structure (3130702) 220210132022
getch();
23
Data Structure (3130702) 220210132022
return 0;
}
}
}
while((top!=-1) && (st[top]!='('))
{
target[j] = pop(st);
j++;
}
target[j]='\0';
}
}
}
} }
els
e
{
25
Data Structure (3130702) 220210132022
printf("\n
STACK
UNDERFLO
W");
v
a
l
=
s
t
[
t
o
p
]
;
t
o
p
-
-
;
26
Data Structure (3130702) 220210132022
return val;
}
Output:
Program:
#include <stdio.h>
void main()
{
int n;
printf("\n Enter the number of rings: ");
scanf("%d", &n);
move(n,'A', 'C', 'B');
}
void move(int n, char source, char dest, char spare)
{
if (n==1)
printf("\n Move from %c to %c",source,dest);
els
e
{ move(n-1, source, spare, dest);
move(1, source, dest, spare);
move(n-1, spare, dest, source);
}
}
27
Data Structure (3130702) 220210132022
Output:
1.5 Identify widely used application which use stack data structure for implementation of
its important feature.
Stack Applications:
1. Stack is used by compilers to check for balancing of parentheses, brackets and braces.
2. Stack is used to evaluate a postfix expression.
3. Stack is used to convert an infix expression into postfix/prefix form.
4. In recursion, all intermediate arguments and return values are stored on the processor’s
stack.
5. During a function call the return address and arguments are pushed onto a stack and on
return they are popped off.
6. Depth first search uses a stack data structure to find an element from a graph.
Observations:
Conclusion:
28
Data Structure (3130702) 220210132022
Quiz:
Suggested Reference:
Marks
29
Data Structure (3130702) 230213132007
Experiment No: 2
AIM : Queue
Date: 17/10/23
Theory:
Queue
A queue is a data structure that follows the First In, First Out (FIFO) principle. It is a special type
of list where items are inserted at the rear and deleted from the front end. Queues can be
compared to real-world scenarios, such as people waiting in line at a bank.
Queue
Circular Queue
D-Queue
Priority Queue
13
Data Structure (3130702) 230213132007
Program:
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("\nEnter choice:\n");
printf("1. Insert\n");
printf("2. Delete\n");
printf("3. Display\n");
printf("4. Exit\n");
scanf("%d", &c);
do {
switch (c) {
case 1:
{
int x;
printf(" Insert in queue: ");
scanf("%d", &x);
Qins(x);
}
break;
case 2:
Qdel();
break;
case 3:
Qdis();
break;
default:
exit(0);
}
printf("\nEnter your choice:\
n"); printf("1. Insert\n");
printf("2. Delete\n");
printf("3. Display\n");
printf("4. Exit\n");
scanf("%d", &c);
} while (c > 0 && c < 4);
return 0;
14
Data Structure (3130702) 230213132007
}
void Qins(int x) {
if (rear == N - 1) {
printf("Inserted...!!\n");
} else {
if (front == -1) {
front = rear = 0;
} else {
rear = rear + 1;
}
Q[rear] = x;
}
}
void Qdel() {
if (front == -1) {
printf("Deleted...!!\n");
} else {
if (front == rear) {
front = rear = -1;
} else {
front = front + 1;
}
}
}
void Qdis() {
int i;
if (front == -1) {
printf("Displayed..!!\n");
} else {
for (i = front; i <= rear; i++) {
printf("%d\t", Q[i]);
}
printf("\n");
}
}
15
Data Structure (3130702) 230213132007
Output:
2.2 Write a program to implement Circular Queue using arrays that performs
following operations. (a) INSERT (b) DELETE (c) DISPLAY
Program:
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 10
if (isEmpty()) {
front = rear = 0;
} else {
rear = (rear + 1) % MAX_SIZE;
16
Data Structure (3130702) 230213132007
}
q[rear] = x;
}
if (front == rear) {
front = rear = -1;
} else {
front = (front + 1) % MAX_SIZE;
}
return deletedItem;
}
int i = front;
do {
printf("%d ", q[i]);
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
printf("\n");
}
int main() {
int c, x;
while (1) {
printf("1. Insert\n");
printf("2. Delete\n");
printf("3. Display\n");
printf("4. Exit\n");
switch (c) {
case 1:
17
Data Structure (3130702) 230213132007
printf("Enter value to insert: ");
scanf("%d", &x);
ins(x);
break;
case 2:
x = del();
if (x != -1)
{ printf("Deleted:
%d\n", x);
}
break;
case 3:
display();
break;
case 4:
exit(0);
default:
printf("Invalid choice!\n");
}
}
return 0;
}
Output:
2.3 Identify widely used application which uses Queue data structure for
implementation of its important feature.
Queues are a versatile data structure used in many widely used applications, including:
• Web servers: to process user requests in order.
• Job schedulers: to manage and execute jobs in order.
• Operating systems: to manage tasks, such as CPU scheduling, disk scheduling, and printing.
• Networking devices: to manage data packets.
• Databases: to manage database transactions.
• Media players: to manage playlists.
• Call centers: to manage customer calls.
• Message brokers: to manage messages between different systems.
18
Data Structure (3130702) 230213132007
Observations:
1. InQueue all deletions (dequeue) are made at the front and all insertions (enqueue) are made at the
rear end.
2. Circular Queue: Circular Queue is just a variation of the linear queue in which front and rear-end are
connected to each other to optimize the space wastage of the Linear queue and make it efficient.
Conclusion:
As the insertion in the queue is from the rear end and in the case of Linear Queue of fixed size insertion is
not possible when rear reaches the end of the queue.
But in the case of Circular Queue, the rear end moves from the last position to the front position
circularly.
Quiz:
(1) Explain concepts of Queue
A queue is an ordered collection of items where the addition of new items happens at
one end, called the “rear,” and the removal of existing items occurs at the other end,
commonly called the “front.”
(2) Define DQueue
a double-ended queue (abbreviated to deque) is an abstract data type that generalizes
a queue, for which elements can be added to or removed from either the front (head)
or back (tail).
(3) Differentiate Circular Queue and Priority Queue
Both circular and priority queues follow queue mechanisms, which are in either a linear
or circular queue fashion. The circular line has the first in, first out functionality,
whereas the priority queue follows the elements with the highest priority to be served
first.
Suggested Reference:
19
Data Structure (3130702) 230213132007
Experiment No: 3
3.1 Write a menu driven program to implement following operations on the singly
linked list.
(a) Insert a node at the front of the linked list.
(b) Insert a node at the end of the linked list.
(c) Insert a node such that linked list is in ascending order. (According to INFO field)
(d) Delete a first node of the linked list.
(e) Delete a node before specified position.
(f) Delete a node after specified position.
3.2 Write a program to implement stack using linked list
3.3 Write a program to implement queue using linked list.
Date: 17-10-23
Theory:
A linked list is a type of data structure that stores a collection of non-sequential data items. Unlike
arrays, linked lists are dynamic and their size can be changed during program execution. Each
data item in a linked list has a pointer that holds the memory address of the next data item in the
list. The data items in a linked list may not be stored in consecutive memory locations, but their
pointers make it easy to access them in any order.
A singly linked list, also known as a linear linked list, is a type of linked list in which all nodes
are connected together sequentially. Each node in a singly linked list contains data and a
20
Data Structure (3130702) 230213132007
pointer to
21
Data Structure (3130702) 230213132007
the next node. The last node's pointer is set to null. The limitation of a singly linked list is that it
can only be traversed in one direction, in a forward direction.
Insert
- Insert at first position
- Insert at last position
- Insert into ordered list
Delete
Traverse list (Print list)
Copy linked list
3.1 Write a menu driven program to implement following operations on the singly
linked list.
(a) Insert a node at the front of the linked list.
(b) Insert a node at the end of the linked list.
(c) Insert a node such that linked list is in ascending order.(According to INFO field)
(d) Delete a first node of the linked list.
(e) Delete a node before specified position.
(f) Delete a node after specified position.
Program:
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
if (*head == NULL) {
*head = newNode;
} else {
struct Node* current = *head;
while (current->next != NULL)
{
22
Data Structure (3130702) 230213132007
current = current->next;
23
Data Structure (3130702) 230213132007
}
current->next = newNode;
}
}
if (position == 2) {
deleteFirstNode(head);
return;
}
24
Data Structure (3130702) 230213132007
return;
}
int main() {
struct Node* head = NULL;
insertAtFront(&head, 3);
insertAtFront(&head, 2);
insertAtFront(&head, 1);
25
Data Structure (3130702) 230213132007
insertAtEnd(&head, 4);
printf("Linked List after inserting a node at the end:\n");
display(head);
insertInAscendingOrder(&head, 2);
printf("Linked List after inserting a node in ascending order:\n");
display(head);
deleteFirstNode(&head);
printf("Linked List after deleting the first node:\
n"); display(head);
deleteNodeBeforePosition(&head, 2);
printf("Linked List after deleting a node before position 2:\n");
display(head);
deleteNodeAfterPosition(&head, 2);
printf("Linked List after deleting a node after position 2:\n");
display(head);
freeLinkedList(head);
return 0;
}
Output:
list Program:
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
int main() {
struct Node* top = NULL;
push(&top, 1);
push(&top, 2);
push(&top, 3);
display(top);
27
Data Structure (3130702) 230213132007
display(top);
return 0;
}
Output:
Program:
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Queue {
struct Node* front;
struct Node* rear;
};
28
Data Structure (3130702) 230213132007
}
int main() {
struct Queue* queue = createQueue();
enqueue(queue, 1);
enqueue(queue, 2);
enqueue(queue, 3);
29
Data Structure (3130702) 230213132007
display(queue);
int dequeued =
dequeue(queue); if (dequeued !
= -1) {
printf("Dequeued element: %d\n", dequeued);
}
display(queue);
return 0;
}
Output:
Observations:
The program is a well-designed and implemented singly linked list program. It allows users to perform
various operations on a linked list, including inserting and deleting nodes, in a user-friendly and error-
free manner. The program also manages memory efficiently, avoiding memory leaks.
Conclusion:
The program is well-designed and implements the fundamental concepts of linked lists correctly. It
provides a user-friendly interface and error handling, making it a reliable tool for managing linked
lists
30
Data Structure (3130702) 230213132007
Quiz
:
1. Which are the operations on singly link list?
INSERTION
DELETION
SEARCH
Suggested Reference:
obtained:
Marks
31
Data Structure (3130702) 230213132007
Experiment No: 4
4.1 Write a program to implement following operations on the doubly linked list.
(a) Insert a node at the front of the linked list.
(b) Insert a node at the end of the linked list.
(c) Delete a last node of the linked list.
(d) Delete a node before specified position.
Date:
Theory:
A doubly linked list is a data structure where each node contains data and two pointers - one to
point to the previous node (LPTR) and another to point to the next node (RPTR). The main
advantage of a doubly linked list is that we can traverse it in any direction, either forward or
backward. Another advantage is that we can delete a node with ease since we have pointers to
both the previous and next nodes. In contrast, a node on a singly linked list cannot be removed
unless we have a pointer to its predecessor. However, the drawback of a doubly linked list is that
it requires more memory than a singly linked list since we need an extra pointer to point to the
previous node. In the image, L and R denote the leftmost and rightmost nodes in the list,
respectively. The left link of the L node and the right link of the R node are both NULL,
indicating the end of the list for each direction.
Insert
32
Data Structure (3130702) 230213132007
- Insert at first position
- Insert at last position
- Insert into ordered list
Delete
Traverse list (Print list)
Copy linked list
4.1 Write a program to implement following operations on the doubly linked list.
(a) Insert a node at the front of the linked list.
(b) Insert a node at the end of the linked list.
(c) Delete a last node of the linked list.
(d) Delete a node before specified position.
Program:
#include<stdio.h>
#include<stdlib.h>
struct Node
{
int data;
struct Node *next;
struct Node *prev;
};
if (*head != NULL)
(*head)->prev = newNode;
// *head->prev = newNode; would not work it has (*head) must be used
33
Data Structure (3130702) 230213132007
while (node != NULL)
34
Data Structure (3130702) 230213132007
{
printf (" %d ", node->data);
end = node;
node = node->next;
}
int main ()
{
struct Node *head = NULL;
display (head);
return 0;
}
Output:
Program:
#include <stdio.h>
int main()
{
//Adding 1 to the
list addAtEnd(1);
display();
//Adding 2 to the
list addAtEnd(2);
display();
//Adding 3 to the list
36
Data Structure (3130702) 230213132007
addAtEnd(3);
display();
//Adding 4 to the
list addAtEnd(4);
display();
//Adding 5 to the
list addAtEnd(5);
display();
return 0;
}
Output:
Program:
#include <stdio.h>
#include <stdlib.h>
//node structure
struct Node {
int data;
struct Node* next;
struct Node* prev;
};
37
Data Structure (3130702) 230213132007
}
38
Data Structure (3130702) 230213132007
temp->next = newNode;
newNode->prev =
temp;
}
}
return 0;
39
Data Structure (3130702) 230213132007
}
Output:
Program:
#include <stdio.h>
#include <stdlib.h>
if (current->prev != NULL) {
// Node to be deleted is not the first node
if (current->next != NULL) {
current->next->prev = current->prev;
40
Data Structure (3130702) 230213132007
}
if (current->next != NULL) {
current->next->prev =
NULL;
}
newNode->data =
newData; newNode->next
= NULL;
if (*head == NULL) {
newNode->prev =
NULL;
*head =
newNode; return;
}
last->next = newNode;
newNode->prev =
last;
}
// Example
41
Data Structure (3130702) 230213132007
usage int main()
{
struct Node* head = NULL;
42
Data Structure (3130702) 230213132007
append(&head, 1);
append(&head, 2);
append(&head, 3);
append(&head, 4);
append(&head, 5);
int positionToDeleteBefore = 3;
deleteNodeBeforePosition(&head, positionToDeleteBefore);
printf("Doubly Linked List after deleting before position %d: ", positionToDeleteBefore);
printList(head);
return 0;
}
Output:
43
Data Structure (3130702) 230213132007
Observations:
The program requires careful management of pointers for linking nodes during insertions and deletions in a
doubly linked list.
Conclusion:
Addressing edge cases, implementing proper memory management, and ensuring code readability contribute
to a robust program for manipulating doubly linked lists with specified operations.
Quiz:
(1) Explain structure of a node of doubly link list
In computer science, a doubly linked list is a linked data structure that consists of a
set of sequentially linked records called nodes. Each node contains three fields: two
link fields (references to the previous and to the next node in the sequence of nodes)
and
one data field.
Suggested Reference:
obtained:
Marks
44
Data Structure (3130702) 230213132007
Experiment No: 5
5.1 Write a program to implement following operations on the circular linked list.
(a) Insert a node at the end of the linked list.
(b) Insert a node before specified position.
(c) Delete a first node of the linked list.
(d) Delete a node after specified position.
5.2 Identify widely used application which uses linked list for implementation of its
important feature.
Date:
Competency and Practical Skills: Logic building and programming
Theory:
A circular linked list is similar to a singly linked list, except that the last node points to the first
node, creating a circular arrangement of nodes. Unlike a singly linked list, it does not contain null
pointers. Traversal can only be done in one direction, i.e., the forward direction. The biggest
advantage of a circular linked list is that it saves time when we want to go from the last node to
the first node because it directly points to the first node. A good example of an application where
a circular linked list can be used is a time-sharing problem that can be solved by the operating
system.
Insert
- Insert at first position
45
Data Structure (3130702) 230213132007
- Insert at last position
- Insert into ordered list
Delete
Traverse list (Print list)
5.1 Write a program to implement following operations on the circular linked list.
(a) Insert a node at the end of the linked list.
(b) Insert a node before specified position.
(c) Delete a first node of the linked list.
(d) Delete a node after specified position.
Program:
#include<stdio.h>
#include<stdlib.h>
struct Node
{
int data;
struct Node *next;
};
46
Data Structure (3130702) 230213132007
}
47
Data Structure (3130702) 230213132007
}
while (temp !=
head); printf ("\n");
}
int main ()
{
return 0;
}
Output:
48
Data Structure (3130702) 230213132007
Program:
#include <stdio.h>
#include <stdlib.h>
// If the list is empty, make the new node the only node and point to itself
if (*head == NULL) {
newNode->next = newNode;
*head =
newNode; return;
}
49
Data Structure (3130702) 230213132007
printf("(head)\n");
}
return 0;
}
Output:
Program:
#include<stdio.h>
#include<stdlib.h>
// structure for Circular Linked
List struct Node
{
int data;
struct Node *next;
};
if (*head == NULL)
{
*head = newNode;
(*head)->next =
*head; return;
}
curr->next = newNode;
newNode->next =
*head;
51
Data Structure (3130702) 230213132007
*head = newNode;
52
Data Structure (3130702) 230213132007
}
}
while (temp !=
head); printf ("\n");
}
int main ()
{
display (head);
deleteBegin(&head);
display (head);
return 0;
}
Output:
53
Data Structure (3130702) 230213132007
Program:
#include <stdio.h>
#include <stdlib.h>
Node *newNode =
createNode(data); temp->next =
newNode;
newNode->next =
head; return head;
}
Node *prev =
NULL; Node *curr =
head; int count = 0;
55
Data Structure (3130702) 230213132007
if (curr == head) {
prev->next = head-
>next; free(head);
head = prev->next;
} else if (curr == NULL)
{ prev->next = head;
} else {
prev->next = curr-
>next; free(curr);
}
return head;
}
Node *temp =
head; do {
printf("%d ", temp->data);
temp = temp->next;
} while (temp !=
head); printf("\n");
}
int main() {
Node *head = NULL;
return 0;
}
56
Data Structure (3130702) 230213132007
Output:
5.2 Identify widely used application which uses linked list for implementation of its
important feature.
Image viewer – Previous and next images are linked and can be accessed by the next and previous
buttons. Previous and next page in a web browser – We can access the previous and next URL searched in
a web browser by pressing the back and next buttons since they are linked as a linked list.
Observations:
1. Insertions: The implemented methods ensure nodes are added seamlessly at the end or before
a specified position, maintaining the circular structure without disruptions.
2. Deletions: Deletion operations effectively adjust pointers, preserving the circular nature of the
linked list, indicating robust handling of node removal.
Conclusion:
The implemented circular linked list operations exhibit robust functionality, preserving the
circular structure during insertions and deletions.
Quiz:
57
Data Structure (3130702) 230213132007
Suggested Reference:
obtained:
Marks
58
Data Structure (3130702) 230213132007
Experiment No: 6
AIM : Tree
Date:
Theory:
A binary search tree is a binary tree in which each node possessed a key that satisfy the
following conditions
1. All key (if any) in the left sub tree of the root precedes the key in the root.
2. The key in the root precedes all key (if any) in the right sub tree.
3. The left and right sub tree sub trees of the root are again search trees.
Operations on tree
The most common operations performed on tree structure are that of traversal. This is a procedure
by which each node in the tree is processed exactly once in a systematic manner.
1. Pre-order Traversal
59
Data Structure (3130702) 230213132007
2. In-order Traversal
3. Post-order Traversal
Pre-order
In-order
Post-order
Program:
#include <stdio.h>
#include <stdlib.h>
61
Data Structure (3130702) 230213132007
// If the tree is empty, create a new node and return
it if (root == NULL) {
return createNode(key);
}
// Example
usage int main()
{
struct TreeNode* root = NULL;
return 0;
}
Output:
62
Data Structure (3130702) 230213132007
6.2 Implement recursive tree traversing methods in-order, preorder and post-order
traversal.
Program:
#include <stdio.h>
#include <stdlib.h>
63
Data Structure (3130702) 230213132007
// Example usage
64
Data Structure (3130702) 230213132007
int main() {
struct TreeNode* root =
createNode(1); root->left =
createNode(2);
root->right = createNode(3);
root->left->left =
createNode(4);
root->left->right = createNode(5);
printf("In-order Traversal:
"); inorderTraversal(root);
printf("\n");
printf("Pre-order Traversal:
"); preorderTraversal(root);
printf("\n");
printf("Post-order Traversal:
"); postorderTraversal(root);
printf("\n");
return 0;
}
Output:
65
Data Structure (3130702) 230213132007
6.3 Identify widely used applications which use Tree data structure for
implementation of its important feature.
File Systems:
File systems often use tree structures to represent the hierarchy of directories and files. Each directory is a
node in the tree, and files are the leaves.
Database Systems:
In database systems, trees are used for indexing and searching. B-trees and B+ trees are common structures
for indexing in databases, allowing for efficient search and retrieval operations.
Compiler Design:
Abstract Syntax Trees (AST) are used in compiler design to represent the hierarchical structure of source
code. ASTs help in the analysis and optimization of code during compilation.
Operating Systems:
Process scheduling and resource allocation in operating systems can be modeled using tree structures.
Process Control Block (PCB) trees are an example, where each process is a node in the tree.
Observations:
Tree Traversal: Recursive methods successfully implement in-order, pre-order, and post-order
traversals.
Applications: Widely used in databases, file systems, networking, and more.
Conclusion:
BST Creation: Efficiently creates a Binary Search Tree (BST).
Quiz:
66
Data Structure (3130702) 230213132007
Suggested Reference:
students:
67
Data Structure (3130702) 230213132007
Experiment No: 7
AIM : Graph
Theory:
Graph:
A graph G can be defined as a non-empty set of vertices or nodes (V) and a set of edges (E) that
represents the relationship or connection between those nodes. The edges can be defined as a
mapping from E to pairs of elements of V. A graph can be represented as G = (V, E), where V
represents the set of nodes and E represents the set of edges. Each edge of the graph G can be
associated with a pair of nodes of the graph. If an edge X belongs to E and is associated with a
pair of nodes (u, v), where u and v belong to V, then we say that edge X connects node u and node
v.
DFS is a graph traversal algorithm that is similar to the preorder traversal of a tree. The traversal
can start from any vertex vi of the graph. Initially, the vertex vi is visited, and then all the adjacent
vertices to vi are traversed recursively using DFS. As a graph can have cycles, we need to avoid
revisiting a node. To achieve this, when a vertex V is visited, it is marked as visited and should
not be selected for traversal again.
68
Data Structure (3130702) 230213132007
Breadth First Search (BFS) starts from a vertex v0 and marks it as visited. Then, all the
vertices adjacent to v0 are visited next.
Let the vertices adjacent to v0 be v1, v2, v3, and v4. These vertices are marked as visited.
All unvisited vertices adjacent to v1, v2, v3, and v4 are visited next.
The above process continues until all vertices are visited.
The algorithm for BFS maintains a list of vertices that have been visited but not explored
for adjacent vertices. This list is stored in a queue.
The queue initially contains the starting vertex.
In each iteration, a vertex is removed from the queue, and its adjacent vertices, which
have not been visited yet, are added to the queue.
The algorithm terminates when the queue becomes empty.
Program:
Output:
7.2 Identify widely used applications which use graphs data structure for
implementation of its important feature.
Observations:
Conclusion:
Quiz:
69
Data Structure (3130702) 230213132007
Suggested Reference:
70
Data Structure (3130702) 230213132007
Experiment No: 8
AIM : Searching
Theory:
Linear/Sequential Search
Linear search, also known as sequential search, is a technique used in computer science to
find a specific value in a list by sequentially checking each of its elements one at a time
until the desired one is found.
It is the simplest search algorithm and a form of brute-force search. Its worst-case cost is
proportional to the number of elements in the list.
Binary Search
If we have an array that is sorted, we can use a much more efficient algorithm called
Binary Search.
In Binary Search, we divide the array into two equal halves and compare the middle
element with the search element.
If the middle element is equal to the search element, we have found the element and return
its index; otherwise, if the middle element is less than the search element, we look at the
71
Data Structure (3130702) 230213132007
right part of the array, and if the middle element is greater than the search element,
Program:
Output:
Program:
Output:
8.3 Identify widely used applications which use Searching technique for implementation
of its important feature.
Observations:
Conclusion:
Quiz:
Suggested Reference:
73
Data Structure (3130702) 230213132007
Experiment No: 9
AIM : Sorting
Theory:
Bubble sort
Bubble sort, also known as sinking sort, is a comparison-based sorting algorithm. It works by
repeatedly scanning through the list to be sorted, comparing adjacent elements and swapping them
if they are not in the correct order. In each pass through the list, the largest element bubbles up to
the top. The algorithm repeats these processes until no more swaps are needed, indicating that the
list is sorted. Although it is simple to understand and implement, bubble sort has a worst-case and
average time complexity of O(n^2), making it too slow for large inputs. Insertion sort is a more
efficient alternative for small lists.
Merge Sort
74
Data Structure (3130702) 230213132007
DIVIDE: Partition the n-element sequence to be sorted into two sub sequences of
n/2 elements each.
CONQUER: Sort the two sub sequences recursively using the merge sort.
COMBINE: Merge the two sorted sub sequences of size n/2 each to produce the
sorted sequence consisting of n elements.
Quick Sort
Quicksort is currently the fastest known sorting algorithm and often the most practical choice for
sorting, with an average expected running time of O(n log(n)). Its operation consists of the
following steps:
Pick an element from the array, known as a pivot.
Reorder the array so that all elements with values less than the pivot are placed before it,
while all elements with values greater than the pivot come after it (elements with equal
values can go either way). This operation is called partitioning, and at the end of it, the
pivot is in its final position.
Recursively apply the above steps to the sub-arrays of elements with smaller and greater
values, respectively. Quicksort, like merge sort, is a divide-and-conquer recursive
algorithm.
The basic divide-and-conquer process for sorting a sub array is given in the following
three easy steps:
Divide
Conquer
Combine
Sort Program:
Output:
Sort Program:
Output:
75
Data Structure (3130702) 230213132007
Sort Program:
Output:
9.4 Identify widely used applications which use Sorting technique for
implementation of its important feature.
Observations:
Conclusion:
Quiz:
Suggested Reference:
76
Data Structure (3130702) 230213132007
Marks
77
Data Structure (3130702) 230213132007
Experiment No: 10
10.1 Write a program to create hash table and handle the collision using linear probing.
10.2 Write a program to demonstrate the file primitives such as fopen, fclose, fprintf.
10.3 Identify widely used applications which use Hashing technique for implementation
of its important feature.
Theory:
Hashing
Hashing is a method used to map a large number of data items to a smaller table by utilizing a
hashing function. This technique transforms a range of key values into a range of indexes of an
array.There are two different forms of hashing.
Hashing Functions
1. Division-Method
2. Folding Method
3. Algebraic Coding
4. Multiplicative Hashing
5. Digit Analysis
6. Mid-square Methods
7. Length Dependent Method
File
In computing, a file is a group of records, where each record comprises one or more fields that
have the same sequence. Typically, each field has a predetermined length.
1. Sequential files
2. Direct files
3. Index files
4. Indexed Sequential files
5. Relative files
1. Creation
2. Insertion
3. Deletion
4. Updation
5. Reading
6. Searching
79
Data Structure (3130702) 230213132007
10.1 Write a program to create hash table and handle the collision using linear probing.
Program:
Output:
10.2 Write a program to demonstrate the file primitives such as fopen, fclose, fprintf.
Program:
Output:
10.3 Identify widely used applications which use Hashing technique for implementation
of its important feature.
Observations:
Conclusion:
Quiz:
Suggested Reference:
Marks
81