Introduction to Data Structures and Algorithms

Why this lesson matters

This is the first step in your Data Structures and Algorithms journey.

For MAANG-style interviews, you are rarely judged only on whether code compiles. Interviewers want to see how you:

• Model a problem
• Choose the right way to store data
• Design clear steps to solve it
• Reason about speed and memory
• Explain trade-offs out loud

In this lesson, we will build the mental foundation for everything that follows: arrays, linked lists, trees, graphs, dynamic programming, hashing, and system design.

Data structures vs algorithms

A data structure is a way to organize and store data so it can be accessed and modified efficiently.

An algorithm is a step-by-step process for solving a problem.

Think of it like cooking:

• Data structure: the pantry, shelves, containers, and labels
• Algorithm: the recipe you follow to prepare a dish

In code, the two work together. A great algorithm can become slow if the data is stored poorly. A good data structure can make a simple algorithm surprisingly powerful.

Which statement best separates a data structure from an algorithm?

Example: finding a maximum

Suppose we have several scores and want the highest one.

The data is stored in a simple Java array. The algorithm scans through the values and keeps track of the largest value seen so far.

Do not worry if arrays still feel new. We will study them properly in the next lesson. For now, focus on the idea: data is stored somewhere, and an algorithm performs steps on it.

```java
public class Main {
    public static int findMax(int[] numbers) {
        if (numbers.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }

        int max = numbers[0];

        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
        }

        return max;
    }

    public static void main(String[] args) {
        int[] scores = {72, 91, 85, 99, 64};
        System.out.println("Highest score: " + findMax(scores));
    }
}
```

True or false: An algorithm can produce the correct answer but still be a poor choice if it is too slow or uses too much memory.

Same answer, different work

Two algorithms can solve the same problem while doing very different amounts of work.

For example, to compute the sum from 1 to n, one approach loops through every number. Another uses a math formula.

This is the beginning of complexity analysis: asking how the work grows as the input grows. We will use this mindset constantly throughout the course.

```java
public class Main {
    public static long loopSum(long n) {
        long sum = 0;
        for (long i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    public static long formulaSum(long n) {
        return n * (n + 1) / 2;
    }

    public static void main(String[] args) {
        long n = 1_000_000;

        System.out.println("Loop sum: " + loopSum(n));
        System.out.println("Formula sum: " + formulaSum(n));
    }
}
```

A way of organizing and storing data so it can be accessed and modified efficiently is called a ____.

There is rarely one perfect choice

A key DSA habit is asking: what operations matter most?

For a problem, you may care about:

• Fast lookup
• Fast insertion
• Fast deletion
• Preserving order
• Saving memory
• Simpler implementation

One structure may be excellent for searching but expensive for insertion. Another may insert quickly but make searching harder.

Interviewers want to hear this reasoning. The answer is not always just code; it is also the explanation behind your choices.

A repeatable problem-solving process

When you face a DSA interview problem, use a consistent workflow:

1. Clarify the problem and constraints
2. Work through examples by hand
3. Start with a simple approach
4. Analyze time and memory
5. Improve using better structures or logic
6. Implement cleanly in Java
7. Test edge cases

This keeps you calm and structured. Even if the problem is unfamiliar, the process is familiar.

Your foundation is set

You now have the core vocabulary:

• Data structures organize data
• Algorithms solve problems step by step
• Efficiency matters as input grows
• Trade-offs guide good design choices

Next, we will start with one of the most important building blocks in DSA: Arrays and Strings. You will begin practicing how data layout affects access, updates, and common interview patterns in Java.