Skip to content

Asymptotic Analysis

Worst, Average and Best Case Analysis of Algorithms

Last Updated : 11 Nov, 2024

In the previous post, we discussed how Asymptotic analysis overcomes the problems of the naive way of analyzing algorithms. Now let us learn about What is Worst, Average, and Best cases of an algorithm:

1. Worst Case Analysis (Mostly used)

In the worst-case analysis, we calculate the upper bound on the running time of an algorithm. We must know the case that causes a maximum number of operations to be executed.
For Linear Search, the worst case happens when the element to be searched (x) is not present in the array. When x is not present, the search() function compares it with all the elements of arr[] one by one.
This is the most commonly used analysis of algorithms (We will be discussing below why). Most of the time we consider the case that causes maximum operations.

2. Best Case Analysis (Very Rarely used)

In the best-case analysis, we calculate the lower bound on the running time of an algorithm. We must know the case that causes a minimum number of operations to be executed.
For linear search, the best case occurs when x is present at the first location. The number of operations in the best case is constant (not dependent on n). So the order of growth of time taken in terms of input size is constant.

3. Average Case Analysis (Rarely used)

In average case analysis, we take all possible inputs and calculate the computing time for all of the inputs. Sum all the calculated values and divide the sum by the total number of inputs.
We must know (or predict) the distribution of cases. For the linear search problem, let us assume that all cases are uniformly distributed (including the case of x not being present in the array). So we sum all the cases and divide the sum by (n+1). We take (n+1) to consider the case when the element is not present.

Why is Worst Case Analysis Mostly Used?

Average Case : The average case analysis is not easy to do in most practical cases and it is rarely done. In the average case analysis, we need to consider every input, its frequency and time taken by it which may not be possible in many scenarios

Best Case : The Best Case analysis is considered bogus. Guaranteeing a lower bound on an algorithm doesn’t provide any information as in the worst case, an algorithm may take years to run.

Worst Case: This is easier than average case and gives an upper bound which is useful information to analyze software products.

Interesting information about asymptotic notations:

A) For some algorithms, all the cases (worst, best, average) are asymptotically the same. i.e., there are no worst and best cases.

Example: Merge Sort does order of n log(n) operations in all cases.
B) Where as most of the other sorting algorithms have worst and best cases.

Example 1: In the typical implementation of Quick Sort (where pivot is chosen as a corner element), the worst occurs when the input array is already sorted and the best occurs when the pivot elements always divide the array into two halves.
Example 2: For insertion sort, the worst case occurs when the array is reverse sorted and the best case occurs when the array is sorted in the same order as output.

Examples with their complexity analysis:

1. Linear search algorithm:

C++

#include <iostream> #include <vector> using namespace std;  // Linearly search target in arr. // If target is present, return the index; // otherwise, return -1 int search(vector<int>& arr, int x) {     for (int i = 0; i < arr.size(); i++) {         if (arr[i] == x)             return i;     }     return -1; }  int main() {     vector<int> arr = {1, 10, 30, 15};     int x = 30;     cout << search(arr, x);     return 0; }

C

#include <stdio.h> #include <stdbool.h>  // Linearly search target in arr. // If target is present, return the index; // otherwise, return -1 int search(int arr[], int size, int x) {     for (int i = 0; i < size; i++) {         if (arr[i] == x)             return i;     }     return -1; }  int main() {     int arr[] = {1, 10, 30, 15};     int size = sizeof(arr) / sizeof(arr[0]);     int x = 30;     printf("%d", search(arr, size, x));     return 0; }

Java

import java.util.Arrays;  // Linearly search target in arr. // If target is present, return the index; // otherwise, return -1 public class GfG {     public static int search(int[] arr, int x) {         for (int i = 0; i < arr.length; i++) {             if (arr[i] == x)                 return i;         }         return -1;     }      public static void main(String[] args) {         int[] arr = {1, 10, 30, 15};         int x = 30;         System.out.println(search(arr, x));     } }

Python

# Linearly search target in arr. # If target is present, return the index; # otherwise, return -1 def search(arr, x):     for i in range(len(arr)):         if arr[i] == x:             return i     return -1  if __name__ == '__main__':     arr = [1, 10, 30, 15]     x = 30     print(search(arr, x))

C#

