The Wikipedia entry has a little simulation that shows how bubble sort works. Th

Question

The Wikipedia entry has a little simulation that shows how bubble sort works. The code looks something like:

bubbleSort(array A){
   n = length(A);

   for(j = n; j > 0, j--)
       for(i = 1; i < j; i++) {
         if A[i-1] > A[i]
             swap(A,i-1, i);
       }
   }
}

swap obviously swaps the elements and can be defined as:

swap(A, pos1, pos2) {
     temp = A[pos1];
     A[pos1] = A[pos2];
     A[pos2] = temp;
}

Another sort is selection sort (http://en.wikipedia.org/wiki/Selection_sort). We saw selection sort in the question in the sub-module on how to determine the complexity of an algorithm. Array A contains n elements, the elements to be sorted. The algorithm starts at the first position in the array and looks through the array for the smallest element. Once it reaches the end of the array, it puts that element in the first cell of the array. It then restarts the whole process from the second position in the array, and continues until the entire array has been sorted.

selection_sort(array A) {
    int i,j
    int iMin;
    for(j = 0; j < n; j++){
       iMin = j;

THE PROJECT

The purpose of the project is to perform a timing experiment. You are required to complete the following activities:

Write a computer program that prompts the user for a number, creates an array for that number of random integers, and then uses the bubble sort to order the array. The program should print out the array prior to the call to the sorting algorithm and afterwards. You can write the program in either Java, C++, C#, or whatever language you are most comfortable in.

Repeat 1 but use selection sort this time.

1 and 2 are primarily intended to make sure that your algorithms work.

Once you are convinced your programs work, do the following

Write a computer program that prompts the user for one number, n for the number of items in the array to sort, and create and sort 1000 arrays of this size timing the run to get an average time to sort an array of this size. Then do the following:

Initiate a variable running_time to 0

Create a for loop that iterates 1000 times.

In the body of the loop,

Create an array of n random integers

Get the time and set this to start-time. You will have to figure out what the appropriate command is in the programming language you are using to find the time

Use bubble sort to sort the array

Get the time and set this to end-time

Subtract start-time from end-time and add the result to total_time

Once the program has run, note

The number of items sorted

The average running time for each array (total_time/1000)

Repeat the process six times, using 50, 250 and 500 as the size of the array for each of the two algorithms.

Repeat 3 using selection sort.

Create a spreadsheet showing the results of 3 and 4 and create a graph to graphically represent the information. Show both sort algorithms on the same graph for comparison.

Write a one page document explaining the results, bearing in mind that both algorithms have a complexity of O(n^2) and what you know about complexity analysis. Use your knowledge of complexity analysis to explain your results.

Please submit

Program code for 1

Program code for 2

Program code used in 3 and the results of the nine program runs

Program code used in 4 and the results of the nine program runs

The spreadsheet created in 5

The report. In the report, say which machine you ran the experiments on (type of processor, RAM, etc).

Use the associated drop box. You can submit all of this in a single file, or in separate files. If you have any questions, post them on the discussion forum.

Grading will be determined by your data , graphs and your write-up including observations and what you have learned.

Explanation / Answer

Below are the codes for the required BubbleSort and SelectionSort algorithms in java. Please use below algorithm to solve part 3 where need to add loop on the main method code to iterate it 1000 times:

(1) BubbleSort.java:

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class BubbleSort {

public static void bubbleSort(int array[]) {

int n = array.length;

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

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

if (array[j] > array[j + 1]) {

swap(array, j);

}

}

}

}

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

int temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

public static void main(String[] args) {

Random rand = new Random();

Scanner scanner = new Scanner(System.in);

int n;

System.out.print("Please enter a number: ");

n = scanner.nextInt();

int[] array = new int[n];

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

array[i] = rand.nextInt();

}

System.out.println("Array before sorting: " + Arrays.toString(array));

bubbleSort(array);

System.out.println("Array after sorting: " + Arrays.toString(array));

scanner.close();

}

}

(2) SelectionSort.java:

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class SelectionSort {

public static void selectionSort(int[] array) {

for (int i = 0; i < array.length - 1; i++) {

int currentMin = array[i];

int currentMinIndex = i;

for (int j = i + 1; j < array.length; j++) {

if (currentMin > array[j]) {

currentMin = array[j];

currentMinIndex = j;

}

}

if (currentMinIndex != i) {

swap(array, i, currentMinIndex);

}

}

}

public static void swap(int[] array,int i,int minIndex) {

int min = array[minIndex];

array[minIndex] = array[i];

array[i] = min;

}

public static void main(String[] args) {

Random rand = new Random();

Scanner scanner = new Scanner(System.in);

int n;

System.out.print("Please enter a number: ");

n = scanner.nextInt();

int[] array = new int[n];

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

array[i] = rand.nextInt();

}

System.out.println("Array before sorting: "+Arrays.toString(array));

selectionSort(array);

System.out.println("Array after sorting: "+Arrays.toString(array));

scanner.close();

}

}

Related Questions

Navigate

• Browse (All)
• Browse T
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.