Lines Matching defs:sort
59 * The maximum number of runs in merge sort.
64 * The maximum length of run in merge sort.
70 * constant, Quicksort is used in preference to merge sort.
76 * constant, insertion sort is used in preference to Quicksort.
82 * constant, counting sort is used in preference to insertion sort.
88 * than this constant, counting sort is used in preference to Quicksort.
107 static void sort(int[] a, int left, int right,
111 sort(a, left, right, true);
134 sort(a, left, right, true);
142 * use Quicksort instead of merge sort.
145 sort(a, left, right, true);
214 private static void sort(int[] a, int left, int right, boolean leftmost) {
217 // Use insertion sort on tiny arrays
221 * Traditional (without sentinel) insertion sort,
250 * sort, which is faster (in the context of Quicksort)
251 * than traditional implementation of insertion sort.
295 // Sort these elements using insertion sort
399 sort(a, left, less - 2, leftmost);
400 sort(a, great + 2, right, false);
472 sort(a, less, great, false);
539 sort(a, left, less - 1, leftmost);
540 sort(a, great + 1, right, false);
555 static void sort(long[] a, int left, int right,
559 sort(a, left, right, true);
582 sort(a, left, right, true);
590 * use Quicksort instead of merge sort.
593 sort(a, left, right, true);
662 private static void sort(long[] a, int left, int right, boolean leftmost) {
665 // Use insertion sort on tiny arrays
669 * Traditional (without sentinel) insertion sort,
698 * sort, which is faster (in the context of Quicksort)
699 * than traditional implementation of insertion sort.
743 // Sort these elements using insertion sort
847 sort(a, left, less - 2, leftmost);
848 sort(a, great + 2, right, false);
920 sort(a, less, great, false);
987 sort(a, left, less - 1, leftmost);
988 sort(a, great + 1, right, false);
1003 static void sort(short[] a, int left, int right,
1005 // Use counting sort on large arrays
1043 sort(a, left, right, true);
1066 sort(a, left, right, true);
1074 * use Quicksort instead of merge sort.
1077 sort(a, left, right, true);
1146 private static void sort(short[] a, int left, int right, boolean leftmost) {
1149 // Use insertion sort on tiny arrays
1153 * Traditional (without sentinel) insertion sort,
1182 * sort, which is faster (in the context of Quicksort)
1183 * than traditional implementation of insertion sort.
1227 // Sort these elements using insertion sort
1331 sort(a, left, less - 2, leftmost);
1332 sort(a, great + 2, right, false);
1404 sort(a, less, great, false);
1471 sort(a, left, less - 1, leftmost);
1472 sort(a, great + 1, right, false);
1487 static void sort(char[] a, int left, int right,
1489 // Use counting sort on large arrays
1527 sort(a, left, right, true);
1550 sort(a, left, right, true);
1558 * use Quicksort instead of merge sort.
1561 sort(a, left, right, true);
1630 private static void sort(char[] a, int left, int right, boolean leftmost) {
1633 // Use insertion sort on tiny arrays
1637 * Traditional (without sentinel) insertion sort,
1666 * sort, which is faster (in the context of Quicksort)
1667 * than traditional implementation of insertion sort.
1711 // Sort these elements using insertion sort
1815 sort(a, left, less - 2, leftmost);
1816 sort(a, great + 2, right, false);
1888 sort(a, less, great, false);
1955 sort(a, left, less - 1, leftmost);
1956 sort(a, great + 1, right, false);
1970 static void sort(byte[] a, int left, int right) {
1971 // Use counting sort on large arrays
1987 } else { // Use insertion sort on small arrays
2012 static void sort(float[] a, int left, int right,
2107 sort(a, left, right, true);
2130 sort(a, left, right, true);
2138 * use Quicksort instead of merge sort.
2141 sort(a, left, right, true);
2210 private static void sort(float[] a, int left, int right, boolean leftmost) {
2213 // Use insertion sort on tiny arrays
2217 * Traditional (without sentinel) insertion sort,
2246 * sort, which is faster (in the context of Quicksort)
2247 * than traditional implementation of insertion sort.
2291 // Sort these elements using insertion sort
2395 sort(a, left, less - 2, leftmost);
2396 sort(a, great + 2, right, false);
2468 sort(a, less, great, false);
2535 sort(a, left, less - 1, leftmost);
2536 sort(a, great + 1, right, false);
2551 static void sort(double[] a, int left, int right,
2646 sort(a, left, right, true);
2669 sort(a, left, right, true);
2677 * use Quicksort instead of merge sort.
2680 sort(a, left, right, true);
2749 private static void sort(double[] a, int left, int right, boolean leftmost) {
2752 // Use insertion sort on tiny arrays
2756 * Traditional (without sentinel) insertion sort,
2785 * sort, which is faster (in the context of Quicksort)
2786 * than traditional implementation of insertion sort.
2830 // Sort these elements using insertion sort
2934 sort(a, left, less - 2, leftmost);
2935 sort(a, great + 2, right, false);
3007 sort(a, less, great, false);
3074 sort(a, left, less - 1, leftmost);
3075 sort(a, great + 1, right, false);