 Open in App
Not now

# Program for Mean and median of an unsorted array

• Difficulty Level : Basic
• Last Updated : 31 Mar, 2023

Given an unsorted array a[] of size N, the task is to find its mean and median.

Mean of an array = (sum of all elements) / (number of elements)

The median of a sorted array of size N is defined as the middle element when N is odd and average of middle two elements when N is even. Since the array is not sorted here, we sort the array first, then apply above formula.

Examples:

Input: a[] = {1, 3, 4, 2, 6, 5, 8, 7}
Output: Mean = 4.5, Median = 4.5
Explanation: Sum of the elements is 1 + 3 + 4 + 2 + 6 + 5 + 8 + 7 = 36, Mean = 36/8 = 4.5
Since number of elements are even, median is average of 4th and 5th largest elements, which means Median = (4 + 5)/2 = 4.5

Input: a[] = {4, 4, 4, 4, 4}
Output: Mean = 4, Median = 4

Approach:  To solve the problem follow the below steps:

### To find median:

• First, simply sort the array
• Then, check if the number of elements present in the array is even or odd
• If odd, then simply return the mid value of the array
• Else, the median is the average of the two middle values

### To find Mean:

• At first, find the sum of all the numbers present in the array.
• Then, simply divide the resulted sum by the size of the array

Below is the code implementation:

## C++

 `// CPP program to find mean and median of` `// an array` `#include ` `using` `namespace` `std;`   `// Function for calculating mean` `double` `findMean(``int` `a[], ``int` `n)` `{` `    ``int` `sum = 0;` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``sum += a[i];`   `    ``return` `(``double``)sum / (``double``)n;` `}`   `// Function for calculating median` `double` `findMedian(``int` `a[], ``int` `n)` `{` `    ``// First we sort the array` `    ``sort(a, a + n);`   `    ``// check for even case` `    ``if` `(n % 2 != 0)` `        ``return` `(``double``)a[n / 2];`   `    ``return` `(``double``)(a[(n - 1) / 2] + a[n / 2]) / 2.0;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `a[] = { 1, 3, 4, 2, 7, 5, 8, 6 };` `    ``int` `N = ``sizeof``(a) / ``sizeof``(a);` `  `  `    ``// Function call` `    ``cout << ``"Mean = "` `<< findMean(a, N) << endl;` `    ``cout << ``"Median = "` `<< findMedian(a, N) << endl;` `    ``return` `0;` `}`

## Java

 `// Java program to find mean` `// and median of an array` `import` `java.util.*;`   `class` `GFG ` `{` `    ``// Function for calculating mean` `    ``public` `static` `double` `findMean(``int` `a[], ``int` `n)` `    ``{` `        ``int` `sum = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``sum += a[i];`   `        ``return` `(``double``)sum / (``double``)n;` `    ``}`   `    ``// Function for calculating median` `    ``public` `static` `double` `findMedian(``int` `a[], ``int` `n)` `    ``{` `        ``// First we sort the array` `        ``Arrays.sort(a);`   `        ``// check for even case` `        ``if` `(n % ``2` `!= ``0``)` `            ``return` `(``double``)a[n / ``2``];`   `        ``return` `(``double``)(a[(n - ``1``) / ``2``] + a[n / ``2``]) / ``2.0``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `a[] = { ``1``, ``3``, ``4``, ``2``, ``7``, ``5``, ``8``, ``6` `};` `        ``int` `n = a.length;` `      `  `        ``// Function call` `        ``System.out.println(``"Mean = "` `+ findMean(a, n));` `        ``System.out.println(``"Median = "` `+ findMedian(a, n));` `    ``}` `}`   `// This article is contributed by Anshika Goyal.`

## Python3

 `# Python3 program to find mean` `# and median of an array`   `# Function for calculating mean`     `def` `findMean(a, n):`   `    ``sum` `=` `0` `    ``for` `i ``in` `range``(``0``, n):` `        ``sum` `+``=` `a[i]`   `    ``return` `float``(``sum``/``n)`   `# Function for calculating median`     `def` `findMedian(a, n):`   `    ``# First we sort the array` `    ``sorted``(a)`   `    ``# check for even case` `    ``if` `n ``%` `2` `!``=` `0``:` `        ``return` `float``(a[``int``(n``/``2``)])`   `    ``return` `float``((a[``int``((n``-``1``)``/``2``)] ``+` `                  ``a[``int``(n``/``2``)])``/``2.0``)`     `# Driver code` `a ``=` `[``1``, ``3``, ``4``, ``2``, ``7``, ``5``, ``8``, ``6``]` `n ``=` `len``(a)`   `# Function call` `print``(``"Mean ="``, findMean(a, n))` `print``(``"Median ="``, findMedian(a, n))`   `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// C# program to find mean` `// and median of an array` `using` `System;`   `class` `GFG ` `{` `    ``// Function for` `    ``// calculating mean` `    ``public` `static` `double` `findMean(``int``[] a, ``int` `n)` `    ``{` `        ``int` `sum = 0;` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``sum += a[i];`   `        ``return` `(``double``)sum / (``double``)n;` `    ``}`   `    ``// Function for` `    ``// calculating median` `    ``public` `static` `double` `findMedian(``int``[] a, ``int` `n)` `    ``{` `        ``// First we sort` `        ``// the array` `        ``Array.Sort(a);`   `        ``// check for` `        ``// even case` `        ``if` `(n % 2 != 0)` `            ``return` `(``double``)a[n / 2];`   `        ``return` `(``double``)(a[(n - 1) / 2] + a[n / 2]) / 2.0;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] a = { 1, 3, 4, 2, 7, 5, 8, 6 };` `        ``int` `n = a.Length;` `      `  `        ``// Function call` `        ``Console.Write(``"Mean = "` `+ findMean(a, n) + ``"\n"``);` `        ``Console.Write(``"Median = "` `+ findMedian(a, n)` `                      ``+ ``"\n"``);` `    ``}` `}`   `// This code is contributed by Smitha .`

