Arrays Data Structure - Complete Guide

// Array declaration and initialization
let numbers = [10, 20, 30, 40, 50];

// Accessing elements by index
console.log(numbers[0]);  // 10 (first element)
console.log(numbers[2]);  // 30 (third element)
console.log(numbers[4]);  // 50 (last element)

// Array length
console.log(numbers.length);  // 5

Arrays store elements in order. Access elements using square brackets with the index. Arrays are zero-indexed.

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

// Access by index - O(1) time complexity
let first = arr[0];    // 10
let third = arr[2];    // 30
let last = arr[arr.length - 1];  // 50

Accessing an element by index takes O(1) constant time because the computer can calculate the memory address directly: base_address + (index × element_size).

// Linear search - O(n) time complexity
function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i;  // Return index if found
    }
  }
  return -1;  // Return -1 if not found
}

let numbers = [10, 20, 30, 40, 50];
console.log(linearSearch(numbers, 30));  // 2
console.log(linearSearch(numbers, 60));  // -1

Linear search checks each element one by one. In the worst case, it checks all n elements, so time complexity is O(n).

let arr = [10, 20, 30, 40];

// Insert at end - O(1) amortized
arr.push(50);  // [10, 20, 30, 40, 50]

// Insert at beginning - O(n)
arr.unshift(5);  // [5, 10, 20, 30, 40, 50]

// Insert at specific index - O(n)
arr.splice(2, 0, 15);  // Insert 15 at index 2
// [5, 10, 15, 20, 30, 40, 50]

Inserting at the end is fast (O(1)), but inserting at the beginning or middle requires shifting all subsequent elements (O(n)).

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

// Delete from end - O(1)
arr.pop();  // [10, 20, 30, 40]

// Delete from beginning - O(n)
arr.shift();  // [20, 30, 40]

// Delete at specific index - O(n)
arr.splice(1, 1);  // Delete element at index 1
// [20, 40]

Similar to insertion, deleting from the end is O(1), but deleting from the beginning or middle requires shifting elements (O(n)).

function findMax(arr) {
  if (arr.length === 0) {
    return null;
  }
  
  let max = arr[0];  // Assume first element is maximum
  
  // Compare with rest of elements
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
      max = arr[i];
    }
  }
  
  return max;
}

let numbers = [3, 7, 2, 9, 1, 5];
console.log(findMax(numbers));  // 9

// Time Complexity: O(n)
// Space Complexity: O(1)

We iterate through the array once, keeping track of the maximum value seen so far. Time complexity is O(n) and space is O(1).

function reverseArray(arr) {
  let left = 0;
  let right = arr.length - 1;
  
  // Swap elements from both ends
  while (left < right) {
    // Swap
    let temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
    
    left++;
    right--;
  }
  
  return arr;
}

let numbers = [1, 2, 3, 4, 5];
reverseArray(numbers);
console.log(numbers);  // [5, 4, 3, 2, 1]

// Time Complexity: O(n)
// Space Complexity: O(1)

We use two pointers starting from both ends, swapping elements until they meet in the middle. This is an in-place reversal.

function rotateArray(arr, k) {
  // Handle edge cases
  if (arr.length === 0 || k === 0) {
    return arr;
  }
  
  k = k % arr.length;  // Handle k > array length
  
  // Reverse entire array
  reverse(arr, 0, arr.length - 1);
  
  // Reverse first k elements
  reverse(arr, 0, k - 1);
  
  // Reverse remaining elements
  reverse(arr, k, arr.length - 1);
  
  return arr;
}

function reverse(arr, start, end) {
  while (start < end) {
    let temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
    start++;
    end--;
  }
}

let numbers = [1, 2, 3, 4, 5];
rotateArray(numbers, 2);
console.log(numbers);  // [4, 5, 1, 2, 3]

// Time Complexity: O(n)
// Space Complexity: O(1)

We rotate by reversing the array in three steps: reverse all, reverse first k, reverse rest. This is an efficient in-place rotation.

// 2D array (matrix)
let matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

// Accessing elements
console.log(matrix[0][0]);  // 1 (first row, first column)
console.log(matrix[1][2]);  // 6 (second row, third column)

// Iterating through 2D array
for (let i = 0; i < matrix.length; i++) {
  for (let j = 0; j < matrix[i].length; j++) {
    console.log(matrix[i][j]);
  }
}

2D arrays are arrays of arrays. Access elements using two indices: row and column.