Loading…

easyBasicsFrequently asked

Maximum in an Array

Basics · 6 min

Given a non-empty integer array nums, return the largest element.

In plain English

Keep a running maximum: start it at the first element and update it whenever you find something bigger.

Examples

Example 1

Input: nums = [3, 7, 2, 9, 4]
Output: 9
Note: 9 is the largest.

Example 2

Input: nums = [-5, -1, -8]
Output: -1
Note: Largest of negatives.

Example 3

Input: nums = [42]
Output: 42
Note: Single element.

Constraints

1 ≤ nums.length ≤ 10^5
-10^9 ≤ nums[i] ≤ 10^9

Clarifying questions1First question: Can the array be empty?Explore questions

Q1.Can the array be empty?
If so I'd return a sentinel or throw; here it's guaranteed non-empty so I seed with nums[0].

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Initialise `max` to `nums[0]` (never to 0 — that breaks on all-negative arrays) and scan once, updating `max` whenever an element is larger.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you write a correct running-max fold and seed the accumulator with a real element.

Where candidates slip

Seeding with 0 (or Integer.MIN handled wrong) so all-negative inputs break.

How to stand out

Note this is the base fold reused by second-largest and Kadane's algorithm.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Running maximum

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Carry a 'best so far' as you walk the array — what should it start as?

2Hint 2Explore hint

Seed it with nums[0], not 0, so all-negative arrays still work.

3Hint 3Explore hint

Update best whenever the current element is larger; one pass is enough.

A · Core idea

Finding the largest element is the canonical running maximum (a 'fold'): carry a best-so-far value and update it whenever you meet something bigger. One pass, constant extra space.

Why seed with `nums[0]`, never 0. The accumulator must start at a value that is actually achievable. If you seed max = 0 and the array is all-negative (e.g. [-5, -1, -8]), nothing ever beats 0, so you'd wrongly return 0 — a value that isn't even in the array. Seeding with the first element guarantees the answer is a real element.

Why one pass is optimal. You cannot know the maximum without looking at every element at least once (any element you skip could be the largest), so O(n) is a hard lower bound — there's no cleverer algorithm.

This fold is the atom of max-of-three, second-largest, Kadane's maximum subarray, and countless other scans. Master the seed-and-update shape here.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [3, 7, 2, 9, 4]

seed

max = nums[0]

Statemax = 3

Final result9

C · Code with teaching comments

solution.javaJava

Running maximum — optimal

2 teaching notes

