One Dimensional Arrays in C++

One-dimensional arrays are like a row of boxes where you can store things where each box can hold one item, such as a number or a word. For example, in an array of numbers, the first box might hold 5, the second 10, and so on. You can easily find or change what's in each box by referring to its position, called an index. Arrays are handy because they let you store lots of related data in one place and access it quickly.

In this article, we will learn about One Dimensional Arrays in C++.

Syntax of 1D Array in C++

The one dimensional array can be declared as shown below:

element_type array_name [size]

Properties of 1D Array in C++

One-dimensional arrays are organized as a sequence of contiguous memory locations, each capable of holding a single data element of the same type. Following are the main properties of 1D array in C++:

Contiguous Memory Allocation

When you create an array in C++, it allocates a block of memory to hold all the elements. This means the elements are stored right next to each other in memory, without any gaps. For example, if you have an array of integers, each integer occupies a fixed-size space in memory, and they're arranged one after the other.

Index-Based Access

Elements in the array are accessed using an index, which is a numeric value indicating the position of the element within the array. The index starts from 0 for the first element and goes up to one less than the size of the array. So, if you have an array with five elements, the indices range from 0 to 4.

Fixed Size

One-dimensional arrays have a fixed size, meaning once you declare an array with a certain number of elements, you can't change its size during runtime. The size of the array needs to be specified at compile time.

Linear Structure

The elements in a one-dimensional array are arranged in a linear or one-dimensional structure. This means there's only one dimension to consider when accessing or arranging the elements. Unlike multi-dimensional arrays, which have rows and columns, one-dimensional arrays have a single row or sequence of elements.

One-dimensional arrays in C++ are organized as a contiguous block of memory locations, accessed using indices, with a fixed size determined at compile time. Their linear structure and index-based access make them efficient for storing and accessing collections of data in computer programs.

How to Use 1d Array in C++

Usage of one-dimensional arrays in C++ involves declaring the array, initializing it with values (optional), accessing and modifying elements, and performing various operations on the array.

Declaring an Array

To declare an array in C++, you specify the data type of the elements followed by the array name and the size of the array in square brackets. For example, to declare an array of integers with five elements:

int arr[5];

This creates an array named arr capable of holding five integers.

Initializing the Array

You can optionally initialize the array with values at the time of declaration or later using a loop or by assigning values individually. For example:

int arr[5] = {10, 20, 30, 40, 50}; // Initializing with values

This initializes the array arr with five integers: 10, 20, 30, 40, and 50.

Accessing and Modifying Elements

Elements in the array are accessed using indices, starting from 0 for the first element. You can access and modify elements using square brackets []. For example:

int value = arr[2]; // Accessing the element at index 2 (30)

arr[3] = 60; // Modifying the element at index 3 to 60

Performing Basic Operations

You can perform various operations on arrays, such as searching for an element, sorting the elements, or calculating the sum of all elements. These operations typically involve iterating through the array using loops and applying the necessary logic. For example, to find the sum of all elements in the array:

int sum = 0;

for (int i = 0; i < 5; i++) {

sum += arr[i];

}

This loop iterates through each element of the array and adds it to the sum variable.

Dynamic Memory Allocation (Optional)

In addition to fixed-size arrays, you can also dynamically allocate memory for arrays using pointers. This allows you to create arrays of variable sizes at runtime. For example:

int* dynamicArr = new int[5]; // Dynamically allocating memory for an array of 5 integers

Remember to deallocate the memory using delete[] when you're done using the dynamically allocated array to avoid memory leaks.

Complexity Analysis of Basic Array Operations

Several basic operations can be performed on one-dimensional arrays in C++, each with its associated time and space complexity:

Accessing an Element by Index

Time Complexity: O(1). Since arrays provide constant-time access to elements based on their indices, accessing an element by index takes constant time regardless of the size of the array.

Space Complexity: O(1). This operation requires no additional space beyond the memory used by the array itself.

Modifying an Element by Index

Time Complexity: O(1). Similar to accessing an element, modifying an element by index takes constant time regardless of the size of the array.

Space Complexity: O(1). No additional space is required beyond the memory used by the array.

Insertion/Deletion

Time Complexity:

Insertion/Deletion at the beginning or middle of the array: O(n). Since shifting elements requires iterating through and potentially moving each element, the time complexity is linearly proportional to the size of the array.

Insertion/Deletion at the end of the array (if space is available): O(1). If there's available space at the end of the array, inserting or deleting an element requires only updating the array's size and doesn't involve shifting elements.

Space Complexity: O(1). Inserting or deleting an element in the array doesn't require additional space beyond the memory used by the array itself.

Understanding the time and space complexities of these basic operations is essential for designing efficient algorithms and data structures that utilize one-dimensional arrays.

Example of One Dimensional Array in C++

#include <iostream>
using namespace std;

int main() {
    // Declaration and initialization of an array
    int arr[5] = {10, 20, 30, 40, 50};

    // Accessing elements of the array
    cout << "Element at index 2: " << arr[2] << endl;

    // Modifying elements of the array
    arr[3] = 60;
    cout << "Modified element at index 3: " << arr[3] << endl;

    // Calculating the sum of all elements
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += arr[i];
    }
    cout << "Sum of all elements: " << sum << endl;

    return 0;
}

Element at index 2: 30
Modified element at index 3: 60
Sum of all elements: 170

Applications of One Dimensional Array

One-dimensional arrays in C++ find wide-ranging applications across various domains due to their simplicity, efficiency, and versatility. Here are some common applications of one-dimensional arrays:

1. Data Storage and Retrieval
2. Numerical Computations
3. Algorithm Design and Implementation
4. Input and Output Operations
5. Memory Management'

omkarchavan_07

Follow

Improve

Article Tags :

• C++
• CPP-DSA
• misc-cpp

Practice Tags :

• CPP