Java 数组中的元素，使其左边的元素和右边的元素和相等

我正在试图解决夏洛克和数组算法的任务。我有一个数组，我需要在数组中找到元素，这样左边的元素和右边的元素相等，就像我在标题中提到的。我的算法适用于小型阵列，但对于大型阵列，它太慢了，我可以做些什么来提高它的速度

我只想提一下。此算法不接受大小为1和2的数组

public static boolean isSherlock(int arr[])
{
    int length = arr.length;
    int leftSum = 0;
    int rightSum = 0;

    for(int i=0; i<length-1; i++)
    {
        leftSum = 0;
        rightSum = 0;

        // Left sum for index i
        for(int j=0; j<i; j++)
            leftSum+=arr[j];

        // Right sum for index i
        for(int j=i+1; j<length && leftSum != 0; j++)
            rightSum+=arr[j];

        if(leftSum == rightSum && leftSum != 0 && rightSum != 0)
        {
            return true;
        }
    }
    return false;
}

公共静态布尔isSherlock（int arr[]）
{
int-length=arr.length；
int leftSum=0；
int rightSum=0；
对于（int i=0；i而言，线性解非常简单

计算数组A中所有元素的和。当然，它可以在线性时间内完成。称之为S

然后迭代所有元素并存储两个和：当前元素左侧所有元素的和和和当前元素右侧所有元素的和。称它们为L和R

对于第一个元素A[0]：

当移动到A[i]时，重新计算L和R：

如果L==R，那么当前元素就是答案。
线性解非常简单

计算数组A中所有元素的和。当然，它可以在线性时间内完成。称之为S

然后迭代所有元素并存储两个和：当前元素左侧所有元素的和和和当前元素右侧所有元素的和。称它们为L和R

对于第一个元素A[0]：

当移动到A[i]时，重新计算L和R：

如果L==R，则当前元素就是答案。
您可以将在上一步计算的左和和右和保存如下：

int sumLeftStepI=0;
int sumRigthStepI = Arrays.stream(a).sum() - a[0];
for (int i=0; i<a.length;i++){
    if(sumLeftStepI==sumRigthStepI){
        System.out.println("found element at position a["+i+"]");
    }
    if(i<a.length-1){
      sumLeftStepI+=a[i];
      sumRigthStepI-=a[i+1];
    }
}

int-sumLeftStepI=0；
int-sumRigthStepI=Arrays.stream（a.sum（）-a[0]；
对于（int i=0；i，您可以保存在上一步计算的左和和右和，如下所示：

int sumLeftStepI=0;
int sumRigthStepI = Arrays.stream(a).sum() - a[0];
for (int i=0; i<a.length;i++){
    if(sumLeftStepI==sumRigthStepI){
        System.out.println("found element at position a["+i+"]");
    }
    if(i<a.length-1){
      sumLeftStepI+=a[i];
      sumRigthStepI-=a[i+1];
    }
}

int-sumLeftStepI=0；
int-sumRigthStepI=Arrays.stream（a.sum（）-a[0]；
对于（int i=0；iAt），首先存储总和，然后使用该总和。下面是代码：

 public static boolean isSherlock(int arr[])
    {

        int length = arr.length;
        int sum = 0;

        for(int i=0; i<length; ++i)
            sum += arr[i];

        int rightSum = sum-arr[0];
        int leftSum = 0;

        for(int i=0; i<length-1; ++i){

            if(leftSum == rightSum)
                return true;

            leftSum += arr[i];
            rightSum -= arr[i+1];
        }

    if (leftSum == rightSum)
        return true;

    return false;
}

公共静态布尔isSherlock（int arr[]）
{
int-length=arr.length；
整数和=0；
对于（int i=0；iAt），首先存储总和，然后使用该总和。下面是代码：

 public static boolean isSherlock(int arr[])
    {

        int length = arr.length;
        int sum = 0;

        for(int i=0; i<length; ++i)
            sum += arr[i];

        int rightSum = sum-arr[0];
        int leftSum = 0;

        for(int i=0; i<length-1; ++i){

            if(leftSum == rightSum)
                return true;

            leftSum += arr[i];
            rightSum -= arr[i+1];
        }

    if (leftSum == rightSum)
        return true;

    return false;
}

公共静态布尔isSherlock（int arr[]）
{
int-length=arr.length；
整数和=0；
对于（inti=0；i试试这个

public static boolean isSherlock(int arr[]) 
{
    if (arr.length > 2) {
        int i = 1;
        for (; i < arr.length - 1; i++) {
            int k = 0;
            int rhs = arr[i + 1];
            int lhs = arr[i - 1];

            int j = arr.length - 1;

            // **In single iteration it is suming from left as well as from right**
            while (k < i - 1 && j > i + 1) {
                rhs += arr[j--];
                lhs += arr[k++];
            }
            // **************

            // If any elements remain
            while (k < i - 1)
                lhs += arr[k++];

            while (j > i + 1)
                rhs += arr[j--];

            // compare
            if (rhs == lhs && lhs != 0 && rhs != 0) {
                return true;
            }
        }
    }
    return false;
}

公共静态布尔isSherlock（int arr[]）
{
如果（arr.length>2）{
int i=1；
对于（；ii+1）{
rhs+=arr[j--]；
lhs+=arr[k++]；
}
// **************
//如果有任何元素残留
而（ki+1）
rhs+=arr[j--]；
//比较
如果（rhs==lhs&&lhs！=0&&rhs！=0）{
返回true；
}
}
}
返回false；
}
试试这个

public static boolean isSherlock(int arr[]) 
{
    if (arr.length > 2) {
        int i = 1;
        for (; i < arr.length - 1; i++) {
            int k = 0;
            int rhs = arr[i + 1];
            int lhs = arr[i - 1];

            int j = arr.length - 1;

            // **In single iteration it is suming from left as well as from right**
            while (k < i - 1 && j > i + 1) {
                rhs += arr[j--];
                lhs += arr[k++];
            }
            // **************

            // If any elements remain
            while (k < i - 1)
                lhs += arr[k++];

            while (j > i + 1)
                rhs += arr[j--];

            // compare
            if (rhs == lhs && lhs != 0 && rhs != 0) {
                return true;
            }
        }
    }
    return false;
}

公共静态布尔isSherlock（int arr[]）
{
如果（arr.length>2）{
int i=1；
对于（；ii+1）{
rhs+=arr[j--]；
lhs+=arr[k++]；
}
// **************
//如果有任何元素残留
而（ki+1）
rhs+=arr[j--]；
//比较
如果（rhs==lhs&&lhs！=0&&rhs！=0）{
返回true；
}
}
}
返回false；
}
无需为sum创建单独的变量。将sum值分配到右侧或左侧。
这是我想出的效率最高的代码

而且很明显，对于长度小于3的数组，结果将是
永远都是假的

private静态布尔平衡intarray（int[]nums）{
int length=nums.length；
如果（长度<3）{
返回false；
}
int left=nums[0]；
int right=0；
对于（int i=2；i
无需为sum创建单独的变量。将sum值分配到右侧或左侧。
这是我想出的效率最高的代码

而且很明显，对于长度小于3的数组，结果将是
永远都是假的

private静态布尔平衡intarray（int[]nums）{
int length=nums.length；
如果（长度<3）{
返回false；
}
int left=nums[0]；
int right=0；
对于（int i=2；i
如果数组中有任何元素，并且你知道左和右和。当你进一步移动一个元素时，如何更新这些和？如何在开始时初始化这些和？@NicoSchertler我想我不理解你的问题。但是每次我们移动到