1
public int maxOf(int[] nums) {
2
    // Seed with the first element so negatives work.
3
    int max = nums[0];
4
    for (int x : nums) {
5
        // Keep the larger value as we scan.
6
        if (x > max) max = x;
7
    }
8
    return max;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Seeding with 0 instead of nums[0] is the classic bug — it returns 0 for an all-negative array.

ComplexityO(n) time, O(1) space — every element is visited once with O(1) work, and you can't find the max without seeing each element at least once.

E · Edge cases and pitfalls5nums = [-5, -1, -8] — Returns -1; seeding with nums[0] (not 0) is what makes this correct.Explore edge cases

Edge cases handled

nums = [-5, -1, -8]Returns -1; seeding with nums[0] (not 0) is what makes this correct.
nums = [42]Single element is the max.
nums = [4, 4, 4]Ties don't matter; returns 4.

Pitfalls

Seeding max with 0 — returns 0 for an all-negative array.
Starting the scan at index 1 but seeding with 0 instead of nums[0].

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int maxOf(int[] nums) { int max = nums[0]; for (int x : nums) { if (x > max) max = x; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Seeding the max with 0

For an all-negative array nothing exceeds 0, so you return 0 — a value not in the array.

Explore the code comparison

Don't write this

int max = 0;
for (int x : nums) if (x > max) max = x;   // [-5,-1] -> 0 (WRONG)

Write this instead

int max = nums[0];
for (int x : nums) if (x > max) max = x;

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Running maximum

Code pattern to memorize

max = nums[0]; for x in nums: if x > max: max = x

Rules to remember

1Seed with nums[0], not 0.
2Update on every larger element.
3Single O(n) pass.

Use this pattern when

Largest/smallest in a sequence
The base step of any running-extreme scan

Choose another pattern when

Array is sorted — the max is just the last element

Interview takeaway

Seed running extremes with the first element, never a constant.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Running maximum. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

easyBasicsFrequently asked

Maximum in an Array

Basics · 6 min

Given a non-empty integer array nums, return the largest element.

In plain English

Keep a running maximum: start it at the first element and update it whenever you find something bigger.

Examples

Example 1

Input: nums = [3, 7, 2, 9, 4]
Output: 9
Note: 9 is the largest.

Example 2

Input: nums = [-5, -1, -8]
Output: -1
Note: Largest of negatives.

Example 3

Input: nums = [42]
Output: 42
Note: Single element.

Constraints

1 ≤ nums.length ≤ 10^5
-10^9 ≤ nums[i] ≤ 10^9

Clarifying questions1First question: Can the array be empty?Explore questions

Q1.Can the array be empty?
If so I'd return a sentinel or throw; here it's guaranteed non-empty so I seed with nums[0].

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Initialise `max` to `nums[0]` (never to 0 — that breaks on all-negative arrays) and scan once, updating `max` whenever an element is larger.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you write a correct running-max fold and seed the accumulator with a real element.

Where candidates slip

Seeding with 0 (or Integer.MIN handled wrong) so all-negative inputs break.

How to stand out

Note this is the base fold reused by second-largest and Kadane's algorithm.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Running maximum

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Carry a 'best so far' as you walk the array — what should it start as?

2Hint 2Explore hint

Seed it with nums[0], not 0, so all-negative arrays still work.

3Hint 3Explore hint

Update best whenever the current element is larger; one pass is enough.

A · Core idea

Finding the largest element is the canonical running maximum (a 'fold'): carry a best-so-far value and update it whenever you meet something bigger. One pass, constant extra space.

This fold is the atom of max-of-three, second-largest, Kadane's maximum subarray, and countless other scans. Master the seed-and-update shape here.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [3, 7, 2, 9, 4]

seed

max = nums[0]

Statemax = 3

Final result9

C · Code with teaching comments

solution.javaJava

Running maximum — optimal

2 teaching notes

1
public int maxOf(int[] nums) {
2
    // Seed with the first element so negatives work.
3
    int max = nums[0];
4
    for (int x : nums) {
5
        // Keep the larger value as we scan.
6
        if (x > max) max = x;
7
    }
8
    return max;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Seeding with 0 instead of nums[0] is the classic bug — it returns 0 for an all-negative array.

ComplexityO(n) time, O(1) space — every element is visited once with O(1) work, and you can't find the max without seeing each element at least once.

E · Edge cases and pitfalls5nums = [-5, -1, -8] — Returns -1; seeding with nums[0] (not 0) is what makes this correct.Explore edge cases

Edge cases handled

nums = [-5, -1, -8]Returns -1; seeding with nums[0] (not 0) is what makes this correct.
nums = [42]Single element is the max.
nums = [4, 4, 4]Ties don't matter; returns 4.

Pitfalls

Seeding max with 0 — returns 0 for an all-negative array.
Starting the scan at index 1 but seeding with 0 instead of nums[0].

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int maxOf(int[] nums) { int max = nums[0]; for (int x : nums) { if (x > max) max = x; }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Seeding the max with 0

For an all-negative array nothing exceeds 0, so you return 0 — a value not in the array.

Explore the code comparison

Don't write this

int max = 0;
for (int x : nums) if (x > max) max = x;   // [-5,-1] -> 0 (WRONG)

Write this instead

int max = nums[0];
for (int x : nums) if (x > max) max = x;

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Running maximum

Code pattern to memorize

max = nums[0]; for x in nums: if x > max: max = x

Rules to remember

1Seed with nums[0], not 0.
2Update on every larger element.
3Single O(n) pass.

Use this pattern when

Largest/smallest in a sequence
The base step of any running-extreme scan

Choose another pattern when

Array is sorted — the max is just the last element

Interview takeaway

Seed running extremes with the first element, never a constant.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Running maximum. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups