Master Data Structures With Arrays The Foundation of DSA

Arrays are one of the most important data structures in computer science. They store multiple values of the same type in contiguous memory locations, making element access extremely fast.

int arr[5] = {10, 20, 30, 40, 50};

Index :  0   1   2   3   4
Value : 10  20  30  40  50

Arrays store elements sequentially in memory. Every element is accessed using an index. Understanding the time complexity of each operation is essential for writing efficient code.

Traversal means visiting every element of the array exactly once. It is the foundation of almost every array algorithm — searching, printing, and computing sums all rely on traversal.

int arr[5] = {10, 20, 30, 40, 50};
int n = 5;

for (int i = 0; i < n; i++)
{
    printf("arr[%d] = %d\n", i, arr[i]);
}

arr[0] = 10
arr[1] = 20
arr[2] = 30
arr[3] = 40
arr[4] = 50

{3, 7, 1, 9, 4, 6}

int arr[] = {3, 7, 1, 9, 4, 6};
int n = 6, sum = 0, max = arr[0];

for (int i = 0; i < n; i++) {
    sum += arr[i];
    if (arr[i] > max) max = arr[i];
}
printf("Sum = %d, Max = %d\n", sum, max);
/* Sum = 30, Max = 9 */

To insert an element at a given position, all elements from that position onward must be shifted one place to the right to create space.

// Insert value at position pos in array of current size n
for (int i = n; i > pos; i--)
{
    arr[i] = arr[i - 1];   // shift right
}
arr[pos] = value;
n++;  // update size

Before : 10  20  40  50   (n = 4)
Insert   30  at pos 2
After  : 10  20  30  40  50  (n = 5)

Deletion requires shifting every element after the deleted position one place to the left to fill the gap. The array size shrinks by one.

// Delete element at position pos
for (int i = pos; i < n - 1; i++)
{
    arr[i] = arr[i + 1];   // shift left
}
n--;  // update size

Before : 10  20  30  40  50
Delete   30  (pos = 2)
After  : 10  20  40  50

{10, 30, 50, 70, 90}

int arr[] = {10, 30, 50, 70, 90};
int n = 5, pos = 2;  // 50 is at index 2

for (int i = pos; i < n - 1; i++)
    arr[i] = arr[i + 1];
n--;

for (int i = 0; i < n; i++)
    printf("%d ", arr[i]);
// Output: 10 30 70 90

Searching means finding the position (index) of a target element inside an array. There are two fundamental approaches: Linear Search and Binary Search.

int linearSearch(int arr[], int n, int key)
{
    for (int i = 0; i < n; i++)
    {
        if (arr[i] == key)
            return i;   // found: return index
    }
    return -1;          // not found
}

Array  : 10  20  30  40  50
Key    : 40
Output : Found at index 3

{25, 50, 75, 100, 125}

int arr[] = {25, 50, 75, 100, 125};
int n = 5, key = 75;

int result = linearSearch(arr, n, key);
if (result != -1)
    printf("Found at index %d\n", result);
else
    printf("Not found\n");
// Output: Found at index 2

Sorting arranges elements in ascending or descending order. It is a prerequisite for Binary Search and many other efficient algorithms.

for (int i = 0; i < n - 1; i++)
{
    for (int j = 0; j < n - i - 1; j++)
    {
        if (arr[j] > arr[j + 1])
        {
            int temp   = arr[j];
            arr[j]     = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

{64, 34, 25, 12, 22}

/* First pass trace:
   64 34 25 12 22
   34 64 25 12 22  (swap 64,34)
   34 25 64 12 22  (swap 64,25)
   34 25 12 64 22  (swap 64,12)
   34 25 12 22 64  (swap 64,22) ← 64 is in final position

   After all passes: 12 22 25 34 64 */

int arr[] = {64, 34, 25, 12, 22};
int n = 5;
bubbleSort(arr, n);   // use the function above

A 2D Array is a collection of rows and columns — essentially an array of arrays. It is the natural way to represent matrices, grids, and board-based problems.

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

// Print the matrix
for (int r = 0; r < 3; r++) {
    for (int c = 0; c < 3; c++)
        printf("%d ", matrix[r][c]);
    printf("\n");
}

1  2  3
4  5  6
7  8  9

Arrays appear in nearly every technical interview. Here is what you need to master to solve them confidently.

• Always clarify: is the array sorted? Can you modify it in-place?
• Watch for off-by-one errors at boundaries.
• Consider edge cases: empty array, single element, all duplicates.
• Know time and space complexity of every built-in sort.
• Practice at least one array problem every day until interviews.

Input : {-2, 1, -3, 4, -1, 2, 1, -5, 4}
Output: 6  (subarray [4, -1, 2, 1])

int maxSubArray(int arr[], int n)
{
    int maxSum  = arr[0];
    int current = arr[0];

    for (int i = 1; i < n; i++)
    {
        // Either extend the current subarray or start fresh
        current = (arr[i] > current + arr[i]) ? arr[i] : current + arr[i];
        if (current > maxSum) maxSum = current;
    }
    return maxSum;
}
// Returns 6 for the example above