Question

Java : Modify the selection sort algorithm to sort an array of integers in descending order. describe how the skills you have gained could be applied in the field.

Please don't use an already answered solution from chegg. I've unfortunately had that happen at many occasion

.......

........

sec01/SelectionSortDemo.java

import java.util.Arrays;

/**
This program demonstrates the selection sort algorithm by
sorting an array that is filled with random numbers.
*/
public class SelectionSortDemo
{
public static void main(String[] args)
{
int[] a = ArrayUtil.randomIntArray(20, 100);
System.out.println(Arrays.toString(a));

SelectionSorter.sort(a);

System.out.println(Arrays.toString(a));
}
}

sec01/ArrayUtil.java

import java.util.Random;

/**
This class contains utility methods for array manipulation.
*/
public class ArrayUtil
{
private static Random generator = new Random();

/**
Creates an array filled with random values.
@param length the length of the array
@param n the number of possible random values
@return an array filled with length numbers between
0 and n - 1
*/
public static int[] randomIntArray(int length, int n)
{
int[] a = new int[length];
for (int i = 0; i < a.length; i++)
{
a[i] = generator.nextInt(n);
}
  
return a;
}

/**
Swaps two entries of an array.
@param a the array
@param i the first position to swap
@param j the second position to swap
*/
public static void swap(int[] a, int i, int j)
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}

sec01/SelectionSorter.java

/**
The sort method of this class sorts an array, using the selection
sort algorithm.
*/
public class SelectionSorter
{
/**
Sorts an array, using selection sort.
@param a the array to sort
*/
public static void sort(int[] a)
{
for (int i = 0; i < a.length - 1; i++)
{
int minPos = minimumPosition(a, i);
ArrayUtil.swap(a, minPos, i);
}
}

/**
Finds the smallest element in a tail range of the array.
@param a the array to sort
@param from the first position in a to compare
@return the position of the smallest element in the
range a[from] . . . a[a.length - 1]
*/
private static int minimumPosition(int[] a, int from)
{
int minPos = from;
for (int i = from + 1; i < a.length; i++)
{
if (a[i] < a[minPos]) { minPos = i; }
}
return minPos;
}
}

Extra Note: Let’s program this algorithm, called selection sort. For this program, as well as the other programs in this chapter, we will use a utility method to generate an array with random entries. We place it into a class ArrayUtil so that we don’t have to repeat the code in every example. To show the array, we call the static toString method of the Arrays class in the Java library and print the resulting string (see Section 7.3.4). We also add a method for swapping elements to the ArrayUtil class. (See Section 7.3.8 for details about swapping array elements.)

This algorithm will sort any array of integers. If speed were not an issue, or if there were no better sorting method available, we could stop the discussion of sorting right here. As the next section shows, however, this algorithm, while entirely correct, shows disappointing performance when run on a large data set.

Special Topic 14.2 discusses insertion sort, another simple sorting algorithm.

Answer 1

Explanation: As you have mentioned please do not already answered solution,we cannot see others answers.I have modified the SelectionSorter.java and in that instead of finding the minimumPosition find the maximumPostition in the array which can be done by changing the method minimumPosition to maximumPostition and then place it at the 0th position in the array, similarly for all the numbers this process is carried out and we get the resulting array in the descending order.The algorithm selection sort works by swapping the largest number at the first position from the array and thus for each iteration this process continues and we get the desired result.If you want some other approach or method please mention in the comments, i will modify the code accordingly.lease upvote if you liked my answer and comment if you need any modification or explanation.

/**
* The sort method of this class sorts an array, using the selection sort
* algorithm.
*/
public class SelectionSorter
{
   /**
   * Sorts an array, using selection sort.
   *
   * @param a the array to sort
   */
   public static void sort(int[] a)
   {
       for (int i = 0; i < a.length - 1; i++)
       {
           int maxPos = maximumPosition(a, i);
           ArrayUtil.swap(a, i, maxPos);
       }
   }

   /**
   * Finds the largest element in a tail range of the array.
   *
   * @param a the array to sort
   * @param from the first position in a to compare
   * @return the position of the largest element in the range a[from] . . .
   * a[a.length - 1]
   */
   private static int maximumPosition(int[] a, int from)
   {
       int maxPos = from;
       for (int i = from + 1; i < a.length; i++)
       {
           if (a[i] > a[maxPos])
           {
               maxPos = i;
           }
       }
       return maxPos;
   }
}

Output: