Arrays are one of the most fundamental data structures in computer science.
They are the building blocks for many more complex data structures. If you want to be good at data structures and algorithms to smash MAANG interviews, you have to understand how each data structure works. And how each one of them handles specific operations such as inserting, retrieving, and deleting.

The Fundamentals

At their core, arrays are contiguous blocks of memory that store elements in sequential order. This simple organization provides two key benefits:

1. Direct access to any element through indexing
2. Efficient memory usage through spatial locality

Memory Organization

Arrays operate at a very low level in the computing stack, close to machine language. When you create an array, the system allocates a continuous block of memory large enough to hold all its elements. Each element occupies a fixed amount of space, determined by the data type being stored.

Performance Characteristics

O(1) Access Time

One of the most powerful features of arrays is their constant-time (O(1)) access to elements. When you request an element at index i, the computer can calculate its exact memory location using a simple formula:

element_address = base_address + (index × element_size)

This direct calculation means that accessing any element takes the same amount of time, regardless of the array's size or the element's position.

Cache Locality

Arrays excel at cache locality, providing a significant performance advantage in practice. When the CPU loads an array element from the main memory into its cache, it also loads neighboring elements. This behavior, known as spatial locality, means that subsequent accesses to nearby elements are much faster since they're already in the cache.

Consider this practical example:

• Reading from RAM might take 100ns
• Reading from CPU cache might take 1ns
• When iterating through an array sequentially, most elements after the first will be read from the cache

This cache-friendly behavior makes arrays particularly efficient for operations that process elements sequentially or access nearby elements frequently.

Dynamic Arrays

Modern programming languages typically implement dynamic arrays (like Java's ArrayList or Python's lists or Ruby's Array) that can grow as needed. Here's how they work:

Initial Capacity

Dynamic arrays start with a pre-allocated capacity (for example 8 or 16 elements) rather than size zero. Why? Simply to avoid frequent resizing operations during the array's early use.

Resizing Operations

When an array needs to grow beyond its current capacity:

1. A new, larger block of memory is allocated (typically 2x the current size)
2. Existing elements are copied to the new location
3. The old memory is freed

Even if resizing operations is expensive, its cost is amortized over many operations. So that at the end of the day we still have an average O(1) time for append operations.