Skip to main content


An algorithm is a set of instructions or rules that are followed to complete a task or solve a problem. Algorithms can be written in any language, including English, and can be designed to perform a wide variety of tasks, from simple mathematical operations to complex computer programs.

In mathematics and computer science, an algorithm is a finite set of well-defined instructions that are used to solve a problem or accomplish a task.

Algorithms can be designed using a variety of methods, including flowcharts, pseudocode, and formal languages such as C++ or Java.

  • Flowcharts are diagrams that show the steps in an algorithm using symbols and arrows.
  • Pseudocode is a combination of programming language and English that is designed to be easy to read and understand.
  • Formal languages are precise mathematical notation systems that are used to write algorithms in a more rigorous way.

Algorithm example

One of the most famous algorithms is the sorting algorithm known as quicksort. Quicksort sorts a list of items by choosing a pivot point and then partitioning the list into two sections: one section containing all items that are less than the pivot, and another section containing all items that are greater than the pivot.

The quicksort algorithm then sorts each of these sections recursively until the entire list is sorted.

Quicksort is an example of a divide-and-conquer algorithm, which means it breaks a problem down into smaller subproblems, solves those subproblems, and then combines the solutions to the subproblems to solve the original problem.

Qualities of a good algorithm

There are many qualities that make a good algorithm, but some of the most important ones are:

  • Correctness:  In order for an algorithm to be effective, it must produce the correct results for all inputs. This may seem like a straightforward requirement, but it can often be difficult to ensure that an algorithm always produces the right output. To do this, programmers must carefully test their algorithms against a wide variety of inputs, looking for any cases where the algorithm produces incorrect results. If an algorithm is found to be incorrect, programmers must then debug the algorithm and find the source of the error. Only by thoroughly testing and debugging their algorithms can programmers be confident that their algorithms are correct.
  • Efficiency: The algorithm should be as efficient as possible, using the least amount of resources (time, memory, etc.) possible. There are many factors to consider when determining the efficiency of an algorithm. The first is the time complexity, or how long the algorithm takes to run. The second is the space complexity, or how much memory the algorithm uses. There are trade-offs between time and space complexity; often, an algorithm with a better time complexity will use more space, and vice versa. It is important to choose the right trade-off for the situation at hand.
  • Simplicity: As anyone who has ever tried to read through a dense technical manual can attest, complexity is often the enemy of understanding. The same principle applies to algorithms: the simpler an algorithm is, the easier it will be to understand and implement. This is not to say that every algorithm needs to be painfully obvious; however, unnecessary complexity can often lead to errors and bugs. In addition, complex algorithms can be difficult to optimize and can slow down execution time. For these reasons, it is important to strive for simplicity whenever possible.
  • Flexibility: Any good algorithm should be able to handle a variety of inputs and different types of data. This flexibility is what allows the algorithm to be applied to many different situations and problems. Without it, the algorithm would be much more limited in its usefulness. This is why flexibility is such an important property of algorithms. It allows them to be used in a wide range of scenarios and makes them more powerful and versatile tools.
  • Robustness: An algorithm should be resistant to errors and able to recover from them gracefully. Robustness is typically measured by two metrics: error handling and recovery time. Recovery time is the amount of time it takes for an algorithm to recover from an error. Error handling is the ability of an algorithm to detect and correct errors. An algorithm that has a low recovery time and a high error handling rate is said to be more robust than one that has a high recovery time and a low error handling rate. Robustness is an important consideration in any engineering design, and it is especially important in the design of algorithms. 

By continuing to use the site, you agree to the use of cookies.