ROHINI COLLEGE OF ENGINEERING AND TECHNOLOGY

DEPARTMENT OF ELECTRICAL AND ELECTRONICS

ENGINEERING

24ES132-PROGRAMMING AND ALGORITHMS

LABORATORY

LAB MANUAL

I Year - I Semester

Regulation 2021
Course PROGRAMMING AND
24ES132 Course Title:
Code: ALGORITHMS LABORATORY
Credits: 2 L–T–P 0-0-4

Course objectives:
 To develop an algorithm & programming on software tools and Digital processors with
peripheral interfaces.
 To expertise in open source software / packages /tools.
 To do hands-on in commercial and licensed Hardware-software suites.

Teaching-Learning Process:
Suggested strategies that teachers may use to effectively achieve the course outcomes:
1. Interactive Simulations
2. Lab experiment videos
3. Blended Mode of Learning
4. Project based Learning
5. Experiential Learning
6. NPTEL and Other Videos
7. Smart Class Room
8. Flipped Class
 LIST OF EXPERIMENTS
1. Implementation of basic programming concepts like conditionals and loops
2. Implementation of function and operator overloading
3. Creation of classes and objects.
4. Implementation of constructors and destructors
5. Implementation of array of objects and dynamic objects.
6. Implementation of inheritance and its types
7. Implementation of polymorphism and its types.
8. Implementation of various sorting algorithms.
9. Application of Stack
10. Implementation of queue using array.
11. Implementation of Linked Lists: Singly linked, doubly linked and Circular lists and applications.

Course outcomes: On completion of the course, the student will have the ability to:

CO1 Implement various object oriented concepts through simple programs.

CO2 Implement different data structures using C++

CO3 Apply the different data structures for implementing solutions to practical problems

CO4 Demonstrate searching algorithms

CO5 Demonstrate sorting algorithms

COs and POs Mapping:

CO/PO PO1 PO2 PO3
CO1 3 - 2
CO2 3 - 2
CO3 3 - 2
CO4 3 - 2
CO5 3 - 2
CO 3 - 2

Level 3- Highly Mapped, Level 2- Moderately Mapped, Level 1- Low Mapped, Level 0- Not
Mapped
 Scheme of Evaluation:
Final
Max Reduce Total
Component Typeof assessment mark
Marks d
s
Marks
Continuous Internal Continuous 75 75 10
Examination (CIE) - Assessment 60
0
Laboratory
Model Lab Exam 25 25

End Semester
Lab Exam 100 40 40 40
Examination (ESE)

Total 100
Exp. No. :
Date :
IMPLEMENTATION OF BASIC PROGRAMMING CONCEPTS LIKE
CONDITIONALS AND LOOPS

AIM :-
To write a program to implement the basic programming concepts like conditions and
loops.
PROGRAM:-

#include <iostream>

Using namespace std;

Int main() {
Int num;

// Asking user input

Cout << “Enter a positive integer: “;
Cin >> num;

// Conditional statement
If (num > 0) {
Cout << “You entered a positive number.” << endl;

// Loop to print numbers from 1 to the entered number

Cout << “Printing numbers from 1 to “ << num << “:” << endl;
For (int i = 1; i <= num; i++) {
Cout << i << “ “;
}
Cout << endl;

// While loop to calculate the sum of numbers from 1 to num

Int sum = 0;
Int i = 1;
While (i <= num) {
Sum += i;
I++;
 }
Cout << “The sum of numbers from 1 to “ << num << “ is: “ << sum << endl;

} else if (num == 0) {
Cout << “You entered zero.” << endl;
} else {
Cout << “You entered a negative number.” << endl;
}

Return 0;
}

Output:

RESULT :-

Thus the program to implement the basic programming concepts like conditions and
loops is executed and the output is verified.
Exp. No. :
Date :

IMPLEMENTATION OF FUNCTION AND OPERATOR OVERLOADING

AIM :-
To write a program to implement the function and operator overloading.

PROGRAM :-
#include <iostream>

Using namespace std;

// Function to add two integers

Int add(int a, int b) {

Return a + b;

}
// Function to add three integers

Int add(int a, int b, int c) {

Return a + b + c;
}

// Function to add two double values

Double add(double a, double b) {

Return a + b;
}

