🎓 Dr.

Ram Manohar Lohia Avadh U

ABC College of Science & Manage

Practical File
Data Structure using C & Python with Mini Project
Bachelor of Computer Applications (BCA) – 2nd Year

Student Name:
Your Full Name
Roll No.:
BCA/2024/001
Section / Batch:
A
Academic Year:
2025 – 2026
Teacher / Guide:
Prof. [Teacher Name]

Submitted in partial fulfilment of the requirements of BCA 2nd Year Practical Examination
— Page 1 —
 CERTIFICATE
of Completion of Practical Work

This is to certify that Your Full Name , student of BCA

2nd Year, Roll No. BCA/2024/001 , Section
A , has satisfactorily completed the
Practical File for the subjects Data Structure using C and Python
with Mini Project for the academic year
2025–2026 .

T E
The practical work has been carried out under my supervision and the

A
student has shown satisfactory understanding of the subject.

F I C
T I
Date: __/__/____ Date: __/__/____

R
Student Signature Prof. [Teacher Name]

CE Teacher / Lab Incharge

External Examiner Signature: ___________________________ Date:

________
— Page 2 —
Acknowledgement

I would like to express my sincere gratitude to all those who helped me in the
completion of this practical file.
First and foremost, I am thankful to my teacher Prof. [Teacher Name] , who
guided me throughout this practical work with patience and encouragement. The
explanations and support provided by them made it easy to understand even the
difficult concepts of Data Structures and Python Programming.
I am also grateful to the Head of the Department and the entire faculty of the
Computer Science department for providing us with a well-equipped lab and a good
learning environment.
I would like to thank my friends and classmates for their cooperation and for sharing
knowledge during the practical sessions.
Last but not least, I am thankful to my family for their constant support and
motivation throughout the course.
This practical file is a result of sincere effort and hard work. I hope it meets the
required standard of the examination.

Submitted by,
Your Full Name
Roll No.: BCA/2024/001
BCA 2nd Year | Section: A
— Page 3 —
Index

[Link]. Program / Topic Subject Page Sign

1 Cover Page — 1
2 Certificate — 2
3 Acknowledgement — 3
4 Index — 4
5-6 Introduction to DS & Python Both 5–6
6 Program 1: Stack using Array DS using C 7
7 Program 2: Queue using Array DS using C 8
8 Program 3: Singly Linked List DS using C 9
9 Program 4: Linear & Binary Search DS using C 10
10 Program 5: Bubble Sort DS using C 11
11 Program 6: Recursion (Factorial) DS using C 12
12 Extra: Binary Tree Traversal DS using C 13
13 Python Mini Project – Introduction Python Lab 14–15
14 Python Code – Student Management Python Lab 16–18
15 Sample Output / Test Run Python Lab 19
16 Conclusion — 20
— Page 4 —
Introduction

Part A — Data Structure using C

A Data Structure is a way to organize and store data in a computer so that it can be
used efficiently. Just like we arrange books in a library to find them easily, data
structures help us arrange data in memory so that programs can run faster.
In this practical file, we will study and implement the following important data
structures in the C programming language:
Stack – A structure that works on the principle of Last In First Out (LIFO).
Queue – A structure that works on the principle of First In First Out (FIFO).
Linked List – A dynamic structure where each element points to the next.
Searching – Techniques to find an element in a list (Linear and Binary Search).
Sorting – Techniques to arrange elements in order (Bubble Sort).
Recursion – A function calling itself to solve problems like factorial and Fibonacci.
C language is chosen because it gives direct control over memory using pointers,
which is essential for understanding how data structures really work at a low level.

Part B — Python with Mini Project

Python is a simple, readable, and powerful programming language. It is widely used
for web development, data science, automation, and building small applications.
Python uses indentation (spaces) instead of curly braces to define blocks of code,
making it easy to read.
In this practical file, the Python section includes a Student Management System – a
simple Command Line Interface (CLI) application that allows the user to:
 Add new student records
Display all students
Search a student by roll number
Delete a student record
Exit the application
The project uses basic Python concepts like lists, dictionaries, functions, loops, and
user input — all topics covered in the BCA 2nd year syllabus.

Difference between C and Python

Feature C Language Python

Type Compiled language Interpreted language

Syntax Complex (curly braces) Simple (indentation)
Memory Manual (malloc, free) Automatic (garbage collection)
Speed Fast Slower than C
Use System programming, DS Scripting, ML, Web, Projects

— Page 5 – 6 —
Program 1 — Stack using Array

