Arrays - Complete Programming Guide

🎯 Quick Reference

Python Arrays (Lists)

# Create and initialize arrays
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "orange"]
mixed = [1, "hello", 3.14, True]

# Access elements
first_element = numbers[0]  # 1
last_element = fruits[-1]  # "orange"

# Modify elements
numbers[0] = 10  # [10, 2, 3, 4, 5]

# Array operations
length = len(numbers)  # 5
numbers.append(6)  # [1, 2, 3, 4, 5, 6]
numbers.pop()  # [1, 2, 3, 4, 5]

# Slicing
subset = numbers[1:4]  # [2, 3, 4]
first_three = numbers[:3]  # [1, 2, 3]
last_three = numbers[-3:]  # [3, 4, 5]

# Array methods
numbers.sort()  # [1, 2, 3, 4, 5]
numbers.reverse()  # [5, 4, 3, 2, 1]
numbers.clear()  # []

# List comprehension
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

Java Arrays

// Declare and initialize arrays
int[] numbers = {1, 2, 3, 4, 5};
String[] fruits = {"apple", "banana", "orange"};
double[] decimals = {1.1, 2.2, 3.3};

// Dynamic array declaration
int[] dynamicArray = new int[5];
dynamicArray[0] = 10;

// Access elements
int first = numbers[0];  // 1
int last = numbers[numbers.length - 1];  // 5

// Array length
int length = numbers.length;  // 5

// Array operations
import java.util.Arrays;
Arrays.sort(numbers);  // Sort array
int max = Arrays.stream(numbers).max().getAsInt();  // Find max
int min = Arrays.stream(numbers).min().getAsInt();  // Find min

// Enhanced for loop
for (int number : numbers) {
    System.out.println(number);
}

// Traditional for loop
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// Copy array
int[] copy = Arrays.copyOf(numbers, numbers.length);
int[] range = Arrays.copyOfRange(numbers, 1, 4);  // [2, 3, 4]

C Arrays

#include <stdio.h>

int main() {
    // Declare and initialize arrays
    int numbers[5] = {1, 2, 3, 4, 5};
    char fruits[3][20] = {"apple", "banana", "orange"};

    // Access elements
    int first = numbers[0];  // 1
    int last = numbers[4];  // 5

    // Calculate array length
    int length = sizeof(numbers) / sizeof(numbers[0]);  // 5

    // Array operations
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // 2D array
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Access 2D array
    printf("Matrix[1][2]: %d\n", matrix[1][2]);  // 6

    return 0;
}

JavaScript Arrays

// Create and initialize arrays
let numbers = [1, 2, 3, 4, 5];
let fruits = ["apple", "banana", "orange"];
let mixed = [1, "hello", 3.14, true];

// Access elements
let first = numbers[0];  // 1
let last = numbers[numbers.length - 1];  // 5

// Array methods
numbers.push(6);  // [1, 2, 3, 4, 5, 6]
numbers.pop();   // [1, 2, 3, 4, 5]
numbers.shift(); // [2, 3, 4, 5]
numbers.unshift(0); // [0, 2, 3, 4, 5]

// Array operations
let length = numbers.length;  // 5
let joined = numbers.join(", ");  // "0, 2, 3, 4, 5"
let found = numbers.includes(3);  // true
let index = numbers.indexOf(3);  // 2

// Array methods
numbers.sort((a, b) => a - b);  // [0, 2, 3, 4, 5]
numbers.reverse();  // [5, 4, 3, 2, 0]

// Array methods (functional)
let doubled = numbers.map(x => x * 2);  // [0, 4, 6, 8, 10]
let evens = numbers.filter(x => x % 2 === 0);  // [0, 2, 4]
let sum = numbers.reduce((acc, val) => acc + val, 0);  // 14

// Spread operator
let copy = [...numbers];
let combined = [...numbers, [6, 7, 8]];  // [0, 2, 3, 4, 5, 6, 7, 8]

C++ Arrays

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // Traditional arrays
    int numbers[5] = {1, 2, 3, 4, 5};
    std::string fruits[3] = {"apple", "banana", "orange"};

    // Vector (dynamic array)
    std::vector<int> dynamicNumbers = {1, 2, 3, 4, 5};
    dynamicNumbers.push_back(6);

    // Access elements
    int first = numbers[0];  // 1
    int last = numbers[4];  // 5

    // Vector operations
    int size = dynamicNumbers.size();  // 6
    dynamicNumbers.pop_back();  // Remove last element

    // Iteration
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // STL algorithms
    std::sort(numbers, numbers + 5);
    int max = *std::max_element(numbers, numbers + 5);
    int min = *std::min_element(numbers, numbers + 5);

    // 2D vectors
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    return 0;
}

🔧 Common Array Operations

Search Operations

# Python
index = numbers.index(3)  # Find index of element
found = 3 in numbers    # Check if element exists

# Java
int index = Arrays.binarySearch(numbers, 3);
boolean found = Arrays.asList(numbers).contains(3);

# JavaScript
let index = numbers.indexOf(3);
let found = numbers.includes(3);

Sorting Algorithms

# Python
numbers.sort()  # In-place sort
sorted_numbers = sorted(numbers)  # Returns new sorted array

# Custom sort
numbers.sort(key=lambda x: x % 3)  # Sort by remainder when divided by 3

Filtering and Mapping

# Python
evens = [x for x in numbers if x % 2 == 0]
squared = [x**2 for x in numbers]

# JavaScript
evens = numbers.filter(x => x % 2 === 0);
squared = numbers.map(x => x ** 2);

Array Statistics

# Python
import statistics
mean = statistics.mean(numbers)
median = statistics.median(numbers)
mode = statistics.mode(numbers)

---

📚 Learn Variable Theory →