/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { if(v->size >= v->capacity) _dynArrSetCapacity(v,2*v->capacity); v->data[v->size] = val; v->size++; }
void addBackDynArr(DynArr *v, TYPE val) { if (v->size >= v->capacity) _dynArrSetCapacity(v, 2*v->capacity); v->data[_absoluteIndex(v, v->size)] = val; //logical back...next open spot.. is at size v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(struct DynArr *v, TYPE val) { v->data[v->size] = val; v->size++; if (v->size == v->capacity) { v = _dynArrSetCapacity(v, v->capacity*2); } }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* Check to see if a resize is necessary */ if(v->size >= v->capacity){ _dynArrSetCapacity(v, 2 * v->capacity); } v->data[v->size] = val; v->size++; }
/* ************************************************************************ Deque Interface Functions *************************************************************************/ void addFrontDynArr(DynArr *v, TYPE val){ if (v->size >= v->capacity) _dynArrSetCapacity(v, 2*v->capacity); v->beg = v->beg - 1; //beginning is decremented! v->data[_absoluteIndex(v, 0)] = val; //logical front is 0 v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* FIXME: You will write this function */ assert(v != 0); if (v->size >= v->capacity) { _dynArrSetCapacity(v, 2 * v->capacity); } v->data[v->size] = val; v->size++; }
/* Put an item into the dynamic array at the specified location, overwriting the element that was there param: v pointer to the dynamic array param: pos the index to put the value into param: val the value to insert pre: v is not null pre: v is not empty pre: pos >= 0 and pos < size of the array post: index pos contains new value, val */ void putDynArr(DynArr *v, int pos, TYPE val) { if (v->size >= v->capacity) _dynArrSetCapacity(v, 2 * v->capacity); for (int i = v->capacity - 1; i >= pos; i--) v->data[i] = v->data[i-1]; v->data[pos] = val; v->size++; }
/* Push an element onto the top of the stack param: v pointer to the dynamic array param: val the value to push onto the stack pre: v is not null post: size increases by 1 if reached capacity, capacity is doubled val is on the top of the stack */ void pushDynArr(DynArr *v, TYPE val) { if (v->size == v->capacity) { _dynArrSetCapacity(v, 2 * v->capacity); } v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* FIXME: You will write this function */ assert(v != 0); // If size is equal or bigger than capacity, new capacity is set as double current capacity if (v->size >= v->capacity) _dynArrSetCapacity(v, 2 * v->capacity); v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { assert(v != 0); if(v->size == v->capacity) _dynArrSetCapacity(v, (v->capacity * 2)); v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* FIXME: You will write this function */ /*Check if resize is needed*/ if(v->size >= v->capacity) { _dynArrSetCapacity(v, 2 * v->capacity); } v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* FIXME: You will write this function */ /* Check to see if a resize is necessary */ if(v->size >= v->capacity) _dynArrSetCapacity(v, 2 * v->capacity); v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, void *val) { assert(v != 0); /* Check to see if a resize is necessary */ if( v->size >= v->capacity ) _dynArrSetCapacity(v, 2 * v->capacity); v->data [ v->size ] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* DONE: You will write this function */ assert(v != 0); if (v->size >= v->capacity) { // If we need to grow, double the size _dynArrSetCapacity ( v, 2 * v->capacity); } v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { if (v->size == v->capacity) { _dynArrSetCapacity(v, 2 * v->capacity); } //printf("%d: \n", v->data[v->size]); /*checking why val is coming in with a value of 0*/ v->data[v->size] = val; v->size++; }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArr is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { /* FIXME: You will write this function */ if (v != 0) { int arrSize = sizeDynArr(v); int arrCap = v->capacity; if (arrCap == arrSize) { //if array is full _dynArrSetCapacity(v,(arrCap*2)); //create more space } v->data[arrSize] = val; //add value to end of the array v->size++; } }
/* Push an element onto the top of the stack param: v pointer to the dynamic array param: val the value to push onto the stack pre: v is not null post: size increases by 1 if reached capacity, capacity is doubled val is on the top of the stack */ void stack_push(struct DynArr *v, TYPE val) { int x; for (x = v->size+1; x > 0; x--) { v->data[x] = v->data[x-1]; } v->data[0] = val; v->size++; if (v->size == v->capacity) { v = _dynArrSetCapacity(v, v->capacity*2); } }
/* Adds an element to the end of the dynamic array param: v pointer to the dynamic array param: val the value to add to the end of the dynamic array pre: the dynArry is not null post: size increases by 1 post: if reached capacity, capacity is doubled post: val is in the last utilized position in the array */ void addDynArr(DynArr *v, TYPE val) { assert(v != 0); int currentSize = sizeDynArr(v); //get size of the array //resize the array if its full if (currentSize == v->capacity) { int newCapacity = v->capacity * 2; _dynArrSetCapacity(v, newCapacity); } v->data[currentSize] = val; //add element to the array v->size++; //update the number of elements in the array }
void addAtDynArr(DynArr *v, int idx, TYPE val) { assert(v!= 0); assert(idx >=0 && idx <= v->size); int i; /* Check to see if a resize is necessary */ if(v->size >= v->capacity) _dynArrSetCapacity(v, 2 * v->capacity); //Move elements down one for(i = v->size; i > idx; i--) v->data[i] = v->data[i-1]; //putDynArr(v, idx, val); //this will increase size v->data[idx] = val; v->size++; assert(v->data[idx] == val); }