/// <summary>
/// Selects a pivot using the SelectPivot method and arranges the input such that left side elements are lesser than pivot
/// and right side elements are greater than pivot
/// </summary>
/// <param name="searchSample"></param>
/// <param name="min"></param>
/// <param name="max"></param>
/// <returns></returns>
public int Partition(int[] searchSample, int min, int max)
{
int pos = SelectPivot(searchSample, min, max);
int x = searchSample[pos];
int i = min - 1;
CommonClass.Swap(ref searchSample[pos], ref searchSample[max]);
for (int j = min; j < max; j++)
{
if (searchSample[j] <= x)
{
i++;
if (i != j)
{
CommonClass.Swap(ref searchSample[i], ref searchSample[j]);
}
}
CommonClass.IncreaseCount();
}
i++;
if (i != max)
{
CommonClass.Swap(ref searchSample[i], ref searchSample[max]);
}
return(i);
}
/// <summary>
/// Partitions the array into two halves and calls the sub arrays recursively
/// </summary>
/// <param name="searchSample"></param>
/// <param name="min"></param>
/// <param name="max"></param>
public void MergeSort(int[] searchSample, int min, int max)
{
int mid;
if (max - min > 1)
{
CommonClass.IncreaseCount();
mid = (int)Math.Floor((double)((min + max) / 2));
int[] leftArray = new int[mid - min];
int[] rightArray = new int[max - mid];
for (int i = 0; i < mid - min; i++)
{
leftArray[i] = searchSample[i];
}
for (int j = 0; j < max - mid; j++)
{
rightArray[j] = searchSample[mid - min + j];
}
MergeSort(leftArray, min, mid);
MergeSort(rightArray, mid, max);
Merge(searchSample, leftArray, rightArray);
}
else
{
return;
}
}
/// <summary>
/// Calls the Partition method to partition the input array into two arrays and recursively calls those arrays
/// </summary>
/// <param name="searchSample"></param>
/// <param name="min"></param>
/// <param name="max"></param>
public void QuickSort(int[] searchSample, int min, int max)
{
if (min < max)
{
CommonClass.IncreaseCount();
int q = Partition(searchSample, min, max);
if (max <= CommonClass.resultSize)
{
QuickSort(searchSample, min, q - 1);
}
QuickSort(searchSample, q + 1, max);
}
else
{
return;
}
}
/// <summary>
/// Takes two sub arrays as input and merges them to a sorted array
/// </summary>
/// <param name="sortedArray"></param>
/// <param name="leftArray"></param>
/// <param name="rightArray"></param>
public void Merge(int[] sortedArray, int[] leftArray, int[] rightArray)
{
int end = leftArray.Length + rightArray.Length;
int left = 0, right = 0;
for (int i = 0; i < end; i++)
{
CommonClass.IncreaseCount(); CommonClass.IncreaseCount();
if (left < leftArray.Length && (right >= rightArray.Length || leftArray[left] <= rightArray[right]))
{
sortedArray[i] = leftArray[left];
left++;
}
else
{
sortedArray[i] = rightArray[right];
right++;
}
}
}
/// <summary>
/// Finds the i largest elements in an array using linear search
/// </summary>
/// <param name="searchSample"></param>
/// <param name="size"></param>
/// <returns></returns>
public int[] LinearSearch(int[] searchSample, int size)
{
int[] result = new int[size];
for (int i = 0; i < size; i++)
{
int max = searchSample[i];
int pos = i;
for (int j = i + 1; j < searchSample.Length; j++)
{
CommonClass.IncreaseCount();
if (searchSample[j] > max)
{
max = searchSample[j];
pos = j;
}
}
CommonClass.Swap(ref searchSample[i], ref searchSample[pos]);
result[i] = max;
}
return(result);
}
/// <summary>
/// Creates the heap around the index i
/// </summary>
/// <param name="searchSample"></param>
/// <param name="index"></param>
public void Heapify(int[] searchSample, int index)
{
int heapsize = searchSample.Length;
int left;
if (index == 0)
{
left = 1;
}
else
{
left = 2 * index + 1;
}
int right = left + 1;
int largest = index;
if (left < heapsize && searchSample[left] > searchSample[largest])
{
largest = left;
}
CommonClass.IncreaseCount(); CommonClass.IncreaseCount();
if (right < heapsize && searchSample[right] > searchSample[largest])
{
largest = right;
}
CommonClass.IncreaseCount(); CommonClass.IncreaseCount();
if (largest != index)
{
CommonClass.Swap(ref searchSample[index], ref searchSample[largest]);
Heapify(searchSample, largest);
}
CommonClass.IncreaseCount();
}
