Leetcode – Sort Array By Parity II Solution in Python

Spread the love

Leetcode offers a rich set of problems that sharpen a developer’s problem-solving skills. One such interesting problem is “Sort Array By Parity II,” which pushes a coder to think about array manipulation in creative ways. This article is dedicated to providing an in-depth understanding of the problem, its underlying principles, Python solutions, and a detailed complexity analysis.

Table of Contents:

  1. Understanding the Problem Statement
  2. Problem Analysis
  3. Two-Pointer Technique
  4. Python Implementation
  5. Complexity Analysis
  6. Alternate Approaches
  7. Conclusion

1. Understanding the Problem Statement


Given an array A of non-negative integers, half of the integers in A are odd, and half of the integers are even. Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even. You may return any answer array that satisfies this condition.


Input: [4,2,5,7]
Output: [4,5,2,7]
Explanation: [4,7,2,5], [2,5,4,7], [2,7,4,5] would also have been accepted.

2. Problem Analysis

A key insight from the problem is that there’s a clear distinction between the positions of even and odd numbers. Our primary objective is to ensure that even indices have even numbers and odd indices have odd numbers.

3. Two-Pointer Technique

A smart way to tackle this problem is by using the two-pointer technique. In this case, we can use:

  • even: a pointer starting at 0, moving in increments of 2.
  • odd: a pointer starting at 1, moving in increments of 2.

We iterate until our even pointer finds an odd number, and our odd pointer finds an even number. Once this condition is met, we swap these two elements.

4. Python Implementation

Below is the Python code for the described approach:

def sortArrayByParityII(A):
    even, odd, n = 0, 1, len(A)

    while even < n and odd < n:
        while even < n and A[even] % 2 == 0:
            even += 2
        while odd < n and A[odd] % 2 == 1:
            odd += 2

        if even < n and odd < n:
            A[even], A[odd] = A[odd], A[even]

    return A

5. Complexity Analysis

Time Complexity: O(n)
The algorithm goes through the list a maximum of two times, leading to a linear time complexity.

Space Complexity: O(1)
No additional space proportional to the input size is used, leading to a constant space complexity.

6. Alternate Approaches

  1. Two new arrays: Create two new arrays – one for even numbers and one for odd numbers. Then, merge these two arrays to form the result, picking alternately from the even array and the odd array.
  2. In-place sorting: Use a custom comparator function to sort the array. While this might work for certain languages/platforms, it isn’t recommended due to the increased time complexity of the sorting operation.

7. Conclusion

The “Sort Array By Parity II” problem offers a great example of the benefits of the two-pointer technique, especially when dealing with array manipulations. Solving problems like these help in refining the approach towards array-based questions, promoting a better understanding of how to harness pointers efficiently.

Leave a Reply