PDE - Access & Storage (Lesson)

Array/List Storage and Access

Arrays, lists, and iterations are great topics that you will need to demonstrate in some fashion for the College Board with your code. Let's try some pseudocode here to work with these concepts.

Please note that the words array and list mean the same thing, a group of items that are related in some way. Example: A grocery list. The order of the list is the order that you write the grocery list to a piece of paper or text message. A computer using zero relative indexing would store the first item in a storage location of zero, and the last item in the storage location of length of the array - 1. In the picture below, the number of storage boxes is 4, thus the length of the list is 4. The computer would store the information in this list in indices 0, 1, 2, and 3 where 3 is the length of the list minus 1, 4 - 1. Indices is the plural of index.

Let's examine the boxes below more closely. Let's let box be the array / list name. Remember, literally there are 4 storage boxes, positions. Using zero relative storage and access, we would use index numbers 0, 1, 2, 3 to access and store in the boxes.

In the picture below, the text string "Dog" a is being put in box 1 literally, but using a zero relative computer language for storage. Accessing the word "Dog" would use box [0] to store and retrieve the information. The [0] is read index 0, the computer storage and access. The word box is the name of the storage array / list. Literally, the position of "Dog" when we look is in the first position of the list, but the computer will access using an index of zero.

The "Cat" is being put literally in the third box, reading from left to right. For storage in a computer using a zero relative computer language, "Cat" would be stored and accessed using box[2], box index 2. The literal position of "Cat" would be 3, but to store or access you would use index 2.

This storage method allows multiple related items to be stored under the same name and accessed by an index number with the array / list name. When we look through the array later, the array variable with the number has the value we put in the box until it is changed.

Instead of boxes as above, let's create an array, a list of animals that are pets. Label your array. My array is named pets. When I access pets I will always use pets[ ]. The brackets tell us that this is a one-dimensional array / list, one set of brackets. Inside the brackets will be a variable or an exact index value to store or access the array data. A variable name, index, is used for efficiency of storing or accessing a complete array with a loop.

Now looking at the box[0] above that holds dogs, if I want "Dog" in pets in the very first box (literal position 1), I would create a code statement that said

pets[0] = "Dog" This would put the word "Dog" in the pets index 0, but if we were looking at the list literally as in the image above, the word "Dog" comes first in the list of animals.

Now let's do "Rabbit". Yes, "Rabbit" is not in the boxes above, but if we want "Rabbit" to be in the second literal position, then our code would be

pets[1] = "Rabbit" This would put the word "Rabbit" in the pets array index 1 for computer storage, but if we were literally looking at the list, "Rabbit" would be in the second position of the list.

Now let's put "Cat" in the pets array.

pets[2] = "Cat" This code would store "Cat" in the pets array index 2 which is literally the third literal position of the array.

If we want one more pet, say a "Hamster", we would write the code

pets[3] = "Hamster" The word "Hamster" is now in pets index array 3 for access and storage which is the fourth literal position in the array.

Note these key points of this example:

The array length is 4 (this is a literal length).
Position is a list is literal.
The indices for computer storage and access when using a zero relative computer language are 0, 1, 2, and 3.
The array length - 1, 4 - 1 = 3 is the last index allowed in an array of length 4. Going past this will cause your program to blow up for trying to access or store information in a location that has not been allocated.

Efficiency is important. So, if this array had been for 25 animals, 30 vocabulary words, or 100 names of people, this would have been a lot of the same code lines to write over and over. For efficiency, we add a reasonable list like this:

TextString[ ] pets ={"Dog", "Rabbit", "Cat", "Hamster"} // TextString is the type of data, pets is the array name

The computer language will take this list and automatically place these items in the pets array for access later using the indices 0, 1, 2, 3 and build the array length variable for you with a value of 4 as there are 4 positions literally.

Another example of building an array for use would be to create an array of numbers to be initially stored for later access. We would use a loop to do this efficiently.

WholeNumber index = 0 // initialize the index to the first index value of the array to be stored

WholeNumber[ ] nbrHolder = new WholeNumber {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} // this is a WholeNumber array named nbrHolder

// this is a default array to be built with a loop,

// the array length is 10 for 10 literal positions

while index < array.length // less than 10 as the indices will be zero through nine

// here you could take in input from the user or take in random numbers

nbrHolder [index] = a choice or one of the above or another method

index = index + 1 // adding 1 controls the index to move to the next position and when the array length is reached stops looping

To access the data in an array, use a loop with the control index being less than the array length as above. Then use the data to create or do something new and interesting.

Arrays reduce complexity when used with proper storage and access procedures - iterations are an array's best friend. Below are ways that complexity is reduced when arrays are used properly with a loop.

The same array name may be used to access all of the data in the array with the use of an index, thus a multitude of variable names are not needed, just the array name [index].
Storage of 10 items or 50 items takes the same amount of code.
One area to debug fixes all of the issues versus many, many statements which would need investigation and fixing, becoming time consuming.
One area for storage easily allows for enlarging or reducing the array size, simply by changing the array length versus individual statements requiring more individual statements or the removal of individual statements. The loop uses the array length to determine the amount of data, so the change to the length requires no direct code changes.
Using the array with an iteration (loop) allows for access to all data values in the array with the same statements, to do the same thing or different options depending on a condition. Again, accessing the array is condensed to manageable code, not repetition of the same code for each item.

In summary:

Positions are 1 relative to humans; thus we start counting at 1. The length of the array is based on actual counting numbers, so the length of an array is the physical number of items counted starting at 1.
Indices are zero relative in most computer languages, thus starting at index 0 for storage and access of the data. The last index available to access or store data in the array using 0 relative numbers is the length of the array minus 1, where the length is the actual literal number of positions available in the array.
Storing or accessing an array / list with an index number outside of the 0 to array length minus 1 will result in your program getting an out of bounds error for attempting to use an invalid index number for the array. Your program will crash.
For efficiency, keep the complexity out of the program. The array / list should be stored and accessed with an iteration using an index. Each of the data items in the array will use the same storage or access statement allowing the loop to control the length of the array.

IMAGE CREATED BY GAVS AND USED ACCORDING TO TERMS OF USE.