Learn Data Structures

What Is DSA?

A data structure is a way of organizing and storing data so it can be accessed and modified efficiently, while an algorithm is a precise, step-by-step procedure for solving a problem or transforming that data into a useful result. DSA is the combined study of both: choosing a shape for your data and a procedure that operates on that shape well.

The same task can run in a fraction of a second or take minutes depending purely on the data structure and algorithm chosen. As data grows from hundreds to millions of records, a poor choice can turn a snappy application into one that grinds to a halt - which is why DSA sits at the core of both technical interviews and real-world system design.

Data Structures at a Glance

• Arrays - contiguous memory with instant index access
• Linked Lists - nodes connected by pointers, flexible size
• Stacks and Queues - restricted-order access (LIFO and FIFO)
• Trees - hierarchical parent-child relationships
• Hash Tables - key-value storage with near-instant lookup
• Graphs - nodes and edges representing networks of relationships

Beyond organizing values into structures, DSA is also about algorithms - searches, sorts, recursive procedures, and more - and about a shared vocabulary for measuring how much work an algorithm does as its input grows, known as Big O notation. Big O describes the shape of an algorithm's growth rather than an exact running time, letting you compare approaches without running code on a specific machine.

def linear_search(numbers, target):
    for index in range(len(numbers)):
        if numbers[index] == target:
            return index
    return -1

data = [4, 2, 9, 7, 5]
result = linear_search(data, 7)
print(result)  # 3

Trace linear_search(data, 7) on data = [4, 2, 9, 7, 5] by hand: at index 0 it compares 4 against 7 (no match), at index 1 it compares 2 against 7 (no match), at index 2 it compares 9 against 7 (no match), and at index 3 it compares 7 against 7 - a match - so the function returns 3 immediately without ever looking at index 4. Because linear search stops the moment it finds the value, its worst case (a missing value, or one at the very last position) still has to inspect every one of the n elements once, giving it O(n) time complexity.

def linear_search_counted(numbers, target):
    comparisons = 0
    for index in range(len(numbers)):
        comparisons += 1
        if numbers[index] == target:
            return index, comparisons
    return -1, comparisons

data = [4, 2, 9, 7, 5, 1, 8]
index, comparisons = linear_search_counted(data, 1)
print(f'found at index {index} after {comparisons} comparisons')
# found at index 5 after 6 comparisons

def build_list(n):
    return list(range(n))

def count_steps(n):
    numbers = build_list(n)
    steps = 0
    for value in numbers:
        steps += 1
    return steps

for n in [10, 20, 40, 80]:
    print(f'n={n} -> steps={count_steps(n)}')
# n=10 -> steps=10
# n=20 -> steps=20
# n=40 -> steps=40
# n=80 -> steps=80