SparseNode *SparseArray_build(int * indicies, int * values, int length)
{
if (length == 0) { return NULL; }
SparseNode * array = NULL;
int j = 0;
array = SparseNode_create(indicies[0], values[0]);
while ((array == NULL) && (j<length)) {
array = SparseNode_create(indicies[j], values[j]);
j++;
}
int i = 0;
for (i = j; i < length; i++) {
SparseArray_add(array, indicies[i], values[i]);
}
return array;
}
SparseNode * SparseArray_insert (SparseNode * array, int index, int value )
{
if(array == NULL)
return SparseNode_create(index, value);
if(value == 0)
return array;
if (array -> index == index)
{
array -> value = value;
return array;
}
if(array -> index > index)
{
array -> left = SparseArray_insert(array -> left, index, value);
return array;
}
else
array -> right = SparseArray_insert(array -> right, index, value);
return array;
}
SparseNode * SparseArray_insert ( SparseNode * array, int index, int value )
{
if (array == NULL)
{
return SparseNode_create(index, value);
}
if ((array -> index) == index)
{
array -> value = value;
return array;
}
if ((array -> index) > index)
{
array -> left = SparseArray_insert(array -> left, index, value);
}
if ((array -> index) < index)
{
array -> right = SparseArray_insert(array -> right, index, value);
}
return array;
}
SparseNode * SparseArray_copy(SparseNode * array)
{
if (array == NULL) { return NULL; }
SparseNode * copy = SparseNode_create(array->index, array->value);
copy->right = SparseArray_copy(array->right);
copy->left = SparseArray_copy(array->left);
return copy;
}
SparseNode * SparseArray_build(int * indices, int * values, int length)
{
if (length ==0) return NULL;
SparseNode * array = SparseNode_create(indices[0], values[0]);
int i;
for(i = 1; i < length; i++) {
array = SparseArray_insert(array,indices[i],values[i]);
}
return array;
}
// gcc -g -Wall -Wshadow -DMYTEST -o answer07 answer07.c && ./answer07
int main(int argc, char * * argv)
{
int val[8] = {0,1,2,4,1,5,8,3};
int ind[8] = {5,2,7,1,9,6,4,3};
printf("\nAbout to run my custom test-cases\n");
// Test sparsenode create
printf("\nSparseNode Create\n");
SparseNode * head = SparseNode_create(7, 5);
dump(head);
//Insert
printf("\nInsert\n");
head = SparseArray_insert(head,10,3);
head = SparseArray_insert(head,4,3);
head = SparseArray_insert(head,1,3);
head = SparseArray_insert(head,10,5);
head = SparseArray_insert(head,8,3);
head = SparseArray_insert(head,12,3);
head = SparseArray_insert(head,5,3);
dump(head);
//Destroy
printf("\nDestroy\n");
SparseArray_destroy(head);
dump(head);
//Build
printf("\nBuild\n");
SparseNode * node;
node = SparseArray_build(ind,val,8);
dump(node);
//Max and Min
printf("\nMax\n");
int max = SparseArray_getMax(node);
int min = SparseArray_getMin(node);
printf("\nMax = %d Min = %d\n",max,min);
//Get Node
printf("\nGet Node\n");
SparseNode * getNode = SparseArray_getNode(node,7);
dump(getNode);
//Remove
node = SparseArray_remove(node,2);
printf("\nAfter Remove\n");
dump(node);
//Copy
printf("\nCopy\n");
dump(node);
SparseNode * copy = SparseArray_copy(node);
printf("\nAfter Copy\n");
dump(copy);
//Merge
printf("\nMerge\n");
return 0;
}
SparseNode * SparseArray_add (SparseNode * array, int index, int value)
{
if(value == 0)
{
return array;
}
if(array == NULL)
{
return SparseNode_create(index, value);//creates index if NULL found
}
if(index == (array -> index))//returns value into existing index
{
array -> value = value;
return array;
}
if(index < (array -> index))//scrolls left creating indices as it goes
{
if(array -> left == NULL)
{
array -> left = SparseNode_create(index, value);
}
else
{
array -> left = SparseArray_add(array -> left, index, value);
}
}
else//scrolls right creating indices as it goes
{
if(array -> right == NULL)
{
array -> right = SparseNode_create(index, value);
}
else
{
array -> right = SparseArray_add(array -> right, index, value);
}
}
return array;
}
SparseNode * Merge_add ( SparseNode * array, int index, int value )
{
if (array == NULL) { return SparseNode_create(index, value); }
if (index < array->index) { array->left = Merge_add(array->left, index, value); }
if (index > array->index) { array-> right = Merge_add(array->right, index, value); }
if (index == array->index) {
array->value += value;
if (array->value == 0) {
array = SparseArray_remove(array, index);
}
}
return array ;
}
SparseNode * SparseArray_add ( SparseNode * array, int index, int value )
{
if (value == 0) { return NULL; }
if (array == NULL) { return SparseNode_create(index, value); }
if (index == (array->index)) {
array->value = value;
return array;
}
if (index < (array->index)) {
array->left = SparseArray_add(array->left,index,value);
}
else
{
array->right = SparseArray_add(array->right,index,value);
}
return array;
}
int tests_SparseNode_create(int test_number) {
const int indices[] = {4,1,0,40000};
const int values[] = {30,22,100,3};
int sparseArrayLen = sizeof(indices) / sizeof(int);
// If test_number is out of range, then...
if(test_number < 0 || test_number >= sparseArrayLen) {
//return how many distinct test-cases we have.
return sparseArrayLen;
}
// Assume failure unless otherwise noted
int success = FALSE;
const int ind = indices[test_number];
const int val = values[test_number];
printf("Testing: SparseNode_create(%d, %d)\n", ind, val);
SparseNode * snode = SparseNode_create(ind, val);
if(snode == NULL) {
printf("Error: NULL result detected.\n");
}
else if(snode->left != NULL) {
printf("Error: snode->left must be NULL.\n");
}
else if(snode->right != NULL) {
printf("Error: snode->right must be NULL.\n");
}
else if(snode->index != ind) {
printf("Error: snode->index != %d.\n", ind);
}
else if(snode->value != val) {
printf("Error: snode->value != %d.\n", val);
}
else {
success = TRUE;
}
// Cleanup
if(snode) {
free(snode);
}
return success;
}
SparseNode * mergeInsert (SparseNode * array, int index, int value, SparseNode * array_1)
{
if (array == NULL)
{
array = SparseNode_create(index, value);
return array;
}
if (array -> index == index)
{
array -> value += value;
return array;
}
if ((array -> index) < index)
array -> right = mergeInsert(array -> right, index, value, array_1);
else
array -> left = mergeInsert(array -> left, index, value, array_1);
return array;
}
SparseNode * SparseArray_add ( SparseNode * array, int index, int value )
{
if (array == NULL)
{
array = SparseNode_create(index, value);
return array;
}
if (array->index > index)
{
SparseArray_add (array->left, index, value);
}
else if (array->index < index)
{
SparseArray_add (array->right, index, value);
}
else if (array->index == index)
{
array->value = value;
}
return array;
}
SparseNode * Merge_Insert (SparseNode * Tree_Array, int index, int value)
{
if (value == 0)
{
return Tree_Array;
}
if (Tree_Array == NULL)
{
return SparseNode_create(index, value);
}
if (Tree_Array -> index == index)
{
Tree_Array -> value = value + Tree_Array -> value;
if(Tree_Array -> value == 0)
{
Tree_Array = SparseArray_remove(Tree_Array, Tree_Array -> index);
}
return Tree_Array;
}
if (Tree_Array -> index > index)
{
Tree_Array -> left = Merge_Insert (Tree_Array -> left, index, value);
}
else
{
Tree_Array -> right = Merge_Insert (Tree_Array -> right, index, value);
}
return Tree_Array;
}
SparseNode * SparseArray_mergeinsert(SparseNode * array1, int index, int value)
{
//int newvalue = 0;
if(array1 == NULL)
{
return SparseNode_create(index, value);
}
if (array1 -> index > index)
{
array1 -> left = SparseArray_mergeinsert(array1 -> left, index, value);
return array1;
}
if (array1 -> index < index)
{
array1 -> right = SparseArray_mergeinsert(array1 -> right, index, value);
return array1;
}
if (array1 -> index == index)
{
array1->value += value;
if(array1 -> value == 0)
{
array1 = SparseArray_remove(array1, array1 -> index);
}
return array1;
}
return 0;
}
