speiger.src.collections.objects.utils

Class ObjectArrays

java.lang.Object

speiger.src.collections.objects.utils.ObjectArrays

public class ObjectArrays
extends java.lang.Object

A Helper class for Arrays

Field Summary

Fields

Modifier and Type	Field and Description
static int	BASE_THRESHOLD Default Limit for Insertion/Selection Sort
static java.lang.Object[]	EMPTY_ARRAY Empty Array Reference used for Uninitialized Collections
static int	PARALLEL_THRESHOLD Default Threshold for Multithreaded Sorting Algorythm options

Constructor Summary

Constructors

Constructor and Description
ObjectArrays()

Method Summary

Modifier and Type	Method and Description
static <T> T[]	heapify(T[] data, int size, java.util.Comparator<? super T> comp) Helper function to create a Heap out of an array.
static <T extends java.lang.Comparable<T>> void	insertionSort(T[] array) Sorts an array according to the natural ascending order using InsertionSort,
static <T> void	insertionSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static <T extends java.lang.Comparable<T>> void	insertionSort(T[] array, int length) Sorts an array according to the natural ascending order using InsertionSort,
static <T> void	insertionSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static <T extends java.lang.Comparable<T>> void	insertionSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using InsertionSort,
static <T> void	insertionSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,
static <T extends java.lang.Comparable<T>> void	memFreeMergeSort(T[] array) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	memFreeMergeSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	memFreeMergeSort(T[] array, int length) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	memFreeMergeSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	memFreeMergeSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	memFreeMergeSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	mergeSort(T[] array) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	mergeSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T extends java.lang.Comparable<T>> void	mergeSort(T[] array, int length) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	mergeSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T extends java.lang.Comparable<T>> void	mergeSort(T[] array, T[] supp, int from, int to) Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	mergeSort(T[] array, T[] supp, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> T[]	newArray(java.lang.Class<T> clz, int length) Function to create a new Array of a given size
static <T extends java.lang.Comparable<T>> void	parallelMemFreeMergeSort(T[] array) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	parallelMemFreeMergeSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	parallelMemFreeMergeSort(T[] array, int length) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	parallelMemFreeMergeSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	parallelMemFreeMergeSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T> void	parallelMemFreeMergeSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array.
static <T extends java.lang.Comparable<T>> void	parallelMergeSort(T[] array) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	parallelMergeSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T extends java.lang.Comparable<T>> void	parallelMergeSort(T[] array, int length) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	parallelMergeSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T extends java.lang.Comparable<T>> void	parallelMergeSort(T[] array, T[] supp, int from, int to) Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T> void	parallelMergeSort(T[] array, T[] supp, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations
static <T extends java.lang.Comparable<T>> void	parallelQuickSort(T[] array) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	parallelQuickSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	parallelQuickSort(T[] array, int length) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	parallelQuickSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	parallelQuickSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	parallelQuickSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	quickSort(T[] array) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	quickSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	quickSort(T[] array, int length) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	quickSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	quickSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T> void	quickSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L.
static <T extends java.lang.Comparable<T>> void	selectionSort(T[] array) Sorts an array according to the natural ascending order using Selection Sort,
static <T> void	selectionSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static <T extends java.lang.Comparable<T>> void	selectionSort(T[] array, int length) Sorts an array according to the natural ascending order using Selection Sort,
static <T> void	selectionSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static <T extends java.lang.Comparable<T>> void	selectionSort(T[] array, int from, int to) Sorts an array according to the natural ascending order using Selection Sort,
static <T> void	selectionSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,
static <T> int	shiftDown(T[] data, int size, int index, java.util.Comparator<? super T> comp) Method to validate if the current value is the lowest value in the heap
static <T> int	shiftUp(T[] data, int index, java.util.Comparator<? super T> comp) Method to sort a specific value into the heap.
static <T> T[]	shuffle(T[] array) Simple Shuffle method for Arrays.
static <T> T[]	shuffle(T[] array, java.util.Random random) Simple Shuffle method for Arrays.
static <T extends java.lang.Comparable<T>> void	stableSort(T[] array) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	stableSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T extends java.lang.Comparable<T>> void	stableSort(T[] array, int length) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	stableSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T extends java.lang.Comparable<T>> void	stableSort(T[] array, int from, int to) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	stableSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T extends java.lang.Comparable<T>> void	unstableSort(T[] array) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	unstableSort(T[] array, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T extends java.lang.Comparable<T>> void	unstableSort(T[] array, int length) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	unstableSort(T[] array, int length, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T extends java.lang.Comparable<T>> void	unstableSort(T[] array, int from, int to) Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array.
static <T> void	unstableSort(T[] array, int from, int to, java.util.Comparator<T> comp) Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BASE_THRESHOLD

public static final int BASE_THRESHOLD

Default Limit for Insertion/Selection Sort

See Also:

Constant Field Values

PARALLEL_THRESHOLD

public static final int PARALLEL_THRESHOLD

Default Threshold for Multithreaded Sorting Algorythm options

See Also:

Constant Field Values

EMPTY_ARRAY

public static final java.lang.Object[] EMPTY_ARRAY

Empty Array Reference used for Uninitialized Collections

Constructor Detail

ObjectArrays

public ObjectArrays()

Method Detail

newArray

public static <T> T[] newArray(java.lang.Class<T> clz,
                               int length)

Function to create a new Array of a given size

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

clz - the class type of array that is requested

length - the lenght the array should be.

Returns:

a Array with the requested type and length

shiftDown

public static <T> int shiftDown(T[] data,
                                int size,
                                int index,
                                java.util.Comparator<? super T> comp)

Method to validate if the current value is the lowest value in the heap

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

data - the current heap.

size - the size of the heap

index - the index that should be validated

comp - the comparator to sort the heap. Can be null

Returns:

the index the element was shifted to

shiftUp

public static <T> int shiftUp(T[] data,
                              int index,
                              java.util.Comparator<? super T> comp)

Method to sort a specific value into the heap.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

data - the heap itself.

index - that should be heapified.

comp - the comparator to sort the heap. Can be null

Returns:

the index the element was shifted to

heapify

public static <T> T[] heapify(T[] data,
                              int size,
                              java.util.Comparator<? super T> comp)

Helper function to create a Heap out of an array.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

data - the array to heapify

size - the current size of elements within the array.

comp - the Comparator to sort the array. Can be null

Returns:

the input array

shuffle

public static <T> T[] shuffle(T[] array)

Simple Shuffle method for Arrays.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the elements that should be shuffled

Returns:

the provided sorted array

Note:

This uses the SanityChecks#getRandom

shuffle

public static <T> T[] shuffle(T[] array,
                              java.util.Random random)

Simple Shuffle method for Arrays.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the elements that should be shuffled

random - the Random Number Generator that should be used for the shuffling

Returns:

the provided sorted array

stableSort

public static <T> void stableSort(T[] array,
                                  java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

stableSort

public static <T> void stableSort(T[] array,
                                  int length,
                                  java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

stableSort

public static <T> void stableSort(T[] array,
                                  int from,
                                  int to,
                                  java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

stableSort

public static <T extends java.lang.Comparable<T>> void stableSort(T[] array)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

stableSort

public static <T extends java.lang.Comparable<T>> void stableSort(T[] array,
                                                                  int length)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

stableSort

public static <T extends java.lang.Comparable<T>> void stableSort(T[] array,
                                                                  int from,
                                                                  int to)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Stable sort referres to Mergesort or Insertionsort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

unstableSort

public static <T> void unstableSort(T[] array,
                                    java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

unstableSort

public static <T> void unstableSort(T[] array,
                                    int length,
                                    java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

unstableSort

public static <T> void unstableSort(T[] array,
                                    int from,
                                    int to,
                                    java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

unstableSort

public static <T extends java.lang.Comparable<T>> void unstableSort(T[] array)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

unstableSort

public static <T extends java.lang.Comparable<T>> void unstableSort(T[] array,
                                                                    int length)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

unstableSort

public static <T extends java.lang.Comparable<T>> void unstableSort(T[] array,
                                                                    int from,
                                                                    int to)

Sorts an array according to the natural ascending order, potentially dynamically choosing an appropriate algorithm given the type and size of the array. Unstable sort referres to QuickSort or SelectionSort

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

insertionSort

public static <T> void insertionSort(T[] array,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

insertionSort

public static <T> void insertionSort(T[] array,
                                     int length,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

insertionSort

public static <T> void insertionSort(T[] array,
                                     int from,
                                     int to,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Insertion Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

insertionSort

public static <T extends java.lang.Comparable<T>> void insertionSort(T[] array)

Sorts an array according to the natural ascending order using InsertionSort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

insertionSort

public static <T extends java.lang.Comparable<T>> void insertionSort(T[] array,
                                                                     int length)

Sorts an array according to the natural ascending order using InsertionSort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

insertionSort

public static <T extends java.lang.Comparable<T>> void insertionSort(T[] array,
                                                                     int from,
                                                                     int to)

Sorts an array according to the natural ascending order using InsertionSort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

selectionSort

public static <T> void selectionSort(T[] array,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

selectionSort

public static <T> void selectionSort(T[] array,
                                     int length,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

selectionSort

public static <T> void selectionSort(T[] array,
                                     int from,
                                     int to,
                                     java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

selectionSort

public static <T extends java.lang.Comparable<T>> void selectionSort(T[] array)

Sorts an array according to the natural ascending order using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

selectionSort

public static <T extends java.lang.Comparable<T>> void selectionSort(T[] array,
                                                                     int length)

Sorts an array according to the natural ascending order using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

selectionSort

public static <T extends java.lang.Comparable<T>> void selectionSort(T[] array,
                                                                     int from,
                                                                     int to)

Sorts an array according to the natural ascending order using Selection Sort,

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

mergeSort

public static <T> void mergeSort(T[] array,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

mergeSort

public static <T> void mergeSort(T[] array,
                                 int length,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

mergeSort

public static <T> void mergeSort(T[] array,
                                 T[] supp,
                                 int from,
                                 int to,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

mergeSort

public static <T extends java.lang.Comparable<T>> void mergeSort(T[] array)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

mergeSort

public static <T extends java.lang.Comparable<T>> void mergeSort(T[] array,
                                                                 int length)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

mergeSort

public static <T extends java.lang.Comparable<T>> void mergeSort(T[] array,
                                                                 T[] supp,
                                                                 int from,
                                                                 int to)

Sorts an array according to the natural ascending order using Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

parallelMergeSort

public static <T> void parallelMergeSort(T[] array,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using a Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static <T> void parallelMergeSort(T[] array,
                                         int length,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static <T> void parallelMergeSort(T[] array,
                                         T[] supp,
                                         int from,
                                         int to,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMergeSort(T[] array)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMergeSort(T[] array,
                                                                         int length)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMergeSort(T[] array,
                                                                         T[] supp,
                                                                         int from,
                                                                         int to)

Sorts an array according to the natural ascending order using Parallel Merge Sort, This implementation was copied from FastUtil with a couple custom optimizations

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

supp - the auxillary array that is used to simplify the sorting

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

memFreeMergeSort

public static <T> void memFreeMergeSort(T[] array,
                                        java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static <T> void memFreeMergeSort(T[] array,
                                        int length,
                                        java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static <T> void memFreeMergeSort(T[] array,
                                        int from,
                                        int to,
                                        java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is in Very Unsorted Instances 50% slower then Mergesort, otherwise it as fast.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

memFreeMergeSort

public static <T extends java.lang.Comparable<T>> void memFreeMergeSort(T[] array)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

memFreeMergeSort

public static <T extends java.lang.Comparable<T>> void memFreeMergeSort(T[] array,
                                                                        int length)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

memFreeMergeSort

public static <T extends java.lang.Comparable<T>> void memFreeMergeSort(T[] array,
                                                                        int from,
                                                                        int to)

Sorts an array according to the natural ascending order using Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

parallelMemFreeMergeSort

public static <T> void parallelMemFreeMergeSort(T[] array,
                                                java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int length,
                                                java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static <T> void parallelMemFreeMergeSort(T[] array,
                                                int from,
                                                int to,
                                                java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMemFreeMergeSort(T[] array)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMemFreeMergeSort(T[] array,
                                                                                int length)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelMemFreeMergeSort

public static <T extends java.lang.Comparable<T>> void parallelMemFreeMergeSort(T[] array,
                                                                                int from,
                                                                                int to)

Sorts an array according to the natural ascending order using Parallel Memory Free Merge Sort, This implementation is inspired by FastUtil original merge sort, but without the need to allocate a copy of the original Array. It is depending on the size and the unsorted level of the input array slower or almost as fast as normal merge sort. Depending on the test size i can be 0.5x slower (5000 elements) or 4x slower (50000 elements) under the assumtion that the array is in its worst case scenario. It does stack allocate tiny amounts of data for shifting around elements.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

quickSort

public static <T> void quickSort(T[] array,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

quickSort

public static <T> void quickSort(T[] array,
                                 int length,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

quickSort

public static <T> void quickSort(T[] array,
                                 int from,
                                 int to,
                                 java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

quickSort

public static <T extends java.lang.Comparable<T>> void quickSort(T[] array)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

quickSort

public static <T extends java.lang.Comparable<T>> void quickSort(T[] array,
                                                                 int length)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

quickSort

public static <T extends java.lang.Comparable<T>> void quickSort(T[] array,
                                                                 int from,
                                                                 int to)

Sorts an array according to the natural ascending order using Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

parallelQuickSort

public static <T> void parallelQuickSort(T[] array,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static <T> void parallelQuickSort(T[] array,
                                         int length,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static <T> void parallelQuickSort(T[] array,
                                         int from,
                                         int to,
                                         java.util.Comparator<T> comp)

Sorts the specified range of elements according to the order induced by the specified comparator using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

comp - the Comparator that decides the sorting order

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static <T extends java.lang.Comparable<T>> void parallelQuickSort(T[] array)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static <T extends java.lang.Comparable<T>> void parallelQuickSort(T[] array,
                                                                         int length)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

length - the maxmium size of the array to be sorted

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed

parallelQuickSort

public static <T extends java.lang.Comparable<T>> void parallelQuickSort(T[] array,
                                                                         int from,
                                                                         int to)

Sorts an array according to the natural ascending order using Parallel Quick Sort, This implementation is a custom of FastUtil quicksort but with a different code structure, and that sorting Algorithm is based on the tuned quicksort adapted from Jon L. Bentley and M. DouglasMcIlroy, "Engineering a Sort Function", Software: Practice and Experience, 23(11), pages1249−1265, 1993.

Type Parameters:

T - the type of array that the operation should be applied

Parameters:

array - the array that needs to be sorted

from - where the array should be sorted from

to - where the array should be sorted to

Note:

This parallelization is invoked through SanityChecks.invokeTask(java.util.concurrent.ForkJoinTask<T>) which the threadpool can be changed as needed