问题分析
我们逐步拆解这个问题：
数组构造规则：对于每个 i 从 1 到 n，我们需要从数字 n 开始，将数字逆序拼接至 i，并将这个逆序数组加入最终的结果。
操作步骤：
对于每个 i（从 1 到 n），我们构造一个子数组，其中包含从 n 到 i 的逆序数字。
把这个子数组拼接到最终的数组中。
示例分析
举个例子，假设 n = 3：
第一步：当 i = 1 时，构造从 n 到 i 的逆序数组，即从 3 到 1，即 [3, 2, 1]。
第二步：当 i = 2 时，构造从 n 到 i 的逆序数组，即从 3 到 2，即 [3, 2]。
第三步：当 i = 3 时，构造从 n 到 i 的逆序数组，即从 3 到 3，即 [3]。
最终拼接后的数组是：[3, 2, 1, 3, 2, 3]。
算法步骤
1.初始化空数组：首先创建一个空的数组 result 用于存储最终结果。
2.循环遍历 i：从 i = 1 到 i = n，依次构造从 n 到 i 的逆序数组。
3.构造逆序数组：对于每个 i，构造从 n 到 i 的数字序列，并将这个序列加入到 result 数组。
4.输出结果：返回最终构造出来的数组 result。
伪代码实现
pythonCopy Code
def construct_array(n):
result = [] # 用于存储最终的拼接结果
# 遍历 i 从 1 到 n
for i in range(1, n + 1):
# 构造从 n 到 i 的逆序数组
for j in range(n, i - 1, -1): # 从 n 到 i
result.append(j) # 将 j 添加到结果中
return result # 返回最终结果数组
代码解析
外层循环：
外层 for 循环是从 i = 1 到 i = n。对于每个 i，我们需要生成一个逆序数组。
内层循环：
内层 for 循环用于从 n 开始，逐个数字递减到 i。例如，如果 i = 1，内层循环会从 n 到 1；如果 i = 2，内层循环会从 n 到 2。
拼接数组：
在内层循环中，我们将每个 j（从 n 到 i 的数字）添加到 result 数组中。每一轮 i 都会向结果数组添加一部分元素，最终形成一个完整的数组。
时间复杂度分析
外层循环：外层循环的次数是 n，即从 1 到 n。
内层循环：内层循环的次数是从 n 到 i，每次的循环次数递减。因此，内层循环的总操作次数是： [ (n) + (n-1) + (n-2) + \cdots + 1 = \frac{n(n+1)}{2} ] 这是一个等差数列求和，时间复杂度为 (O(n^2))。
因此，整个算法的时间复杂度是 (O(n^2))。
示例代码
pythonCopy Code
def construct_array(n):
result = [] # 用于存储最终的拼接结果
# 遍历 i 从 1 到 n
for i in range(1, n + 1):
# 构造从 n 到 i 的逆序数组
for j in range(n, i - 1, -1): # 从 n 到 i
result.append(j) # 将 j 添加到结果中
return result # 返回最终结果数组
测试案例
n = 3print(construct_array(n)) # 输出：[3, 2, 1, 3, 2, 3]
总结
该问题的关键是理解如何构造从 n 到 i 的逆序数组并将其拼接到最终结果中。
通过两层嵌套的循环完成数组的构建，外层循环控制逆序数组的长度，内层循环构造每个逆序数组。
时间复杂度为 (O(n^2))，适合较小的 n，对于较大的 n，可能需要优化或采取其他方法来减少复杂度。
