Q.

No Statement and answer CO

mapping
Section A
5 x 2 = 10 marks
1 Define a class in C++ and explain the purpose of access specifiers. CO1

Ans : A class in C++ is a blueprint for creating objects with related data
and functions. It encapsulates data (variables) and functions (methods)
into a single unit.

Access specifiers (public, private, and protected) control the visibility and
accessibility of class members. They ensure encapsulation, which means
hiding the internal implementation details of a class from outside
interference.

2 Describe the difference between linear and non-linear data structures. CO2
Provide an example of each.

Ans : The difference between linear and non-linear data structures are -

3 Explain how a stack functions and provide an example use case within CO4
a program.

Ans : Here's a brief explanation of how a stack works:

• When an element is pushed onto the stack, it's added to the top.
• When an element is popped from the stack, the top element is
removed.
• Stacks are typically implemented using arrays or linked lists, with the
top element being tracked for easy access.
 One common use case of a stack is in managing function calls in
programming languages. When a function is called, its execution context,
including local variables and return address, is pushed onto a call stack.
When the function finishes executing, its context is popped off the stack,
and the program resumes execution from where it left off.

4 How is a linked list represented in memory, and why is this CO4

advantageous?

Ans : A linked list is represented in memory using a collection of nodes,

where each node contains two parts: the data and a reference (or pointer)
to the next node in the sequence.

The flexibility and efficiency of linked lists make them suitable for
various applications, especially when the size of the data structure is
unpredictable or when frequent insertion and deletion operations are
expected.

5 What is the purpose of a circular queue, and how does it differ from a CO5
linear queue?

Ans : A circular queue serves the purpose of efficiently managing data in

scenarios where a fixed-size buffer is needed, such as in embedded
systems, communication systems, and data streaming applications.

It differs from a linear queue in that it efficiently utilizes memory and

avoids the overhead of shifting elements when the queue becomes full.

Section B
4 x 5 = 20 marks
6 Write a program in C++ demonstrating the use of constructors and CO1
destructors. Explain their importance.

Ans : A program in C++ demonstrating the use of constructors and

destructors is given below -
#include <iostream>
using namespace std;

class Example {
private:
 int data;

public:
// Constructor
Example(int value) {
data = value;
cout << "Constructor called with value: " << value << endl;
}

// Destructor
~Example() {
cout << "Destructor called with value: " << data << endl;
}

// Function to display data

void displayData() {
cout << "Data: " << data << endl;
}
};

int main() {
// Creating an object and invoking constructor
Example obj(10);

// Using the object to display data

obj.displayData();

// Destructor will be invoked when the object goes out of scope

return 0;
}

The importance of constructors and destructors lie in the following

aspects :
• Constructors enable the creation of objects with initial values,
ensuring that they are in a consistent state before being used.
• Constructors play a crucial role in achieving encapsulation by
controlling how objects are created and initialized.
• Destructors prevent resource leaks by ensuring that resources
acquired by objects are properly released when they are no longer
needed.
• Destructors are particularly important when dealing with dynamically
allocated memory and managing system resources.

7 Write a program to perform binary search in an array and explain CO3

how it works.

Ans : A program to perform binary search in an array is given below :

#include<iostream>
#include<algorithm>
using namespace std;

int binary(int arr[],int size,int target){

int left=0;
int right=size-1;

while(left<=right){
int mid=left + (right-left)/2;
if(arr[mid]==target){
return mid;
}else if(arr[mid]<target){
left=mid+1;
}else{
right=mid-1;
}
}
return -1;
}
int main(){
int n;
cout<<"Enter number of elements : ";
cin>>n;
int a[n];
for(int i=0;i<n;i++){
cout<<"Enter element "<<i+1<<" : ";
cin>>a[i];
}
cout<<"\nArray created. The elements are : "<<endl;
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}

sort(a,a+n);

int key;
cout<<"\nEnter element to be searched : ";
cin>>key;

