Arrays in C

C Programming: Mastering Arrays

Imagine you need to store the test scores of 1,000 students. Creating 1,000 individual variables (like score1, score2, score3) would take hours and create a chaotic, unreadable program. Instead, programmers use Arrays.

An array is a single, continuous block of memory divided into perfectly equal compartments. Real-life example: Think of a daily pill organizer. Instead of carrying 7 different pill bottles, you carry one plastic container that has 7 connected compartments labeled Monday through Sunday. You open one specific compartment using its index.

1. Dimensions of Arrays

Arrays come in different shapes and sizes depending on how you need to organize your data.

• 1D Arrays: This is a simple, straight line of variables. You locate an item using a single index number. In C, arrays always start counting at index 0.

// Creates a row of 5 connected integer boxes.
// You access them using arr[0] through arr[4].
int arr[5];

• 2D Arrays: This acts exactly like a spreadsheet or a chessboard. It has rows and columns. You locate an item by providing two indexes: the row number and the column number. Programmers use these to build game boards, matrices, and data tables.

// Creates a grid with 3 rows and 3 columns (9 boxes total).
// You access the very first box using arr[0][0].
int arr[3][3];

2. Problem Solving Focus: Array Algorithms

Companies test your understanding of memory and loops by asking you to manipulate arrays. Below are five essential array problems and the exact logic you need to solve them.

Problem 1: Reverse an Array

To reverse an array without creating a brand new one, we use the "Two Pointer" technique. We place one pointer at the start and one at the end. We swap their values, then move the pointers toward the center until they cross.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = 5;
    int start = 0, end = n - 1, temp;

    while(start < end) {
        // Swap the elements
        temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // Move the pointers closer to the center
        start++;
        end--;
    }

    printf("Reversed Array: ");
    for(int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

Problem 2: Find the Largest Element

We solve this by blindly assuming the first element is the largest. We then loop through the rest of the array. If we encounter a number bigger than our current champion, we dethrone the champion and update our variable.

#include <stdio.h>

int main() {
    int arr[] = {45, 12, 89, 33, 71};
    int n = 5;
    int max = arr[0]; // Assume the first element is the biggest

    for(int i = 1; i < n; i++) {
        if(arr[i] > max) {
            max = arr[i]; // Found a new champion!
        }
    }

    printf("Largest Element: %d\n", max);
    return 0;
}

Problem 3: Find the Second Largest Element

To find the second largest, we track two variables simultaneously. As we scan the array, if we find a new absolute largest number, the old largest number gets demoted and instantly becomes the second largest.

#include <stdio.h>

int main() {
    int arr[] = {12, 35, 1, 10, 34, 1};
    int n = 6;
    int largest = -1, secondLargest = -1;

    for(int i = 0; i < n; i++) {
        if(arr[i] > largest) {
            secondLargest = largest; // Demote the old champion
            largest = arr[i]; // Crown the new champion
        } else if(arr[i] > secondLargest && arr[i] != largest) {
            // If it's smaller than the largest but bigger than the second
            secondLargest = arr[i];
        }
    }

    printf("Second Largest: %d\n", secondLargest);
    return 0;
}

Problem 4: Rotate an Array (Left by 1)

Rotating an array pushes every element to the left. The very first element falls off the front edge and gets carried around to the back. We do this by storing the first element in a temporary box, shifting the rest of the array left using a loop, and then dropping the temporary box into the final empty slot.

#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = 5;
    int temp = arr[0]; // Save the first element

    // Shift everything left by one position
    for(int i = 0; i < n - 1; i++) {
        arr[i] = arr[i + 1];
    }

    // Put the first element at the very end
    arr[n - 1] = temp;

    printf("Left Rotated Array: ");
    for(int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

Problem 5: Merge Two Arrays

To merge two distinct arrays, we create a third, larger array. We run one loop to copy all the elements from the first array into the new container, and then a second loop to copy the elements from the second array right where the first one ended.

#include <stdio.h>

int main() {
    int arr1[] = {1, 2, 3};
    int arr2[] = {4, 5, 6};
    int merged[6];
    int i, index = 0;

    // Copy the first array
    for(i = 0; i < 3; i++) {
        merged[index] = arr1[i];
        index++;
    }

    // Copy the second array
    for(i = 0; i < 3; i++) {
        merged[index] = arr2[i];
        index++;
    }

    printf("Merged Array: ");
    for(i = 0; i < 6; i++)
        printf("%d ", merged[i]);
    return 0;
}

Summary: Arrays

• Arrays allow you to group multiple variables of the same data type into a single, continuous block of memory.
• You can create 1D arrays for linear lists or 2D arrays for grid-based data like tables and matrices.
• Because arrays allocate memory continuously, you must define their exact size at the time of creation; they cannot shrink or grow later.
• You use the Two Pointer technique to efficiently reverse arrays or find specific data points.
• In C programming, array indexes always start at 0, meaning an array of size 5 is accessed from index 0 to 4.

C Programming Interview Questions (FAQs)

1. Array vs. Linked List: What is the difference?

An array stores its data in a single, continuous block of memory. Because of this, arrays have a fixed size that you cannot change, but they allow extremely fast access to any random element. A Linked List scatters its data randomly across the RAM, linking them together with pointers. This allows a Linked List to grow and shrink dynamically, but finding a specific element is slow because you must read the list sequentially from the very beginning.

2. Why is array access mathematically O(1) constant time?

Array access is instant because it relies on pure mathematics instead of searching. When you ask the computer for arr[4], it does not scan through the first three elements. Instead, it takes the base memory address of the array and applies a formula: Base_Address + (Index * Size_of_Data_Type). For an integer array, it multiplies the index (4) by the size of an integer (4 bytes) and jumps exactly 16 bytes forward in the RAM to grab the data instantly.

➔ Read more about Data Types ➔ Read more about Fundamentals ➔ Read more about Variables and Storage Classes ➔ Read more about String ➔ Read more about Operators ➔ Read more about Control Statements and Loops in C ➔ Read more about Functions ➔ Read more about Arrays ➔ Read more about Pointers ➔ Read more about Structures ➔ Read more about Enum ➔ Read more about Union