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

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++完整代码如下：

#include <iostream>
#include <vector>

std::vector<int> rotateElements(std::vector<int>& nums, int k) {
    // 取出非负数
    std::vector<int> 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<int> nums = {5, 4, -9, 6};
    int k = 2;
    std::vector<int> result = rotateElements(nums, k);

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

    return 0;
}