/// <summary>
/// Sort the top K element from an array, using floyd build heap.
/// it will not modify the input.
/// <remark>
/// Complexity expected to be:
/// O(k+(n-k)Log(k)) => O(nlog(k))
/// </remark>
/// </summary>
/// <param name="len"></param>
/// <param name="k"></param>
/// <returns></returns>
public static T[] TopKSortDoubleArrayUsingBinaryHeap <T>(T[] arr, int k)
where T : IComparable <T>
{
if (k <= 0 || arr == null || arr.Length == 0)
{
return(null);
}
k = k >= arr.Length ? arr.Length : k;
IPriorityQ <T> q = new SimpleBinaryHeap <T>(arr, 0, k);
for (int i = k; i < arr.Length; i++)
{
T element = arr[i];
if (element.CompareTo(q.Peek()) > 0)
{
q.RemoveMin();
q.Enqueue(element);
}
}
T[] res = new T[k];
for (int i = 0; i < k; i++)
{
res[i] = q.RemoveMin();
}
return(res);
}
private void SimpleBinaryHeapRandomOperations(IReadOnlyList <int> startingValues)
{
var simpleBinaryHeap = new SimpleBinaryHeap <int>(startingValues);
int randomValuesIndex = 0;
foreach (int operation in _randomOperations)
{
if (operation == 1 || simpleBinaryHeap.Size <= 1)
{
simpleBinaryHeap.Add(_randomValues[randomValuesIndex++]);
}
else if (operation == 2)
{
simpleBinaryHeap.Extract();
}
else if (operation == 3)
{
simpleBinaryHeap.Replace(_randomValues[randomValuesIndex++]);
}
else
{
int top = simpleBinaryHeap.Top;
}
}
}
public void VerifyRandomOperationsAgainstEachOther()
{
var rand = new Random();
var simpleNaiveHeap = new SimpleNaiveHeap <int>(_sourceArray);
var simpleBinaryHeap = new SimpleBinaryHeap <int>(_sourceArray);
for (int i = 0; i < 10000; ++i)
{
int operation = rand.Next(1, 3 + 1);
if (operation == 1 || simpleNaiveHeap.Size <= 1)
{
int value = rand.Next();
simpleNaiveHeap.Add(value);
simpleBinaryHeap.Add(value);
}
else if (operation == 2)
{
int simpleNaiveHeapTop = simpleNaiveHeap.Extract();
int simpleBinaryHeapTop = simpleBinaryHeap.Extract();
Assert.AreEqual(simpleNaiveHeapTop, simpleBinaryHeapTop);
}
else
{
int value = rand.Next();
int simpleNaiveHeapTop = simpleNaiveHeap.Replace(value);
int simpleBinaryHeapTop = simpleBinaryHeap.Replace(value);
Assert.AreEqual(simpleNaiveHeapTop, simpleBinaryHeapTop);
}
Assert.AreEqual(simpleNaiveHeap.Size, simpleBinaryHeap.Size);
Assert.AreEqual(simpleNaiveHeap.IsEmpty, simpleBinaryHeap.IsEmpty);
Assert.AreEqual(simpleNaiveHeap.Top, simpleBinaryHeap.Top);
}
}
public void TestPartialFloydBuildHeap()
{
int[] randomarr = GetRandomizedIntSequence(100);
IPriorityQ <int> q = new SimpleBinaryHeap <int>(randomarr, 90, 9);
int pre = q.RemoveMin();
while (q.Size != 0)
{
Assert.IsTrue(q.Peek() > pre);
pre = q.RemoveMin();
}
}
/// <summary>
/// Null cannot be added to the queue at all.
/// </summary>
public void TestBinaryHeapException()
{
IPriorityQ <string> q = new SimpleBinaryHeap <string>();
TestDelegate stuff = () =>
{
q.Enqueue(null);
};
AssertThrow <InvalidArgumentException>(stuff);
TestDelegate stuff2 = () =>
{
q.RemoveMin();
};
AssertThrow <InvalidOperationException>(stuff2);
}
public void BinaryHeapBasic(int size, int repetition)
{
for (int j = 1; j <= repetition; j++)
{
IPriorityQ <int> q = new SimpleBinaryHeap <int>();
int[] randomarr = GetRandomizedIntSequence(size);
for (int i = 0; i < randomarr.Length; q.Enqueue(randomarr[i]), i++)
{
;
}
for (int i = 0;
i < randomarr.Length;
Assert.AreEqual(i + 1, q.RemoveMin()), i++)
{
;
}
}
}
