Question

PROGRAM DESCRIPTION

Implement the combined O(n) radix/bucket sort as described in class. (i.e. divide the input by radix, bucket sort (with no insertion sort step) once for each radix starting from the least significant. Make sure that your overall implementation is O(n)

NPUT

The input to your program will an unspecified number of entries. Each entry is a non-negative integer containing nine (zero padded) digits ( this means that the integer may have either leading or trailing zeros), one per line. Read your input from STDIN.

OUTPUT

Send the values, one per line, as they were input (all nine digits including leading zeroes, if any), sorted in ascending order, to STDOUT. The only output of your program is the numeric results. (i.e. don't output your name, assignment number, prompts etc.)

NOTES

You may use vectors for your buckets.

Answer 1

CODE:

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class BucketSort {

public static void main(String[] args) {

Scanner getInput = new Scanner(System.in);

System.out.println("Enter total number of values you want to sort");

int arraySize = getInput.nextInt();

List numbers = new ArrayList<>();

System.out.println("Enter " + arraySize + " values");

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

int num = getInput.nextInt();

numbers.add(num);

}

System.out.println("Sorted values...");

for (Integer value : sort(numbers, numbers.size())) {

System.out.println(value);

}

}

public static List sort(List array, int bucketSize) {

if (array.size() == 0) {

return null;

}

// Determine minimum and maximum

valuesInteger minValue = array.get(0);

Integer maxValue = array.get(0);

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

if (array.get(i) < minValue) {

minValue = array.get(i);

}

else if (array.get(i) > maxValue) {

maxValue = array.get(i);

}

}

// Initialise buckets

int bucketCount = (maxValue - minValue) / bucketSize + 1;

List> buckets = new ArrayList>(bucketCount);

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

buckets.add(new ArrayList());

}

// Distribute input array values into buckets

for (int i = 0; i < array.size(); i++) {

buckets.get((array.get(i) - minValue) / bucketSize).add(array.get(i));

}

// Sort buckets and place back into input array

int currentIndex = 0;

array.clear();

for (int i = 0; i < buckets.size(); i++) {

Integer[] bucketArray = new Integer[buckets.get(i).size()];

bucketArray = buckets.get(i).toArray(bucketArray);

InsertionSort.sort(bucketArray);

for (int j = 0;

j < bucketArray.length; j++) {

array.add(currentIndex++, bucketArray[j]);

}

}

return array;

}

static class InsertionSort {

public static > void sort(T[] array) {

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

T item = array[i];

int indexHole = i;

while (indexHole > 0 && array[indexHole - 1].compareTo(item) > 0) {

array[indexHole] = array[--indexHole];

}

array[indexHole] = item;

}

}

}

}