Here you are provided with some sample code for searching/sorting algorithms, which are currently based on integer arrays. However, you are tasked to utilize a custom class that will implement comparable and represents CDs. Each CD has an artist, title, serial number, and price. You decide they should be sorted by serial number. After careful consideration, you also decide to employ ArrayLists instead of the current integer arrays in make the search routines more generally applicable. Given your previous experience with Generics, you finally decide that you should implement the search and sort algorithms by utilizing comparable generics. Create a Java program and create a test case that showcases its functionality for each search/sort. (Five classes provided) need help finishing this code.

import java.util.Random; public class Main { static Random randomGenerator = new Random(); static int ITEMS = 1000; public static void main(String[] args) { int[] randomNumbers = new int[ITEMS]; for (int i=0; ipublic class MergeSort { public static void merge(int numbers[], int i, int j, int k) { int mergedSize = k - i + 1; // Size of merged partition int mergedNumbers[] = new int[mergedSize]; // Temporary array for merged numbers int mergePos = 0; // Position to insert merged number int leftPos = 0; // Position of elements in left partition int rightPos = 0; // Position of elements in right partition leftPos = i; // Initialize left partition position rightPos = j + 1; // Initialize right partition position // Add smallest element from left or right partition to merged numbers while (leftPos <= j && rightPos <= k) { if (numbers[leftPos] < numbers[rightPos]) { mergedNumbers[mergePos] = numbers[leftPos]; ++leftPos; } else { mergedNumbers[mergePos] = numbers[rightPos]; ++rightPos; } ++mergePos; } // If left partition is not empty, add remaining elements to merged numbers while (leftPos <= j) { mergedNumbers[mergePos] = numbers[leftPos]; ++leftPos; ++mergePos; } // If right partition is not empty, add remaining elements to merged numbers while (rightPos <= k) { mergedNumbers[mergePos] = numbers[rightPos]; ++rightPos; ++mergePos; } // Copy merge number back to numbers for (mergePos = 0; mergePos < mergedSize; ++mergePos) { numbers[i + mergePos] = mergedNumbers[mergePos]; } } public static void mergesort(int numbers[], int i, int k) { int j = 0; if (i < k) { j = (i + k) / 2; // Find the midpoint in the partition // Recursively sort left and right partitions mergesort(numbers, i, j); mergesort(numbers, j + 1, k); // Merge left and right partition in sorted order merge(numbers, i, j, k); } } } public class QuickSort { public static int partition(int numbers[], int i, int k) { int l = 0; int h = 0; int midpoint = 0; int pivot = 0; int temp = 0; boolean done = false; /* Pick middle element as pivot */ midpoint = i + (k - i) / 2; pivot = numbers[midpoint]; l = i; h = k; while (!done) { /* Increment l while numbers[l] < pivot */ while (numbers[l] < pivot) { ++l; } /* Decrement h while pivot < numbers[h] */ while (pivot < numbers[h]) { --h; } /* * If there are zero or one items remaining, all numbers are partitioned. Return * h */ if (l >= h) { done = true; } else { /* * Swap numbers[l] and numbers[h], update l and h */ temp = numbers[l]; numbers[l] = numbers[h]; numbers[h] = temp; ++l; --h; } } return h; } public static void quicksort(int numbers[], int i, int k) { int j = 0; /* * Base case: If there are 1 or zero entries to sort, partition is already * sorted */ if (i >= k) { return; } /* * Partition the data within the array. Value j returned from partitioning is * location of last item in low partition. */ j = partition(numbers, i, k); /* * Recursively sort low partition (i to j) and high partition (j + 1 to k) */ quicksort(numbers, i, j); quicksort(numbers, j + 1, k); return; } } public class Searching { public static int linearSearch(int numbers[], int key) { int i = 0; for (i = 0; i < numbers.length; ++i) { if (numbers[i] == key) { return i; /* position */ } } return -1; /* not found */ } public static int binarySearch(int numbers[], int key) { int mid = 0; int low = 0; int high = 0; high = numbers.length - 1; while (high >= low) { mid = (high + low) / 2; if (numbers[mid] < key) { low = mid + 1; } else if (numbers[mid] > key) { high = mid - 1; } else { return mid; } } return -1; // not found } } public class Sorting { public static void selectionSort(int[] numbers) { int i = 0; int j = 0; int indexSmallest = 0; int temp = 0; // Temporary variable for swap for (i = 0; i < numbers.length; ++i) { // Find index of smallest remaining element indexSmallest = i; for (j = i + 1; j < numbers.length; ++j) { if (numbers[j] < numbers[indexSmallest]) { indexSmallest = j; } } // Swap numbers[i] and numbers[indexSmallest] temp = numbers[i]; numbers[i] = numbers[indexSmallest]; numbers[indexSmallest] = temp; } } public static void insertionSort(int[] numbers) { int i = 0; int j = 0; int temp = 0; // Temporary variable for swap for (i = 1; i < numbers.length; ++i) { j = i; // Insert numbers[i] into sorted part // stopping once numbers[i] in correct position while (j > 0 && numbers[j] < numbers[j - 1]) { // Swap numbers[j] and numbers[j - 1] temp = numbers[j]; numbers[j] = numbers[j - 1]; numbers[j - 1] = temp; --j; } } } public static void mergeSort(int[] numbers) { MergeSort.mergesort(numbers, 0, numbers.length - 1); } public static void quickSort(int[] numbers) { QuickSort.quicksort(numbers, 0, numbers.length - 1); } }