2164. Sort Even and Odd Indices Independently LeetCode Solution

In this guide, you will get 2164. Sort Even and Odd Indices Independently LeetCode Solution with the best time and space complexity. The solution to Sort Even and Odd Indices Independently problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Sort Even and Odd Indices Independently solution in C++
Sort Even and Odd Indices Independently solution in Java
Sort Even and Odd Indices Independently solution in Python
Additional Resources

2164. Sort Even and Odd Indices Independently LeetCode Solution image

Problem Statement of Sort Even and Odd Indices Independently

You are given a 0-indexed integer array nums. Rearrange the values of nums according to the following rules:

Sort the values at odd indices of nums in non-increasing order.

For example, if nums = [4,1,2,3] before this step, it becomes [4,3,2,1] after. The values at odd indices 1 and 3 are sorted in non-increasing order.

Sort the values at even indices of nums in non-decreasing order.

For example, if nums = [4,1,2,3] before this step, it becomes [2,1,4,3] after. The values at even indices 0 and 2 are sorted in non-decreasing order.

Return the array formed after rearranging the values of nums.

Example 1:

Input: nums = [4,1,2,3]
Output: [2,3,4,1]
Explanation:
First, we sort the values present at odd indices (1 and 3) in non-increasing order.
So, nums changes from [4,1,2,3] to [4,3,2,1].
Next, we sort the values present at even indices (0 and 2) in non-decreasing order.
So, nums changes from [4,1,2,3] to [2,3,4,1].
Thus, the array formed after rearranging the values is [2,3,4,1].

Example 2:

Input: nums = [2,1]
Output: [2,1]
Explanation:
Since there is exactly one odd index and one even index, no rearrangement of values takes place.
The resultant array formed is [2,1], which is the same as the initial array.

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100

Complexity Analysis

Time Complexity: O(n)
Space Complexity: O(n)

2164. Sort Even and Odd Indices Independently LeetCode Solution in C++

class Solution {
 public:
  vector<int> sortEvenOdd(vector<int>& nums) {
    const int n = nums.size();
    vector<int> ans(n);
    vector<int> evenCount(101);
    vector<int> oddCount(101);

    for (int i = 0; i < n; ++i)
      if (i % 2 == 1)
        ++oddCount[nums[i]];
      else
        ++evenCount[nums[i]];

    int ansIndex = 0;
    for (int i = 1; i < 101; ++i)
      while (evenCount[i]--) {
        ans[ansIndex] = i;
        ansIndex += 2;
      }

    ansIndex = 1;
    for (int i = 100; i > 0; --i)
      while (oddCount[i]--) {
        ans[ansIndex] = i;
        ansIndex += 2;
      }

    return ans;
  }
};
/* code provided by PROGIEZ */

2164. Sort Even and Odd Indices Independently LeetCode Solution in Java

class Solution {
  public int[] sortEvenOdd(int[] nums) {
    final int n = nums.length;
    int[] ans = new int[n];
    int[] evenCount = new int[101];
    int[] oddCount = new int[101];

    for (int i = 0; i < n; ++i)
      if (i % 2 == 1)
        ++oddCount[nums[i]];
      else
        ++evenCount[nums[i]];

    int ansIndex = 0;
    for (int i = 1; i < 101; ++i)
      while (evenCount[i]-- > 0) {
        ans[ansIndex] = i;
        ansIndex += 2;
      }

    ansIndex = 1;
    for (int i = 100; i > 0; --i)
      while (oddCount[i]-- > 0) {
        ans[ansIndex] = i;
        ansIndex += 2;
      }

    return ans;
  }
}
// code provided by PROGIEZ

2164. Sort Even and Odd Indices Independently LeetCode Solution in Python

class Solution:
  def sortEvenOdd(self, nums: list[int]) -> list[int]:
    ans = [0] * len(nums)
    evenCount = collections.Counter(nums[::2])
    oddCount = collections.Counter(nums[1::2])

    ansIndex = 0
    for i in range(1, 101):
      while evenCount[i] > 0:
        ans[ansIndex] = i
        ansIndex += 2
        evenCount[i] -= 1

    ansIndex = 1
    for i in range(100, 0, -1):
      while oddCount[i] > 0:
        ans[ansIndex] = i
        ansIndex += 2
        oddCount[i] -= 1

    return ans
 # code by PROGIEZ