DSA Nish
DSA Nish
DSA Nish
Practical-1
AIM.1: WRITE A PROGRAM TO IMPLEMENT SELECTION SORT:
PROGRAM:
#include <iostream>
using namespace std;
void selection(int arr[], int n)
{
int i, j, small;
for (i = 0; i < n-1; i++)
{
small = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[small])
small = j;
int temp = arr[small];
arr[small] = arr[i];
arr[i] = temp;
}
}
void printArr(int a[], int n) /* function to print the array */
{
int i;
for (i = 0; i < n; i++)
cout<< a[i] <<" ";
}
int main()
{
int a[] = { 80, 10, 29, 11, 8, 30, 15 };
int n = sizeof(a) / sizeof(a[0]);
cout<< "Before sorting array elements are - "<<endl;
printArr(a, n);
selection(a, n);
cout<< "\nAfter sorting array elements are - "<<endl;
printArr(a, n);
return 0;
}
OUTPUT:
Practical-2
AIM.1(b): IMPLEMENT BUBBLE SORT AND INSERTION SORT ?
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]);
}
}
}
}
void insertionSort(int arr[], int n)
{
for (int i = 1; i < n; i++)
{
int key = arr[i];
int j = i - 1;
(j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int main()
{
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "Original Array: ";
printArray(arr, n);
bubbleSort(arr, n);
cout << "Array after Bubble Sort: ";
printArray(arr, n);
int originalArr[] = {64, 34, 25, 12, 22, 11, 90};
for (int i = 0; i < n; i++) {
arr[i] = originalArr[i];
}
insertionSort(arr, n);
cout << "Array after Insertion Sort: ";
printArray(arr, n)
return 0;
}
OUTPUT:
Practical-3
AIM.1(c): IMPLEMENT QUICK SORT AND MERGE SORT
PROGRAM:
#include<iostream>
using namespace std;
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = low - 1;
Practical-4
AIM.2 IMPLEMENT LINEAR SEARCH AND BINARY SERACH:
PROGRAM:
#include <iostream>
#include <algorithm>
using namespace std;
int linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key) {
return i;
}
}
return -1;
}
int binarySearch(int arr[], int low, int high, int key) {
while (low <= high) {
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
return mid;
} else if (arr[mid] < key) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int main() {
int arr[] = {11, 12, 22, 25, 34, 64, 90};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "Original Sorted Array: ";
printArray(arr, n);
int key;
cout << "Enter the key for Linear Search: ";
cin >> key;
int linearResult = linearSearch(arr, n, key);
if (linearResult != -1) {
cout << "Linear Search: Key found at index " << linearResult << endl;
} else {
cout << "Linear Search: Key not found" << endl;
}
sort(arr, arr + n);
cout << "Array after sorting: ";
printArray(arr, n);
cout << "Enter the key for Binary Search: ";
cin >> key;
int binaryResult = binarySearch(arr, 0, n - 1, key);
if (binaryResult != -1) {
cout << "Binary Search: Key found at index " << binaryResult << endl;
} else {
cout << "Binary Search: Key not found" << endl;
}
return 0;
}
OUTPUT:
Practical-5
AIM : Write a program to implement following STACK operations.
PUSH (2) POP (3) PEEP (4) CHANGE (5) DISPLAY:
PROGRAM:
#include <iostream>
using namespace std;
#define MAX_SIZE 10
class Stack {
private:
int arr[MAX_SIZE];
int top;
public:
Stack() {
top = -1;
}
bool isEmpty() {
return top == -1;
}
bool isFull() {
return top == MAX_SIZE - 1;
}
void push(int value) {
if (isFull()) {
cout << "Error: Stack overflow\n";
} else {
arr[++top] = value;
cout << "Pushed " << value << " onto the stack\n";
}
}
void pop() {
if (isEmpty()) {
cout << "Error: Stack underflow\n";
} else {
cout << "Popped " << arr[top--] << " from the stack\n";
}
}
void peep() {
if (isEmpty()) {
cout << "Stack is empty\n";
} else {
cout << "Top element of the stack: " << arr[top] << endl;
}
}
void change(int value) {
if (isEmpty()) {
cout << "Error: Stack is empty, cannot change\n";
} else {
arr[top] = value;
cout << "Changed top element to " << value << endl;
}
}
void display() {
if (isEmpty()) {
cout << "Stack is empty\n";
} else {
cout << "Stack elements: ";
for (int i = 0; i <= top; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
}
};
int main() {
Stack stack;
stack.push(2);
stack.push(4);
stack.push(6);
stack.display();
stack.pop();
stack.display();
stack.peep();
stack.change(8);
stack.display();
return 0;
}
OUTPUT:
Practical-6
AIM: Write a program to implement following QUEUE operations.
INSERT (2) DELETE (3) DISPLAY:
PROGRAM:
#include <iostream>
using namespace std;
#define MAX_SIZE 10
class Queue {
private:
int arr[MAX_SIZE];
int front, rear;
public:
Queue() {
front = rear = -1;
}
bool isEmpty() {
return front == -1;
}
bool isFull() {
return (rear + 1) % MAX_SIZE == front;
}
void insert(int value) {
if (isFull()) {
cout << "Error: Queue overflow\n";
} else {
if (isEmpty()) {
front = rear = 0;
} else {
rear = (rear + 1) % MAX_SIZE;
}
arr[rear] = value;
cout << "Inserted " << value << " into the queue\n";
}
}
void remove() {
if (isEmpty()) {
cout << "Error: Queue underflow\n";
} else {
cout << "Deleted " << arr[front] << " from the queue\n";
if (front == rear) {
front = rear = -1;
} else {
front = (front + 1) % MAX_SIZE;
}
}
}
void display() {
if (isEmpty()) {
cout << "Queue is empty\n";
} else {
cout << "Queue elements: ";
int i = front;
do {
cout << arr[i] << " ";
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
cout << endl;
}
}
};
int main() {
Queue queue;
queue.insert(2);
queue.insert(4);
queue.insert(6);
queue.display();
queue.remove();
queue.display();
queue.insert(8);
queue.display();
return 0;
}
OUTPUT:
Practical-7
AIM: Write a program to implement following CQUEUE operations.
INSERT (2) DELETE (3) DISPLAY:
PROGRAM:
#include <iostream>
using namespace std;
#define MAX_SIZE 5
class CircularQueue {
private:
int arr[MAX_SIZE];
int front, rear;
public:
CircularQueue() {
front = rear = -1;
}
bool isEmpty() {
return front == -1;
}
bool isFull() {
return (rear + 1) % MAX_SIZE == front;
}
void insert(int value) {
if (isFull()) {
cout << "Error: Circular Queue overflow\n";
} else {
if (isEmpty()) {
front = rear = 0;
} else {
rear = (rear + 1) % MAX_SIZE;
}
arr[rear] = value;
cout << "Inserted " << value << " into the circular queue\n";
}
}
void remove() {
if (isEmpty()) {
cout << "Error: Circular Queue underflow\n";
} else {
cout << "Deleted " << arr[front] << " from the circular queue\n";
if (front == rear) {
front = rear = -1;
} else {
front = (front + 1) % MAX_SIZE;
}
}
}
void display() {
if (isEmpty()) {
cout << "Circular Queue is empty\n";
} else {
cout << "Circular Queue elements: ";
int i = front;
do {
cout << arr[i] << " ";
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
cout << endl;
}
}
};
int main() {
CircularQueue cqueue;
cqueue.insert(2);
cqueue.insert(4);
cqueue.insert(6);
cqueue.display();
cqueue.remove();
cqueue.display();
cqueue.insert(8);
cqueue.display();
return 0;
}
OUTPUT:
Practical-8
AIM: WRITE A PROGRAM TO IMPLEMENT SINGLE LINKED LIST:
PROGRAM:
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node(int value) : data(value), next(nullptr) {}
};
class LinkedList {
private:
Node* head;
public:
LinkedList() : head(nullptr) {}
void insert(int value) {
Node* newNode = new Node(value);
if (head == nullptr) {
head = newNode;
} else {
Node* current = head;
while (current->next != nullptr) {
current = current->next;
}
current->next = newNode;
}
}
void display() {
Node* current = head;
Practical-9
AIM: Write a program to implement following operations of the doubly linked list
PROGRAM:
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node* prev;
Node(int value) : data(value), next(nullptr), prev(nullptr) {}
};
class DoublyLinkedList {
private:
Node* head;
public:
DoublyLinkedList() : head(nullptr) {}
void insert(int value) {
Node* newNode = new Node(value);
if (head == nullptr) {
head = newNode;
} else {
Node* current = head;
while (current->next != nullptr) {
current = current->next;
}
current->next = newNode;
newNode->prev = current;
}
}
void displayForward() {
Node* current = head;
while (current != nullptr) {
cout << current->data << " ";
current = current->next;
}
cout << endl;
}
void displayBackward() {
Node* current = head;
while (current->next != nullptr) {
current = current->next;
}
while (current != nullptr) {
cout << current->data << " ";
current = current->prev;
}
cout << endl;
}
~DoublyLinkedList() {
Node* current = head;
Node* nextNode;
while (current != nullptr) {
nextNode = current->next;
delete current;
current = nextNode;
}
}
};
int main() {
DoublyLinkedList myList;
myList.insert(2);
myList.insert(4);
myList.insert(6);
cout << "Doubly Linked List (Forward): ";
myList.displayForward();
cout << "Doubly Linked List (Backward): ";
myList.displayBackward();
return 0;
}
OUTPUT:
Practical-10
AIM: Write a program to implement stack using linked list
PROGRAM:
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node(int value) : data(value), next(nullptr) {}
};
class Stack {
private:
Node* top;
public:
Stack() : top(nullptr) {}
bool isEmpty() {
return top == nullptr;
}
void push(int value) {
Node* newNode = new Node(value);
newNode->next = top;
top = newNode;
cout << "Pushed " << value << " onto the stack\n";
}
void pop() {
if (isEmpty()) {
cout << "Error: Stack underflow\n";
} else {
Node* temp = top;
top = top->next;
cout << "Popped " << temp->data << " from the stack\n";
delete temp;
}
}
void display() {
if (isEmpty()) {
cout << "Stack is empty\n";
} else {
cout << "Stack elements: ";
Node* current = top;
while (current != nullptr) {
cout << current->data << " ";
current = current->next;
}
cout << endl;
}
}
~Stack() {
Node* current = top;
Node* nextNode;
while (current != nullptr) {
nextNode = current->next;
delete current;
current = nextNode;
}
}
};
int main() {
Stack myStack;
myStack.push(2);
myStack.push(4);
myStack.push(6);
myStack.display();
myStack.pop();
myStack.display();
myStack.push(8);
myStack.display();
return 0;
}
OUTPUT:
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies: