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#
using System;
class Program
{
static int FindMax(int[] arr)
{
if (arr == null || arr.Length == 0)
{
throw new ArgumentException("Array must not be empty.");
}
int max = arr[0];
for (int i = 1; i < arr.Length; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
return max;
}
static void Main()
{
int[] numbers = { 12, 45, 7, 42, 19 };
Console.WriteLine("Maximum = " + FindMax(numbers));
}
}
Output
Maximum = 45
How It Works
Reject null or empty arrays before reading arr[0].
Seed max with the first element.
Loop from index 1 so you never compare the seed against itself needlessly.
Update when arr[i] > max.
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#
using System;
class Program
{
static int FindMaxIndex(int[] arr)
{
if (arr == null || arr.Length == 0)
{
throw new ArgumentException("Array must not be empty.");
}
int maxIndex = 0;
for (int i = 1; i < arr.Length; i++)
{
if (arr[i] > arr[maxIndex])
{
maxIndex = i;
}
}
return maxIndex;
}
static void Main()
{
int[] numbers = { 12, 45, 7, 42, 19 };
int index = FindMaxIndex(numbers);
Console.WriteLine("Max = " + numbers[index] + " at index " + index);
}
}
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 Length > 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.