## PHP

 ``

## Javascript

 ``

Output

```Mean = 4.5
Median = 4.5```

Complexity Analysis:

Time Complexity to find mean: O(N)
Time Complexity to find median: O(N Log N) as we need to sort the array first.
Auxiliary Space: O(1)

This article is contributed by Himanshu Ranjan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Approach 2:-Using STL library

• Declare the vector to store the elements of the unsorted array:
• Calculate the sum of all elements in the array using the std::accumulate function:
• Calculate the mean by dividing the sum by the number of elements in the array:
• Sort the vector using the std::sort function to find the median:
• Calculate the median by checking if the number of elements in the array is odd or even, and then taking the middle element(s) accordingly:

## C++

 `#include ` `#include ` `#include ` `#include `   `using` `namespace` `std;`   `double` `mean(vector<``int``> arr)` `{` `    ``int` `sum = accumulate(arr.begin(), arr.end(), 0);` `    ``return` `(``double``)sum / arr.size();` `}`   `double` `median(vector<``int``> arr)` `{` `    ``int` `n = arr.size();` `    ``sort(arr.begin(), arr.end());` `    ``if` `(n % 2 == 0) {` `        ``return` `(``double``)(arr[n/2 - 1] + arr[n/2]) / 2;` `    ``} ``else` `{` `        ``return` `(``double``)arr[n/2];` `    ``}` `}`   `int` `main()` `{` `    ``vector<``int``> arr = { 1, 3, 4, 2, 7, 5, 8, 6 };` `    ``cout << ``"Mean: "` `<< mean(arr) << endl;` `    ``cout << ``"Median: "` `<< median(arr) << endl;` `    ``return` `0;` `}`

## Python3

 `from` `typing ``import` `List`   `def` `mean(arr: ``List``[``int``]) ``-``> ``float``:` `    ``sum_ ``=` `sum``(arr)` `    ``return` `sum_ ``/` `len``(arr)`   `def` `median(arr: ``List``[``int``]) ``-``> ``float``:` `    ``n ``=` `len``(arr)` `    ``arr.sort()` `    ``if` `n ``%` `2` `=``=` `0``:` `        ``return` `(arr[n``/``/``2` `-` `1``] ``+` `arr[n``/``/``2``]) ``/` `2` `    ``else``:` `        ``return` `arr[n``/``/``2``]`   `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``1``, ``3``, ``4``, ``2``, ``7``, ``5``, ``8``, ``6``]` `    ``print``(``"Mean:"``, mean(arr))` `    ``print``(``"Median:"``, median(arr))`

## Java

 `import` `java.util.ArrayList;` `import` `java.util.Collections;`   `public` `class` `Main {` `    ``// Calculates the mean of an ArrayList of integers` `    ``public` `static` `double` `mean(ArrayList arr) {` `        ``int` `sum = ``0``;` `        ``// Iterate over the ArrayList and add it to the sum` `        ``for` `(``int` `i : arr) {` `            ``sum += i;` `        ``}` `        ``// Divide the sum by the number of elements to get the mean` `        ``return` `(``double``) sum / arr.size();` `    ``}`   `    ``// Calculates the median of an ArrayList of integers` `    ``public` `static` `double` `median(ArrayList arr) {` `        ``int` `n = arr.size();` `        ``// Sort the ArrayList in ascending order` `        ``Collections.sort(arr);` `        ``if` `(n % ``2` `== ``0``) {` `            ``// If even number of elements, calculate the average of the two middle elements` `            ``return` `(``double``) (arr.get(n / ``2` `- ``1``) + arr.get(n / ``2``)) / ``2``;` `        ``} ``else` `{` `            ``// If odd number of elements, return the middle element` `            ``return` `(``double``) arr.get(n / ``2``);` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``// Create an ArrayList of integers and add some values` `        ``ArrayList arr = ``new` `ArrayList();` `        ``arr.add(``1``);` `        ``arr.add(``3``);` `        ``arr.add(``4``);` `        ``arr.add(``2``);` `        ``arr.add(``7``);` `        ``arr.add(``5``);` `        ``arr.add(``8``);` `        ``arr.add(``6``);`   `        ``// Print the mean and median of the ArrayList` `        ``System.out.println(``"Mean: "` `+ mean(arr));` `        ``System.out.println(``"Median: "` `+ median(arr));` `    ``}` `}`

Output

```Mean: 4.5
Median: 4.5```

Time Complexity to find mean: O(N)
Time Complexity to find median: O(N Log N) as we need to sort the array first.

The time complexity of this program is O(n log n) due to the use of the std::sort function, which has an average-case time complexity of O(n log n). The std::accumulate function used to calculate the sum of elements has a time complexity of O(n).

Auxiliary Space: O(N)

The time complexity of this program is O(n log n) due to the use of the std::sort function, which has an average-case time complexity of O(n log n). The std::accumulate function used to calculate the sum of elements has a time complexity of O(n).

My Personal Notes arrow_drop_up
Related Articles