Scribd
Upload
6 views11 pages

DAA Practical Imp

The document contains Java code implementations for Merge Sort and Quick Sort algorithms, including methods for measuring execution time and saving results to files. It provides practical examples of sorting arrays of varying sizes and outputs the sorted arrays. Additionally, it includes user input handling for sorting operations.

Uploaded by

shekhar22302
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
6 views11 pages

DAA Practical Imp

The document contains Java code implementations for Merge Sort and Quick Sort algorithms, including methods for measuring execution time and saving results to files. It provides practical examples of sorting arrays of varying sizes and outputs the sorted arrays. Additionally, it includes user input handling for sorting operations.

Uploaded by

shekhar22302
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

Shekhar Krishna 2100320130157

Practical 7
CODE:
import java.util.ArrayList;
import java.util.List;
import java.io.*;
import java.util.Random;
import java.util.Collections;
import java.util.Arrays;

public class Main {


public static void merge(List<Integer> arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
List<Integer> leftHalf = new ArrayList<>(n1);
List<Integer> rightHalf = new ArrayList<>(n2);

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


leftHalf.add(arr.get(left + i));
}

for (int j = 0; j < n2; j++) {


rightHalf.add(arr.get(mid + 1 + j));
}

int i = 0, j = 0, k = left;

while (i < n1 && j < n2) {


if (leftHalf.get(i) <= rightHalf.get(j)) {
arr.set(k, leftHalf.get(i));
i++;
} else {
arr.set(k, rightHalf.get(j));
j++;
}
k++;
}

while (i < n1) {


arr.set(k, leftHalf.get(i));
i++;
k++;
}
Shekhar Krishna 2100320130157

while (j < n2) {


arr.set(k, rightHalf.get(j));
j++;
k++;
}
}

public static void mergeSort(List<Integer> arr, int left, int right) {


if (left < right) {
int mid = left + (right - left) / 2;

mergeSort(arr, left, mid);


mergeSort(arr, mid + 1, right);

merge(arr, left, mid, right);


}
}

public static double measureMergeSortTime(List<Integer> arr) {


long startTime = System.nanoTime();
mergeSort(arr, 0, arr.size() - 1);
long endTime = System.nanoTime();
double duration = (endTime - startTime) / 1e9;
return duration;
}

public static void main(String[] args) {


List<Integer> inputSizes = Arrays.asList(5000, 10000, 15000, 20000, 25000);
List<Double> executionTimes = new ArrayList<>();

for (int n : inputSizes) {


List<Integer> inputArray = new ArrayList<>(n);

Random rand = new Random();


for (int i = 0; i < n; i++) {
inputArray.add(rand.nextInt(10000) + 1);
}

List<Integer> inputArrayCopy = new ArrayList<>(inputArray);


double executionTime = measureMergeSortTime(inputArrayCopy);
executionTimes.add(executionTime);

System.out.println("Sorted an array of size " + n + " in " + executionTime + "


seconds.");
Shekhar Krishna 2100320130157

try {
BufferedWriter writer = new BufferedWriter(new
FileWriter("merge_sort_performance.txt"));
for (int i = 0; i < inputSizes.size(); i++) {
writer.write(inputSizes.get(i) + " " + executionTimes.get(i) + "\n");
}
writer.close();
System.out.println("Data saved to 'merge_sort_performance.txt'. Use gnuplot to
generate a plot.");
} catch (IOException e) {
e.printStackTrace();
}
}
}

OUTPUT:
Shekhar Krishna 2100320130157

Practical 8

CODE:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main {


public static void merge(List<Integer> arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
List<Integer> leftHalf = new ArrayList<>(n1);
List<Integer> rightHalf = new ArrayList<>(n2);

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


leftHalf.add(arr.get(left + i));
}

for (int j = 0; j < n2; j++) {


rightHalf.add(arr.get(mid + 1 + j));
}

int i = 0;
int j = 0;
int k = left;

while (i < n1 && j < n2) {


if (leftHalf.get(i) <= rightHalf.get(j)) {
arr.set(k, leftHalf.get(i));
i++;
} else {
arr.set(k, rightHalf.get(j));
j++;
}
k++;
}

while (i < n1) {


arr.set(k, leftHalf.get(i));
i++;
k++;
Shekhar Krishna 2100320130157

while (j < n2) {


arr.set(k, rightHalf.get(j));
j++;
k++;
}
}

public static void mergeSort(List<Integer> arr, int left, int right) {


if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}

public static double measureMergeSortTime(List<Integer> arr) {


long startTime = System.nanoTime();
mergeSort(arr, 0, arr.size() - 1);
long endTime = System.nanoTime();
double duration = (endTime - startTime) / 1e9;
return duration;
}

public static void main(String[] args) {


try {
BufferedWriter resultFile = new BufferedWriter(new
FileWriter("merge_sort_results.csv"));
resultFile.write("Input Size,Time Taken (s)\n");

List<Integer> inputSizes = List.of(5000, 10000, 15000, 20000, 25000);

for (int n : inputSizes) {


List<Integer> inputArray = new ArrayList<>(n);

Random rand = new Random();


for (int i = 0; i < n; i++) {
inputArray.add(rand.nextInt(10000) + 1);
}

List<Integer> inputArrayCopy = new ArrayList<>(inputArray);


Shekhar Krishna 2100320130157

double executionTime = measureMergeSortTime(inputArrayCopy);


System.out.println("Sorted an array of size " + n + " in " + executionTime + "
seconds");
resultFile.write(n + "," + executionTime + "\n");
}

resultFile.close();
System.out.println("Results saved to 'merge_sort_results.csv'");
} catch (IOException e) {
e.printStackTrace();
}
}
}

OUTPUT:
Shekhar Krishna 2100320130157

Practical-5

5.) WAP to implement QuickSort.

Code:-

import java.util.*;
public class QuickSort {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n;
System.out.println("Enter the Number of Element");
n=sc.nextInt();
int[] arr = new int[n];
System.out.println("Enter the Element of Array");
for(int i=0;i<n;i++){
arr[i]=sc.nextInt();
}
quickSort(arr, 0, arr.length - 1);

System.out.println("Sorted array: ");


for (int num : arr) {
System.out.print(num + " ");
}
}

public static void quickSort(int[] arr, int low, int high) {


if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}

public static int partition(int[] arr, int low, int high) {


Shekhar Krishna 2100320130157

int pivot = arr[high];


int i = low - 1;

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


if (arr[j] < pivot) {
i++;
swap(arr, i, j);
}
}

swap(arr, i + 1, high);
return i + 1;
}

public static void swap(int[] arr, int i, int j) {


int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

Output:-
Shekhar Krishna 2100320130157

Practical-6

6.)WAP to implement MergeSort.

Code:-

import java.util.Scanner;

public class MergeSort {


public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
int n = scanner.nextInt();

int[] arr = new int[n];


System.out.println("Enter the elements: ");
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}

mergeSort(arr, 0, n - 1);

System.out.println("Sorted array: ");


for (int num : arr) {
System.out.print(num + " ");
}

scanner.close();
}

public static void mergeSort(int[] arr, int left, int right) {


if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
Shekhar Krishna 2100320130157

public static void merge(int[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;

int[] L = new int[n1];


int[] R = new int[n2];

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


L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[mid + 1 + j];
}

int i = 0, j = 0, k = left;

while (i < n1 && j < n2) {


if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {


arr[k] = L[i];
i++;
k++;
}

while (j < n2) {


arr[k] = R[j];
j++;
Shekhar Krishna 2100320130157

k++;
}
}
}

Output:-

You might also like