🎯 Aim: To implement a Stack data structure using an array in C language, supporting

PUSH, POP, and DISPLAY operations.

📖 Theory (Short)
A Stack is a linear data structure that follows the LIFO (Last In, First Out) principle
— the last element added is the first one to be removed. Think of it like a stack of
plates: you always pick from the top.
Common operations: PUSH (insert), POP (delete), PEEK (view top), isEmpty (check
empty).
📋 Algorithm

1. Define array stack[MAX] and variable top = -1

2. PUSH: If top == MAX-1 → Overflow. Else top++ and stack[top] = element.
3. POP: If top == -1 → Underflow. Else print stack[top] and top--.
4. DISPLAY: Loop from top to 0 and print each element.

💻 C Code

C LANGUAGE Copy

/* Stack Implementation using Array in C */

#include <stdio.h>

#define MAX 5
int stack[MAX], top = -1;
 /* Function to push element onto stack */
void push(int val) {
if (top == MAX - 1)
printf("Stack Overflow!\n");
else
stack[++top] = val;
}

/* Function to pop element from stack */

void pop() {
if (top == -1)
printf("Stack Underflow!\n");
else
printf("Popped: %d\n", stack[top--]);
}

/* Function to display stack elements */

void display() {
if (top == -1) { printf("Stack is empty!\n"); return; }
printf("Stack (top→bottom): ");
for (int i = top; i >= 0; i--)
printf("%d ", stack[i]);
printf("\n");
}

int main() {
push(10); push(20); push(30);
display();
pop();
display();
return 0;
}

📟 Sample Output
Stack (top→bottom): 30 20 10
Popped: 30
Stack (top→bottom): 20 10

✅ Result: Program executed successfully. Stack operations (PUSH, POP,

DISPLAY) are working correctly.
— Page 7 —
Program 2 — Queue using Array

🎯 Aim: To implement a Queue data structure using an array in C, supporting

ENQUEUE, DEQUEUE, and DISPLAY operations.

📖 Theory (Short)
A Queue follows the FIFO (First In, First Out) principle — just like a line at a ticket
counter. The person who joins first gets the ticket first. We maintain two pointers:
front (for deletion) and rear (for insertion).
📋 Algorithm

1. Initialize front = -1, rear = -1

2. ENQUEUE: If rear == MAX-1 → Overflow. Else rear++ and queue[rear] =
element. If front == -1, set front = 0.
3. DEQUEUE: If front == -1 → Underflow. Else print queue[front] and front++. If
front > rear, reset both to -1.
4. DISPLAY: Loop from front to rear and print each element.

💻 C Code

C LANGUAGE Copy

/* Queue Implementation using Array in C */

#include <stdio.h>
#define MAX 5

int queue[MAX], front = -1, rear = -1;

 /* Insert element at rear */
void enqueue(int val) {
if (rear == MAX - 1) { printf("Queue Full!\n"); return; }
if (front == -1) front = 0;
queue[++rear] = val;
printf("Inserted: %d\n", val);
}

/* Remove element from front */

void dequeue() {
if (front == -1) { printf("Queue Empty!\n"); return; }
printf("Removed: %d\n", queue[front++]);
if (front > rear) front = rear = -1;
}

/* Display all elements in queue */

void display() {
if (front == -1) { printf("Queue is empty!\n"); return; }
printf("Queue (front→rear): ");
for (int i = front; i <= rear; i++)
printf("%d ", queue[i]);
printf("\n");
}

int main() {
enqueue(10); enqueue(20); enqueue(30);
display();
dequeue();
display();
return 0;
}

📟 Sample Output
Inserted: 10
Inserted: 20
Inserted: 30
Queue (front→rear): 10 20 30
Removed: 10
Queue (front→rear): 20 30

✅ Result: Program executed successfully. Queue operations (ENQUEUE,

DEQUEUE, DISPLAY) are working correctly.
— Page 8 —
Program 3 — Singly Linked List

🎯 Aim: To implement a Singly Linked List in C with insertion at front, display, and
deletion operations.

📖 Theory (Short)
A Linked List is a dynamic data structure where each element (called a node)
contains data and a pointer to the next node. Unlike arrays, linked lists do not need
contiguous memory and can grow/shrink during program execution.
Structure of a Node: [ Data | Next Pointer ] → [ Data | Next ] → NULL

📋 Algorithm

1. Create a structure Node with data and *next pointer.

