Algorithms

Whenever we want a computer to solve a problem, we need to give it a set of instructions. The computer doesn't simply understand what we want; we need to tell it what to do and in what order.

These step-by-step instructions are called an algorithm.

In simple words, an algorithm is a step-by-step procedure used to solve a problem or perform a task.

For example, suppose you want to find the largest number from a list:

10, 25, 7, 40, 18

You could start with 10, compare it with the next number, keep the larger one, and continue until you've checked every number.

The steps might look like this:

Start with 10
Compare with 25 → 25 is larger
Compare with 7  → 25 is larger
Compare with 40 → 40 is larger
Compare with 18 → 40 is larger

Answer → 40

Those steps are an algorithm.

Why Do We Need Algorithms?

Computers are very fast, but they still need clear instructions.

Imagine you're building a food delivery application. When a user orders food, the application needs to perform several steps:

Receive the order
      ↓
Find the restaurant
      ↓
Find an available delivery person
      ↓
Calculate the route
      ↓
Track the delivery

Each of these tasks can involve different algorithms.

A good algorithm can make a program faster and more efficient, while a poor algorithm can make the same program unnecessarily slow.

This becomes especially important when we're working with large amounts of data.

A Simple Example

Let's say we have an array:

int[] numbers = {10, 25, 7, 40, 18};

We want to find 40.

One simple algorithm is linear search. We check each element one by one:

for (int number : numbers) {
    if (number == 40) {
        System.out.println("Found");
        break;
    }
}

The algorithm is basically:

Start from the first element
        ↓
Compare it with the target
        ↓
If it matches → stop
        ↓
Otherwise → move to the next element
        ↓
Repeat

The code is just the implementation of the algorithm.

Algorithm vs Program

These two terms are related, but they're not the same.

An algorithm is the logic or steps used to solve a problem.

A program is the actual implementation of that solution using a programming language.

For example, the algorithm for finding the largest number could be:

1. Assume the first number is the largest.
2. Compare it with the next number.
3. If the next number is larger, update the largest number.
4. Continue until all numbers are checked.
5. Return the largest number.

We can then implement those steps in Java:

int[] numbers = {10, 25, 7, 40, 18};

int largest = numbers[0];

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

System.out.println(largest);

Output:

40

So the algorithm is the idea and steps, while the Java code is the implementation.

Characteristics of a Good Algorithm

A good algorithm should have some important characteristics.

It should be clear, meaning we should be able to understand what each step does.

It should have a definite result. The instructions shouldn't be ambiguous.

It should eventually finish rather than continuing forever.

And most importantly, it should solve the problem efficiently.

For example, if two algorithms solve the same problem but one takes much less time for large inputs, the more efficient algorithm is usually the better choice.

Algorithm Efficiency

Suppose we need to find a name in a list of 10 people.

Almost any reasonable approach will be fast enough.

But what if the list contains 10 million people?

Now the efficiency of our algorithm matters a lot.

This is why, while learning DSA, you'll often hear about time complexity and space complexity.

Time complexity helps us understand how the running time of an algorithm grows as the input becomes larger.

Space complexity helps us understand how much additional memory an algorithm needs.

For example, an algorithm that checks every element in a list of n elements may take up to n steps.

We commonly describe this as:

O(n)

We'll learn Big O and complexity properly in the upcoming topics.

Different Types of Algorithms

There isn't just one type of algorithm. Different problems require different approaches.

Some important categories you'll encounter in DSA include:

• Searching algorithms

• Sorting algorithms

• Recursive algorithms

• Divide and conquer

• Greedy algorithms

• Backtracking

• Dynamic programming

• Graph algorithms

For example, searching algorithms are used to find elements, while sorting algorithms arrange elements in a particular order.

Later, we'll study these approaches individually and understand when each one is useful.

Real-Life Example

Think about using Google Maps to travel from one city to another.

You give it:

Starting point → Destination

The application has to figure out a suitable route.

It doesn't randomly try roads until it finds one. It uses algorithms to analyze roads, distances, and other information to calculate a route.

The same idea applies to many other applications.

When Netflix recommends a movie, when a search engine finds relevant results, or when an application sorts thousands of products, algorithms are working behind the scenes.

How to Approach an Algorithm Problem

When you get a DSA problem, don't immediately start writing code.

First, understand exactly what the problem is asking.

Then think about:

What is the input?
        ↓
What should the output be?
        ↓
What steps can solve the problem?
        ↓
Can I make those steps more efficient?

For example, if you're asked to find the largest number in an array, first think about how you would do it manually.

Once you understand the logic, convert those steps into Java code.

This habit will make solving DSA problems much easier.

The Main Idea

An algorithm is simply a well-defined sequence of steps used to solve a problem.

You don't need to think of algorithms as something mysterious or extremely complicated. Even something as simple as finding the largest number in an array is an algorithm.

As you progress through DSA, the problems will become more challenging, and you'll learn different techniques for solving them efficiently.

The real skill is not just knowing an algorithm. It's being able to look at a problem and think:

"What approach can I use to solve this problem efficiently?"