Int main() {

Cout << “Add two integers: “ << add(3, 4) << endl; // Calls add(int, int)
 Cout << “Add three integers: “ << add(3, 4, 5) << endl; // Calls add(int, int, int)

cout << "Add two doubles: " << add(2.5, 3.5) << endl; // Calls add(double, double)

return 0;

Output:

RESULT :-
Thus the program to implement the function and operator overloading is executed and the
output is verified.
Exp. No. :
Date :

CREATION OF CLASSES AND OBJECTS

AIM :-
To write a program to create classes and objects .

PROGRAM :-
#include <iostream>
using namespace std;

// Define a class called "Car"

class Car {

private:

// Data members (attributes)

string brand;
string model;

int year;

public:

// Constructor to initialize a Car object

Car(string b, string m, int y) {

brand = b;

model = m;
year = y;

// Member function to display car details

 void displayDetails() {

cout << "Brand: " << brand << ", Model: " << model << ", Year: " << year << endl;

// Setter for the year attribute

void setYear(int y) {

year = y;

// Getter for the year attribute

int getYear() {

return year;
}

};

int main() {

// Creating objects of class Car

Car car1("Toyota", "Corolla", 2018);

Car car2("Honda", "Civic", 2020);

// Displaying details of car1 and car2

car1.displayDetails();

car2.displayDetails();

// Modifying the year of car1 using the setter function

car1.setYear(2021);
cout << "Updated year of car1: " << car1.getYear() << endl;
 return 0;

Output:

RESULT :-
Thus the program to create classes and objects is executed and the output is verified.
Exp. No. :
Date :
IMPLEMENTATION OF CONSTRUCTORS AND DESTRUCTORS

AIM :-
To write a program to implement the constructors and destructors .

PROGRAM :-
#include <iostream>

using namespace std;

class Person {

private:

string name;

int age;

public:
// Default constructor

Person() {

name = "Unknown";
age = 0;

cout << "Default constructor called" << endl;

// Parameterized constructor
Person(string n, int a) {

name = n;

age = a;

cout << "Parameterized constructor called for " << name << endl;
 }

// Destructor

~Person() {
cout << "Destructor called for " << name << endl;

// Member function to display person details

void display() {

cout << "Name: " << name << ", Age: " << age << endl;

};

int main() {

// Creating an object using the default constructor

Person person1;

person1.display();

// Creating an object using the parameterized constructor

Person person2("Alice", 30);

person2.display();

// Creating an object in a block scope

Person person3("Bob", 25);

person3.display();
} // person3 goes out of scope here, and the destructor is called
 cout << "End of main function" << endl;

return 0;
}

Output:

RESULT :-
Thus the program to implement the constructors and destructors is executed and the output is
verified.
Exp. No. :
Date :

IMPLEMENTATION OF ARRAY OF OBJECTS AND DYNAMIC OBJECTS

AIM :-
To write a program to implement the array of objects and dynamic objects.

PROGRAM :-
#include <iostream>
using namespace std;

class Student {

private:

string name;

int rollNumber;

public:

// Parameterized constructor

Student(string n, int r) {
name = n;

rollNumber = r;

// Default constructor
Student() {

name = "Unknown";

rollNumber = 0;

}
 // Function to display student details

void display() {

cout << "Name: " << name << ", Roll Number: " << rollNumber << endl;
}

};

int main() {

// Creating an array of Student objects with 3 elements

Student students[3] = { {"Alice", 1}, {"Bob", 2}, {"Charlie", 3} };

// Displaying details of each student

for (int i = 0; i < 3; i++) {

students[i].display();

return 0;

Output:

RESULT :-
Thus the program to implement the array of objects and dynamic objects is executed and the
output is verified .
Exp. No. :
Date :

IMPLEMENTATION OF INHERITANCE AND ITS TYPES

AIM :-
To write a program to implement the inheritance and its types.

PROGRAM :-
#include <iostream>
using namespace std;

// Base class

class Animal {

public:

void eat() {

cout << "Eating..." << endl;

}

};

// Derived class (Single Inheritance)

class Dog : public Animal {

public:

void bark() {

cout << "Barking..." << endl;

}

};

// Derived class (Multiple Inheritance)

class Pet {

public:

void beFriendly() {

cout << "Being friendly..." << endl;

}

};

class Bulldog : public Dog, public Pet {

public:

void guard() {

cout << "Guarding..." << endl;

}
};

// Derived class (Multilevel Inheritance)

class Puppy : public Dog {

public:

void weep() {

cout << "Weeping..." << endl;

}

};

int main() {

Dog dog;

dog.eat(); // From Animal

dog.bark(); // From Dog

 Bulldog bulldog;

bulldog.bark(); // From Dog

bulldog.beFriendly(); // From Pet

bulldog.guard(); // From Bulldog

Puppy puppy;

puppy.weep(); // From Puppy

puppy.bark(); // From Dog

puppy.eat(); // From Animal

return 0;

Output:

RESULT :-
Thus the program to implement the inheritance and its types is executed and the output is
verified .
Exp. No. :
Date :

IMPLEMENTATION OF POLYMORPHISM AND ITS TYPES

AIM :-
To write a program to implement the polymorphism and its types.

PROGRAM :-
#include <iostream>
using namespace std;

// Base class

class Shape {

public:

virtual void draw() {

cout << "Drawing a shape" << endl;

}

};

// Derived class

class Circle : public Shape {

public:

void draw() override {

cout << "Drawing a circle" << endl;

}

};

// Derived class
class Rectangle : public Shape {

public:

void draw() override {

cout << "Drawing a rectangle" << endl;

}

};

int main() {

Shape* shape1 = new Circle();

Shape* shape2 = new Rectangle();

// Runtime polymorphism
shape1->draw(); // Output: Drawing a circle

shape2->draw(); // Output: Drawing a rectangle

delete shape1;

delete shape2;

return 0;
}

Output:

RESULT :-
Thus the program to implement the polymorphism and its types is executed and the output is
verified .
Exp. No. :
Date :

IMPLEMENTATION OF VARIOUS SORTING ALGORITHMS

AIM :-
To write a program to implement the various sorting algorithms .

PROGRAM :-
#include <iostream>

Using namespace std;

Void bubbleSort(int arr[], int n) {

For (int i = 0; i < n – 1; i++) {

For (int j = 0; j < n – i – 1; j++) {

If (arr[j] > arr[j + 1]) {

Swap(arr[j], arr[j + 1]);

}
}

Int partition(int arr[], int low, int high) {

Int pivot = arr[high];

Int i = (low – 1);

For (int j = low; j < high; j++) {

If (arr[j] < pivot) {

I++;
 Swap(arr[i], arr[j]);

Swap(arr[i + 1], arr[high]);

Return (i + 1);

Void quickSort(int arr[], int low, int high) {

If (low < high) {

Int pi = partition(arr, low, high);

quickSort(arr, low, pi – 1);

quickSort(arr, pi + 1, high);
}

Int main() {

Int arr[] = {64, 25, 12, 22, 11};

Int n = sizeof(arr) / sizeof(arr[0]);

bubbleSort(arr, n);

cout << “Bubble Sorted array: “;

for (int i = 0; i < n; i++)

cout << arr[i] << “ “;

cout << endl;

int arr2[] = {64, 25, 12, 22, 11};

quickSort(arr2, 0, n – 1);
 cout << “Quick Sorted array: “;

for (int i = 0; i < n; i++)

cout << arr2[i] << “ “;

cout << endl;

return 0;

Output:

RESULT :-
Thus the program to implement the various sorting algorithms is executed and the output is
verified .
Exp. No. :
Date :

APPLICATION OF STACK

AIM :-
To write a program of application of stack .

PROGRAM :-
#include <iostream>
#include <stack>

Using namespace std;

Int main() {

Stack<int> stk;

Stk.push(10);

Stk.push(20);
Stk.push(30);

While (!stk.empty()) {
Cout << “Stack top: “ << stk.top() << endl;

Stk.pop();

Return 0;
}
 Output:

RESULT :-
Thus the program of application of stack is executed and the output is verified .
Exp. No. :
Date :

IMPLEMENTATION OF QUEUE USING ARRAY

AIM :-
To write a program to implement the queue using array .

PROGRAM :-
#include <iostream>
using namespace std;

#define SIZE 5

class Queue {

private:

int items[SIZE], front, rear;

public:

Queue() {
front = -1;

rear = -1;

void enqueue(int value) {

if (rear == SIZE - 1)

cout << "Queue is full" << endl;

else {

if (front == -1) front = 0;

 items[++rear] = value;

cout << "Inserted " << value << endl;

void dequeue() {

if (front == -1 || front > rear)

cout << "Queue is empty" << endl;

else

cout << "Removed " << items[front++] << endl;

void display() {

if (front == -1)

cout << "Queue is empty" << endl;

else {

for (int i = front; i <= rear; i++) {

cout << items[i] << " ";

}
cout << endl;

};

int main() {

Queue q;
q.enqueue(10);
 q.enqueue(20);

q.enqueue(30);

q.display();

q.dequeue();
q.display();

return 0;

Output:

RESULT :-
Thus the program to implement the queue using array is executed and the output is verified.
Exp. No. :
Date :

IMPLEMENTATION OF LINKED LISTS: SINGLY LINKED, DOUBLY LINKED AND

CIRCULAR LISTS AND APPLICATIONS

AIM :-
To write a program to implement the Linked Lists: Singly linked, doubly linked and Circular
lists and applications.

PROGRAM :-
#include <iostream>

Using namespace std;

Class Node {

Public:

Int data;

Node* next;

Node(int val) : data(val), next(nullptr) {}

};

Class SinglyLinkedList {

Private:

Node* head;

Public:

SinglyLinkedList() : head(nullptr) {}
 Void insert(int data) {

Node* newNode = new Node(data);

If (!head) {

Head = newNode;
} else {

Node* temp = head;

While (temp->next)

Temp = temp->next;

Temp->next = newNode;

Void display() {

Node* temp = head;

While (temp) {

Cout << temp->data << “ -> “;

Temp = temp->next;

Cout << “nullptr” << endl;

}

};

Int main() {

SinglyLinkedList list;

List.insert(10);

List.insert(20);
List.insert(30);
 List.display();

Return 0;

}
#include <iostream>

Using namespace std;

Class Node {

Public:

Int data;

Node* next;

Node* prev;
Node(int val) : data(val), next(nullptr), prev(nullptr) {}

};

Class DoublyLinkedList {

Private:

Node* head;

Public:

DoublyLinkedList() : head(nullptr) {}

Void insert(int data) {

Node* newNode = new Node(data);

If (!head) {

Head = newNode;
} else {
 Node* temp = head;

While (temp->next)

Temp = temp->next;

Temp->next = newNode;
newNode->prev = temp;

Void display() {

Node* temp = head;

While (temp) {

Cout << temp->data << “ <-> “;

Temp = temp->next;

Cout << “nullptr” << endl;

};

Int main() {
DoublyLinkedList list;

List.insert(10);

List.insert(20);

List.insert(30);

List.display();

Return 0;
}
#include <iostream>

Using namespace std;

Class Node {
Public:

Int data;

Node* next;

Node(int val) : data(val), next(nullptr) {}

};

Class CircularLinkedList {
Private:

Node* head;

Public:

CircularLinkedList() : head(nullptr) {}

// Function to insert a node at the end of the list

Void insert(int data) {

Node* newNode = new Node(data);

If (head == nullptr) {

Head = newNode;

Head->next = head; // Points to itself to form the circular link

} else {

Node* temp = head;

While (temp->next != head) {
 Temp = temp->next;

Temp->next = newNode;

newNode->next = head; // Point back to the head

}

// Function to display the list

Void display() {

If (head == nullptr) {

Cout << “The list is empty.” << endl;

Return;
}

Node* temp = head;

Do {

Cout << temp->data << “ -> “;

Temp = temp->next;

} while (temp != head);

Cout << “(head)” << endl;

// Function to delete a node by value

Void deleteNode(int key) {

If (head == nullptr) {

Cout << “The list is empty. Nothing to delete.” << endl;

Return;
}

// If the node to be deleted is the head node

If (head->data == key) {
If (head->next == head) {

// Only one node in the list

Delete head;

Head = nullptr;

} else {

Node* temp = head;

While (temp->next != head) {

Temp = temp->next;
}

Node* toDelete = head;

Head = head->next;

Temp->next = head;

Delete toDelete;

Cout << “Node with value “ << key << “ deleted.” << endl;
Return;

// If the node to be deleted is not the head

Node* current = head;

Node* previous = nullptr;

Do {
Previous = current;
 Current = current->next;

If (current->data == key) {

Previous->next = current->next;

Delete current;
Cout << “Node with value “ << key << “ deleted.” << endl;

Return;

} while (current != head);

Cout << “Node with value “ << key << “ not found.” << endl;

};

Int main() {

CircularLinkedList list;

// Inserting nodes into the circular linked list

List.insert(10);

List.insert(20);
List.insert(30);

List.insert(40);

// Displaying the circular linked list

Cout << “Circular Linked List: “;

List.display();

// Deleting a node from the circular linked list

 List.deleteNode(20);

Cout << “After deleting 20: “;

List.display();

List.deleteNode(40);

Cout << “After deleting 40: “;

List.display();

List.deleteNode(10);

Cout << “After deleting 10: “;

List.display();

List.deleteNode(30);

Cout << “After deleting 30: “;

List.display();

Return 0;

Output:

RESULT:-
Thus the program to implement the Linked Lists: Singly linked, doubly linked and Circular
lists and applications is executed and the output is verified.