Java 为什么；int mid=（左-右）/2+；对",；会导致堆栈溢出吗？

今天我编写了合并排序的代码，当我运行

intmid=（left-right）/2+right时遇到了StackOverFlow错误。但是当我使用
intmid=left+（right-left）/2时一切都很好。我很困惑，因为它们两个的数学意义是相同的（如果不是，为什么？）

我见过这个问题，但我不确定它是否回答了这个问题。

这是我的代码，很抱歉我以前没有上传代码

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        int[] array = {3,5,1,2,4,8};
        int[] result = mergeSort(array);
        System.out.println(Arrays.toString(result));
    }

    public static int[] mergeSort(int[] array) {
        if (array == null || array.length <= 1) {
            return array;
        }
        int[] helper = new int[array.length];
        sort(array, helper, 0, array.length - 1);
        return array;
    }

    public static void sort(int[] array, int[] helper, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = (left - right)/2 + right;
        //int mid = left + (right - left) / 2;
        sort(array, helper, left, mid);
        sort(array, helper, mid + 1, right);

        combine(array, helper, left, mid, right);
    }

    public static void combine(int[] array, int[] helper, int left, int mid, int right) {
        for (int i = left; i <= right; i++) {
            helper[i] = array[i];
        }

        int leftIndex = left;
        int rightIndex = mid + 1;
        while (leftIndex <= mid && rightIndex <= right) {
            if (helper[leftIndex] <= helper[rightIndex]) {
                array[left] = helper[leftIndex];
                left++;
                leftIndex++;
            } else {
                array[left] = helper[rightIndex];
                left++;
                rightIndex++;
            }
        }

        while (leftIndex <= mid) {
            array[left] = helper[leftIndex];
            left++;
            leftIndex++;
        }
    }
}

导入java.util.array；
公共类解决方案{
公共静态void main（字符串[]args）{
int[]数组={3,5,1,2,4,8}；
int[]结果=合并排序（数组）；
System.out.println（Arrays.toString（result））；
}
公共静态int[]合并排序（int[]数组）{
if（array==null | | array.length=right）{
回来
}
int mid=（左-右）/2+右；
//int mid=左+（右-左）/2；
排序（数组、辅助对象、左侧、中间）；
排序（数组，辅助对象，中间+1，右侧）；
组合（阵列、辅助对象、左、中、右）；
}
公共静态void组合（int[]数组、int[]辅助对象、int left、int mid、int right）{
对于（int i=left；i当您运行此程序时，
left
很可能比
right
小一个-例如，可能
left=3
和
right=4

在这种情况下，
（左-右）/2
和
（右-左）/2
都计算为
0
，因为整数除法舍入为零

int mid = (left - right)/2 + right;
sort(array, helper, left, mid);

在对
排序（数组、助手、左、右）
的调用中，您将使用完全相同的值重复调用。这将导致无限递归-一个
堆栈溢出错误

但是当你有

int mid = left + (right - left)/2;
sort(array, helper, left, mid); 

然后你用不同的值重复一个调用，因此递归有机会结束。
我很困惑，因为它们两个的数学意义是相同的。
不，不是。请回答你的问题，并向我们展示你方法的完整代码。而不仅仅是一行（你的问题，不要在注释中添加代码）需要明确的是，您所说的是整数溢出，而不是堆栈溢出。如果您收到的是
StackOverflowerError
，那么您的问题就在其他地方。为什么您对所链接问题的答案不满意？不，这是
StackOverflowerError
。这是因为整数除以负数向零舍入。因此，当您到达
right=1+left
时，
mid
与
right
的结果相同。取决于您的其余代码如何处理此问题，您可能会无休止地递归。现在-如果您显示所有代码（而不仅仅是一行），可能会有人提出修复建议。