2. Insert at Front: Allocate new node, set data, point next to head, update head.
3. Display: Traverse from head till NULL, print each node's data.
4. Delete from Front: If head != NULL, store head in temp, move head =
head→next, free temp.

💻 C Code

C LANGUAGE Copy

/* Singly Linked List in C */

#include <stdio.h>
#include <stdlib.h>

/* Node structure */
struct Node {
 int data;
struct Node *next;
};
struct Node *head = NULL;

/* Insert node at front of list */

void insertFront(int val) {
struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = val;
newNode->next = head;
head = newNode;
}

/* Display all nodes */

void display() {
struct Node *temp = head;
if (!temp) { printf("List is empty!\n"); return; }
while (temp) {
printf("%d → ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}

/* Delete node from front */

void deleteFront() {
if (!head) { printf("List empty!\n"); return; }
struct Node *temp = head;
head = head->next;
printf("Deleted: %d\n", temp->data);
free(temp);
}

int main() {
insertFront(30); insertFront(20); insertFront(10);
 display();
deleteFront();
display();
return 0;
}

📟 Sample Output

10 → 20 → 30 → NULL
Deleted: 10
20 → 30 → NULL

✅ Result: Singly Linked List implemented successfully with Insert, Display, and
Delete operations.
— Page 9 —
Program 4 — Linear & Binary Search

🎯 Aim: To implement Linear Search and Binary Search in C and compare their
working.

📖 Theory (Short)
Linear Search: Searches element one by one from the beginning of the array. Works
on both sorted and unsorted arrays. Time Complexity: O(n).
Binary Search: Works only on sorted arrays. Divides the array into two halves
repeatedly. Time Complexity: O(log n) — much faster than linear search.
📋 Algorithm — Binary Search

1. Set low = 0, high = n-1

2. Find mid = (low + high) / 2
3. If arr[mid] == key → Found at position mid
4. If key < arr[mid] → search left half (high = mid - 1)
5. If key > arr[mid] → search right half (low = mid + 1)
6. Repeat until found or low > high → Not found

💻 C Code

C LANGUAGE Copy

/* Linear and Binary Search in C */

#include <stdio.h>

/* Linear Search - checks one by one */

void linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key) {
printf("Linear: Found at index %d\n", i);
return;
}
}
printf("Linear: Not found\n");
}

/* Binary Search - works on sorted array */

void binarySearch(int arr[], int n, int key) {
int low = 0, high = n - 1, mid;
while (low <= high) {
mid = (low + high) / 2;
if (arr[mid] == key) {
printf("Binary: Found at index %d\n", mid);
return;
} else if (key < arr[mid])
high = mid - 1;
else
low = mid + 1;
}
printf("Binary: Not found\n");
}

int main() {
int arr[] = {10, 20, 30, 40, 50};
int n = 5, key = 30;
linearSearch(arr, n, key);
binarySearch(arr, n, key);
return 0;
}
📟 Sample Output

Linear: Found at index 2

Binary: Found at index 2

✅ Result: Both Linear and Binary Search programs executed correctly. Binary
Search is faster for sorted arrays.
— Page 10 —
Program 5 — Bubble Sort

🎯 Aim: To sort an array of integers in ascending order using the Bubble Sort algorithm
in C.

📖 Theory (Short)
Bubble Sort works by repeatedly comparing adjacent elements and swapping them
if they are in the wrong order. Larger elements "bubble up" to the end of the array in
each pass. It is simple but not efficient for large arrays — Time Complexity: O(n²).
📋 Algorithm

1. Repeat n-1 times (outer loop for passes)

2. In each pass, compare adjacent elements arr[j] and arr[j+1]
3. If arr[j] > arr[j+1], swap them
4. After each pass, the largest unsorted element reaches its correct position
5. Print the sorted array

💻 C Code

C LANGUAGE Copy

/* Bubble Sort in C */
#include <stdio.h>

/* Function to perform bubble sort */

