Kadane's Algorithm Maximum Subarray in DSA C# - Build from Scratch

Kadane's Algorithm Maximum Subarray

📖 Scenario: You are analyzing daily temperature changes to find the longest period of warming days. You have a list of temperature changes, and you want to find the maximum sum of consecutive days where the temperature increased.

🎯 Goal: Build a program that uses Kadane's Algorithm to find the maximum sum of a contiguous subarray in a list of integers representing daily temperature changes.

📋 What You'll Learn

Create an integer array called temperatureChanges with the exact values: -2, 1, -3, 4, -1, 2, 1, -5, 4.

Create an integer variable called maxSoFar and set it to the first element of temperatureChanges.

Create an integer variable called currentMax and set it to the first element of temperatureChanges.

Use a for loop with variable i starting from 1 to iterate over temperatureChanges.

Inside the loop, update currentMax to be the maximum of temperatureChanges[i] and currentMax + temperatureChanges[i].

Update maxSoFar to be the maximum of maxSoFar and currentMax.

Print the value of maxSoFar.

💡 Why This Matters

🌍 Real World

Finding the maximum sum of consecutive positive changes is useful in finance to find the best time to buy and sell stocks, or in weather analysis to find the longest warming period.

💼 Career

Kadane's Algorithm is a classic example of dynamic programming and is often asked in coding interviews to test problem-solving and optimization skills.

1

Create the temperature changes array

Create an integer array called temperatureChanges with these exact values: -2, 1, -3, 4, -1, 2, 1, -5, 4.

DSA C#

# Create the temperatureChanges array with the given values
// Your code here

Hint

Use int[] temperatureChanges = new int[] { ... }; to create the array.

2

Initialize maxSoFar and currentMax variables

Create an integer variable called maxSoFar and set it to the first element of temperatureChanges. Also create an integer variable called currentMax and set it to the first element of temperatureChanges.

DSA C#

int[] temperatureChanges = new int[] { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
// Initialize maxSoFar and currentMax to the first element
// Your code here

Hint

Use int maxSoFar = temperatureChanges[0]; and int currentMax = temperatureChanges[0];.

3

Implement Kadane's Algorithm loop

Use a for loop with variable i starting from 1 to iterate over temperatureChanges. Inside the loop, update currentMax to be the maximum of temperatureChanges[i] and currentMax + temperatureChanges[i]. Then update maxSoFar to be the maximum of maxSoFar and currentMax.

DSA C#

int[] temperatureChanges = new int[] { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
int maxSoFar = temperatureChanges[0];
int currentMax = temperatureChanges[0];
// Add a for loop starting from i = 1
// Update currentMax and maxSoFar inside the loop
// Your code here

Hint

Use for (int i = 1; i < temperatureChanges.Length; i++) and update currentMax and maxSoFar using Math.Max.

4

Print the maximum subarray sum

Print the value of maxSoFar using Console.WriteLine(maxSoFar);.

DSA C#

int[] temperatureChanges = new int[] { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
int maxSoFar = temperatureChanges[0];
int currentMax = temperatureChanges[0];
for (int i = 1; i < temperatureChanges.Length; i++)
{
    currentMax = Math.Max(temperatureChanges[i], currentMax + temperatureChanges[i]);
    maxSoFar = Math.Max(maxSoFar, currentMax);
}
// Print maxSoFar
// Your code here

Hint

Use Console.WriteLine(maxSoFar); to print the result.

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