Getting Started with Array Data Structure

Array is a collection of items of the same variable type that are stored at contiguous memory locations. It is one of the most popular and simple data structures used in programming.

Basic terminologies of Array

• Array Index: In an array, elements are identified by their indexes. Array index starts from 0.
• Array element: Elements are items stored in an array and can be accessed by their index.
• Array Length: The length of an array is determined by the number of elements it can contain. 

Memory representation of Array

In an array, all the elements are stored in contiguous memory locations. So, if we initialize an array, the elements will be allocated sequentially in memory. This allows for efficient access and manipulation of elements.

1 / 3

Declaration of Array

Arrays can be declared in various ways in different languages. For better illustration, below are some language-specific array declarations:

// This array will store integer type element
int arr[5];      

// This array will store char type element
char arr[10];   

// This array will store float type element
float arr[20];  

// This array will store integer type element
int arr[5];      

// This array will store char type element
char arr[10];   

// This array will store float type element
float arr[20];  

// This array will store integer type element
int arr[];     

// This array will store char type element
char arr[];   

// This array will store float type element
float arr[];  

# In Python, all types of lists are created same way
arr = []

// This array will store integer type element
int[] arr;

// This array will store char type element
char[] arr2;

// This array will store float type element
float[] arr3;

// JS code
let arr = []

Initialization of Array

Arrays can be initialized in different ways in different languages. Below are some language-specific array initializations:

int arr[] = { 1, 2, 3, 4, 5 };
char arr[5] = { 'a', 'b', 'c', 'd', 'e' };
float arr[10] = { 1.4, 2.0, 24, 5.0, 0.0 };

int arr[] = { 1, 2, 3, 4, 5 };
char arr[5] = { 'a', 'b', 'c', 'd', 'e' };
float arr[10] = { 1.4, 2.0, 24, 5.0, 0.0 };

int arr[] = { 1, 2, 3, 4, 5 };
char arr[] = { 'a', 'b', 'c', 'd', 'e' };
float arr[] = { 1.4f, 2.0f, 24f, 5.0f, 0.0f };

# This list will store integer type elements
arr = [1, 2, 3, 4, 5]

# This list will store character type elements (strings in Python)
arr = ['a', 'b', 'c', 'd', 'e']

# This list will store float type elements
arr = [1.4, 2.0, 24.0, 5.0, 0.0]  # All float values

int[] arr = { 1, 2, 3, 4, 5 };
char[] arr = { 'a', 'b', 'c', 'd', 'e' };
float[] arr = { 1.4f, 2.0f, 24f, 5.0f, 0.0f };

let arr = [ 1, 2, 3, 4, 5 ];
let arr = [ 'a', 'b', 'c', 'd', 'e' ];
let arr = [ 1.4, 2.0, 24, 5.0, 0.0 ];

Why do we Need Arrays?

Assume there is a class of five students and if we have to keep records of their marks in examination then, we can do this by declaring five variables individual and keeping track of records but what if the number of students becomes very large, it would be challenging to manipulate and maintain the data.

What it means is that, we can use normal variables (v1, v2, v3, ..) when we have a small number of objects. But if we want to store a large number of instances, it becomes difficult to manage them with normal variables.

The idea of an array is to represent many instances in one variable.

Types of Arrays

Arrays can be classified in two ways:

• On the basis of Size
• On the basis of Dimensions

Types of Arrays on the basis of Size

1. Fixed Sized Arrays

We cannot alter or update the size of this array. Here only a fixed size (i,e. the size that is mentioned in square brackets []) of memory will be allocated for storage. In case, we don’t know the size of the array then if we declare a larger size and store a lesser number of elements will result in a wastage of memory or we declare a lesser size than the number of elements then we won’t get enough memory to store all the elements. In such cases, static memory allocation is not preferred.

// Method 1 to create a fixed sized array. 
// Here the memory is allocated at compile time.
int arr[5]; 
// Another way (creation and initialization both)
int arr2[5] = {1, 2, 3, 4, 5}; 

// Method 2 to create a fixed sized array
// Here memory is allocated at run time (Also
// known as dynamically allocated arrays)
int *arr = new int[5]; 

// Method 1 to create a fixed sized array. 
// Here the memory is allocated at compile time.
int arr1[5];
// Another way (creation and initialization both)
int arr2[5] = {1, 2, 3, 4, 5}; 


// Method 2 to create a fixed sized array
// Here memory is allocated at run time (Also
// known as dynamically allocated arrays)
int *arr = (int*)malloc(n * sizeof(int));

// Fixed sized array examples
int[] arr1 = new int [5];

// Another way (Array creation and 
// initialization both)
int[] arr2 = {1, 2, 3, 4, 5};

# Create a fixed-size list of length 5, 
# initialized with zeros
arr = [0] * 5

