Java实现将大数组按往返索引规则累加填充至小数组

首先，先修正你代码里的基础错误：你的循环变量用了i但递增的是k，而且是直接赋值=而不是累加+=，这会导致后续元素覆盖之前的值，无法实现累加需求。

接下来，针对你需要的“先递增索引到目标数组最大索引，再反转方向递减，按需循环”的需求，我们可以通过跟踪当前目标索引和移动方向来实现，不需要额外生成索引序列，效率很高。

完整实现代码（匹配你的示例需求） #

public class YourClassName {
    private int[] rowHeights;
    private int[] rowHeightsTwo;

    public YourClassName() {
        // 初始化原数组
        this.rowHeights = new int[] {3, 1, 2, 4, 6, 8, 9, 1, 3, 4};
        // 注意：你的示例中用到了索引7，所以目标数组长度设为8（索引0-7），若需其他长度可直接修改
        this.rowHeightsTwo = new int[8];
        
        fillRowHeightsTwo();
    }

    private void fillRowHeightsTwo() {
        if (rowHeightsTwo.length == 0) {
            return; // 避免空数组异常
        }

        int maxTargetIdx = rowHeightsTwo.length - 1; // 目标数组的最大索引
        int currentTargetIdx = 0; // 当前要填充的目标索引
        boolean isForward = true; // 标记当前是否为正向（递增）移动
        boolean hasReachedMax = false; // 标记是否第一次到达最大索引

        for (int num : rowHeights) {
            // 将当前元素累加到目标数组对应索引
            rowHeightsTwo[currentTargetIdx] += num;

            // 控制索引移动逻辑
            if (isForward) {
                if (currentTargetIdx == maxTargetIdx) {
                    hasReachedMax = true;
                    // 第一次到达最大索引，先停留一次再反转方向
                } else {
                    currentTargetIdx++;
                }
            } else {
                currentTargetIdx--;
                if (currentTargetIdx == 0) {
                    isForward = true; // 回到起点后重新正向移动（若不需要循环可去掉）
                }
            }

            // 第一次停留后切换为反向移动
            if (hasReachedMax && isForward) {
                isForward = false;
                hasReachedMax = false;
            }
        }

        // 打印结果验证
        for (int i = 0; i < rowHeightsTwo.length; i++) {
            System.out.println("rowHeightsTwo[" + i + "] = " + rowHeightsTwo[i]);
        }
    }

    public static void main(String[] args) {
        new YourClassName();
    }
}

代码逻辑解释 #

1. 变量初始化：

   • maxTargetIdx：动态获取目标数组的最大索引，适配任意长度的目标数组。
   • currentTargetIdx：跟踪当前要填充的目标索引，初始从0开始。
   • isForward：标记当前索引移动方向，true为正向递增，false为反向递减。
   • hasReachedMax：标记是否第一次到达目标数组的最大索引，用于实现示例中“在最大索引停留一次”的需求。

2. 遍历原数组：

   • 对原数组的每个元素，用+=将其值累加到目标数组对应索引位置，保证后续元素不会覆盖已有值。
   • 根据当前方向和是否到达边界，调整目标索引：
     • 正向移动时，到达最大索引后先停留一次，再切换为反向。
     • 反向移动时，到达起点后可重新切换为正向（若不需要循环填充，可删除此逻辑）。

示例验证结果 #

运行上述代码后，输出将完全匹配你的示例：

rowHeightsTwo[0] = 3
rowHeightsTwo[1] = 1
rowHeightsTwo[2] = 2
rowHeightsTwo[3] = 4
rowHeightsTwo[4] = 6
rowHeightsTwo[5] = 8
rowHeightsTwo[6] = 13 （原数组的9 + 3）
rowHeightsTwo[7] = 4 （原数组的1 + 4）

灵活调整方向逻辑 #

如果你的索引序列需求是“正向到最大索引后直接反向递减，不需要停留”，可以简化方向控制逻辑：

private void fillRowHeightsTwo() {
    if (rowHeightsTwo.length == 0) {
        return;
    }

    int maxTargetIdx = rowHeightsTwo.length - 1;
    int currentTargetIdx = 0;
    int direction = 1; // 1为正向递增，-1为反向递减

    for (int num : rowHeights) {
        rowHeightsTwo[currentTargetIdx] += num;
        
        // 到达边界时反转方向
        if (currentTargetIdx == maxTargetIdx) {
            direction = -1;
        } else if (currentTargetIdx == 0) {
            direction = 1;
        }
        
        currentTargetIdx += direction;
    }
}

内容的提问来源于stack exchange，提问作者user13011998