Java正在自己对我的double数组进行排序。为什么？

我试图为一个类创建一个合并排序，但无意中发现了这一点。出于某种原因，当我将原始数组拆分为更小的数组时，它会将内容从最小到最大排序。所以，我所要做的就是把它们重新组合起来，最终得到我想要的结果。我找遍了我能想到的任何地方，找不到任何解释。再多的谷歌搜索也没有给我任何答案

原始数组的内容是使用Math.random（）生成的双精度数组

以下是相关代码：

import java.util.Random;
import java.lang.*;


public class Sorting
{
private static int n = 10;
private static double[] arrOne = null;
private static double[] arrTwo = null;
private static boolean timedOut = false;
private static boolean bubbleTimeOut = false;
private static boolean mergeTimeOut = false;
private static long startTime = 0;
private static long endTime = 0;
private static long bubbleSortTime = 0;
private static long mergeSortTime = 0;

public static void main(String[] args)
{
    try
    {
        while(!(timedOut))
        {
            arrOne = fillArray();
            arrTwo = arrOne;

            if(bubbleTimeOut==false)
            {
                startTime = System.currentTimeMillis();
                bubbleSort();
                endTime = System.currentTimeMillis();
                bubbleSortTime = endTime-startTime;
                System.out.println("Bubble sort with "+n+" items takes "+bubbleSortTime+"ms.");
            }

            if(mergeTimeOut==false)
            {
                startTime = System.currentTimeMillis();
                arrTwo = mergeSort(arrTwo);
                endTime = System.currentTimeMillis();
                mergeSortTime = endTime-startTime;
                System.out.println("Merge sort with "+n+" items takes "+mergeSortTime+"ms.");
            }

            if(bubbleTimeOut && mergeTimeOut)
            {
                timedOut = true;
            }

            n = n*10;
        }
    }
    catch(Exception e)
    {
        System.out.println("Java ran out of memory.");
    }
}

public static double[] mergeSort(double[] arr)
{
    if(arr.length<=1)
    {
        return arr;
    }
    int middle = arr.length/2;
    int left = middle;
    int right = arr.length - left;
    double[] tempOne = new double[left];
    double[] tempTwo = new double[right];

    //put first half into an array
    for(int i=0; i<left; i++)
    {
        tempOne[i] = arr[i];
        endTime = System.currentTimeMillis();
        if(endTime-startTime>20000)
        {
            mergeTimeOut = true;
            return arr;
        }
    }
    //put second half into an array
    int temp = 0;
    for(int i=left;i<arr.length;i++)
    {
        tempTwo[temp] = arr[i];
        temp++;
        endTime = System.currentTimeMillis();
        if(endTime-startTime>20000)
        {
            mergeTimeOut = true;
            return arr;
        }
    }

    int ph = tempOne.length + tempTwo.length;
    double[] tempThree = new double[ph];
    for(int i=0;i<tempOne.length;i++)
    {
        tempThree[i] = tempOne[i];
        endTime = System.currentTimeMillis();
        if(endTime-startTime>20000)
        {
            mergeTimeOut = true;
            return arr;
        }
    }
    int k = tempOne.length;
    for(int i=0; i<tempTwo.length;i++)
    {
        tempThree[k] = tempTwo[i];  
        k++;
        endTime = System.currentTimeMillis();
        if(endTime-startTime>20000)
        {
            mergeTimeOut = true;
            return arr;
        }
    }
    return arr;
}

public static void bubbleSort()
{
    double ph = 0;
    boolean swapped = true;
    while(swapped)
    {
        swapped = false;
        for(int i=n-1; i>0; i--)
        {
            if(arrOne[i] < arrOne[i-1])
            {
                ph = arrOne[i];
                arrOne[i] = arrOne[i-1];
                arrOne[i-1] = ph;
                swapped = true;
            }
            endTime = System.currentTimeMillis();
            if(endTime-startTime>20000)
            {
                swapped = false;
                bubbleTimeOut = true;
            }
        }
    }
}

//this method is just to help me test my code.
public static void printArray(double[] arr)
{
    for(int i=0; i<arr.length; i++)
    {
        System.out.println(arr[i]);
    }
}

public static double[] fillArray()
{
    double[] arr = new double[n];
    double rand = 0.0;
    for(int i=0;i<n;i++)
    {
        rand = Math.random();
        arr[i] = rand;
    }
    return arr;
}
}

import java.util.Random；
导入java.lang.*；
公共类排序
{
私有静态int n=10；
私有静态双[]arrOne=null；
私有静态双[]arrTwo=null；
私有静态布尔timedOut=false；
私有静态布尔bubbleTimeOut=false；
私有静态布尔合并超时=false；
私有静态长起始时间=0；
私有静态长结束时间=0；
私有静态长bubbleSortTime=0；
私有静态长mergeSortTime=0；
公共静态void main（字符串[]args）
{
尝试
{
而（！（timedOut））
{
arrOne=fillArray（）；
arrTwo=arrOne；
if（bubbleTimeOut==false）
{
startTime=System.currentTimeMillis（）；
泡泡运动（）；
endTime=System.currentTimeMillis（）；
bubbleSortTime=结束时间开始时间；
System.out.println（“带有“+n+”项的冒泡排序需要“+bubbleSortTime+”毫秒”）；
}
if（mergeTimeOut==false）
{
startTime=System.currentTimeMillis（）；
arrTwo=合并排序（arrTwo）；
endTime=System.currentTimeMillis（）；
mergeSortTime=结束时间开始时间；
System.out.println（“与“+n+”项合并排序采用“+mergeSortTime+”ms.”；
}
如果（bubbleTimeOut&&mergeTimeOut）
{
timedOut=true；
}
n=n*10；
}
}
捕获（例外e）
{
println（“Java内存不足”）；
}
}
公共静态双[]合并排序（双[]arr）
{
if（arr.length0；i--）
{
if（arrOne[i]20000）
{
交换=假；
bubbleTimeOut=true；
}
}
}
}
//这个方法只是为了帮助我测试我的代码。
公共静态void打印数组（双[]arr）
{
对于（int i=0；i，故障从这里开始：

arrOne = fillArray();
arrTwo = arrOne;

这使得arrTwo只是arrOne的一个“别名”，即引用相同数据的另一个名称。为了避免这种情况，如果您确实希望它们是具有相同内容的两个单独数组，则必须复制该数组，例如使用

arrOne = fillArray();
arrTwo = Arrays.copyOf(arrOne,arrOne.length);

当然，如果你不能使用数组，也可以使用
for
循环手动执行。
你在我们看不到的地方做了一些奇怪的事情。我继续添加了完整的代码。如果有奇怪的事情，我看不到。你知道你提供了一个预排序数组来合并排序，因为
arrTwo=arrOne
？还有，abunda使用globals会使代码变得脆弱且难以阅读，例如startTime和endTime的使用方式，可以完全在本地解决。当您使用
arrOne=fillArray（）时，您是否了解这一点；arrTwo=arrOne；
您只有一个数组，有两个不同的引用指向同一个数组？因此，在冒泡排序之后，您将一个已排序的数组（使用不同的引用）传递给合并排序。返回并检查您的代码，查看您假设正在创建一个新数组但未创建的每个位置。