void dyAddAt(DynamicArray* array, TYPE value, int position)
{
assert(position <= array->size);
dyAdd(array, value);
int i;
for (i = array->size - 1; i > position; i--)
{
dySwap(array, i, i - 1);
}
}
void testDyHeapGetMin(CuTest* test)
{
const int n = 10;
DynamicArray* heap = dyNew(1);
Task* tasks = createTasks(n);
for (int i = 0; i < n; i++)
{
dyAdd(heap, &tasks[i]);
}
CuAssertPtrNotNull(test, dyHeapGetMin(heap));
CuAssertTrue(test, dyGet(heap, 0) == dyHeapGetMin(heap));
shuffle(heap);
CuAssertPtrNotNull(test, dyHeapGetMin(heap));
CuAssertTrue(test, dyGet(heap, 0) == dyHeapGetMin(heap));
free(tasks);
dyDelete(heap);
}
void testBuildHeap(CuTest* test)
{
const int n = 100;
Task* tasks = createTasks(n);
DynamicArray* heap = dyNew(1);
for (int i = 0; i < n; i++)
{
dyAdd(heap, &tasks[i]);
}
for (int i = 0; i < n; i++)
{
shuffle(heap);
buildHeap(heap, taskCompare);
CuAssertIntEquals(test, n, dySize(heap));
assertHeapProperty(test, heap);
}
dyDelete(heap);
free(tasks);
}
void testDyHeapSort(CuTest* test)
{
const int n = 100;
struct Task* tasks = createTasks(n);
DynamicArray* heap = dyNew(1);
for (int i = 0; i < n; i++)
{
dyAdd(heap, &tasks[i]);
}
shuffle(heap);
dyHeapSort(heap, taskCompare);
CuAssertIntEquals(test, n, dySize(heap));
for (int i = 0; i < n; i++)
{
CuAssertTrue(test, dyGet(heap, i) == &tasks[n - i - 1]);
}
free(tasks);
dyDelete(heap);
}
/**
* Adds an element to the heap.
* @param heap
* @param value value to be added to heap.
* @param compare pointer to compare function.
*/
void dyHeapAdd(DynamicArray* heap, TYPE value, compareFunction compare)
{
//int pos = dySize(heap) - 1;
dyAdd(heap, value);
int pos = dySize(heap) - 1;
int parent;
while (pos > 0) {
parent = (pos - 1) / 2;
if(compare(dyGet(heap, pos), dyGet(heap, parent)) == -1){
dySwap(heap, pos, parent);
pos = parent;
}
else
break;
}
}
void testAdjustHeap(CuTest* test)
{
const int n = 100;
Task* tasks = createTasks(n);
for (int j = 0; j < n; j++)
{
DynamicArray* heap = dyNew(1);
for (int i = 0; i < n; i++)
{
dyAdd(heap, &tasks[i]);
}
for (int i = 0; i < n; i++)
{
dyPut(heap, &tasks[rand() % n], 0);
adjustHeap(heap, dySize(heap) - 1, 0, taskCompare);
assertHeapProperty(test, heap);
}
dyDelete(heap);
}
free(tasks);
}
void dyBagAdd(DynamicArray* bag, TYPE value)
{
dyAdd(bag, value);
}
void dyStackPush(DynamicArray* stack, TYPE value)
{
dyAdd(stack, value);
}
void testDyHeapRemoveMin(CuTest* test)
{
const int n = 100;
Task* tasks = createTasks(n);
DynamicArray* heap = dyNew(1);
for (int i = 0; i < n; i++)
{
dyAdd(heap, &tasks[i]);
}
for (int i = 0; i < n; i++)
{
CuAssertIntEquals(test, n - i, dySize(heap));
CuAssertTrue(test, dyGet(heap, 0) == &tasks[i]);
dyHeapRemoveMin(heap, taskCompare);
assertHeapProperty(test, heap);
CuAssertIntEquals(test, n - i - 1, dySize(heap));
}
dyDelete(heap);
free(tasks);
}
