Create an array

In our Algorithm Beginners’ Tutorial series, the previous article introduced recursive algorithms, where we discussed how to solve common problems using recursion. Today, we’ll delve into a fundamental data structure: the array. After covering the core concepts and characteristics of arrays, we’ll lay a solid foundation for our upcoming discussion on linked lists.

Basic Concepts of Arrays

An array is a linear data structure used to store a collection of elements of the same type. Compared with other data structures, arrays exhibit several distinctive features:

1. Fixed Size: When an array is created, its size must be specified—and once set, it cannot be changed.
2. Contiguous Memory Storage: Array elements are stored in adjacent memory locations, enabling fast access to any element via its index.
3. Random Access: Because elements reside contiguously in memory, any element can be accessed directly using its index, achieving $O(1)$ time complexity for access.

Creating and Accessing Arrays

The syntax for creating arrays varies across programming languages. In Python, for example, arrays are commonly implemented using lists.

# Create an array
arr = [1, 2, 3, 4, 5]

# Access elements in the array
print(arr[0])  # Output: 1
print(arr[2])  # Output: 3

In this example, we define an array arr containing five integers and access individual elements using their indices.

Advantages and Disadvantages of Arrays

Arrays possess several clear strengths—and limitations:

Advantages

• Fast Access: Due to contiguous memory layout, elements can be retrieved in $O(1)$ time using their index.
• Efficient Memory Usage: Contiguous allocation enables effective cache utilization, improving overall access speed.

Disadvantages

• Fixed Size: Once declared, an array’s capacity cannot be altered—dynamic resizing is not supported natively.
• Inefficient Insertion and Deletion: Inserting or removing elements requires shifting subsequent elements; in the worst case, this incurs $O(n)$ time complexity.

Practical Use Case: Computing the Average

Arrays are widely used in everyday programming. Below is a simple example demonstrating how to compute the average of a set of numbers using an array:

# Compute the average of a list of numbers
def calculate_average(numbers):
    total = 0
    count = len(numbers)
    
    for num in numbers:
        total += num
        
    return total / count if count > 0 else 0

# Example array
data = [10, 20, 30, 40, 50]
average = calculate_average(data)
print(f"Average of the array: {average}")  # Output: Average of the array: 30.0

Here, we define a function calculate_average that accepts an array and computes its arithmetic mean by summing all elements and dividing by the count.

Sorting Arrays

Sorting is a frequent operation performed on arrays. As an illustrative example, here's a basic implementation of bubble sort:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]  # Swap
    return arr

# Example
unsorted_arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(unsorted_arr)
print(f"Sorted array: {sorted_arr}")  # Output: Sorted array: [11, 12, 22, 25, 34, 64, 90]

This example implements the classic bubble sort algorithm to transform an unsorted array into ascending order.

Summary

In this article, we explored the array—a foundational data structure—covering its essential properties, advantages and disadvantages, and practical applications. Arrays serve as the bedrock for many advanced data structures and algorithms; understanding them thoroughly is indispensable when studying more complex constructs like linked lists.

In the next article, we’ll continue our exploration with the linked list data structure, comparing it with arrays and examining its unique use cases. If you’d like to dive deeper into other sophisticated algorithms, stay tuned for more installments in our tutorial series!