# Output the fixed-size list
print(arr)

// Fixed sized array examples
int[] arr1 = new int [5];

// Another way (Array creation and 
// initialization both)
int[] arr2 = {1, 2, 3, 4, 5};

2. Dynamic Sized Arrays

The size of the array changes as per user requirements during execution of code so the coders do not have to worry about sizes. They can add and removed the elements as per the need. The memory is mostly dynamically allocated and de-allocated in these arrays.

#include<vector>

// Dynamic Integer Array
vector<int> v;

// C does not seem to support
// dynamic sized arrays as of now

// Dynamic Integer Array
ArrayList<Integer> arr = new ArrayList<>();

# Dynamic Array
arr = []

// Similar to Java
ArrayList myList = new ArrayList(); 

// Dynamic Sized Array
let arr = new Array();  

Types of Arrays on the basis of Dimensions

1. One-dimensional Array(1-D Array): You can imagine a 1d array as a row, where elements are stored one after another.

2. Multi-dimensional Array: A multi-dimensional array is an array with more than one dimension. We can use multidimensional array to store complex data in the form of tables, etc. We can have 2-D arrays, 3-D arrays, 4-D arrays and so on.

• Two-Dimensional Array(2-D Array or Matrix): 2-D Multidimensional arrays can be considered as an array of arrays or as a matrix consisting of rows and columns.

To read more about Matrix Refer, Matrix Data Structure

• Three-Dimensional Array(3-D Array): A 3-D Multidimensional array contains three dimensions, so it can be considered an array of two-dimensional arrays.

To read more about Multidimensional Array Refer, Multidimensional Arrays in C – 2D and 3D Arrays

Operations on Array

1. Array Traversal

Array traversal refers to the process of accessing and processing each element of an array sequentially. This is one of the most fundamental operations in programming, as arrays are widely used data structures for storing multiple elements in a single variable.

How Array Traversal Works?

When an array is created, it occupies a contiguous block of memory where elements are stored in an indexed manner. Each element can be accessed using its index, which starts from 0 in most programming languages.

For example, consider an array containing five integers:

arr = [10, 20, 30, 40, 50]

Here:

• The first element (10) is at index 0.
• The second element (20) is at index 1.
• The last element (50) is at index 4.

Array traversal means accessing each element from start to end (or sometimes in reverse order), usually by using a loop.

Types of Array Traversal

Array traversal can be done in multiple ways based on the requirement:

1. Sequential (Linear) Traversal
   • This is the most common way of traversing an array.
   • It involves iterating through the array one element at a time from the first index to the last.
   • Used for printing elements, searching, or performing calculations (such as sum or average).
2. Reverse Traversal
   • Instead of starting from index 0, the traversal begins from the last element and moves towards the first.
   • This is useful in cases where we need to process elements from the end.

To read more about Array Traversal Refer, Traversal in Array

2. Insertion in Array

Insertion in an array refers to the process of adding a new element at a specific position while maintaining the order of the existing elements. Since arrays have a fixed size in static implementations, inserting an element often requires shifting existing elements to make space.

How Insertion Works in an Array?

Arrays are stored in contiguous memory locations, meaning elements are arranged in a sequential block. When inserting a new element, the following happens:

1. Identify the Position: Determine where the new element should be inserted.
2. Shift Elements: Move the existing elements one position forward to create space for the new element.
3. Insert the New Element: Place the new value in the correct position.
4. Update the Size (if applicable): If the array is dynamic, its size is increased.

For example, if we have the array:

arr = [10, 20, 30, 40, 50]

and we want to insert 25 at index 2, the new array will be:

arr = [10, 20, 25, 30, 40, 50]

Here, elements 30, 40, and 50 have shifted right to make space.

Types of Insertion

1. Insertion at the Beginning (Index 0)

• Every element must shift one position right.
• This is the least efficient case for large arrays as it affects all elements.

2. Insertion at a Specific Index

• Elements after the index shift right.
• If the index is in the middle, half of the array moves.

3. Insertion at the End

• The simplest case since no shifting is required.
• Used in dynamic arrays where size increases automatically (e.g., Python lists, Java ArrayList).

To read more about Insertion in Array Refer, Inserting Elements in an Array – Array Operations

3. Deletion in Array

Deletion in an array refers to the process of removing an element from a specific position while maintaining the order of the remaining elements. Unlike linked lists, where deletion is efficient, removing an element from an array requires shifting elements to fill the gap.

How Deletion Works in an Array?

Since arrays have contiguous memory allocation, deleting an element does not reduce the allocated memory size. Instead, it involves:

1. Identify the Position: Find the index of the element to be deleted.
2. Shift Elements: Move the elements after the deleted element one position to the left.
3. Update the Size (if applicable): If using a dynamic array, the size might be reduced.

