AssociativeSort (topicmodeling.commons 0.0.3-SNAPSHOT API)

java.lang.Object
- org.dice_research.topicmodeling.commons.sort.AssociativeSort

```
public class AssociativeSort
extends Object
```
This class is a container for some static functions to sort associative. Note that this class has been generated automatically using the AssociativeSortClassGenerator class. Do never change the source code in this class because changes could be overwritten by the genrating class. Change the source code of the AssociativeSortClassGenerator class instead.

Author:

Martin Nettling, Michael Röder

Field Summary

Fields
Modifier and Type Field and Description

static int MIN_SIZE_FOR_QUICKSORT
Constant defining at which array size quicksort or insertion sort is used.

Fields
Modifier and Type	Field and Description
`static int`	`MIN_SIZE_FOR_QUICKSORT` Constant defining at which array size quicksort or insertion sort is used.

Constructor Summary

Constructors
Constructor and Description

AssociativeSort()

Constructors
Constructor and Description
`AssociativeSort()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static byte[]`	`insertionSort(byte[] A, boolean[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, byte[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, char[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, char[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, double[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, double[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, float[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, float[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, int[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, int[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, long[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, long[] Assoc, int left, int right)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, short[] Assoc)` Insertion sort.
`static byte[]`	`insertionSort(byte[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> byte[]`	`insertionSort(byte[] A, T[] Assoc)` Insertion sort.
`static <T> byte[]`	`insertionSort(byte[] A, T[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, boolean[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, byte[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, char[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, char[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, double[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, double[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, float[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, float[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, int[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, int[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, long[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, long[] Assoc, int left, int right)` Insertion sort.
`static char[]`	`insertionSort(char[] A, short[] Assoc)` Insertion sort.
`static char[]`	`insertionSort(char[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> char[]`	`insertionSort(char[] A, T[] Assoc)` Insertion sort.
`static <T> char[]`	`insertionSort(char[] A, T[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, boolean[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, byte[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, char[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, char[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, double[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, double[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, float[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, float[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, int[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, int[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, long[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, long[] Assoc, int left, int right)` Insertion sort.
`static double[]`	`insertionSort(double[] A, short[] Assoc)` Insertion sort.
`static double[]`	`insertionSort(double[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> double[]`	`insertionSort(double[] A, T[] Assoc)` Insertion sort.
`static <T> double[]`	`insertionSort(double[] A, T[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, boolean[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, byte[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, char[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, char[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, double[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, double[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, float[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, float[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, int[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, int[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, long[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, long[] Assoc, int left, int right)` Insertion sort.
`static float[]`	`insertionSort(float[] A, short[] Assoc)` Insertion sort.
`static float[]`	`insertionSort(float[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> float[]`	`insertionSort(float[] A, T[] Assoc)` Insertion sort.
`static <T> float[]`	`insertionSort(float[] A, T[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, boolean[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, byte[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, char[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, char[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, double[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, double[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, float[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, float[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, int[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, int[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, long[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, long[] Assoc, int left, int right)` Insertion sort.
`static int[]`	`insertionSort(int[] A, short[] Assoc)` Insertion sort.
`static int[]`	`insertionSort(int[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> int[]`	`insertionSort(int[] A, T[] Assoc)` Insertion sort.
`static <T> int[]`	`insertionSort(int[] A, T[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, boolean[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, byte[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, char[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, char[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, double[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, double[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, float[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, float[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, int[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, int[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, long[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, long[] Assoc, int left, int right)` Insertion sort.
`static long[]`	`insertionSort(long[] A, short[] Assoc)` Insertion sort.
`static long[]`	`insertionSort(long[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> long[]`	`insertionSort(long[] A, T[] Assoc)` Insertion sort.
`static <T> long[]`	`insertionSort(long[] A, T[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, boolean[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, boolean[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, byte[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, byte[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, char[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, char[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, double[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, double[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, float[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, float[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, int[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, int[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, long[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, long[] Assoc, int left, int right)` Insertion sort.
`static short[]`	`insertionSort(short[] A, short[] Assoc)` Insertion sort.
`static short[]`	`insertionSort(short[] A, short[] Assoc, int left, int right)` Insertion sort.
`static <T> short[]`	`insertionSort(short[] A, T[] Assoc)` Insertion sort.
`static <T> short[]`	`insertionSort(short[] A, T[] Assoc, int left, int right)` Insertion sort.
`private static int`	`partition(byte[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(byte[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(byte[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(char[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(char[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(double[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(double[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(float[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(float[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(int[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(int[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(long[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(long[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, boolean[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, byte[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, char[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, double[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, float[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, int[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, long[] Assoc, int left, int right)` Partitions part of an array.
`private static int`	`partition(short[] A, short[] Assoc, int left, int right)` Partitions part of an array.
`private static <T> int`	`partition(short[] A, T[] Assoc, int left, int right)` Partitions part of an array.
`static byte[]`	`quickSort(byte[] A, boolean[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, byte[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, byte[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, char[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, char[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, double[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, double[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, float[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, float[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, int[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, int[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, long[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, long[] Assoc, int left, int right)` Quicksort.
`static byte[]`	`quickSort(byte[] A, short[] Assoc)` Quicksort for two arrays.
`static byte[]`	`quickSort(byte[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> byte[]`	`quickSort(byte[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> byte[]`	`quickSort(byte[] A, T[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, boolean[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, byte[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, byte[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, char[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, char[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, double[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, double[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, float[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, float[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, int[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, int[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, long[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, long[] Assoc, int left, int right)` Quicksort.
`static char[]`	`quickSort(char[] A, short[] Assoc)` Quicksort for two arrays.
`static char[]`	`quickSort(char[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> char[]`	`quickSort(char[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> char[]`	`quickSort(char[] A, T[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, boolean[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, byte[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, byte[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, char[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, char[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, double[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, double[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, float[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, float[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, int[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, int[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, long[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, long[] Assoc, int left, int right)` Quicksort.
`static double[]`	`quickSort(double[] A, short[] Assoc)` Quicksort for two arrays.
`static double[]`	`quickSort(double[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> double[]`	`quickSort(double[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> double[]`	`quickSort(double[] A, T[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, boolean[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, byte[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, byte[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, char[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, char[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, double[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, double[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, float[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, float[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, int[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, int[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, long[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, long[] Assoc, int left, int right)` Quicksort.
`static float[]`	`quickSort(float[] A, short[] Assoc)` Quicksort for two arrays.
`static float[]`	`quickSort(float[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> float[]`	`quickSort(float[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> float[]`	`quickSort(float[] A, T[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, boolean[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, byte[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, byte[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, char[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, char[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, double[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, double[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, float[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, float[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, int[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, int[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, long[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, long[] Assoc, int left, int right)` Quicksort.
`static int[]`	`quickSort(int[] A, short[] Assoc)` Quicksort for two arrays.
`static int[]`	`quickSort(int[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> int[]`	`quickSort(int[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> int[]`	`quickSort(int[] A, T[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, boolean[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, byte[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, byte[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, char[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, char[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, double[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, double[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, float[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, float[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, int[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, int[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, long[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, long[] Assoc, int left, int right)` Quicksort.
`static long[]`	`quickSort(long[] A, short[] Assoc)` Quicksort for two arrays.
`static long[]`	`quickSort(long[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> long[]`	`quickSort(long[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> long[]`	`quickSort(long[] A, T[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, boolean[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, boolean[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, byte[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, byte[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, char[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, char[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, double[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, double[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, float[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, float[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, int[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, int[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, long[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, long[] Assoc, int left, int right)` Quicksort.
`static short[]`	`quickSort(short[] A, short[] Assoc)` Quicksort for two arrays.
`static short[]`	`quickSort(short[] A, short[] Assoc, int left, int right)` Quicksort.
`static <T> short[]`	`quickSort(short[] A, T[] Assoc)` Quicksort for two arrays.
`static <T> short[]`	`quickSort(short[] A, T[] Assoc, int left, int right)` Quicksort.
`static void`	`swap(byte[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(byte[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(byte[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(char[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(char[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(double[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(double[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(float[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(float[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(int[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(int[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(long[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(long[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, boolean[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, byte[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, char[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, double[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, float[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, int[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, long[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static void`	`swap(short[] A, short[] Assoc, int i, int j)` Swaps the element at index i with element at index j
`static <T> void`	`swap(short[] A, T[] Assoc, int i, int j)` Swaps the element at index i with element at index j

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MIN_SIZE_FOR_QUICKSORT
```
public static int MIN_SIZE_FOR_QUICKSORT
```
    Constant defining at which array size quicksort or insertion sort is used. This parameter was chosen by making performance tests for arrays of the sizes 50 - 500000 and different parameters in the range 2 - 200.
