Types of Arrays in C Programming

Arrays in C can be classified based on their dimensions, and the most common types are:

1. One-Dimensional Arrays
2. Two-Dimensional Arrays

Both types of arrays allow you to store multiple values under a single variable name, but they differ in how data is organized and accessed.

---

1. One-Dimensional Arrays

A One-Dimensional Array is the simplest form of an array, where elements are stored in a single row. It is essentially a list of elements, and each element is accessed using a single index.

Declaration and Syntax:

data_type array_name[array_size];

• data_type: The type of the elements (e.g., int, float, char).
• array_name: The name of the array.
• array_size: The number of elements the array can store.

Example:

int numbers[5];  // Declare an array 'numbers' to store 5 integers

You can also initialize the array during declaration:

int numbers[5] = {10, 20, 30, 40, 50};  // Declare and initialize

Accessing Elements in a One-Dimensional Array:

You can access each element in the array using the index, which starts from 0.

int first = numbers[0];  // Access the first element
int third = numbers[2];  // Access the third element

Example of a One-Dimensional Array:

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};

    // Accessing elements
    for (int i = 0; i < 5; i++) {
        printf("Element at index %d: %d\n", i, numbers[i]);
    }

    return 0;
}

Output:

Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Memory Representation:

A one-dimensional array is stored in contiguous memory locations. If the array contains 5 elements and the starting address is 100, the next element will be stored at 104 (assuming 4 bytes per integer).

Index       : 0     1     2     3     4
Array       : 10    20    30    40    50
Memory Addr : 100   104   108   112   116

Advantages of One-Dimensional Arrays:

• Simplifies the storage of related data under one name.
• Allows random access to elements using an index.
• Efficient for linear data like lists.

---

2. Two-Dimensional Arrays

A Two-Dimensional Array is an array of arrays, meaning it has rows and columns. It can be visualized as a table or matrix, where each element is accessed using two indices: one for the row and one for the column.

Declaration and Syntax:

data_type array_name[rows][columns];

• data_type: The type of the elements (e.g., int, float, char).
• array_name: The name of the array.
• rows: The number of rows in the array.
• columns: The number of columns in the array.

Example:

int matrix[2][3];  // Declare a 2x3 matrix (2 rows, 3 columns)

You can also initialize the array during declaration:

int matrix[2][3] = {
    {1, 2, 3},  // First row
    {4, 5, 6}   // Second row
};

Accessing Elements in a Two-Dimensional Array:

You can access elements using two indices: the row index and the column index.

int first_element = matrix[0][0];  // Access the element in the first row, first column
int second_element = matrix[0][1]; // Access the element in the first row, second column

Example of a Two-Dimensional Array:

#include <stdio.h>

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

    // Accessing elements
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("Element at [%d][%d]: %d\n", i, j, matrix[i][j]);
        }
    }

    return 0;
}

Output:

Element at [0][0]: 1
Element at [0][1]: 2
Element at [0][2]: 3
Element at [1][0]: 4
Element at [1][1]: 5
Element at [1][2]: 6

Memory Representation:

A two-dimensional array is stored in contiguous memory locations, and elements are stored in row-major order, meaning that all elements of the first row are stored first, followed by the elements of the second row, and so on.

Matrix Representation:
Row 0:   1    2    3
Row 1:   4    5    6

Memory Layout:
Index       : [0][0]  [0][1]  [0][2]  [1][0]  [1][1]  [1][2]
Array       :   1       2       3       4       5       6
Memory Addr : 100     104     108     112     116     120

Advantages of Two-Dimensional Arrays:

• Useful for representing data in tabular form (e.g., matrices, grids).
• Can be used to represent mathematical concepts like matrices, tables, and more.
• Efficient storage for multi-row data.

---

Comparison Between One-Dimensional and Two-Dimensional Arrays

Feature	One-Dimensional Array	Two-Dimensional Array
Definition	Stores elements in a single row	Stores elements in a table with rows and columns
Access	Accessed using a single index	Accessed using two indices (row, column)
Example	int arr[5];	int matrix[2][3];
Memory Representation	Stored in contiguous memory locations	Stored in contiguous memory (row-major order)
Use Case	Best for linear data (lists, sequences)	Best for tabular data (matrices, grids)

---

When to Use One-Dimensional vs. Two-Dimensional Arrays

• One-Dimensional Arrays:
• Use when you need to store linear data such as a list of numbers, marks, or names.
• Suitable for simple data storage where elements are sequential and can be accessed using a single index.
• Two-Dimensional Arrays:
• Use when you need to represent data in a table or grid format, such as a matrix or a spreadsheet.
• Ideal for complex structures like tables, matrices, and image data (pixel grids).

---

Summary of Types of Arrays

1. One-Dimensional Arrays:

• A linear collection of elements accessed by a single index.
• Best for simple lists or sequences.

1. Two-Dimensional Arrays:

• A matrix-like structure with rows and columns, accessed by two indices.
• Ideal for tabular data such as grids and matrices.

Understanding these two types of arrays allows you to efficiently store and manage data based on the structure of your problem. By choosing the right type of array, you can organize your data and simplify access and manipulation.