What are Algorithms?

Algorithms are step-by-step procedures for solving a problem in a finite number of steps. Algorithms are often used to help computers make decisions, and in programming, you can also use algorithms to automate tasks.

In this article, we will explore what algorithms are in great detail. But, before we do that, let’s quickly explore the topics listed under the table of contents (TOC) that we will cover in this article.

Table of contents (TOC)

• What are algorithms?
• How do algorithms work?
• Characteristics of algorithms
• Types of algorithms
  • Greedy
  • Brute Force
  • Recursive
  • Hashing
  • Searching
  • Backtracking
  • Divide and Conquer
• Prerequisites for creating an algorithm
• How do you create algorithms?
• Ways in which algorithms can be expressed
• Advantages of algorithms
• Disadvantages of algorithms

What are algorithms? 

Algorithm definition: An algorithm refers to a series of step-by-step procedures or a collection of guidelines or rules to follow in order to complete a specific task or solve a specific problem.

If we talk about algorithms in programming, algorithms tell a computer how to accomplish a particular task. A computer can accomplish a task by following the instructions provided in an algorithm form, such as what steps to execute, in what order those steps should be executed, etc. Let’s understand what an algorithm is, in a better way, with the help of a simple example.

Algorithm example

Suppose you want to perform a binary search of a particular array, say A. These will be the steps involved, and the algorithm for this will be something like this:

1. Sort the array A, say, in ascending order.
2. Find the midpoint of sorted array A.
3. Compare the midpoint of the sorted array, A, to the interest value.
4. If the midpoint in array A is larger than the value, perform a binary search on the right half of the array. And, if the midpoint is smaller than the value, perform a binary search on the left half of the array.
5. Continue to perform the above steps until the midpoint value equals the interest value.

How do algorithms work? 

Working of algorithms is very easy, and it will be much easier to understand with the help of the image shown:

The image shows that algorithms take input and apply each step to generate an output. To put it simply, algorithms function through input and output. Let’s look at an example to help you understand better.

When you decide to search the web for information about algorithms, you open a search engine (which, in this case, is a type of algorithm) and type your query into it. After receiving the query, the search engine searches its database for articles that contain the words in the query. Once the search is complete, it outputs the results.

Characteristics of algorithms

Algorithms can be written in plain simple English language so that it is easily understandable even by non-programmers. And algorithms are programming languages independent in nature.

Now, a question arises: Are all the written programming instructions algorithms? No, they are not. So how do you know which programming instructions are algorithms and which aren’t? You can quickly solve this problem by comparing the characteristics of those instructions. If it corresponds to the characteristics of an algorithm, it is one of them. So, without further ado, let us discuss algorithmic characteristics.

• Input: An algorithm must have an input, and that input should not be zero (0).
• Output: At the end, you must receive at least one output.
• Clear instructions: An algorithm must have thorough and clear instructions.
• Finiteness: An algorithm must consist of a finite number of steps, i.e., it must be finite and should terminate.
• Workable: The algorithms must be simple and straightforward and should not include any future technology or anything else. It should be executable with the available resources.
• Language independent: Algorithms should not be dependent on any programming language. In simple terms, you should receive the same output, even after running on different programming languages.

Types of algorithms 

There are numerous algorithms, but we will discuss some of the most important ones in this article, such as:

• Greedy algorithm: It is a method of problem-solving in which the best option that is currently available is chosen without respect for something like the end result.
• Brute force algorithm: It is a method that seeks out all possible solutions in order to find a reasonable solution to a specific problem.
• Recursive algorithm: It is a method in which the algorithm instructs itself to sort a smaller portion of the array before merging the partially sorted outcomes.
• Hashing algorithm: It is a method in which an alogorithm maps data of any size to a fixed-size hash. It’s a mathematical formula.
• Searching algorithm: It is a method in which an algorithm searches for or retrieves an element from whatever data structure within which it is stored.
• Backtracking algorithm: It is a method of solving a computational problem that involves considering every possible combination.
• Divide and Conquer algorithm: It is a method of breaking down a problem into relatively small sub-problems.

Prerequisites for creating an algorithm

Because we already discussed the characteristics of an algorithm in the preceding section, understanding what are the prerequisites of an algorithm will be much easier for you. The following are the prerequisites that need to be completed in order to create an algorithm.

• 1st step: Identify the problem you wish to solve.
• 2nd step: Decide the problem’s constraints that you must consider to solve the problem.
• 3rd step: Decide the input.
• 4th step: Decide what output you need.
• 5th step: We must remember that the solution to the problem should be within the constraints decided in the 2nd step.

Let’s take an example to understand it in a better way:

Suppose you want to multiply two numbers, so the algorithm for that will be something like this:

• 1st step: Identify the problem you wish to solve. (Multiply two numbers)
• 2nd step: Decide the problem’s constraints that you must consider to solve the problem. (Numbers should be in the form of digits and should not contain any characters, such as 4b*5a).
• 3rd step: Decide the input. (Let’s take input as 4 and 5)
• 4th step: Decide what output you need. (Value after multiplication)
• 5th step: We must remember that the solution to the problem should be within the constraints decided in the 2nd step. (You can use the “*” operator, as it is allowed per the constraints mentioned in the 2nd step).

How to create algorithms?

Here are the steps to create an algorithm:

• 1st step: Fulfill the prerequisites
• 2nd strep: Design the algorithm
• 3rd step: Test the algorithm

Let’s continue with the example discussed in the above section, as we have already fulfilled the prerequisites part. So, continuing with the second step:

Design the algorithm

Let’s design an algorithm in simple English for the above problem:

1. START
2. Declare two integer variables, num1 and num2.
3. Take the two numbers to be multiplied as inputs in variables num1 and num2, respectively.
4. Declare an integer variable “multiply” to store the resultant multiplication of the two numbers.
5. Multiply the two numbers and store the result in the variable “multiply.”
6. Print the multiplied value.
7. END

Test the algorithm

Now, once the design phase is completed, let’s test this algorithm in java language.

The output will be:

Ways in which algorithms can be expressed 

There are three ways in which you can express algorithms, and those three ways are:

• Natural English: It is one of the ways to express an algorithm in the natural English language. But, sometimes, it gets difficult to understand the algorithm because of unclear or misleading information.
• Flow chart: It is a better alternative to express algorithms from the natural English language. In this, you can express the steps by making a graphical or pictorial representation of those steps.
• Pseudo code: It is the best way to express algorithms because it uses annotations and informative text written in plain English that is very similar to actual code but lacks syntax like any programming language.

Advantages of algorithms

There are various advantages an algorithm, and some of those advantages are:

• An algorithm follows a specific procedure.
• Algorithms serve as a program’s blueprint and aid in program development.
• Each step in an algorithm has its logical sequence, making it simple to debug.
• Because an algorithm is a stepwise representation of solutions to a given problem, it is simple to understand.
• As algorithms are not dependent on any programming language, they are simple to understand, even for those without programming experience.

Disadvantages of algorithms

Some of the disadvantages of an algorithm are:

• Branching and looping are complicated in algorithms.
• Understanding complex logic via algorithms can be challenging.
• Algorithms take time to develop, and large tasks are difficult to incorporate into algorithms.

Conclusion

After reading this article, you should be able to answer the question, “What are algorithms?” You will also be able to write better code and solve complex problems through algorithms.