2026-05-27：非负元素轮替。用go语言，给定整数数组 nums 和整数 k。操作规则如下： 1.数组中所有非负数参与处理；它们需要像循环轮替一|go语言|nums|循环轮替|指针|整数|移动|负数|非负元素

2026-05-27：非负元素轮替。用go语言，给定整数数组 nums 和整数 k。操作规则如下：

1.数组中所有非负数参与处理；它们需要像循环轮替一样整体向左移动 k 位。轮替的含义是，移出数组末端的非负数会从开头继续接到后面。

2.数组中所有负数必须完全固定在原位置，不允许移动。

3.轮替结束后，把轮替后的非负数按顺序依次放回数组中，但只会填入原来那些位置为非负数的槽位；所有原本是负数的位置保持不变并跳过不填。

4.最终返回处理后的数组。

1 <= nums.length <= 100000。

-1000000000 <= nums[i] <= 1000000000。

0 <= k <= 100000。

输入： nums = [5,4,-9,6], k = 2。

输出： [6,5,-9,4]。

解释：

非负元素按顺序为 [5, 4, 6]。

以 k = 2 进行向左轮替，结果为 [6, 5, 4]。

将它们放回非负值对应的位置，结果为 [6, 5, -9, 4]。

题目来自离开3819。

一、整体执行过程步骤 1：提取数组中所有非负数，形成一个独立的非负数列表

遍历原始数组，只把 >= 0 的数字挑出来，负数直接忽略。

• 遍历 5 → 非负 → 加入列表
• 遍历 4 → 非负 → 加入列表
• 遍历 -9 → 负数 → 跳过
• 遍历 6 → 非负 → 加入列表

最终得到非负元素列表：
a = [5, 4, 6]
这个列表长度 = 3。

步骤 2：对非负列表进行向左循环轮替 k 位

规则：
非负列表整体向左移动 k 位，左边移出的元素从右侧末尾补回。
k=2，列表长度=3。

原非负列表：[5,4,6]
向左轮替 2 位：

• 第 1 位 5 移走
• 第 2 位 4 移走
• 剩下 6
• 移走的 5、4 接到末尾

轮替后结果：[6,5,4]

（代码里没有显式生成轮替后的数组，而是通过索引计算直接取值，效果等价）

步骤 3：把轮替后的非负数，按顺序填回原数组的非负位置

负数位置完全不动、不修改、不覆盖。
只填回原来是非负数的位置。

遍历原始数组，逐个判断：

1. 位置 0：原是 5（非负）→ 填入轮替后的第 0 个值6
2. 位置 1：原是 4（非负）→ 填入轮替后的第 1 个值5
3. 位置 2：原是 -9（负数）→保持不动，还是 -9
4. 位置 3：原是 6（非负）→ 填入轮替后的第 2 个值4

步骤 4：得到最终数组

填完后数组为：
[6, 5, -9, 4]
与题目要求输出完全一致。

二、时间复杂度

整个过程只做了两次完整遍历数组：

1. 第一次遍历：提取非负数
2. 第二次遍历：回填轮替后的值

两次都是O(n)，n 是数组长度。
常数系数不影响复杂度，因此：
总时间复杂度 = O(n)

三、额外空间复杂度

额外空间指：除了输入输出外，程序运行时主动开辟的内存。

这里只开辟了一个存储非负数的切片 a，最坏情况（数组全是非负）时，a 的长度等于 n。
因此：
总额外空间复杂度 = O(n)

总结

1. 执行过程：提取非负数 → 向左轮替 k 位 → 按原非负位置回填 → 负数不动
2. 时间复杂度：O(n)（线性遍历）
3. 额外空间复杂度：O(n)（存储非负列表）

Go完整代码如下：

package main

 import (
    "fmt"
)

 func rotateElements(nums []int, k int) []int {
    // 取出非负数
    a := []int{}
    for _, x := range nums {
        if x >= 0 {
            a = append(a, x)
        }
    }

     // 双指针，把 a 填入 nums，跳过负数
    j := k
    for i, x := range nums {
        if x >= 0 {
            nums[i] = a[j%len(a)]
            j++
        }
    }
    return nums
}

 func main() {
    nums := []int{5, 4, -9, 6}
    k := 2
    result := rotateElements(nums, k)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def rotate_elements(nums, k):
    # 取出非负数
    a = [x for x in nums if x >= 0]
    # 双指针，把 a 填入 nums，跳过负数
    j = k
    for i, x in enumerate(nums):
        if x >= 0:
            nums[i] = a[j % len(a)]
            j += 1
    return nums

 def main():
    nums = [5, 4, -9, 6]
    k = 2
    result = rotate_elements(nums, k)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

  

  


 std::vector rotateElements(std::vector& nums, int k) {
    // 取出非负数
    std::vector a;
    for (int x : nums) {
        if (x >= 0) {
            a.push_back(x);
        }
    }

     // 双指针，把 a 填入 nums，跳过负数
    int j = k;
    for (int i = 0; i < nums.size(); i++) {
        if (nums[i] >= 0) {
            nums[i] = a[j % a.size()];
            j++;
        }
    }
    return nums;
}

 int main() {
    std::vector nums = {5, 4, -9, 6};
    int k = 2;
    std::vector result = rotateElements(nums, k);

     for (int x : result) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

     return0;
}