Question

TO DO: IMPLEMENT SELECTION SORT, BUBBLE SORT, MERGE SORT

INSTRUCTIONS:

1. GENERATE AN ARRAY arr AND FILL IT WITH 100 RANDOM INTEGERS, HAVING VALUES 0-99.
2. PRINT THE UNSORTED ARRAY
3. IMPLEMENT EACH SORTING ALGORITHM (DO NOT USE THE BUILT-IN LIBRARIES)
4. FOR EACH ALGORITHM, INCLUDE PSEUDOCODE WITH NUMBERED STEPS.
5. IN YOUR CODE, CLEARLY COMMENT WHICH STEP IS BEING PERFORMED BY THE LINE OR BLOCK OF CODE.
6. USE A TIMER TO CHECK HOW LONG EACH ALGORITHM TAKES TO SORT THE ARRAY. THIS SHOULD BE IN SECONDS
7. AFTER CALLING EACH SORTING ALGORITHM, PRINT THE ALGORITHM NAME, THE SORTED ARRAY, AND THE AMOUNT OF TIME THE ALGORITHM REQUIRED.
8. WHICH ONE IS FASTEST? WHICH ONE IS SLOWEST?

Answer 1

Since you have not mentioned the language of your preference, I am providing the code in JAVA.

CODE

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class Main {

void bubbleSort(int arr[]) {

int n = arr.length;

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

for (int j = 0; j < n-i-1; j++)

if (arr[j] > arr[j+1])

{

// swap temp and arr[i]

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

void selectionSort(int arr[]) {

int n = arr.length;

// One by one move boundary of unsorted subarray

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

{

// Find the minimum element in unsorted array

int min_idx = i;

for (int j = i+1; j < n; j++)

if (arr[j] < arr[min_idx])

min_idx = j;

// Swap the found minimum element with the first

// element

int temp = arr[min_idx];

arr[min_idx] = arr[i];

arr[i] = temp;

}

}

// Merges two subarrays of arr[].

// First subarray is arr[l..m]

// Second subarray is arr[m+1..r]

void merge(int arr[], int l, int m, int r)

{

// Find sizes of two subarrays to be merged

int n1 = m - l + 1;

int n2 = r - m;

/* Create temp arrays */

int L[] = new int [n1];

int R[] = new int [n2];

/*Copy data to temp arrays*/

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

L[i] = arr[l + i];

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

R[j] = arr[m + 1+ j];

/* Merge the temp arrays */

// Initial indexes of first and second subarrays

int i = 0, j = 0;

// Initial index of merged subarry array

int k = l;

while (i < n1 && j < n2)

{

if (L[i] <= R[j])

{

arr[k] = L[i];

i++;

}

else

{

arr[k] = R[j];

j++;

}

k++;

}

/* Copy remaining elements of L[] if any */

while (i < n1)

{

arr[k] = L[i];

i++;

k++;

}

/* Copy remaining elements of R[] if any */

while (j < n2)

{

arr[k] = R[j];

j++;

k++;

}

}

// Main function that sorts arr[l..r] using

// merge()

void mergeSort(int arr[], int l, int r)

{

if (l < r)

{

// Find the middle point

int m = (l+r)/2;

// Sort first and second halves

mergeSort(arr, l, m);

mergeSort(arr , m+1, r);

// Merge the sorted halves

merge(arr, l, m, r);

}

}

/* A utility function to print array of size n */

static void printArray(int arr[]) {

int n = arr.length;

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

System.out.print(arr[i] + " ");

System.out.println();

}

public static void main(String args[]) {

int n;

n = 100;

int a[] = new int[n];

int temp[] = new int[n];

Random rand = new Random();

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

a[i] = rand.nextInt(100);

}

System.out.println("The unsorted array is: ");

printArray(a);

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

temp[i] = a[i];

}

long startTime, endTime, duration;

Main sort = new Main();

startTime = System.nanoTime();

sort.bubbleSort(a);

endTime = System.nanoTime();

duration = (endTime - startTime) / 1000000000;

System.out.println("\nBubble Sort took " + duration + " seconds\n");

System.out.println("The sorted array: ");

printArray(a);

a = temp;

startTime = System.nanoTime();

sort.selectionSort(a);

endTime = System.nanoTime();

duration = (endTime - startTime) / 1000000000;

System.out.println("\nSelection Sort took " + duration + " seconds\n");

System.out.println("The sorted array: ");

printArray(a);

a = temp;

startTime = System.nanoTime();

sort.mergeSort(a, 0, a.length-1);

endTime = System.nanoTime();

duration = (endTime - startTime) / 1000000000;

System.out.println("\nMerge Sort took " + duration + " seconds\n");

System.out.println("The sorted array: ");

printArray(a);

}

}

Fastest Sort Algorithm: Merge sort

Slowest Sort Algorithm: Bubble Sort