Lines Matching defs:sort
54 * The maximum number of runs in merge sort.
59 * The maximum length of run in merge sort.
65 * constant, Quicksort is used in preference to merge sort.
71 * constant, insertion sort is used in preference to Quicksort.
77 * constant, counting sort is used in preference to insertion sort.
83 * than this constant, counting sort is used in preference to Quicksort.
96 public static void sort(int[] a) {
97 sort(a, 0, a.length - 1);
107 public static void sort(int[] a, int left, int right) {
110 sort(a, left, right, true);
133 sort(a, left, right, true);
141 * use Quicksort instead of merge sort.
144 sort(a, left, right, true);
201 private static void sort(int[] a, int left, int right, boolean leftmost) {
204 // Use insertion sort on tiny arrays
208 * Traditional (without sentinel) insertion sort,
237 * sort, which is faster (in the context of Quicksort)
238 * than traditional implementation of insertion sort.
282 // Sort these elements using insertion sort
386 sort(a, left, less - 2, leftmost);
387 sort(a, great + 2, right, false);
459 sort(a, less, great, false);
526 sort(a, left, less - 1, leftmost);
527 sort(a, great + 1, right, false);
536 public static void sort(long[] a) {
537 sort(a, 0, a.length - 1);
547 public static void sort(long[] a, int left, int right) {
550 sort(a, left, right, true);
573 sort(a, left, right, true);
581 * use Quicksort instead of merge sort.
584 sort(a, left, right, true);
641 private static void sort(long[] a, int left, int right, boolean leftmost) {
644 // Use insertion sort on tiny arrays
648 * Traditional (without sentinel) insertion sort,
677 * sort, which is faster (in the context of Quicksort)
678 * than traditional implementation of insertion sort.
722 // Sort these elements using insertion sort
826 sort(a, left, less - 2, leftmost);
827 sort(a, great + 2, right, false);
899 sort(a, less, great, false);
966 sort(a, left, less - 1, leftmost);
967 sort(a, great + 1, right, false);
976 public static void sort(short[] a) {
977 sort(a, 0, a.length - 1);
987 public static void sort(short[] a, int left, int right) {
988 // Use counting sort on large arrays
1022 sort(a, left, right, true);
1045 sort(a, left, right, true);
1053 * use Quicksort instead of merge sort.
1056 sort(a, left, right, true);
1113 private static void sort(short[] a, int left, int right, boolean leftmost) {
1116 // Use insertion sort on tiny arrays
1120 * Traditional (without sentinel) insertion sort,
1149 * sort, which is faster (in the context of Quicksort)
1150 * than traditional implementation of insertion sort.
1194 // Sort these elements using insertion sort
1298 sort(a, left, less - 2, leftmost);
1299 sort(a, great + 2, right, false);
1371 sort(a, less, great, false);
1438 sort(a, left, less - 1, leftmost);
1439 sort(a, great + 1, right, false);
1448 public static void sort(char[] a) {
1449 sort(a, 0, a.length - 1);
1459 public static void sort(char[] a, int left, int right) {
1460 // Use counting sort on large arrays
1494 sort(a, left, right, true);
1517 sort(a, left, right, true);
1525 * use Quicksort instead of merge sort.
1528 sort(a, left, right, true);
1585 private static void sort(char[] a, int left, int right, boolean leftmost) {
1588 // Use insertion sort on tiny arrays
1592 * Traditional (without sentinel) insertion sort,
1621 * sort, which is faster (in the context of Quicksort)
1622 * than traditional implementation of insertion sort.
1666 // Sort these elements using insertion sort
1770 sort(a, left, less - 2, leftmost);
1771 sort(a, great + 2, right, false);
1843 sort(a, less, great, false);
1910 sort(a, left, less - 1, leftmost);
1911 sort(a, great + 1, right, false);
1923 public static void sort(byte[] a) {
1924 sort(a, 0, a.length - 1);
1934 public static void sort(byte[] a, int left, int right) {
1935 // Use counting sort on large arrays
1951 } else { // Use insertion sort on small arrays
1970 public static void sort(float[] a) {
1971 sort(a, 0, a.length - 1);
1981 public static void sort(float[] a, int left, int right) {
2071 sort(a, left, right, true);
2094 sort(a, left, right, true);
2102 * use Quicksort instead of merge sort.
2105 sort(a, left, right, true);
2162 private static void sort(float[] a, int left, int right, boolean leftmost) {
2165 // Use insertion sort on tiny arrays
2169 * Traditional (without sentinel) insertion sort,
2198 * sort, which is faster (in the context of Quicksort)
2199 * than traditional implementation of insertion sort.
2243 // Sort these elements using insertion sort
2347 sort(a, left, less - 2, leftmost);
2348 sort(a, great + 2, right, false);
2420 sort(a, less, great, false);
2487 sort(a, left, less - 1, leftmost);
2488 sort(a, great + 1, right, false);
2497 public static void sort(double[] a) {
2498 sort(a, 0, a.length - 1);
2508 public static void sort(double[] a, int left, int right) {
2598 sort(a, left, right, true);
2621 sort(a, left, right, true);
2629 * use Quicksort instead of merge sort.
2632 sort(a, left, right, true);
2689 private static void sort(double[] a, int left, int right, boolean leftmost) {
2692 // Use insertion sort on tiny arrays
2696 * Traditional (without sentinel) insertion sort,
2725 * sort, which is faster (in the context of Quicksort)
2726 * than traditional implementation of insertion sort.
2770 // Sort these elements using insertion sort
2874 sort(a, left, less - 2, leftmost);
2875 sort(a, great + 2, right, false);
2947 sort(a, less, great, false);
3014 sort(a, left, less - 1, leftmost);
3015 sort(a, great + 1, right, false);