- Constructor Detail
  - AssociativeSort
```
public AssociativeSort()
```
- Method Detail
  - swap
```
public static void swap(byte[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               boolean[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   boolean[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               byte[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   byte[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               char[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   char[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               short[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   short[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               int[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   int[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               long[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   long[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               float[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   float[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(byte[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static byte[] quickSort(byte[] A,
                               double[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(byte[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static byte[] insertionSort(byte[] A,
                                   double[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(byte[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> byte[] quickSort(byte[] A,
                                   T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> byte[] quickSort(byte[] A,
                                   T[] Assoc,
                                   int left,
                                   int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(byte[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> byte[] insertionSort(byte[] A,
                                       T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> byte[] insertionSort(byte[] A,
                                       T[] Assoc,
                                       int left,
                                       int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               boolean[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   boolean[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               byte[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   byte[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               char[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   char[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               short[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   short[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               int[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   int[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               long[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   long[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               float[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   float[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(char[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static char[] quickSort(char[] A,
                               double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static char[] quickSort(char[] A,
                               double[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(char[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static char[] insertionSort(char[] A,
                                   double[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(char[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> char[] quickSort(char[] A,
                                   T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> char[] quickSort(char[] A,
                                   T[] Assoc,
                                   int left,
                                   int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(char[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> char[] insertionSort(char[] A,
                                       T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> char[] insertionSort(char[] A,
                                       T[] Assoc,
                                       int left,
                                       int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                boolean[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    boolean[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                byte[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    byte[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                char[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    char[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                short[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    short[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                int[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    int[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                long[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    long[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                float[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    float[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(short[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static short[] quickSort(short[] A,
                                double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static short[] quickSort(short[] A,
                                double[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(short[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static short[] insertionSort(short[] A,
                                    double[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(short[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> short[] quickSort(short[] A,
                                    T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> short[] quickSort(short[] A,
                                    T[] Assoc,
                                    int left,
                                    int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(short[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> short[] insertionSort(short[] A,
                                        T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> short[] insertionSort(short[] A,
                                        T[] Assoc,
                                        int left,
                                        int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              boolean[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  boolean[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              byte[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  byte[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              char[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  char[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              short[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  short[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              int[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  int[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              long[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  long[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              float[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  float[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(int[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static int[] quickSort(int[] A,
                              double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static int[] quickSort(int[] A,
                              double[] Assoc,
                              int left,
                              int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(int[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static int[] insertionSort(int[] A,
                                  double[] Assoc,
                                  int left,
                                  int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(int[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> int[] quickSort(int[] A,
                                  T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> int[] quickSort(int[] A,
                                  T[] Assoc,
                                  int left,
                                  int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(int[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> int[] insertionSort(int[] A,
                                      T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> int[] insertionSort(int[] A,
                                      T[] Assoc,
                                      int left,
                                      int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               boolean[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   boolean[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               byte[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   byte[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               char[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   char[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               short[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   short[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               int[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   int[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               long[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   long[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               float[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   float[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(long[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static long[] quickSort(long[] A,
                               double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static long[] quickSort(long[] A,
                               double[] Assoc,
                               int left,
                               int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(long[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static long[] insertionSort(long[] A,
                                   double[] Assoc,
                                   int left,
                                   int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(long[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> long[] quickSort(long[] A,
                                   T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> long[] quickSort(long[] A,
                                   T[] Assoc,
                                   int left,
                                   int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(long[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> long[] insertionSort(long[] A,
                                       T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> long[] insertionSort(long[] A,
                                       T[] Assoc,
                                       int left,
                                       int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                boolean[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    boolean[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                byte[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    byte[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                char[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    char[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                short[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    short[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                int[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    int[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                long[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    long[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                float[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    float[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(float[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static float[] quickSort(float[] A,
                                double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static float[] quickSort(float[] A,
                                double[] Assoc,
                                int left,
                                int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(float[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static float[] insertionSort(float[] A,
                                    double[] Assoc,
                                    int left,
                                    int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(float[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> float[] quickSort(float[] A,
                                    T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> float[] quickSort(float[] A,
                                    T[] Assoc,
                                    int left,
                                    int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(float[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> float[] insertionSort(float[] A,
                                        T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> float[] insertionSort(float[] A,
                                        T[] Assoc,
                                        int left,
                                        int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        boolean[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 boolean[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 boolean[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             boolean[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     boolean[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     boolean[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        byte[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 byte[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 byte[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             byte[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     byte[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     byte[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        char[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 char[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 char[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             char[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     char[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     char[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        short[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 short[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 short[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             short[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     short[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     short[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        int[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 int[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 int[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             int[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     int[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     int[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        long[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 long[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 long[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             long[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     long[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     long[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        float[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 float[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 float[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             float[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     float[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     float[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static void swap(double[] A,
                        double[] Assoc,
                        int i,
                        int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static double[] quickSort(double[] A,
                                 double[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static double[] quickSort(double[] A,
                                 double[] Assoc,
                                 int left,
                                 int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static int partition(double[] A,
                             double[] Assoc,
                             int left,
                             int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     double[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static double[] insertionSort(double[] A,
                                     double[] Assoc,
                                     int left,
                                     int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - swap
```
public static <T> void swap(double[] A,
                            T[] Assoc,
                            int i,
                            int j)