void bubbleSort(int arr[], int n) {
int temp;
for (int i = 0; i < n - 1; i++) {
 for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
/* Swap adjacent elements */
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

/* Function to print array */

void printArray(int arr[], int n) {
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[] = {64, 34, 25, 12, 22};
int n = 5;
printf("Before sorting: ");
printArray(arr, n);
bubbleSort(arr, n);
printf("After sorting: ");
printArray(arr, n);
return 0;
}

📟 Sample Output

Before sorting: 64 34 25 12 22
After sorting: 12 22 25 34 64
✅ Result: Bubble Sort program executed successfully. Array sorted in ascending
order.
— Page 11 —
Program 6 — Recursion (Factorial & Fibonacci)

🎯 Aim: To understand and implement Recursion in C by finding Factorial of a number

and Fibonacci series.

📖 Theory (Short)
Recursion is a technique where a function calls itself again and again until a base
condition is reached. Every recursive function must have: (1) A base case that stops
the recursion, and (2) A recursive case that moves toward the base case.
Example: factorial(5) = 5 × factorial(4) = 5 × 4 × 3 × 2 × 1 = 120
📋 Algorithm — Factorial

1. If n == 0 or n == 1, return 1 (Base Case)

2. Else return n × factorial(n-1) (Recursive Case)

💻 C Code

C LANGUAGE Copy

/* Recursion - Factorial and Fibonacci in C */

#include <stdio.h>

/* Recursive function to find factorial */

int factorial(int n) {
if (n == 0 || n == 1)
return 1; /* Base case */
return n * factorial(n - 1); /* Recursive call */
}
 /* Recursive function to find nth Fibonacci number */
int fibonacci(int n) {
if (n == 0) return 0; /* Base case */
if (n == 1) return 1; /* Base case */
return fibonacci(n-1) + fibonacci(n-2);
}

int main() {
int num = 5;
printf("Factorial of %d = %d\n", num, factorial(num));

printf("Fibonacci series (first 7): ");

for (int i = 0; i < 7; i++)
printf("%d ", fibonacci(i));
printf("\n");
return 0;
}

📟 Sample Output

Factorial of 5 = 120
Fibonacci series (first 7): 0 1 1 2 3 5 8

✅ Result: Recursion program executed successfully. Factorial and Fibonacci

series calculated correctly.
— Page 12 —
Extra Program — Binary Tree Traversal

🎯 Aim: To implement a Binary Tree in C and perform Inorder, Preorder, and Postorder
traversals.

📖 Theory (Short)
A Binary Tree is a tree where each node has at most two children: left and right.
Tree traversal means visiting every node in a specific order:
Inorder (L → Root → R): Left subtree, Root, Right subtree
Preorder (Root → L → R): Root, Left subtree, Right subtree
Postorder (L → R → Root): Left, Right, then Root
💻 C Code

C LANGUAGE Copy

/* Binary Tree Traversal in C */

#include <stdio.h>
#include <stdlib.h>

/* Node structure for Binary Tree */

struct Node {
int data;
struct Node *left, *right;
};

/* Create new node */

struct Node* newNode(int val) {
struct Node* node = (struct Node*)malloc(sizeof(struct Node));
node->data = val;
 node->left = node->right = NULL;
return node;
}

/* Inorder: Left → Root → Right */

void inorder(struct Node* root) {
if (root) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
}

/* Preorder: Root → Left → Right */

void preorder(struct Node* root) {
if (root) {
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}

/* Postorder: Left → Right → Root */

void postorder(struct Node* root) {
if (root) {
postorder(root->left);
postorder(root->right);
printf("%d ", root->data);
}
}

int main() {
struct Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
 root->left->left = newNode(4);
root->left->right = newNode(5);
printf("Inorder: "); inorder(root); printf("\n");
printf("Preorder: "); preorder(root); printf("\n");
printf("Postorder: "); postorder(root); printf("\n");
return 0;
}

📟 Sample Output

Inorder: 4 2 5 1 3
Preorder: 1 2 4 5 3
Postorder: 4 5 2 3 1

✅ Result: Binary Tree created and all three traversals (Inorder, Preorder,
Postorder) performed successfully.
— Page 13 —
Python Mini Project — Introduction

Project Title: Student Management System

Language Used: Python 3.x | Interface: Command Line Interface (CLI)
Academic Year: 2025–2026 | Subject: Python with Mini Project

Project Description
The Student Management System is a simple Python-based application that allows
users to manage student records through a text-based menu. It is built using basic
Python concepts like lists, dictionaries, functions, loops, and user input — making it
perfect for BCA 2nd year level.
No external libraries or database is required. All data is stored in a Python list (in-
memory) during program execution.
Features of the Project

# Feature Description

1 Add Student Add name, roll no, marks, and course of a new student
2 Display All Students Show all stored student records in a formatted table
3 Search Student Search any student by their Roll Number
4 Delete Student Remove a student record using Roll Number
5 Calculate Average Show average marks of all students
6 Error Handling Invalid inputs are handled using try-except blocks
7 Exit Cleanly exit the program
Technologies & Concepts Used
Data Type: List of Dictionaries (to store student records)
Functions: Separate function for each operation
Loops: while loop for menu, for loop for display/search
User Input: input() function with type conversion
Error Handling: try-except for invalid numeric input
String Formatting: f-strings and .format() for clean output
System Requirements

Type Requirement

Software Python 3.6 or above

OS Windows / Linux / macOS
IDE IDLE / VS Code / Thonny / Terminal
Libraries None (uses only built-in Python)

Program Flow (Brief)

Start → Show Menu → User selects option:

1. Option 1: Take student details → add to list
2. Option 2: Loop through list → print all records
3. Option 3: Take roll no → search in list → show record
4. Option 4: Take roll no → find and remove from list
5. Option 5: Sum all marks → divide by count → show average
6. Option 6: Exit the program
Loop back to menu after every operation (until user exits).

— Page 14 – 15 —
Python Code — Student Management System

PYTHON 3 Copy

# ============================================================
# Student Management System — Python Mini Project
# BCA 2nd Year | Python with Mini Project Lab
# ============================================================

# Global list to store all student records as dictionaries

students = []

# ──────────────────────────────────────────────────────────
# Function 1: Add a new student record
# ──────────────────────────────────────────────────────────
def add_student():
print("\n--- Add New Student ---")
name = input("Enter Student Name : ")
roll = input("Enter Roll Number : ")
course = input("Enter Course Name : ")
try:
marks = float(input("Enter Marks (0-100) : "))
if marks < 0 or marks > 100:
print("Error: Marks must be between 0 and 100.")
return
except ValueError:
print("Error: Please enter a valid number for marks.")
return

# Check if roll number already exists

for s in students:
if s['roll'] == roll:
 print("Error: Roll number already exists!")
return

# Calculate grade based on marks

if marks >= 90: grade = "A+"
elif marks >= 80: grade = "A"
elif marks >= 70: grade = "B"
elif marks >= 60: grade = "C"
elif marks >= 40: grade = "D"
else: grade = "F (Fail)"

# Create student dictionary and add to list

student = {
'name' : name,
'roll' : roll,
'course': course,
'marks' : marks,
'grade' : grade
}
[Link](student)
print(f"✓ Student '{name}' added successfully! Grade: {grade}")

# ──────────────────────────────────────────────────────────
# Function 2: Display all student records
# ──────────────────────────────────────────────────────────
def display_all():
print("\n--- All Student Records ---")
if not students:
print("No records found. Please add students first.")
return
print(f"{'Roll':10} {'Name':20} {'Course':15} {'Marks':8} {'Grade'}")
print("-" * 60)
for s in students:
print(f"{s['roll']:10} {s['name']:20} {s['course']:15} {s['marks']:8.1f
# ──────────────────────────────────────────────────────────
# Function 3: Search student by roll number
# ──────────────────────────────────────────────────────────
def search_student():
print("\n--- Search Student ---")
roll = input("Enter Roll Number to search: ")
for s in students:
if s['roll'] == roll:
print(f"\nRecord Found:")
print(f" Name : {s['name']}")
print(f" Roll : {s['roll']}")
print(f" Course : {s['course']}")
print(f" Marks : {s['marks']}")
print(f" Grade : {s['grade']}")
return
print("Student not found with given roll number.")

# ──────────────────────────────────────────────────────────
# Function 4: Delete student by roll number
# ──────────────────────────────────────────────────────────
def delete_student():
print("\n--- Delete Student ---")
roll = input("Enter Roll Number to delete: ")
for s in students:
if s['roll'] == roll:
[Link](s)
print(f"✓ Student with Roll No. {roll} deleted successfully.")
return
print("Student not found.")

# ──────────────────────────────────────────────────────────
# Function 5: Calculate and show average marks
# ──────────────────────────────────────────────────────────
def show_average():
if not students:
print("No students found.")
return
total = sum(s['marks'] for s in students)
avg = total / len(students)
print(f"\nTotal Students : {len(students)}")
print(f"Average Marks : {avg:.2f}")

# ──────────────────────────────────────────────────────────
# Main Menu — Program starts here
# ──────────────────────────────────────────────────────────
def main():
print("=" * 40)
print(" STUDENT MANAGEMENT SYSTEM")
print(" BCA 2nd Year - Python Mini Project")
print("=" * 40)

while True:
print("\n[1] Add Student")
print("[2] Display All Students")
print("[3] Search Student")
print("[4] Delete Student")
print("[5] Show Average Marks")
print("[6] Exit")

choice = input("\nEnter your choice (1-6): ")

if choice == '1': add_student()

elif choice == '2': display_all()
elif choice == '3': search_student()
elif choice == '4': delete_student()
 elif choice == '5': show_average()
elif choice == '6':
print("\nThank you! Exiting program. Goodbye!")
break
else:
print("Invalid choice! Please enter 1 to 6.")

# Call main function to run the program

main()

— Page 16 – 18 —
Sample Output — Student Management System

Below is a sample run of the Python program showing all features in action:

$ python student_management.py

========================================
STUDENT MANAGEMENT SYSTEM
BCA 2nd Year - Python Mini Project
========================================

[1] Add Student

[2] Display All Students
[3] Search Student
[4] Delete Student
[5] Show Average Marks
[6] Exit

Enter your choice (1-6): 1

--- Add New Student ---

Enter Student Name : Ravi Sharma
Enter Roll Number : BCA001
Enter Course Name : BCA
Enter Marks (0-100) : 85
✓ Student 'Ravi Sharma' added successfully! Grade: A

Enter your choice (1-6): 1

Enter Student Name : Priya Gupta
Enter Roll Number : BCA002
Enter Course Name : BCA
Enter Marks (0-100) : 92
✓ Student 'Priya Gupta' added successfully! Grade: A+

Enter your choice (1-6): 2

--- All Student Records ---

Roll Name Course Marks Grade
------------------------------------------------------------
BCA001 Ravi Sharma BCA 85.0 A
BCA002 Priya Gupta BCA 92.0 A+

Enter your choice (1-6): 3

--- Search Student ---
Enter Roll Number to search: BCA001

Record Found:
Name : Ravi Sharma
Roll : BCA001
Course : BCA
Marks : 85.0
Grade : A

Enter your choice (1-6): 5

Total Students : 2
Average Marks : 88.50

Enter your choice (1-6): 4

--- Delete Student ---
Enter Roll Number to delete: BCA002
✓ Student with Roll No. BCA002 deleted successfully.

Enter your choice (1-6): 6

Thank you! Exiting program. Goodbye!

Testing Table

# Input Expected Output Actual Output Result

1 Add student Grade: A, added ✓ Grade A, student added PASS

(marks = 85) successfully
2 Add duplicate Error: Roll number Error: Roll number already PASS
roll no. exists exists!
3 Display when No records found No records found. Please PASS
empty message add students first.
4 Search invalid Student not found Student not found with PASS
roll no. given roll number.
5 Enter marks = Error: invalid range Error: Marks must be PASS
150 between 0 and 100.
6 Enter marks = ValueError handled Error: Please enter a valid PASS
"abc" number for marks.

— Page 19 —
Conclusion

Part A — Data Structure using C

Through this practical file, we successfully implemented and studied the following
data structures in C programming language:
Stack – understood LIFO concept using push and pop operations
Queue – understood FIFO concept using enqueue and dequeue operations
Linked List – learned dynamic memory allocation and pointer-based structures
Searching – implemented both Linear and Binary search and compared their
efficiency
Sorting – applied Bubble Sort to arrange elements in ascending order
Recursion – used function calling itself to solve Factorial and Fibonacci problems
Binary Tree – learned tree traversal techniques (Inorder, Preorder, Postorder)
We learned that data structures are fundamental to computer science. Choosing the
right data structure can greatly improve program performance and memory usage.

Part B — Python Mini Project

The Student Management System was successfully built using Python. The project
demonstrated practical application of important Python concepts:
Use of lists and dictionaries to store structured data
Modular programming using functions
Input/output handling with proper error handling using try-except
Basic CRUD operations (Create, Read, Update/Delete) without any database
This project helped in understanding how a real-world application is structured and
developed step by step.
Overall Learning
This practical file helped us understand the difference between low-level
programming (C) and high-level scripting (Python). While C gives more control over
memory, Python makes development faster and easier. Both languages are
important in the field of Computer Science.

Bibliography / References
1. Seymour Lipschutz, Data Structures, Schaum's Outline Series, McGraw-Hill
Education.
2. E. Balagurusamy, Programming in ANSI C, 8th Edition, McGraw-Hill Education.
3. Mark Lutz, Learning Python, 5th Edition, O'Reilly Media, 2013.
4. GeeksforGeeks — Data Structures: [Link]
5. Python Official Documentation: [Link]

This practical file was prepared sincerely as part of the BCA 2nd Year curriculum.
Your Full Name | Roll: BCA/2024/001 | 2025–
2026

— Page 20 —