Arrays and Loops (C++)

Why This Matters

Arrays and loops are fundamental concepts in C++ programming that allow you to store, manipulate, and iterate over large collections of data efficiently. Understanding these concepts is crucial for tackling real-world problems, acing coding interviews, and debugging complex programs.

Prerequisites

Before diving into arrays and loops, it's essential that you have a good grasp of C++ syntax, variables, and basic input/output operations. If you haven't already, check out our lessons on C++ Basics and C++ Input/Output.

Core Concept

Arrays

An array in C++ is a collection of elements of the same data type, stored at contiguous memory locations. The elements can be accessed using an index, which starts from 0 and goes up to one less than the size of the array. To declare an array, you use the following syntax:

dataType arrayName[arraySize];

For example, to create an array of integers named numbers with a capacity of 10 elements, you would write:

int numbers[10];

Loops

Loops in C++ allow you to execute a block of code repeatedly. The two most common types of loops are for and while.

For Loop

The for loop is used when the number of iterations is known or can be easily calculated. It has three parts: initialization, condition, and increment/decrement. Here's an example:

for (initialization; condition; increment/decrement) {
// code to be executed on each iteration
}

While Loop

The while loop continues executing as long as the specified condition is true. The syntax for a while loop is:

while (condition) {
// code to be executed on each iteration
}

Using Arrays with Loops

Combining arrays and loops allows you to iterate through all elements of an array, making it easier to perform operations like searching, sorting, or modifying the data. Here's an example that initializes an array, prints its contents, and then increments each element by 1:

#include <iostream>
using namespace std;

int main() {
int numbers[5] = {1, 2, 3, 4, 5};

for (int i = 0; i < 5; ++i) {
cout << numbers[i] << " "; // prints the current element
numbers[i] += 1; // increments the current element
}

cout << endl; // prints a newline after the loop

for (int i = 0; i < 5; ++i) {
cout << numbers[i] << " "; // prints the updated elements
}

return 0;
}

Multi-dimensional Arrays

In addition to one-dimensional arrays, C++ also supports multi-dimensional arrays. A two-dimensional array can be declared as follows:

dataType arrayName[rows][columns];

For example:

int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};

To access an element in a multi-dimensional array, you can use multiple indices. For instance, matrix[1][2] would give you the value 6.

Looping through Multi-dimensional Arrays

You can loop through a multi-dimensional array using nested loops. Here's an example that prints the contents of a 3x4 matrix:

#include <iostream>
using namespace std;

int main() {
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};

for (int i = 0; i < 3; ++i) { // loop through rows
for (int j = 0; j < 4; ++j) { // loop through columns
cout << matrix[i][j] << " ";
}
cout << endl; // print a newline after each row
}

return 0;
}

Worked Example

Problem: Find the sum of all even numbers in an array.

Input: An array of integers arr[] with size n.

Output: The sum of all even numbers in the array.

Here's a solution using a loop and conditional statements:

#include <iostream>
using namespace std;

int main() {
int arr[5] = {1, 2, 3, 4, 5};
int sumOfEvens = 0;

for (int i = 0; i < 5; ++i) {
if (arr[i] % 2 == 0) { // checks if the current number is even
sumOfEvens += arr[i]; // adds the current number to the sum of evens if it's even
}
}

cout << "The sum of all even numbers in the array is: " << sumOfEvens << endl;

return 0;
}

Common Mistakes

1. ### Forgetting to initialize arrays or loop variables

Always make sure to initialize your arrays and loop variables before using them, as uninitialized variables contain random values that can lead to unexpected behavior.

1. ### Using the wrong index for array access

Array indices start at 0, so if you're working with a 5-element array, the valid indices are 0 through 4. Accessing an index outside this range will result in undefined behavior.

1. ### Not properly handling edge cases

Always consider what happens when the input size is 0 or when the array contains only odd numbers (or any other unusual scenario). Properly handling these edge cases can help prevent errors and improve your code's robustness.

1. ### Misusing loops in complex conditions

When using loops with complex conditions, be careful not to create infinite loops or unintended jumps in the loop sequence. Always ensure that the loop condition is updated correctly during each iteration.

1. ### Not optimizing array access when possible

In some cases, it may be more efficient to use pointer arithmetic instead of using indices when accessing array elements. This can help reduce the number of memory lookups and improve performance.

Practice Questions

1. Write a program that sorts an array of integers in ascending order using a loop.
2. Given an array of strings, write a program that counts the number of unique words in the array.
3. Write a program that finds the second-largest number in an array.
4. Given two arrays of different sizes, write a program that checks if they have any common elements.
5. Write a program that finds the smallest and largest numbers in an array using loops.
6. Write a program that reverses the order of elements in an array using a loop.
7. Write a program that multiplies each element in an array by 2 using a loop.
8. Write a program that checks if an array contains any duplicate elements using a loop and hash table (optional).
9. Write a program that finds the kth largest number in an array using a loop and heap sort algorithm (optional).
10. Write a program that rotates an array by k positions to the left using a loop (optional).

FAQ

### Why do we use loops with arrays?

Loops allow you to iterate through all elements of an array, making it easier to perform operations like searching, sorting, or modifying the data.

### What happens if I access an index outside the range of my array?

Accessing an index outside the valid range (0 to one less than the size of the array) will result in undefined behavior, such as a segmentation fault.

### How can I find the largest number in an array using a loop?

To find the largest number in an array using a loop, initialize a variable to hold the largest number found so far and compare each element of the array with this variable. Update the variable whenever you find a larger number. Here's an example:

int arr[5] = {1, 2, 3, 4, 5};
int largest = arr[0]; // initialize largest to the first element

for (int i = 1; i < 5; ++i) { // start loop from 1 since we already have the first element
if (arr[i] > largest) {
largest = arr[i];
}
}

cout << "The largest number in the array is: " << largest << endl;

### How can I find the smallest number in an array using a loop?

To find the smallest number in an array using a loop, initialize a variable to hold the smallest number found so far and compare each element of the array with this variable. Update the variable whenever you find a smaller number. Here's an example:

int arr[5] = {1, 2, 3, 4, 5};
int smallest = arr[0]; // initialize smallest to the first element

for (int i = 1; i < 5; ++i) { // start loop from 1 since we already have the first element
if (arr[i] < smallest) {
smallest = arr[i];
}
}

cout << "The smallest number in the array is: " << smallest << endl;

### How can I reverse the order of elements in an array using a loop?

To reverse the order of elements in an array using a loop, you can swap the first and last elements, then iterate through the array from the second element to the second-to-last element and swap each pair of adjacent elements. Here's an example:

#include <iostream>
using namespace std;

void reverseArray(int arr[], int size) {
for (int i = 0; i < size / 2; ++i) {
int temp = arr[i];
arr[i] = arr[size - i - 1];
arr[size - i - 1] = temp;
}
}

int main() {
int arr[5] = {1, 2, 3, 4, 5};
reverseArray(arr, 5);

for (int i = 0; i < 5; ++i) {
cout << arr[i] << " ";
}

cout << endl;

return 0;
}