int result=binary(a,n,key);

if(result!=-1){
cout<<"Element found at position "<<result+1<<endl;
}else{
cout<<"Element not found in array"<<endl;
}
 return 0;
}

Code explanation :
• The code defines a function binary for performing binary search on a
sorted array.
• Inside the binary function, it initializes two pointers left and right to
the start and end of the array respectively.
• It iterates through the array using a while loop, updating left and right
pointers based on whether the middle element is less than or greater
than the target element.
• If the target element is found, the function returns its index;
otherwise, it returns -1 to indicate that the element is not present in
the array.
• In the main function, the user inputs the number of elements and then
enters each element of the array.
• The array is displayed after creation.
• The array is sorted using the sort function from the <algorithm>
library.
• The user inputs a key element to be searched in the array.
• The binary function is called to search for the key element in the
sorted array.
• If the key element is found, its position in the array is displayed;
otherwise, a message indicating that the element is not found is
printed.

8 Describe the role of a stack in evaluating postfix expressions. Evaluate CO4

the expression: "3 4 + 5 *".

Ans : In postfix notation (also known as Reverse Polish Notation, or

RPN), operators come after their operands. The role of a stack in
evaluating postfix expressions is crucial. Here's how it works:

Scanning the Expression:

1. Start scanning the expression from left to right.
2. For each element encountered:
• If it's an operand, push it onto the stack.
• If it's an operator, pop the required number of operands from the
stack, perform the operation, and push the result back onto the stack.

Evaluation Process:
1. The postfix notation eliminates the need for parentheses and operator
precedence rules.
2. It relies on the order of operators and operands.
As a result, postfix expressions can be evaluated efficiently using a stack.
 Stack Operations:
1. A stack is used to store operands.
2. When an operator is encountered, the required number of operands are
popped from the stack, the operation is performed, and the result is pushed
back onto the stack.
3. This process continues until the entire expression is scanned.

Evaluating the given expression "3 4 + 5 *", we have -

• Push operand 3 onto the stack.
• Push operand 4 onto the stack.
• Encountered operator '+': Pop operands 4 and 3 from the stack,
perform addition (4 + 3 = 7), and push the result (7) onto the stack.
• Push operand 5 onto the stack.
• Encountered operator '*': Pop operands 5 and 7 from the stack,
perform multiplication (5 * 7 = 35), and push the result (35) onto the
stack.
After scanning the entire expression, the stack contains only one element,
which is the result of the evaluation.

9 Define different types of queues and explain their differences. CO5

Ans : The different types of queues are explained and compared in the
table below -

Section C
3 x 10 = 30 marks
10 Explain the different modes of inheritance in C++. Provide a code CO2
example demonstrating single inheritance.

Ans :
In C++, inheritance is a mechanism by which a class (derived class) can
inherit properties and behaviors (member variables and functions) from
another class (base class). There are different modes of inheritance,
including:
 • Single Inheritance: A derived class inherits from only one base class.
• Multiple Inheritance: A derived class inherits from more than one
base class.
• Multilevel Inheritance: A derived class inherits from another derived
class, creating a hierarchy of inheritance.
• Hierarchical Inheritance: Multiple derived classes inherit from a
single base class.
• Hybrid Inheritance: Combination of multiple inheritance types.

A code example demonstrating single inheritance is given below :

#include <iostream>

// Base class
class Animal {
public:
void eat() {
std::cout << "Animal is eating" << std::endl;
}
};

// Derived class inheriting from Animal

class Dog : public Animal {
public:
void bark() {
std::cout << "Dog is barking" << std::endl;
}
};

int main() {
// Create an object of the derived class
Dog dog;

// Call member functions of both base and derived classes

dog.eat(); // Inherited from Animal
dog.bark(); // Defined in Dog

return 0;
}

This example demonstrates single inheritance where Dog class inherits

properties and behaviors from the Animal class.

