60  * example, the algorithm used by {@code sort(Object[])} does not have to be
125     public static void sort(int[] a) {
126         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
149     public static void sort(int[] a, int fromIndex, int toIndex) {
151         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
165     public static void sort(long[] a) {
166         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
189     public static void sort(long[] a, int fromIndex, int toIndex) {
191         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
205     public static void sort(short[] a) {
206         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
229     public static void sort(short[] a, int fromIndex, int toIndex) {
231         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
245     public static void sort(char[] a) {
246         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
269     public static void sort(char[] a, int fromIndex, int toIndex) {
271         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
285     public static void sort(byte[] a) {
286         DualPivotQuicksort.sort(a, 0, a.length - 1);
309     public static void sort(byte[] a, int fromIndex, int toIndex) {
311         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);
333     public static void sort(float[] a) {
334         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
365     public static void sort(float[] a, int fromIndex, int toIndex) {
367         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
389     public static void sort(double[] a) {
390         DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
421     public static void sort(double[] a, int fromIndex, int toIndex) {
423         DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
429      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
432      * sorted using the appropriate {@link Arrays#sort(byte[]) Arrays.sort}
435      * Arrays#sort(byte[]) Arrays.sort} method. The algorithm requires a
448             DualPivotQuicksort.sort(a, 0, n - 1);
462      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
465      * sorted using the appropriate {@link Arrays#sort(byte[]) Arrays.sort}
468      * Arrays#sort(byte[]) Arrays.sort} method. The algorithm requires a working
488             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);
499      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
502      * sorted using the appropriate {@link Arrays#sort(char[]) Arrays.sort}
505      * Arrays#sort(char[]) Arrays.sort} method. The algorithm requires a
518             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
532       @implNote The sorting algorithm is a parallel sort-merge that breaks the
535      * sorted using the appropriate {@link Arrays#sort(char[]) Arrays.sort}
538      * Arrays#sort(char[]) Arrays.sort} method. The algorithm requires a working
558             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
569      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
572      * sorted using the appropriate {@link Arrays#sort(short[]) Arrays.sort}
575      * Arrays#sort(short[]) Arrays.sort} method. The algorithm requires a
588             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
602      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
605      * sorted using the appropriate {@link Arrays#sort(short[]) Arrays.sort}
608      * Arrays#sort(short[]) Arrays.sort} method. The algorithm requires a working
628             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
639      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
642      * sorted using the appropriate {@link Arrays#sort(int[]) Arrays.sort}
645      * Arrays#sort(int[]) Arrays.sort} method. The algorithm requires a
658             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
672      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
675      * sorted using the appropriate {@link Arrays#sort(int[]) Arrays.sort}
678      * Arrays#sort(int[]) Arrays.sort} method. The algorithm requires a working
698             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
709      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
712      * sorted using the appropriate {@link Arrays#sort(long[]) Arrays.sort}
715      * Arrays#sort(long[]) Arrays.sort} method. The algorithm requires a
728             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
742      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
745      * sorted using the appropriate {@link Arrays#sort(long[]) Arrays.sort}
748      * Arrays#sort(long[]) Arrays.sort} method. The algorithm requires a working
768             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
787      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
790      * sorted using the appropriate {@link Arrays#sort(float[]) Arrays.sort}
793      * Arrays#sort(float[]) Arrays.sort} method. The algorithm requires a
806             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
828      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
831      * sorted using the appropriate {@link Arrays#sort(float[]) Arrays.sort}
834      * Arrays#sort(float[]) Arrays.sort} method. The algorithm requires a working
854             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
873      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
876      * sorted using the appropriate {@link Arrays#sort(double[]) Arrays.sort}
879      * Arrays#sort(double[]) Arrays.sort} method. The algorithm requires a
892             DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
914      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
917      * sorted using the appropriate {@link Arrays#sort(double[]) Arrays.sort}
920      * Arrays#sort(double[]) Arrays.sort} method. The algorithm requires a working
940             DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
957      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
958      * not be reordered as a result of the sort.
960      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
963      * sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
966      * Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a
987             TimSort.sort(a, 0, n, NaturalOrder.INSTANCE, null, 0, 0);
1009      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1010      * not be reordered as a result of the sort.
1012      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
1015      * sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
1018      * Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a working
1046             TimSort.sort(a, fromIndex, toIndex, NaturalOrder.INSTANCE, null, 0, 0);
1062      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1063      * not be reordered as a result of the sort.
1065      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
1068      * sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
1071      * Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a
1095             TimSort.sort(a, 0, n, cmp, null, 0, 0);
1114      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1115      * not be reordered as a result of the sort.
1117      * @implNote The sorting algorithm is a parallel sort-merge that breaks the
1120      * sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
1123      * Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a working
1156             TimSort.sort(a, fromIndex, toIndex, cmp, null, 0, 0);
1170      * Old merge sort implementation can be selected (for
1176         // Android-changed: Never use circular merge sort.
1205 //    public static void sort(Object[] a) {
1206 //        sort(a, 0, a.length, NATURAL_ORDER);
1209 //    public static void sort(Object[] a, int fromIndex, int toIndex) {
1210 //        sort(a, fromIndex, toIndex, NATURAL_ORDER);
1222      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1223      * not be reordered as a result of the sort.
1239      * simply concatenate the arrays and sort the resulting array.
1241      * <p>The implementation was adapted from Tim Peters's list sort for Python
1255     public static void sort(Object[] a) {
1259             ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
1281      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1282      * not be reordered as a result of the sort.
1298      * simply concatenate the arrays and sort the resulting array.
1300      * <p>The implementation was adapted from Tim Peters's list sort for Python
1320     public static void sort(Object[] a, int fromIndex, int toIndex) {
1325             ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
1337      * Tuning parameter: list size at or below which insertion sort will be
1358         // Insertion sort on smallest arrays
1367         // Recursively sort halves of dest into src
1408      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1409      * not be reordered as a result of the sort.
1425      * simply concatenate the arrays and sort the resulting array.
1427      * <p>The implementation was adapted from Tim Peters's list sort for Python
1443     public static <T> void sort(T[] a, Comparator<? super T> c) {
1445             sort(a);
1450                 TimSort.sort(a, 0, a.length, c, null, 0, 0);
1473      * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
1474      * not be reordered as a result of the sort.
1490      * simply concatenate the arrays and sort the resulting array.
1492      * <p>The implementation was adapted from Tim Peters's list sort for Python
1514     public static <T> void sort(T[] a, int fromIndex, int toIndex,
1517             sort(a, fromIndex, toIndex);
1523                 TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
1552         // Insertion sort on smallest arrays
1560         // Recursively sort halves of dest into src
1795      * by the {@link #sort(long[])} method) prior to making this call.  If it
1820      * by the {@link #sort(long[], int, int)} method)
1876      * by the {@link #sort(int[])} method) prior to making this call.  If it
1901      * by the {@link #sort(int[], int, int)} method)
1957      * (as by the {@link #sort(short[])} method) prior to making this call.  If
1982      * (as by the {@link #sort(short[], int, int)} method)
2038      * by the {@link #sort(char[])} method) prior to making this call.  If it
2063      * by the {@link #sort(char[], int, int)} method)
2119      * by the {@link #sort(byte[])} method) prior to making this call.  If it
2144      * by the {@link #sort(byte[], int, int)} method)
2200      * (as by the {@link #sort(double[])} method) prior to making this call.
2226      * (as by the {@link #sort(double[], int, int)} method)
2291      * (as by the {@link #sort(float[])} method) prior to making this call. If
2317      * (as by the {@link #sort(float[], int, int)} method)
2385      * {@link #sort(Object[])} method) prior to making this call.
2419      * {@link #sort(Object[], int, int)} method) prior to making this
2482      * {@link #sort(Object[], Comparator) sort(T[], Comparator)}
2517      * {@link #sort(Object[], int, int, Comparator)
2518      * sort(T[], int, int, Comparator)}

Indexes created Wed Aug 24 13:21:36 CEST 2016