The fastest way to sort the array of the random integers

Question

I have an array which consists of 10 random integers, what will be the fastest way to sort it from the largest to the smallest?

public class Main {
    public static void main(String args[])
    {
        int [] array = new int[10];

        array[0] = ((int)(Math.random()*100+1));
        array[1] = ((int)(Math.random()*100+1));
        array[2] = ((int)(Math.random()*100+1));
        array[3] = ((int)(Math.random()*100+1));
        array[4] = ((int)(Math.random()*100+1));
        array[5] = ((int)(Math.random()*100+1));
        array[6] = ((int)(Math.random()*100+1));
        array[7] = ((int)(Math.random()*100+1));
        array[8] = ((int)(Math.random()*100+1));
        array[9] = ((int)(Math.random()*100+1));
        
        for (int i = 0; i < 10; i++){
            System.out.println(i + ") " + array[i]);
        }
    }
}

The only thing that comes to mind is bubble sort and the insertion sort

This should help you https://stackoverflow.com/questions/1415173/what-is-the-fastest-possible-way-to-sort-an-array-of-7-integers — rhowell, Nov 15 '22 at 22:02
if you know anything about sorts, you know that neither of those is particularly fast — njzk2, Nov 15 '22 at 22:04
@njzk2 actually insertion sort is very good for a small set of numbers like this... — rhowell, Nov 15 '22 at 22:07
For only 10 numbers, it hardly seems to matter which is fastest. But as the answer says, Arrays.sort is the most convenient. (Incidentally, you should write a loop to fill the array, rather than 10 identical assignment statements) — access violation, Nov 15 '22 at 22:41

OscarRyz · Answer 1 · 2022-11-16T15:21:34.613

1

For ascending order it would be as easy as:

Arrays.sort(array);

Unfortunately due to the unboxing feature, it's a bit more complicated but still doable.

    array = Arrays.stream(array)   // turn into an IntStream
           .boxed()                // Then into a Stream<Integer>
           .sorted((a,b) -> b - a) // Sort descending
           .mapToInt(i -> i)       // Convert Integer back to int
           .toArray();             // Convert back to int[]

edited Nov 16 '22 at 15:21

answered Nov 15 '22 at 22:03

OscarRyz

196,001
113
385
569

I agree with using Array.sort, but the order will be low to high, and the OP wants high to low. Thus, you either need to use a pass over the result to reverse it, or else use the form of sort with a comparator argument, but that will involve making an Integer array. My instinct is to stick with int and do the reversal. – access violation Nov 15 '22 at 22:44
My bad, I didn't see that part. Editing – OscarRyz Nov 16 '22 at 14:50

score 0 · Answer 2 · answered Nov 16 '22 at 02:07

Although there are several ways to do this, this is one way. Read the comments in code:

int [] array = new int[10];

/* Generate an int[] Array with 10 elements consisting 
   of 10 elements holding a random number from 1 to 100
   (duplicates allowed).                  */
System.out.println("Generated Array (Random Order):");
// Display the generated Array...
for (int i = 0; i < array.length; i++){
    array[i] = ((int)(Math.random()*100+1));
    System.out.printf("%2d) %-6d%n", (i+1), array[i]);
}
    
System.out.println();
    
// Sort the Array in Ascending Order 'first'!
System.out.println("Sorted Array (Ascending Order):");
Arrays.sort(array);  // Sort in ascending order
// Display the sorted Array...
for (int i = 0; i < array.length; i++){
    System.out.printf("%2d) %-6d%n",(i+1), array[i]);
}
    
System.out.println();
    
// Sort the Array in Ddescending Order 'second'!
System.out.println("Sorted Array (Descending Order):");
// Create a new int[] Array (arr[]) and place array[] into it in Descending order.
int[] arr = IntStream.rangeClosed(1, array.length).map(i -> array[array.length - i]).toArray();
// Copy the arr[] array into the array[] Array to overwrite it.        
System.arraycopy(arr, 0, array, 0, arr.length);
// Display the sorted Array...
for (int i = 0; i < arr.length; i++){
    System.out.printf("%2d) %-6d%n",(i+1), array[i]);
}

When the code is run, you could see something similar to this:

Generated Array (Random Order):
 1) 80    
 2) 54    
 3) 100   
 4) 96    
 5) 71    
 6) 87    
 7) 22    
 8) 60    
 9) 67    
10) 18    

Sorted Array (Ascending Order):
 1) 18    
 2) 22    
 3) 54    
 4) 60    
 5) 67    
 6) 71    
 7) 80    
 8) 87    
 9) 96    
10) 100   

Sorted Array (Descending Order):
 1) 100   
 2) 96    
 3) 87    
 4) 80    
 5) 71    
 6) 67    
 7) 60    
 8) 54    
 9) 22    
10) 18

score 0 · Answer 3 · answered Nov 16 '22 at 13:06

You can flip the bits of integers to sort in ascending order, then flip the bits again to sort in descending order.

array = IntStream.of(array).map(i -> ~i).sorted().map(i -> ~i).toArray();

for (int i = 0; i < 10; i++) {
    System.out.println(i + ") " + array[i]);
}

output:

Since everything is positive in this case, you can do the same thing with sign reversal instead of bit reversal.

array = IntStream.of(array).map(i -> -i).sorted().map(i -> -i).toArray();

Note that numbers containing Integer.MIN_VALUE can't be sorted this way, because they are themselves when they are sign-reversed.

The fastest way to sort the array of the random integers

3 Answers3