Programming/Arrays

test

Arrays are one of the most common data structures.

For the most basic implementation (that most languages use), arrays are a sequential block of memory, where items are placed one after another from beginning to end. In other words, you can think of an array as a sequential, non-interrupting list of items.

Specifying an index declares which item number you wish to examine in the list.

Note: The first array index for most (but not all) languages will start at 0. This is contradictory to what most people expect when being introduced to arrays, who will (naturally) assume it starts at 1.

Generally speaking, the syntax for arrays in most languages uses [ ] (square brackets).

Ex: [1, 2, 3, 4, 5, 6, 10]

Managing Arrays

Computers generally need to be explicitly told what to do. This is no exception for arrays. Thus, when an array is created, an explicit size needs to be provided so the computer understands how large to make it.

Furthermore, in most languages, each array can only hold one single data type. To be able to allocate multiple data types, either use multiple arrays or consider making an array of predefined Structs.

Tip: Some languages, such as JavaScript and Python are intelligent enough to handle array sizing for you, in the background. However, for most languages such as C, C#, and Java, you have to manage the size of the array yourself.

Resizing Arrays

Since array sizes need to be explicitly defined, they can't be arbitrarily expanded or shrunken. To change the size of an already existing array, create a new array of the desired size, then loop through the indexes of the old one and copy each value over.

For example, achieving this in C# may look as follows:

// Original array creation. Has 4 total elements, with indexes 0 through 3.
old_array = new string[4] { "Apple", "Orange", "Pineapple", "Pear" };
 
...
 
// Updating array to hold another element.
// Following the advice below, we upgrade our array to a size of 8.
new_array = new string[8];
for (int index = 0; index < old_array.Length; index++) {
    new_array[index] = old_array[index];
}

Furthermore, consider keeping the array size as a power of 2. This is for two reasons:

1. Due to how computer memory management works, powers of 2 tend to be the most efficient, space-wise.
2. This forces creation of multiple new index values, instead of just one. That way, the array doesn't need to be recreated for each individual new index added. Instead it's recreated once in a while, and the extra indexes effectively provide a buffer for future additions.

For example, if you need an array of 5 elements, use a size of 8 (aka $2^{3}$).

Then, at a later date, say you hypothetically need to increase the size of this array to be four times larger (20 elements). Create a new array of size 32 (aka $2^{5}$), and then copy those initial 5 elements over from the original array.

Multi-Dimensional Arrays

ToDo: Add this section.