Сортировка массива

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Random;
 
class Sorts {
    private static long time;
 
    private static void start() {
        time = System.currentTimeMillis();
    }
 
    private static String finish() {
        long end = System.currentTimeMillis() - time;
        return String.format("%d.%s sec.", end / 1000, new DecimalFormat("000").format(end % 1000));
    }
 
    static String sortShell(int[] array) {
        start();
        if (array != null && array.length > 1) {
            int n = array.length;
            int d = n / 2;
            int j;
            int temp;
            while (d > 0) {
                for (int index = 0; index < n - d; index++) {
                    j = index;
                    while (j >= 0 && array[j] > array[j + d]) {
                        temp = array[j];
                        array[j] = array[j + d];
                        array[j + d] = temp;
                        j--;
                    }
                }
                d /= 2;
            }
        }
        return finish();
    }
 
    static String sortQuick(int[] array) {
        start();
        quickSortRecursion(array, 0, array.length - 1);
        return finish();
    }
 
    private static void quickSortRecursion(int[] array, int low, int high) {
        if (array != null && array.length > 1 && low < high) {
            int middle = low + (high - low) / 2;
            int cursor = array[middle];
            int i = low;
            int j = high;
            int temp;
            while (i <= j) {
                while (array[i] < cursor) {
                    i++;
                }
                while (array[j] > cursor) {
                    j--;
                }
                if (i <= j) {
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    i++;
                    j--;
                }
            }
            if (low < j) {
                quickSortRecursion(array, low, j);
            }
            if (high > i) {
                quickSortRecursion(array, i, high);
            }
        }
    }
}
 
class SortsTest {
    private static final int N_VISUAL_TEST = 10;
    private static final int[] N = {100, 1_000, 100_000, 1_000_000};
    private static final int MIN = 100;
    private static final int MAX = 999;
 
 
    public static void main(String[] args) {
        int[] array = createArray(N_VISUAL_TEST, MIN, MAX);
        int[] arrayShell = array.clone();
        Sorts.sortShell(arrayShell);
        int[] arrayQuick = array.clone();
        Sorts.sortQuick(arrayQuick);
        System.out.println("Arrays:       " + Arrays.toString(array));
        System.out.println("Arrays Shell: " + Arrays.toString(arrayShell));
        System.out.println("Arrays quick: " + Arrays.toString(arrayQuick));
        System.out.println();
 
        //START TESTS
        for (int count = 0; count < N.length; count++) {
            int[] first = createArray(N[count], MIN, MAX);
            int[] second = createArray(N[count], MIN, MAX);
            System.out.printf("TEST #%d: length = %d;\n", count + 1, N[count]);
            System.out.printf("   Shell sort: %30s\n", Sorts.sortShell(first));
            System.out.printf("   Quick sort: %30s\n", Sorts.sortQuick(second));
            System.out.println();
        }
 
    }
 
    private static int[] createArray(int length, int min, int max) {
        return new Random().ints(length, min, max + 1).toArray();
    }
}

Arrays:       [198, 779, 528, 110, 775, 884, 324, 806, 243, 464]
Arrays Shell: [110, 198, 243, 324, 464, 528, 775, 779, 806, 884]
Arrays quick: [110, 198, 243, 324, 464, 528, 775, 779, 806, 884]
 
TEST #1: length = 100;
   Shell sort:                     0.000 sec.
   Quick sort:                     0.000 sec.
 
TEST #2: length = 1000;
   Shell sort:                     0.003 sec.
   Quick sort:                     0.001 sec.
 
TEST #3: length = 100000;
   Shell sort:                     1.127 sec.
   Quick sort:                     0.046 sec.
 
TEST #4: length = 1000000;
   Shell sort:                    90.477 sec.
   Quick sort:                     0.100 sec.
 
 
Process finished with exit code 0