6 Common Algorithm Examples Every Beginner Should Know

When starting your journey in programming or computer science, one of the first concepts you’ll encounter is an algorithm. An algorithm is essentially a step-by-step procedure to solve a problem or accomplish a task. Think of it as a recipe in a cookbook: follow the steps correctly, and you’ll get the desired result.

In this article, we will explore common algorithm examples in detail, explain how they work, and show practical examples so you can start understanding algorithms in a user-friendly way.

1. Sorting Algorithms

Sorting algorithms are used to arrange data in a particular order, usually ascending or descending. Sorting is everywhere — from arranging your music playlist to ranking students by grades. Here are the most common examples:

a) Bubble Sort

Bubble Sort is one of the simplest sorting algorithms. It repeatedly compares adjacent elements and swaps them if they are in the wrong order. This process continues until the list is completely sorted.

How it works:

1. Compare the first two elements.
   
2. Swap them if the first is greater than the second.
   
3. Move to the next pair and repeat.
   
4. Repeat the whole process until no swaps are needed.

Example:
Array: [5, 2, 8, 1]

• Step 1: Compare 5 and 2 → swap → [2, 5, 8, 1]
  
• Step 2: Compare 5 and 8 → no swap → [2, 5, 8, 1]
  
• Step 3: Compare 8 and 1 → swap → [2, 5, 1, 8]
  
• Repeat → Final sorted array: [1, 2, 5, 8]

Pros: Easy to understand
Cons: Slow for large datasets

b) Selection Sort

Selection Sort works by finding the smallest (or largest) element from the unsorted part of the array and swapping it with the first unsorted element.

How it works:

1. Find the smallest element in the array.
   
2. Swap it with the first element.
   
3. Move the boundary one step forward.
   
4. Repeat until the array is sorted.

Example:
Array: [64, 25, 12, 22]

• Step 1: Smallest = 12 → swap with 64 → [12, 25, 64, 22]
  
• Step 2: Smallest in remaining = 22 → swap with 25 → [12, 22, 64, 25]
  
• Step 3: Smallest = 25 → swap with 64 → [12, 22, 25, 64]

Pros: Simple, fewer swaps than Bubble Sort
Cons: Still not efficient for large arrays

c) Merge Sort

Merge Sort is an efficient, divide-and-conquer sorting algorithm. It divides the array into halves, sorts each half, and then merges them back together in order.

How it works:

1. Divide the array into two halves.
   
2. Recursively sort each half.
   
3. Merge the sorted halves.

Example:
Array: [38, 27, 43, 3]

• Step 1: Divide → [38, 27] and [43, 3]
  
• Step 2: Sort halves → [27, 38] and [3, 43]
  
• Step 3: Merge → [3, 27, 38, 43]

Pros: Very efficient, O(n log n) time complexity
Cons: Uses extra memory

2. Searching Algorithms

Searching algorithms are used to find elements within a data structure.

a) Linear Search

Linear Search checks each element one by one until it finds the target. It’s simple but slow for large datasets.

Example:
Array: [5, 1, 3, 7]
Target: 3

• Check 5 → not 3
  
• Check 1 → not 3
  
• Check 3 → found!

Pros: Works on unsorted data
Cons: Slow for large arrays

b) Binary Search

Binary Search is much faster but requires a sorted array. It divides the array in half repeatedly until it finds the target.

How it works:

1. Find the middle element.
   
2. If it’s the target, return it.
   
3. If target < middle, search left half.
   
4. If target > middle, search right half.
   
5. Repeat until found.

Example:
Array: [1, 3, 5, 7, 9]
Target: 5

• Middle element = 5 → found!

Pros: Very fast, O(log n) time complexity
Cons: Requires sorted array

You may also like to read this:
Beginner Algorithm Guides: Learn Algorithms Step By Step

Top Algorithm Problem Solving Tips For Programmers

Sorting And Searching Algorithms Explained For Beginners

Step By Step Algorithm Tutorials: Learn Algorithms Easily

3. Recursive Algorithms

A recursive algorithm solves a problem by calling itself with smaller inputs until reaching a base case.

Example: Factorial Calculation

• 5! = 5 × 4 × 3 × 2 × 1
  
• Recursive function:

def factorial(n):

    if n == 1:

        return 1

    else:

        return n * factorial(n-1)

Pros: Elegant for problems with repeated patterns
Cons: Can use a lot of memory if recursion is deep

4. Greedy Algorithms

Greedy algorithms make locally optimal choices at each step with the hope of finding a global optimum.

Example: Coin Change Problem

• You need to make 47 cents using coins [25, 10, 5, 1]
  
• Step 1: Pick largest coin ≤ 47 → 25 → remaining = 22
  
• Step 2: Pick 10 → remaining = 12
  
• Step 3: Pick 10 → remaining = 2
  
• Step 4: Pick 1 → remaining = 1 → Pick 1 → done

Pros: Fast and simple for some problems
Cons: Doesn’t always guarantee the best solution

5. Dynamic Programming Algorithms

Dynamic Programming (DP) solves complex problems by breaking them into smaller overlapping subproblems and storing results to avoid repeated work.

Example: Fibonacci Sequence

• Formula: Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)
  
• Using DP:

fib = [0, 1]

for i in range(2, n+1):

    fib.append(fib[i-1] + fib[i-2])

Pros: Highly efficient for problems with overlapping subproblems
Cons: Requires careful planning and memory

6. Graph Algorithms

Graphs are used in networks, social media, maps, and many other areas.

a) Depth-First Search (DFS)

• Explores as far as possible along each branch before backtracking.

b) Breadth-First Search (BFS)

• Explores all neighbors before moving to the next level.

c) Dijkstra’s Algorithm

• Finds the shortest path between nodes in a weighted graph.

Why Learning Common Algorithms is Important

Understanding common algorithm examples is not just for coding interviews. Algorithms:

• Improve your problem-solving skills
  
• Make your code efficient
  
• Help you design better software
  
• Give you a foundation for advanced topics in AI, data science, and more

Conclusion

Algorithms are the building blocks of programming and computer science. By learning common algorithm examples such as sorting, searching, recursion, greedy, dynamic programming, and graph algorithms, you can solve real-world problems efficiently. 

Start with simple algorithms like Bubble Sort and Linear Search, and gradually explore advanced ones like Merge Sort and Dijkstra’s Algorithm. Practice is key — the more you try them out, the more intuitive they become.

FAQs: Common Algorithm Examples