using System;  public class Program {        // Linearly search target in arr.     // If target is present, return the index;     // otherwise, return -1     public static int Search(int[] arr, int target) {         for (int i = 0; i < arr.Length; i++) {             if (arr[i] == target)                 return i;         }         return -1;     }      public static void Main() {         int[] arr = {1, 10, 30, 15};         int target = 30;         Console.WriteLine(Search(arr, target));     } }

JavaScript

// Linearly search target in arr. // If target is present, return the index; // otherwise, return -1 function search(arr, x) {     for (let i = 0; i < arr.length; i++) {         if (arr[i] === x)             return i;     }     return -1; }  const arr = [1, 10, 30, 15]; const x = 30; console.log(search(arr, x));

Output

Best Case: Constant Time irrespective of input size. This will take place if the element to be searched is on the first index of the given list. So, the number of comparisons, in this case, is 1.
Average Case: Linear Time, This will take place if the element to be searched is at the middle index (in an average search) of the given list.
Worst Case: The element to be searched is not present in the list

2. Special Array Sum : In this example, we will take an array of length (n) and deals with the following cases :

If (n) is even then our output will be 0
If (n) is odd then our output will be the sum of the elements of the array.

Below is the implementation of the given problem:

C++

#include <iostream> #include <vector> using namespace std;  int getSum(const vector<int>& arr1) {     int n = arr1.size();     if (n % 2 == 0) // (n) is even         return 0;          int sum = 0;     for (int i = 0; i < n; i++) {         sum += arr1[i];     }     return sum; // (n) is odd }  int main() {        // Declaring two vectors, one with an odd length     // and the other with an even length     vector<int> arr1 = {1, 2, 3, 4};     vector<int> arr2 = {1, 2, 3, 4, 5};     cout << getSum(arr1) << endl;      cout << getSum(arr2) << endl;     return 0; }

C

#include <stdio.h> #include <stdlib.h>  int getSum(const int* arr1, int n) {     if (n % 2 == 0) // (n) is even         return 0;          int sum = 0;     for (int i = 0; i < n; i++) {         sum += arr1[i];     }     return sum; // (n) is odd }  int main() {     // Declaring two arrays, one with an odd length     // and the other with an even length     int arr1[] = {1, 2, 3, 4};     int arr2[] = {1, 2, 3, 4, 5};     printf("%d\n", getSum(arr1, 4));     printf("%d\n", getSum(arr2, 5));     return 0; }

Java

import java.util.Arrays;  public class Main {     public static int getSum(int[] arr1) {         int n = arr1.length;         if (n % 2 == 0) // (n) is even             return 0;                  int sum = 0;         for (int i = 0; i < n; i++) {             sum += arr1[i];         }         return sum; // (n) is odd     }      public static void main(String[] args) {         // Declaring two arrays, one with an odd length         // and the other with an even length         int[] arr1 = {1, 2, 3, 4};         int[] arr2 = {1, 2, 3, 4, 5};         System.out.println(getSum(arr1));         System.out.println(getSum(arr2));     } }

Python

def getSum(arr1):     n = len(arr1)     if n % 2 == 0:  # (n) is even         return 0          sum = 0     for i in range(n):         sum += arr1[i]     return sum  # (n) is odd  if __name__ == '__main__':     # Declaring two lists, one with an odd length     # and the other with an even length     arr1 = [1, 2, 3, 4]     arr2 = [1, 2, 3, 4, 5]     print(getSum(arr1))     print(getSum(arr2))

C#

using System;  class Program {     static int getSum(int[] arr1) {         int n = arr1.Length;         if (n % 2 == 0) // (n) is even             return 0;                  int sum = 0;         for (int i = 0; i < n; i++) {             sum += arr1[i];         }         return sum; // (n) is odd     }      static void Main() {         // Declaring two arrays, one with an odd length         // and the other with an even length         int[] arr1 = {1, 2, 3, 4};         int[] arr2 = {1, 2, 3, 4, 5};         Console.WriteLine(getSum(arr1));         Console.WriteLine(getSum(arr2));     } }

JavaScript

function getSum(arr1) {     const n = arr1.length;     if (n % 2 === 0) // (n) is even         return 0;          let sum = 0;     for (let i = 0; i < n; i++) {         sum += arr1[i];     }     return sum; // (n) is odd }  // Declaring two arrays, one with an odd length // and the other with an even length const arr1 = [1, 2, 3, 4]; const arr2 = [1, 2, 3, 4, 5]; console.log(getSum(arr1)); console.log(getSum(arr2));

PHP

<?php function getSum($arr1) {     $n = count($arr1);     if ($n % 2 == 0) // (n) is even         return 0;          $sum = 0;     for ($i = 0; $i < $n; $i++) {         $sum += $arr1[$i];     }     return $sum; // (n) is odd }  // Declaring two arrays, one with an odd length // and the other with an even length $arr1 = [1, 2, 3, 4]; $arr2 = [1, 2, 3, 4, 5]; echo getSum($arr1) . "\n"; echo getSum($arr2) . "\n"; ?>

Output

0 15

Time Complexity Analysis:

Best Case: The order of growth will be constant because in the best case we are assuming that (n) is even.
Average Case: In this case, we will assume that even and odd are equally likely, therefore Order of growth will be linear
Worst Case: The order of growth will be linear because in this case, we are assuming that (n) is always odd.

Next Articles to Read

Reference books:

“Introduction to Algorithms” by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein is a comprehensive guide to algorithm analysis, including worst, average, and best case analysis.
“Algorithm Design” by Jon Kleinberg and Éva Tardos provides a modern approach to algorithm design, with a focus on worst case analysis.
“The Art of Computer Programming” by Donald Knuth is a classic text on algorithms and programming, which includes a detailed discussion of worst case analysis.
“Algorithms Unlocked” by Thomas H. Cormen provides a gentle introduction to algorithm analysis, including worst, average, and best case analysis.

Asymptotic Analysis

kartik

Improve

Article Tags :

Practice Tags :

Algorithms

Similar Reads

Analysis of Algorithms

Analysis of Algorithms is a fundamental aspect of computer science that involves evaluating performance of algorithms and programs. Efficiency is measured in terms of time and space. Basics on Analysis of Algorithms:Why is Analysis Important?Order of GrowthAsymptotic Analysis Worst, Average and Best

Complete Guide On Complexity Analysis - Data Structure and Algorithms Tutorial

Complexity analysis is defined as a technique to characterise the time taken by an algorithm with respect to input size (independent from the machine, language and compiler). It is used for evaluating the variations of execution time on different algorithms. What is the need for Complexity Analysis?

Why is Analysis of Algorithm important?

Why is Performance of Algorithms Important ? There are many important things that should be taken care of, like user-friendliness, modularity, security, maintainability, etc. Why worry about performance? The answer to this is simple, we can have all the above things only if we have performance. So p

Types of Asymptotic Notations in Complexity Analysis of Algorithms

We have discussed Asymptotic Analysis, and Worst, Average, and Best Cases of Algorithms. The main idea of asymptotic analysis is to have a measure of the efficiency of algorithms that don't depend on machine-specific constants and don't require algorithms to be implemented and time taken by programs

Worst, Average and Best Case Analysis of Algorithms

In the previous post, we discussed how Asymptotic analysis overcomes the problems of the naive way of analyzing algorithms. Now let us learn about What is Worst, Average, and Best cases of an algorithm: 1. Worst Case Analysis (Mostly used) In the worst-case analysis, we calculate the upper bound on

Asymptotic Analysis

Given two algorithms for a task, how do we find out which one is better? One naive way of doing this is - to implement both the algorithms and run the two programs on your computer for different inputs and see which one takes less time. There are many problems with this approach for the analysis of

How to Analyse Loops for Complexity Analysis of Algorithms

We have discussed Asymptotic Analysis, Worst, Average and Best Cases and Asymptotic Notations in previous posts. In this post, an analysis of iterative programs with simple examples is discussed. The analysis of loops for the complexity analysis of algorithms involves finding the number of operation

Sample Practice Problems on Complexity Analysis of Algorithms

Prerequisite: Asymptotic Analysis, Worst, Average and Best Cases, Asymptotic Notations, Analysis of loops. Problem 1: Find the complexity of the below recurrence: { 3T(n-1), if n>0,T(n) = { 1, otherwise Solution: Let us solve using substitution. T(n) = 3T(n-1) = 3(3T(n-2)) = 32T(n-2) = 33T(n-3) .