What are the applications for single dimensional arrays in c?

Answer 1

All arrays are one dimensional; multi-dimensional arrays are implemented as one-dimensional arrays of one-dimensional arrays (for as many dimensions as required).

Arrays have many applications. The most common array type is the character array which we typically use to represent null-terminated strings. That is, we allocate sufficient storage to accommodate a string of characters plus a null-terminator. Standard ASCII strings use the char data type which is always 1 byte in length. The null-terminator is always the all-zeroes bit pattern which is the literal character '\0' (or ASCII character code 0). Wide strings typically use the wchar_t data type where the null-terminator is denoted by the literal character L'\0'.

Aside from strings, the most common reason to use an array is to be able to refer to a collection of values by address rather than by name. That is, each value in the array has an address and we can easily calculate that address knowing the start address of the array and the zero-based index of the element we wish to access:

int A[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

int x = A[3]; // same as: int x = *(A + 3);

assert (x==7);

The conventional array suffix notation A[3] is nothing more than sugar-coating for pointer arithmetic. What the compiler actually "sees" is *(A+3). However, the index, 3, is variable so we can easily traverse an array of values knowing only the start address and the number of elements to traverse:

void f (int* A, unsigned elements) {

for (int i=0; i

A[i] = i*i; // equivalent to: *(A+i) = i*i;

}

Note that *(A+i) has the same runtime cost regardless of the value of i, thus we have constant-time, random-access to any element in the array.

All array elements other than the first element are anonymous; they have no names. While naming variables is useful in itself, a name can only refer to one value at most, but we don't always know how many variables we might need at runtime. Arrays allow us to store as many variables as required whenever we require them. Imagine naming 1000 variables individually! Then imagine how you would access them sequentially let alone randomly.

Arrays needn't exit solely in working memory, they can also exit on mass storage mediums such as a hard-disk drive. This greatly increases the storage capacity allowing us to store literally billions of variables in consecutive storage locations that can be retrieved (reasonably) quickly.

When we sort an array we can also take advantage of binary search. That is, we look at the middle element of the array. If that's not the value we're looking for, we compare the two values and this will tell us in which half of the array to look, effectively eliminating one half of the array. We then search the remaining half in the same way, starting at the middle element. We repeat the process until we locate the value in the middle of the remaining half or the remaining half has no elements in which case the value doesn't exist. In this way, searching an array of n elements takes O(log n) time instead of O(n) time.