2026-08-20：连接逆序数组。用go语言，给定一个整数数组，需要生成一个新数组，长度是原来的两倍。新数组的前半部分就是把原数组从左到右原样放进去；后半部分

2026-08-20：连接逆序数组。用go语言，给定一个整数数组，需要生成一个新数组，长度是原来的两倍。新数组的前半部分就是把原数组从左到右原样放进去；后半部分则是把原数组从右到左逆序放进去。也就是说，先顺序复制一遍，再倒序复制一遍，最后把这两段拼接起来返回。

1 <= nums.length <= 100。

1 <= nums[i] <= 100。

输入： nums = [1,2,3]。

输出： [1,2,3,3,2,1]。

解释：

ans 的前 n 个元素与 nums 相同。

接下来的 n = 3 个元素按照 nums 的逆序填入：

ans[3] = nums[2] = 3

ans[4] = nums[1] = 2

ans[5] = nums[0] = 1

因此，ans = [1, 2, 3, 3, 2, 1]。

题目来自力扣3925。

分步骤过程描述

1. 接收输入数组
   设输入数组为 nums，长度为 n。例如 nums = [1, 2, 3]，此时 n = 3。

2. 复制原数组
   创建一个新的切片 rev，它的长度和内容与 nums 完全相同。
   这一步是为了避免后续反转操作影响原始数组 nums 的内容。

3. 反转副本
   对副本 rev 执行反转操作，即将 rev 的第一个元素与最后一个元素交换、第二个与倒数第二个交换，以此类推，直到整个数组顺序完全颠倒。
   反转后，rev 中的元素顺序变为原数组的逆序。
   例如原数组 [1, 2, 3] 反转后变为 [3, 2, 1]。

4. 拼接两个部分
   构建最终的结果数组 ans：

   • 先将 nums 中的所有元素按原顺序放入 ans 的前 n 个位置。
   • 再将已经反转的 rev 中的所有元素依次追加到 ans 的后 n 个位置。

   这样，ans 的前半部分就是原数组顺序，后半部分就是原数组逆序。

5. 返回结果
   最终得到的 ans 长度为 2 * n，内容为：
   nums[0], nums[1], ..., nums[n-1], nums[n-1], nums[n-2], ..., nums[0]
   例如输入 [1, 2, 3]，输出 [1, 2, 3, 3, 2, 1]。

复杂度分析

• 时间复杂度
  整个过程主要包括：

  • 复制数组：需要遍历 nums 一次，耗时 O(n)。
  • 反转数组：需要交换 n/2 对元素，同样为 O(n)。
  • 拼接数组：将两个长度为 n 的数组依次放入新数组，也是 O(n)。

  所有步骤都是线性操作，因此总时间复杂度为 O(n)，其中 n 是原数组的长度。

• 额外空间复杂度

  • 创建了辅助数组 rev，长度为 n，占用 O(n) 空间。
  • 最终返回的结果数组 ans 长度为 2n，也需要 O(n) 空间（输出数组是否计入额外空间取决于分析惯例，但无论是否计入，其数量级都是 O(n)）。

  因此，整个算法使用的额外空间（不含输入数组本身）为 O(n)。即使只考虑辅助数组 rev，额外空间也是 O(n)。

Go完整代码如下：

package main

import (
	"fmt"
	"slices"
)

func concatWithReverse(nums []int) []int {
	rev := slices.Clone(nums)
	slices.Reverse(rev)
	return append(nums, rev...)
}

func main() {
	nums := []int{1, 2, 3}
	result := concatWithReverse(nums)
	fmt.Println(result)
}

Python完整代码如下：

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

def concat_with_reverse(nums):
    rev = nums[::-1]
    return nums + rev


def main():
    nums = [1, 2, 3]
    result = concat_with_reverse(nums)
    print(result)


if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <algorithm>

std::vector<int> concatWithReverse(const std::vector<int>& nums) {
    std::vector<int> rev = nums;
    std::reverse(rev.begin(), rev.end());

    std::vector<int> result = nums;
    result.insert(result.end(), rev.begin(), rev.end());
    return result;
}

int main() {
    std::vector<int> nums = {1, 2, 3};
    std::vector<int> result = concatWithReverse(nums);

    std::cout << "[";
    for (size_t i = 0; i < result.size(); ++i) {
        std::cout << result[i];
        if (i != result.size() - 1) std::cout << " ";
    }
    std::cout << "]" << std::endl;

    return 0;
}