The maximum is the largest element in the array. For an unsorted array, scan once from left to right and keep a running best.
Remember
arr = [12, 45, 7, 42, 19]
max = 45
Idea:
max = arr[0]
for each later element x:
if x > max → max = x
Works for negatives too:
[-8, -1, -15] → max = -1
Array
Maximum
[12, 45, 7, 42, 19]
45
[-8, -1, -15]
-1
[5]
5
[]
undefined — handle empty
Approach
How to Find the Maximum in C++
Four clear steps — one linear pass is enough.
Reject an empty array (no maximum exists).
Set max = arr[0] as the first candidate.
Loop from index 1 to the end.
Whenever arr[i] > max, update max (optionally track the index too).
Method
Idea
Time
Best for
Linear scan
Running maximum with >
O(n)
Interviews, unsorted arrays
Track index
Same scan, also store the position
O(n)
When you need where the max is
Pseudocode
Pseudocode
function FindMax(arr):
if length(arr) == 0:
error "empty array"
max = arr[0]
for i from 1 to length(arr) - 1:
if arr[i] > max:
max = arr[i]
return max
Reference
Cheat Sheet
Keep these facts handy while writing the program.
Topic
Detail
Start
max = arr[0]
Update
if arr[i] > max
Empty
Validate before reading arr[0]
Negatives
Still use > — do not assume positive
Avoid
Sorting just to get the max
Classic check
[12, 45, 7, 42, 19] → 45
Try it
Live Preview
Pick a sample array to see the running maximum after each step.
Tap a chip to run the linear scan trace.
Result
arr = [12, 45, 7, 42, 19]
start max = 12
45 > 12 → max = 45
7 ≤ 45
42 ≤ 45
19 ≤ 45
Maximum = 45
Trace
Worked Walkthrough — [12, 45, 7, 42, 19]
Start at the first element and update whenever a larger value appears.
Calculation
max = 12
i=1 → 45 > 12 → max = 45
i=2 → 7 ≤ 45 → no change
i=3 → 42 ≤ 45 → no change
i=4 → 19 ≤ 45 → no change
Maximum = 45
Code
C++ Programs
Start with a simple running maximum. Then track the index when you also need the position.
Example 1 — Linear Scan
Keep a running maximum and update it whenever a larger element appears.
C++
#include <iostream>
#include <stdexcept>
using namespace std;
int FindMax(int arr[], int n)
{
if (n <= 0)
{
throw invalid_argument("Array must not be empty.");
}
int maxVal = arr[0];
for (int i = 1; i < n; i++)
{
if (arr[i] > maxVal)
{
maxVal = arr[i];
}
}
return maxVal;
}
int main()
{
int numbers[] = {12, 45, 7, 42, 19};
int n = sizeof(numbers) / sizeof(numbers[0]);
cout << "Maximum = " << FindMax(numbers, n) << endl;
return 0;
}
Output
Maximum = 45
How It Works
Reject empty arrays (n <= 0) before reading arr[0].
Seed maxVal with the first element.
Loop from index 1 so you never compare the seed against itself needlessly.
Update when arr[i] > maxVal.
Return the final running maximum after one pass.
Example 2 — Track Index
Same scan, but also remember the first index where the maximum appears.
C++
#include <iostream>
#include <stdexcept>
using namespace std;
int FindMaxIndex(int arr[], int n)
{
if (n <= 0)
{
throw invalid_argument("Array must not be empty.");
}
int maxIndex = 0;
for (int i = 1; i < n; i++)
{
if (arr[i] > arr[maxIndex])
{
maxIndex = i;
}
}
return maxIndex;
}
int main()
{
int numbers[] = {12, 45, 7, 42, 19};
int n = sizeof(numbers) / sizeof(numbers[0]);
int index = FindMaxIndex(numbers, n);
cout << "Max = " << numbers[index]
<< " at index " << index << endl;
return 0;
}
Output
Max = 45 at index 1
How It Works
Start with maxIndex = 0 (first element is the candidate).
Compare each later element to arr[maxIndex].
When a larger value appears, store that new index.
Ties keep the earlier index because the test uses strict >.
Read the value with numbers[index] after the scan.
Edge Cases & Pitfalls
Check these before calling the solution done.
Empty
No maximum
Validate length before using arr[0].
Negatives
Still works
Do not seed with 0 — that fails for all-negative arrays.
Duplicates
Same answer
Multiple copies of the max still return that value.
Sorting
Overkill
One scan is enough; sorting is usually slower for this goal.
Analysis
Time and Space Complexity
Program
Time
Extra space
Linear scan
O(n)
O(1)
Track index
O(n)
O(1)
You need about n − 1 comparisons in the worst case. One pass is optimal for an unsorted array.
Remember
Key Takeaways
Pattern: seed with arr[0], then scan with >.
Empty: validate before reading the first element.
Index: same loop can track where the max sits.
Test: [12, 45, 7, 42, 19] → 45.
One line: one pass, keep the larger value — that is the maximum.
Frequently Asked Questions
The first element is a valid candidate. Then every later element is compared against that running maximum.
An empty array has no maximum. Validate n > 0 and throw or return early.
Yes. The maximum is still the greatest value, even if it is negative (for example −1 is greater than −8).
No. Sorting is usually slower than one linear scan when you only need the maximum.
One pass over n elements: O(n) time and O(1) extra space.
