Kadane's Algorithm Maximum Subarray in DSA C# - Execution Trace

Concept Flow - Kadane's Algorithm Maximum Subarray

Start with first element

↓

Initialize current_sum and max_sum

↓

For each next element

↓

Update current_sum = max(element, current_sum + element)

↓

Update max_sum = max(max_sum, current_sum)

↓

Repeat until end of array

↓

Return max_sum as max subarray sum

Kadane's algorithm scans the array once, keeping track of the best sum ending at each position and the overall best sum found.

Execution Sample

DSA C#

int[] arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
int current_sum = arr[0];
int max_sum = arr[0];
for (int i = 1; i < arr.Length; i++) {
  current_sum = Math.Max(arr[i], current_sum + arr[i]);
  max_sum = Math.Max(max_sum, current_sum);
}
Console.WriteLine(max_sum);

This code finds the maximum sum of any contiguous subarray in the given array.

Execution Table

Step	Operation	Current Element	current_sum	max_sum	Visual State (Subarray contributing to current_sum)
0	Initialize	-2	-2	-2	[-2]
1	Compare arr[1] and current_sum+arr[1]	1	max(1, -2+1)=1	max(-2,1)=1	[1]
2	Compare arr[2] and current_sum+arr[2]	-3	max(-3,1-3)=-2	max(1,-2)=1	[1, -3]
3	Compare arr[3] and current_sum+arr[3]	4	max(4,-2+4)=4	max(1,4)=4	[4] (restart)
4	Compare arr[4] and current_sum+arr[4]	-1	max(-1,4-1)=3	max(4,3)=4	[4, -1]
5	Compare arr[5] and current_sum+arr[5]	2	max(2,3+2)=5	max(4,5)=5	[4, -1, 2]
6	Compare arr[6] and current_sum+arr[6]	1	max(1,5+1)=6	max(5,6)=6	[4, -1, 2, 1]
7	Compare arr[7] and current_sum+arr[7]	-5	max(-5,6-5)=1	max(6,1)=6	[4, -1, 2, 1, -5]
8	Compare arr[8] and current_sum+arr[8]	4	max(4,1+4)=5	max(6,5)=6	[4, -1, 2, 1, -5, 4]
End	Loop ends	-	-	-	Maximum subarray sum found: 6

💡 Reached end of array, max_sum = 6 is the maximum subarray sum.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	Final
current_sum	-2	1	-2	4	3	5	6	1	5	5
max_sum	-2	1	1	4	4	5	6	6	6	6
current_element	-2	1	-3	4	-1	2	1	-5	4	-

Key Moments - 3 Insights

Why do we compare current element with current_sum + current element?

Because if current_sum + current element is less than the current element alone, it means starting fresh from current element gives a better sum. See execution_table rows 1 and 3 where current_sum resets.

Why do we update max_sum after updating current_sum?

Because max_sum must always hold the best sum found so far, including the new current_sum. See execution_table rows 3 to 6 where max_sum updates after current_sum changes.

What happens when current_sum becomes negative?

When current_sum is negative, adding next elements might reduce sum, so we restart from next element if it is larger. This is why current_sum resets in row 3.

Visual Quiz - 3 Questions

Look at the execution_table at Step 3. What is the value of current_sum?

A -2

B 4

C 1

D -3

💡 Hint

Check the 'current_sum' column at Step 3 in execution_table.

At which step does max_sum first become 6?

A Step 6

B Step 5

C Step 7

D Step 8

💡 Hint

Look at the 'max_sum' column in execution_table and find when it changes to 6.

If the array started with all negative numbers, how would current_sum behave?

A It would never reset

B It would accumulate all elements regardless

C It would always reset to the current element if larger

D max_sum would always be zero

💡 Hint

Refer to key_moments about why current_sum compares current element and current_sum + element.

Concept Snapshot

Kadane's Algorithm finds max sum of contiguous subarray.
Initialize current_sum and max_sum with first element.
For each element, update current_sum = max(element, current_sum + element).
Update max_sum = max(max_sum, current_sum).
Return max_sum after full scan.
Runs in O(n) time with O(1) space.

Full Transcript

Kadane's Algorithm scans the array once, keeping track of the maximum sum of subarrays ending at each position. It starts by setting current_sum and max_sum to the first element. Then for each next element, it decides whether to add it to the current_sum or start fresh from that element, whichever is larger. After updating current_sum, it updates max_sum if current_sum is greater. This way, it finds the maximum sum of any contiguous subarray efficiently in one pass.

Practice

1. What does Kadane's Algorithm primarily help to find in an array of integers?

easy

A. The minimum element in the array

B. The maximum sum of a contiguous subarray

C. The total sum of all elements

D. The number of positive elements

Solution

1. Step 1: Understand the problem Kadane's Algorithm solves

   Kadane's Algorithm is designed to find the maximum sum of any contiguous subarray within a given array.

2. Step 2: Differentiate from other array operations

   It does not find minimum elements, total sums, or count positives, but specifically the largest sum of a continuous segment.

3. Final Answer:

   The maximum sum of a contiguous subarray -> Option B

4. Quick Check:

   Maximum subarray sum = The maximum sum of a contiguous subarray [OK]

Hint: Kadane's finds max sum in continuous subarray fast [OK]

Common Mistakes:

• Confusing maximum subarray sum with total array sum
• Thinking it finds minimum or count of elements
• Assuming it works on non-contiguous elements

2. Which of the following is the correct initialization for Kadane's Algorithm variables in C#?

easy

A. int maxSoFar = 0, maxEndingHere = 0;

