What is the main strategy for Sort Even and Odd Indices Independently?

The core strategy is to separate values by even and odd indices, sort each list according to the problem rules, then merge them back into their original positions.

Can I sort the entire array at once for this problem?

No, sorting the entire array without separating indices will break the pattern and produce incorrect results.

How should I handle arrays with only one element at an index type?

Single-element even or odd indices do not need sorting, but you must still merge correctly to maintain the overall pattern.

What is the time complexity of sorting even and odd indices separately?

Sorting two separate lists of length n/2 each results in O(n log n) time complexity.

Does GhostInterview check the final merged array correctness?

Yes, it validates that the merged array preserves even and odd index patterns while maintaining the required sorted order.

#2164

Easy

auto_awesome数组·排序

LeetCode 题解工作台

对奇偶下标分别排序

给你一个下标从 0 开始的整数数组 nums 。根据下述规则重排 nums 中的值：按非递增顺序排列 nums 奇数下标上的所有值。举个例子，如果排序前 nums = [4, 1 ,2, 3 ] ，对奇数下标的值排序后变为 [4, 3 ,2, 1 ] 。奇数下标 1 和 3 的值按照非递增…

数组排序

题目描述

给你一个下标从 0 开始的整数数组 nums 。根据下述规则重排 nums 中的值：

按 非递增 顺序排列 nums 奇数下标 上的所有值。
- 举个例子，如果排序前 nums = [4,1,2,3] ，对奇数下标的值排序后变为 [4,3,2,1] 。奇数下标 1 和 3 的值按照非递增顺序重排。
按 非递减 顺序排列 nums 偶数下标 上的所有值。
- 举个例子，如果排序前 nums = [4,1,2,3] ，对偶数下标的值排序后变为 [2,1,4,3] 。偶数下标 0 和 2 的值按照非递减顺序重排。

返回重排 nums 的值之后形成的数组。

示例 1：

输入：nums = [4,1,2,3]
输出：[2,3,4,1]
解释：
首先，按非递增顺序重排奇数下标（1 和 3）的值。
所以，nums 从 [4,1,2,3] 变为 [4,3,2,1] 。
然后，按非递减顺序重排偶数下标（0 和 2）的值。
所以，nums 从 [4,1,2,3] 变为 [2,3,4,1] 。
因此，重排之后形成的数组是 [2,3,4,1] 。

示例 2：

输入：nums = [2,1]
输出：[2,1]
解释：
由于只有一个奇数下标和一个偶数下标，所以不会发生重排。
形成的结果数组是 [2,1] ，和初始数组一样。

提示：

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

lightbulb

解题思路

方法一：排序

我们可以将奇数下标和偶数下标分别取出来，然后对奇数下标的数组进行非递增排序，对偶数下标的数组进行非递减排序，最后再将两个数组合并即可。

时间复杂度 $O(n \times \log n)$ ，空间复杂度 $O(n)$ 。其中 $n$ 为数组 $\textit{nums}$ 的长度。

1

2

3

4

5

6

7

8

class Solution:
    def sortEvenOdd(self, nums: List[int]) -> List[int]:
        a = sorted(nums[::2])
        b = sorted(nums[1::2], reverse=True)
        nums[::2] = a
        nums[1::2] = b
        return nums

speed

复杂度分析

指标	值
时间	complexity is O(n log n) due to sorting two separate lists of up to n/2 elements each. Space complexity is O(n) for storing the even and odd lists before merging back into the array.
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
Can you separate values by index type before sorting?
question_mark
What happens if you mix odd and even index elements during sorting?
question_mark
How does your approach maintain the pattern while sorting independently?

warning

常见陷阱

外企场景

error
Sorting the entire array without separating indices causes incorrect order.
error
Failing to handle single-element even or odd positions may produce errors.
error
Merging incorrectly by index can overwrite values and break the desired pattern.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Sorting odd indices in ascending order instead of descending.
arrow_right_alt
Handling arrays with duplicate values at the same index type.
arrow_right_alt
Sorting indices independently for multi-dimensional arrays or subarrays.

help

常见问题

外企场景

继续练习

#2171 拿出最少数目的魔法豆 #2154 将找到的值乘以 2 #2148 元素计数