Arrays and Loops

Objective: Use loops to process arrays

Arrays are fundamental data structures in computer science used to store collections of items of the same data type. Processing arrays often involves iterating through each element to perform a specific operation. Loops are essential for this task. This section explores how to use various types of loops (for, while, do-while) to effectively process arrays.

Array Basics

An array is a contiguous block of memory locations that store elements of the same data type. Each element in an array is accessed using an index, which is an integer starting from 0.

Example: An array of integers might be represented as:

[10, 20, 30, 40, 50]

In this example, the index 0 refers to 10, index 1 refers to 20, and so on.

For Loops for Array Processing

The `for` loop is commonly used for iterating over arrays when the number of iterations is known in advance (i.e., the size of the array).

Syntax: for (initialization; condition; increment) { // code to be executed for each element }

Example (C++):

int myArray[] = {1, 2, 3, 4, 5};
int arraySize = sizeof(myArray) / sizeof(myArray[0]); // Calculate array size

for (int i = 0; i < arraySize; i++) {
  std::cout << "Element at index " << i << ": " << myArray[i] << std::endl;
}

In this example, the loop iterates from index 0 up to (but not including) the array size. In each iteration, the element at the current index `i` is accessed and processed.

While Loops for Array Processing

The `while` loop is useful when the number of iterations is not known beforehand, and the loop continues as long as a certain condition is true.

Syntax: while (condition) { // code to be executed while the condition is true }

Example (C++):

int myArray[] = {10, 20, 30, 40, 50};
int arraySize = sizeof(myArray) / sizeof(myArray[0]);
int i = 0;

while (i < arraySize) {
  std::cout << "Element at index " << i << ": " << myArray[i] << std::endl;
  i++;
}

Here, the loop continues as long as the index `i` is less than the array size. The index `i` is incremented in each iteration.

Do-While Loops for Array Processing

The `do-while` loop is similar to the `while` loop, but it guarantees that the code block will be executed at least once, even if the condition is initially false.

Syntax: do { // code to be executed } while (condition);

Example (C++):

int myArray[] = {10, 20, 30, 40, 50};
int arraySize = sizeof(myArray) / sizeof(myArray[0]);
int i = 0;

do {
  std::cout << "Element at index " << i << ": " << myArray[i] << std::endl;
  i++;
} while (i < arraySize);

The code block is executed first, and then the condition is checked. If the condition is true, the loop continues; otherwise, it terminates.

Array Traversal Techniques

Besides simple iteration, arrays can be processed using various techniques:

• Sum of Elements: Calculate the sum of all elements in the array.
• Finding the Maximum/Minimum: Determine the largest or smallest element in the array.
• Reversing the Array: Reverse the order of elements in the array.
• Searching for a Specific Value: Check if a particular value exists in the array and return its index.

Example: Calculating the Sum of Array Elements

This example demonstrates how to use a `for` loop to calculate the sum of all elements in an array.

Step	Description	Array	Sum
Initialization	Initialize a variable to store the sum (e.g., `sum = 0`).		0
Iteration 1	Add the first element (10) to the sum.	[10, 20, 30, 40, 50]	10
Iteration 2	Add the second element (20) to the sum.	[10, 20, 30, 40, 50]	30
Iteration 3	Add the third element (30) to the sum.	[10, 20, 30, 40, 50]	60
Iteration 4	Add the fourth element (40) to the sum.	[10, 20, 30, 40, 50]	100
Iteration 5	Add the fifth element (50) to the sum.	[10, 20, 30, 40, 50]	150
Result	The final sum is 150.		150

Example Code (C++)

#include 

int main() {
  int myArray[] = {10, 20, 30, 40, 50};
  int arraySize = sizeof(myArray) / sizeof(myArray[0]);
  int sum = 0;

  for (int i = 0; i < arraySize; i++) {
    sum += myArray[i];
  }

  std::cout << "The sum of the array elements is: " << sum << std::endl;

  return 0;
}

Conclusion

Understanding how to use loops to process arrays is a crucial skill in computer science. The choice of loop (for, while, do-while) depends on the specific requirements of the task. Mastering these techniques allows you to efficiently manipulate and analyze data stored in arrays.