For example, consider the array:

arr = [10, 20, 30, 40, 50]

If we delete the element 30 (index 2), the new array will be:

arr = [10, 20, 40, 50]

Here, elements 40 and 50 shifted left to fill the gap.

Types of Deletion

1. Deletion at the Beginning (Index 0)

• Every element shifts left by one position.
• This is the most expensive case as it affects all elements.

2. Deletion at a Specific Index

• Only elements after the index shift left.
• If the index is in the middle, half of the array moves.

3. Deletion at the End

• The simplest case since no shifting is required.
• The size of the array is reduced (in dynamic arrays).

To read more about Deletion in Array Refer, Deleting Elements in an Array – Array Operations

4. Searching in Array

Searching in an array refers to the process of finding a specific element in a given list of elements. The goal is to determine whether the element exists in the array and, if so, find its index (position).

Searching is a fundamental operation in programming, as it is used in data retrieval, filtering, and processing.

Types of Searching in an Array

There are two main types of searching techniques in an array:

1. Linear Search (Sequential Search)

• This is the simplest search algorithm.
• It traverses the array one element at a time and compares each element with the target value.
• If a match is found, it returns the index of the element.
• If the element is not found, the search continues until the end of the array.

Example:

Consider an array:

arr = [10, 20, 30, 40, 50]

If we search for 30, the algorithm will:

1. Compare 10 with 30 → No match.
2. Compare 20 with 30 → No match.
3. Compare 30 with 30 → Match found at index 2.

2. Binary Search (Efficient Search for Sorted Arrays)

• Works only on sorted arrays (in increasing or decreasing order).
• Uses a divide and conquer approach.
• It repeatedly divides the search space in half until the target element is found.

How Binary Search Works?

1. Find the middle element of the array.
2. If the target is equal to the middle element, return its index.
3. If the target is less than the middle element, search the left half.
4. If the target is greater than the middle element, search the right half.
5. Repeat until the element is found or the search space is empty.

Example:

Consider a sorted array:

arr = [10, 20, 30, 40, 50]

If we search for 30:

1. Middle element = 30 → Match found!
2. The search ends in just one step, making it much faster than linear search.

To read more about Searching in Array Refer, Searching Elements in Array

Next Read: Applications, Advantages and Disadvantages of Array

Related articles:

• Top 50 Array Coding Problems for Interviews
• How to start learning DSA?
• Competitive Programming – A Complete Guide
• How can one become good at Data Structures and Algorithms easily?
• Why Data Structures and Algorithms Are Important to Learn?
• Top 15 Websites for Coding Challenges and competitions
• SDE SHEET – A Complete Guide for SDE Preparation
• Amazon SDE Sheet – A Guide for Amazon SDE Interview Preparation
• Google Interview Preparation For Software Engineer – A Complete Guide
• 100 Days of Code – A Complete Guide For Beginners and Experienced

Frequently Asked Questions (FAQs) on Arrays

1. What is an array in data structure with example?

An array is a collection of items of the same data type stored at contiguous memory locations. Ex. int arr[5] = {1,2,3,4,5};

2. Why array is a data structure?

Arrays store elements of the same type, they are classified as homogeneous data structures. They can store numbers, strings, characters, boolean values (true and false), objects, and so on.

3. What data structure is an array?

 An array is a linear data structure that stores similar elements in contiguous memory locations.

4. What are the types of arrays?

There are majorly two types of arrays:

• One dimensional array
• Multidimensional array

5. How is data stored in an array?

An array is a collection of items of the same data type stored at contiguous memory locations or says the elements are stored one after another in memory. An array uses an index system starting at 0 and going to (n-1), where n is its size.

6. Difference between array and structure?

The structure can contain variables of different types but an array only contains variables of the same type. 

7. What are the limitations of an array?

An array is a collection of items of the same data type. That means, in an integer array only integer values can be stored, while in a float array only floating values and character array can have only characters. Thus, no array can have values of two data types.

8. What are the advantages of an array?

There are multiple advantages of array data structure and some of them are:

• Arrays allow random access to elements. This makes accessing elements by position faster.
• Arrays store multiple data of similar types with the same name.
• Array data structures are used to implement the other data structures like linked lists, stacks, queues, trees, graphs, etc.

9. What is the purpose of using arrays?

An array is used when several variables of the same type need to be used, and it can be defined as a sequence of objects of the same type.  

10. What is a multidimensional array?

A multi-dimensional array can be termed as an array of arrays that stores homogeneous data in tabular form. Data in Multidimensional Arrays are stored in row-major order. 

kartik

Follow

Improve

Article Tags :

• Data Structures
• DSA
• DSA Tutorials

Practice Tags :

• Data Structures