Arrays in Data Structure Operations is an important Data Structure topic because it shows up in real projects, debugging sessions, and interviews. Learn the meaning first, then connect it to a small working example so the rule does not stay abstract.
Focus on what problem Arrays in Data Structure Operations solves, where developers usually make mistakes, and how to verify the result with output, behavior, or a small test.
A strong understanding of Arrays in Data Structure Operations should include syntax, behavior, one realistic use case, one failure case, and one quick way to check your work.
Arrays in Data Structure Operations should be studied as a practical Data Structure lesson, not as a label. Start by naming the input, the rule that changes the input, and the result a learner should be able to predict after reading the page.
In the data-structure > arrays page, the notes should connect the definition with a working scenario, a mistake that beginners actually make, and the exact check that proves the fix. That makes the topic useful for coding, debugging, and interview revision.
An array is the simplest and most widely used data structure. It stores a fixed-size collection of elements of the same type in contiguous memory locations. Each element is accessed directly by its index (position), starting from 0.
Think of an array like a row of numbered lockers - you can instantly open locker #5 without checking lockers 1 through 4.
| Property | Value |
|---|---|
| Access by index | O(1) - instant |
| Search (unsorted) | O(n) - must check each element |
| Search (sorted) | O(log n) - binary search |
| Insert at end | O(1) - if space available |
| Insert at middle | O(n) - must shift elements |
| Delete | O(n) - must shift elements |
| Memory | Contiguous - cache-friendly |
| Size | Fixed (static) or dynamic (ArrayList/vector) |
#include <iostream>
#include <vector>
using namespace std;
int main() {
// Static array - fixed size
int arr[5] = {10, 20, 30, 40, 50};
// Access by index - O(1)
cout << "arr[0] = " << arr[0] << endl; // 10
cout << "arr[4] = " << arr[4] << endl; // 50
// Traversal
cout << "Elements: ";
for (int i = 0; i < 5; i++) cout << arr[i] << " ";
cout << endl;
// Range-based for (C++11)
for (int x : arr) cout << x << " ";
cout << endl;
// Dynamic array - vector (preferred in C++)
vector<int> v = {1, 2, 3, 4, 5};
v.push_back(6); // add to end - O(1) amortized
v.pop_back(); // remove last - O(1)
cout << "Size: " << v.size() << endl;
// 2D array
int matrix[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
cout << "matrix[1][2] = " << matrix[1][2] << endl; // 6
return 0;
}import java.util.ArrayList;
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
// Static array - fixed size
int[] arr = {10, 20, 30, 40, 50};
// Access by index - O(1)
System.out.println("arr[0] = " + arr[0]); // 10
System.out.println("arr[4] = " + arr[4]); // 50
// Traversal
System.out.print("Elements: ");
for (int i = 0; i < arr.length; i++) System.out.print(arr[i] + " ");
System.out.println();
// Enhanced for loop
for (int x : arr) System.out.print(x + " ");
System.out.println();
// Dynamic array - ArrayList
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
list.add(6); // add to end - O(1) amortized
list.remove(0); // remove at index - O(n)
System.out.println("Size: " + list.size());
// 2D array
int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
System.out.println("matrix[1][2] = " + matrix[1][2]); // 6
}
}# Python list - dynamic array (no fixed-size arrays by default)
arr = [10, 20, 30, 40, 50]
# Access by index - O(1)
print("arr[0] =", arr[0]) # 10
print("arr[-1] =", arr[-1]) # 50 (negative index from end)
# Traversal
print("Elements:", arr)
for x in arr:
print(x, end=" ")
print()
# Dynamic operations
arr.append(60) # add to end - O(1)
arr.insert(2, 25) # insert at index 2 - O(n)
arr.pop() # remove last - O(1)
arr.pop(0) # remove at index - O(n)
print("After ops:", arr)
# List slicing
print("First 3:", arr[:3])
print("Last 2:", arr[-2:])
print("Reversed:", arr[::-1])
# 2D array (list of lists)
matrix = [[1,2,3],[4,5,6],[7,8,9]]
print("matrix[1][2] =", matrix[1][2]) # 6
# NumPy for true arrays (optional)
# import numpy as np
# arr = np.array([1, 2, 3, 4, 5])// JavaScript Array - dynamic, can hold mixed types
const arr = [10, 20, 30, 40, 50];
// Access by index - O(1)
console.log("arr[0] =", arr[0]); // 10
console.log("arr[4] =", arr[4]); // 50
// Traversal
arr.forEach(x => process.stdout.write(x + " "));
console.log();
// Dynamic operations
arr.push(60); // add to end - O(1)
arr.pop(); // remove last - O(1)
arr.unshift(5); // add to front - O(n)
arr.shift(); // remove from front - O(n)
arr.splice(2, 0, 25); // insert at index 2 - O(n)
// Useful array methods
const doubled = arr.map(x => x * 2);
const evens = arr.filter(x => x % 2 === 0);
const sum = arr.reduce((acc, x) => acc + x, 0);
console.log("Sum:", sum);
// 2D array
const matrix = [[1,2,3],[4,5,6],[7,8,9]];
console.log("matrix[1][2] =", matrix[1][2]); // 6#include <iostream>
#include <algorithm>
using namespace std;
// Find maximum element - O(n)
int findMax(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > max) max = arr[i];
return max;
}
// Reverse array in-place - O(n)
void reverse(int arr[], int n) {
int lo = 0, hi = n - 1;
while (lo < hi) {
swap(arr[lo], arr[hi]);
lo++; hi--;
}
}
// Rotate array left by k positions - O(n)
void rotateLeft(int arr[], int n, int k) {
k %= n;
reverse(arr, arr + k);
reverse(arr + k, arr + n);
reverse(arr, arr + n);
}
int main() {
int arr[] = {3, 1, 4, 1, 5, 9, 2, 6};
int n = 8;
cout << "Max: " << findMax(arr, n) << endl; // 9
reverse(arr, n);
for (int x : arr) cout << x << " "; // 6 2 9 5 1 4 1 3
return 0;
}import java.util.Arrays;
public class ArrayAlgorithms {
static int findMax(int[] arr) {
int max = arr[0];
for (int x : arr) if (x > max) max = x;
return max;
}
static void reverse(int[] arr) {
int lo = 0, hi = arr.length - 1;
while (lo < hi) {
int temp = arr[lo]; arr[lo] = arr[hi]; arr[hi] = temp;
lo++; hi--;
}
}
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
System.out.println("Max: " + findMax(arr)); // 9
reverse(arr);
System.out.println(Arrays.toString(arr)); // [6, 2, 9, 5, 1, 4, 1, 3]
}
}arr = [3, 1, 4, 1, 5, 9, 2, 6]
# Find max - O(n)
print("Max:", max(arr)) # 9
print("Max:", max(arr, key=abs)) # using key function
# Reverse - O(n)
arr.reverse() # in-place
print("Reversed:", arr)
# Or using slicing (creates new list)
reversed_arr = arr[::-1]
# Rotate left by k - O(n)
def rotate_left(arr, k):
k %= len(arr)
return arr[k:] + arr[:k]
arr = [1, 2, 3, 4, 5]
print("Rotated left by 2:", rotate_left(arr, 2)) # [3, 4, 5, 1, 2]
# Two-pointer: find pair with given sum
def two_sum(arr, target):
seen = {}
for i, x in enumerate(arr):
if target - x in seen:
return [seen[target - x], i]
seen[x] = i
return []
print(two_sum([2, 7, 11, 15], 9)) # [0, 1]const arr = [3, 1, 4, 1, 5, 9, 2, 6];
// Find max - O(n)
const max = Math.max(...arr);
console.log("Max:", max); // 9
// Reverse - O(n)
const reversed = [...arr].reverse(); // non-destructive
console.log("Reversed:", reversed);
// Rotate left by k
function rotateLeft(arr, k) {
k = k % arr.length;
return [...arr.slice(k), ...arr.slice(0, k)];
}
console.log("Rotated:", rotateLeft([1,2,3,4,5], 2)); // [3,4,5,1,2]
// Two Sum - O(n)
function twoSum(arr, target) {
const seen = new Map();
for (let i = 0; i < arr.length; i++) {
const complement = target - arr[i];
if (seen.has(complement)) return [seen.get(complement), i];
seen.set(arr[i], i);
}
return [];
}
console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]1. Define the input for Arrays in Data Structure Operations.
2. Apply the rule from the lesson.
3. Compare the actual result with the expected result.
4. Record the fix if the result differs.1. Try empty, missing, duplicate, or invalid data.
2. Identify where Arrays in Data Structure Operations changes behavior.
3. Explain the safest correction.
4. Retest the normal path.Memorizing Arrays in Data Structure Operations without the situation where it is useful.
Connect Arrays in Data Structure Operations to a concrete Data Structure task.
Testing Arrays in Data Structure Operations only with the perfect input.
Include empty, missing, duplicate, incompatible, or failed cases when relevant.
Changing code before reading the visible symptom or error message.
Inspect the output, state, configuration, or stack trace connected to Arrays in Data Structure Operations.
Memorizing Arrays in Data Structure Operations without the situation where it is useful.
Connect Arrays in Data Structure Operations to a concrete Data Structure task.
Access: O(1) | Search: O(n) | Insertion at end: O(1) amortized | Insertion at beginning: O(n) | Deletion at end: O(1) | Deletion at beginning: O(n) | Sorting: O(n log n)
Use arrays when you need fast random access (O(1)) and the size is known. Use linked lists when you need frequent insertions/deletions at the beginning or middle, and do not need random access.
Two pointers start at different positions (usually both ends) and move toward each other. Used for: finding pairs with a target sum, reversing arrays, removing duplicates. Reduces O(n^2) to O(n).
A prefix sum array stores cumulative sums: prefix[i] = arr[0]+arr[1]+...+arr[i]. Range sum query [l,r] = prefix[r] - prefix[l-1] in O(1). Useful for subarray sum problems.
Explore 500+ free tutorials across 20+ languages and frameworks.