B. int maxSoFar = int.MaxValue, maxEndingHere = int.MaxValue;

C. int maxSoFar = int.MinValue, maxEndingHere = 0;

D. int maxSoFar = 0, maxEndingHere = int.MinValue;

Solution

1. Step 1: Understand variable roles in Kadane's Algorithm

   maxSoFar stores the maximum sum found so far, so it should start very low (int.MinValue) to handle negative arrays. maxEndingHere tracks current subarray sum and starts at 0.

2. Step 2: Check each initialization

   int maxSoFar = int.MinValue, maxEndingHere = 0; correctly initializes maxSoFar to int.MinValue and maxEndingHere to 0, allowing correct updates during iteration.

3. Final Answer:

   int maxSoFar = int.MinValue, maxEndingHere = 0; -> Option C

4. Quick Check:

   Initialize maxSoFar low, maxEndingHere zero [OK]

Hint: Start maxSoFar at int.MinValue to handle negatives [OK]

Common Mistakes:

• Initializing maxSoFar to 0 causes wrong results with all negatives
• Setting maxEndingHere to int.MinValue breaks sum calculation
• Using int.MaxValue causes logic errors

3. What is the output of the following C# code using Kadane's Algorithm?

int[] arr = { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
int maxSoFar = int.MinValue, maxEndingHere = 0;
foreach (int x in arr) {
    maxEndingHere = Math.Max(x, maxEndingHere + x);
    maxSoFar = Math.Max(maxSoFar, maxEndingHere);
}
Console.WriteLine(maxSoFar);

medium

A. 6

B. 7

C. 5

D. 4

Solution

1. Step 1: Trace Kadane's Algorithm on the array

   Iterate and update maxEndingHere and maxSoFar:
   - Start maxSoFar = -∞, maxEndingHere = 0
   - x=-2: maxEndingHere=max(-2,0-2)=-2; maxSoFar=max(-∞,-2)=-2
   - x=1: maxEndingHere=max(1,-2+1)=1; maxSoFar=max(-2,1)=1
   - x=-3: maxEndingHere=max(-3,1-3)=-2; maxSoFar=1
   - x=4: maxEndingHere=max(4,-2+4)=4; maxSoFar=4
   - x=-1: maxEndingHere=max(-1,4-1)=3; maxSoFar=4
   - x=2: maxEndingHere=max(2,3+2)=5; maxSoFar=5
   - x=1: maxEndingHere=max(1,5+1)=6; maxSoFar=6
   - x=-5: maxEndingHere=max(-5,6-5)=1; maxSoFar=6
   - x=4: maxEndingHere=max(4,1+4)=5; maxSoFar=6

2. Step 2: Identify the maximum sum found

   The maximum sum found is 6, which corresponds to the subarray [4, -1, 2, 1].

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Max subarray sum = 6 [OK]

Hint: Track maxEndingHere and maxSoFar stepwise [OK]

Common Mistakes:

• Adding all positive numbers incorrectly
• Not resetting maxEndingHere properly
• Confusing maxSoFar with last maxEndingHere

4. Identify the bug in this Kadane's Algorithm implementation and select the fix:

int maxSoFar = 0, maxEndingHere = 0;
foreach (int x in arr) {
    maxEndingHere += x;
    if (maxSoFar < maxEndingHere) maxSoFar = maxEndingHere;
    if (maxEndingHere < 0) maxEndingHere = 0;
}
return maxSoFar;

medium

A. Add a check to skip negative numbers in the loop

B. Remove resetting maxEndingHere to 0 when negative

C. Change maxEndingHere += x to maxEndingHere = x

D. Initialize maxSoFar to int.MinValue instead of 0

Solution

1. Step 1: Analyze initialization impact

   Initializing maxSoFar to 0 causes wrong results if all numbers are negative, as maxSoFar will never be less than 0.

2. Step 2: Correct initialization to handle negatives

   Setting maxSoFar to int.MinValue allows the algorithm to correctly track maximum sums even if all elements are negative.

3. Final Answer:

   Initialize maxSoFar to int.MinValue instead of 0 -> Option D

4. Quick Check:

   Use int.MinValue for maxSoFar to handle negatives [OK]

Hint: Use int.MinValue for maxSoFar to handle all negatives [OK]

Common Mistakes:

• Leaving maxSoFar at 0 causes wrong max for negative arrays
• Removing reset breaks Kadane's logic
• Changing addition to assignment loses cumulative sum

5. Given an array of integers, how would you modify Kadane's Algorithm to also return the start and end indices of the maximum sum subarray?

hard

A. Track temporary start index when maxEndingHere resets and update final start/end when maxSoFar changes

B. Store all subarrays and pick the max sum one at the end

C. Use two nested loops to find all subarrays and their sums

D. Return the first positive element's index as start and end

Solution

1. Step 1: Understand Kadane's Algorithm extension

   When maxEndingHere resets to current element, record that index as temporary start. When maxSoFar updates, update final start and end indices accordingly.

2. Step 2: Avoid brute force methods

   Storing all subarrays and using two nested loops are brute force and inefficient. Returning the first positive element's index as start and end is incorrect as max subarray may not start at first positive element.

3. Final Answer:

   Track temporary start index when maxEndingHere resets and update final start/end when maxSoFar changes -> Option A

4. Quick Check:

   Track indices on resets and max updates [OK]

Hint: Update start index when resetting maxEndingHere [OK]

Common Mistakes:

• Using nested loops instead of Kadane's linear approach
• Ignoring index tracking during sum updates
• Assuming max subarray always starts at first positive