数组 - 求元素的邻居？

Question

这个问题要求编写静态方法sumNeighbours，它将一个整数数组作为参数，并返回一个与原始数组具有相同元素数的数组，这样新数组中的每个整数都是它的邻居和它自身的总和。阵列。

例如

[10, 20, 30, 40]

将会

[30, 60, 90, 70]
30(10+20) 60(20+10+30) 90(30+20+40) 70(40+30)

谢谢。 这是我已经完成的代码并且它可以工作，但仅适用于某些情况，而不是所有情况。 有人能推荐一种更有效的方法吗？ 没有硬编码所有那些if和其他的特定情况。

public static int[] sumNeighbours(int[] values) {
int[] list = new int[values.length];
for (int i=0; i<values.length; i++) {
    if (values.length > 1) {
        if (values[i] == values[0]) {
            list[i] = values[i] + values[i+1];
        }
        else if (values[i] == values[values.length-1]) {
            list[i] = values[i] + values[i-1];
        }
        else {
            list[i] = values[i] + values[i-1] + values[i+1];
        }
    }
    else {
        list [i] = values[i];
    }
}
return list;
}   

Answer 1

首先：您的输入可能为null，因此首先进行null检查，我猜在这种情况下返回null。

第二：创建相同大小的数组后，需要迭代输入，并为每个索引检查两件事：

1. 如果index小于（length-1），则在右侧添加元素
2. 如果索引大于0，则在左侧添加元素
3. 始终在当前索引中添加元素

完成了吗？

Answer 2

不要使用值来检查元素是否是最后一个，使用索引并且还具有nullptr检查。 您的代码将因[30,30,30]这样的情况而失败

    public static int[] sumNeighbours(int[] values) {
        if (null == values)
            return null;
        int[] list = new int[values.length];
        for (int i=0; i<values.length; i++) {
            if (values.length > 1) {
                if (i == 0) {
                    list[i] = values[i] + values[i+1];
                }
                else if (i == values.length-1) {
                    list[i] = values[i] + values[i-1];
                }
                else {
                    list[i] = values[i] + values[i-1] + values[i+1];
                }
            }
            else {
                list [i] = values[i];
            }
        }
        return list;

    }

Answer 3

这是我已经完成的代码并且它可以工作，但仅适用于某些情况，而不是所有情况

可能是因为你比较值而不是索引： if (values[i] == values[0])必须是if (i == 0)和if (values[i] == values[values.length-1])必须是if (i == values.length - 1) 。

使用较少代码和空检查的代码段可能如下所示

public static int[] sumNeighbours(int[] input) {
    if (input == null) {
        return null;
    }

    int[] result = new int[input.length];
    for (int i = 0; i < input.length; i++) {
        int sum = input[i];

        if (i > 0) {
            sum += input[i - 1];
        }
        if (i < (input.length - 1)) {
            sum += input[i + 1];
        }

        result[i] = sum;
    }

    return result;
}

Answer 4

如果在循环中删除if块，效率更高：

public static int[] sumNeighbours(final int[] values) {

    if (null == values || 2 > values.length) {
        return values;
    }

    final int len = values.length;
    final int[] list = new int[len];

    list[0] = values[0] + values[1];
    list[len - 1] = values[len - 2] + values[len - 1];

    for (int i = 1; i < len - 2; i++) {
        list[i] = values[i - 1] + values[i] + values[i + 1];
    }

    return list;
}

边缘上不需要汇总3数字。

Answer 5

看一下这个，

public static int[] sumNeighbours(int[] values) {
int[] list = new int[(values.length)];
for (int i=0; i<values.length; i++) {
 if (values.length > 1) { //To Check if there are more than one values
    if(i==0) //It will check if it is first element
    {
        list[i]=values[i]+values[i+1]; //Add First value and second value to place it in first location. As first location has only one Neighbor 

    }
    else if (i==(values.length-1)) //TO check If its last value
    {
        list[i]=values[i]+values[i-1]; //As Last Location has only one Neighbor
    }
    else
    {
         list[i]=values[i]+values[i-1]+values[i+1]; //For All intermediate locations
  }
}
}
return list;
}