11 Compare and contrast different sorting algorithms (e.g., bubble sort, CO3
insertion sort, selection sort). Discuss the advantages and
disadvantages of any one of the sorting techniques and write their
algorithm as well.
 Ans : The comparison of the different sorting algorithms is presented
below -

The algorithm for bubble sort is given below -

1. Start
2. Input: Prompt user for the number of elements (n). Read n.
3. Array Creation:
- Declare an array a of size n.
- For each index i from 0 to n-1:
- Prompt the user to enter element i+1.
- Store the entered element in a[i].
4. Display Array:
- Print "Array created. The elements are:".
- For each index i from 0 to n-1, print a[i].
5. Bubble Sort:
- For each pass i from 0 to n-2:
- For each index j from 0 to n-2:
- If a[j] > a[j+1], swap a[j] and a[j+1].
6. Display Sorted Array:
- Print "Array sorted. The elements are:".
- For each index i from 0 to n-1, print a[i].
7. End.

Advantages of Bubble Sort:

1. Simple implementation.
2. Works well for small datasets.

Disadvantages of Bubble Sort:

1. Inefficient for large datasets (time complexity: O(n^2)).
2. Not suitable for nearly sorted or reverse sorted data.

12 Explain the different types of linked lists (singly, doubly, circular) and CO4
discuss their features.

Ans : The different types of linked lists include -

1. Singly Linked List:

• In a singly linked list, each node contains a data field and a reference
(or pointer) to the next node in the sequence.
• The last node's pointer typically points to NULL, indicating the end of
 the list.
• Singly linked lists are straightforward to implement and are efficient
for insertion and deletion at the beginning or end of the list.
• However, accessing elements by index or traversing in reverse
requires traversing the list from the beginning, resulting in linear time
complexity.

2. Doubly Linked List:

• In a doubly linked list, each node contains a data field and two
references (or pointers): one to the previous node and one to the next
node in the sequence.
• Doubly linked lists allow traversal in both forward and backward
directions, as each node maintains links to both its previous and next
nodes.
• This bidirectional traversal makes operations like insertion and
deletion at any position more efficient than in singly linked lists.
• However, doubly linked lists require more memory to store the
additional pointers.

3. Circular Linked List:

• In a circular linked list, the last node's pointer points back to the first
node, forming a circular structure.
• Circular linked lists can be singly or doubly linked.
• They are useful for applications where traversal needs to wrap around
the list continuously.
• Operations like insertion and deletion are similar to those in non-
circular linked lists but require special handling at the list's start and
end points.

13 Discuss the importance of arrays in data processing. Provide a code CO4

example demonstrating operations like traversing, insertion, or
deletion in arrays.

Ans : The importance of arrays in data processing lie in the following

aspects -

• Efficiency: Arrays provide fast and direct access to elements, crucial

for processing large datasets quickly.
• Memory Efficiency: Contiguous memory allocation reduces overhead
and enhances cache locality, improving access times.
• Simplicity: Arrays are easy to understand and use, making them ideal
for various data processing tasks.
• Versatility: Arrays can store homogeneous elements of any data type,
accommodating diverse datasets efficiently.
• Foundation for Data Structures: Many data structures and algorithms
rely on arrays, making them essential for mastering advanced data
processing techniques.
A code demonstrating creation and insertion of element is shown below -

#include<iostream>
using namespace std;

int main(){
int n,el,p;
cout<<"Enter number of elements : ";
cin>>n;
int a[n];
for(int i=0;i<n;i++){
cout<<"Enter element "<<i+1<<" : ";
cin>>a[i];
}
cout<<"\nArray created. The elements are : "<<endl;
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}

cout<<"\nEnter element to be inserted and position : ";

cin>>el>>p;
for(int i=n-1;i>=p;i--){
a[i+1]=a[i];
}
a[p-1]=el;
n++;

cout<<"\nArray modified. The elements after insertion are : ";

for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
return 0;
}

--------