```
    Swaps the element at index i with element at index j
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    i - index of first element
    
    j - index of second element
  - quickSort
```
public static <T> double[] quickSort(double[] A,
                                     T[] Assoc)
```
    Quicksort for two arrays. The first array will be sorted. All swaps that are done to this array during the sorting will be done to the second, associative array, too.
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    Returns:
    
    A reference to the array that was sorted.
  - quickSort
```
public static <T> double[] quickSort(double[] A,
                                     T[] Assoc,
                                     int left,
                                     int right)
```
    Quicksort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n*log(n) ) asymptotic upper bound.
    This version of quicksort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - The array to be sorted.
    
    Assoc - The Array to sort associative to the given Array A
    
    left - The left boundary of what will be sorted.
    
    right - The right boundary of what will be sorted.
    
    Returns:
    
    A reference to the array that was sorted.
  - partition
```
private static <T> int partition(double[] A,
                                 T[] Assoc,
                                 int left,
                                 int right)
```
    Partitions part of an array.
    The part of the array between left and right will be partitioned around the value held at A[right-1].
    
    Parameters:
    
    A - The array to be partitioned.
    
    Assoc - The associative Array to partitioned
    
    left - The left bound of the array.
    
    right - The right bound of the array.
    
    Returns:
    
    The index of the pivot after the partition has occured.
  - insertionSort
```
public static <T> double[] insertionSort(double[] A,
                                         T[] Assoc)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.
  - insertionSort
```
public static <T> double[] insertionSort(double[] A,
                                         T[] Assoc,
                                         int left,
                                         int right)
```
    Insertion sort. The bounds specify which part of the array is to be sorted.
    
    Algorithm of O( n² ).
    This version of insertion sort also allows for bounds to be put in to specify what part of the array will be sorted.
    The part of the array that lies between left and right is the only part that will be sorted.
    
    Parameters:
    
    A - an array of Comparable items.
    
    Assoc - The associative Array
    
    left - the left-most index of the subarray.
    
    right - the right-most index of the subarray.
    
    Returns:
    
    A reference to the array that was sorted.

Class AssociativeSort

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MIN_SIZE_FOR_QUICKSORT

Constructor Detail

AssociativeSort

Method Detail

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition

insertionSort

insertionSort

swap

quickSort

quickSort

partition