Question

我正在尝试用Java编写通用的Merge排序方法。

这是我的源代码：

import java.util.ArrayList;
import java.util.List;

/**
 * An implementation of MergeSort
 *
 * @param <T> the type of data held by the array.
 */
public class MergeSort<T extends Comparable<? super T>> implements ArraySort<T>
{
    /**
     * Sort the array using a MergeSort.
     *
     * (recursively breaks down the array into sub arrays until arrays of size 1 are reached.)
     * (then works backwards merging these arrays back into each other until a sorted array state is reached containing
     *  all the elements of the initial unsorted array, but now sorted).
     *
     * @param array the array to be sorted.
     * @return array (sorted)
     */
    @Override
    public T[] sort(T[] array)
    {
        //If the array being sorted is less than 2 elements, it is already sorted and cannot be split into two separate
        //     arrays, so return the initial array to prevent an exception.
        if(array.length < 2)
        {
            return array;
        }

        //Create two sub arrays from the initial array passed in.
        T[] temp1 = copy(array, 0, (array.length/2) - 1);
        T[] temp2 = copy(array, (array.length/2), array.length - 1);

        //Sort these two arrays.
        sort(temp1);
        sort(temp2);

        //Merge the two subarrays back into the initial array.
        merge(array, temp1, temp2);

        //return the now sorted array.
        return array;
    }

    /**
     * Create and return a new array, comprised of a sublist of a passed in array.
     *
     * @param list the array to create the subarray from.
     * @param from the lower bound within list to copy.
     * @param to the upper bound within list to copy.
     * @return a new list comprised of the elements from 'from' to 'to' in 'list'
     */
    private <T> T[] copy(T[] list, int from, int to)
    {
        List<T> copyL = new ArrayList<>();
        for(int i = 0; i < to - from + 1; i++)
        {
            copyL.add(list[from + i]);
        }
        return copyL.toArray(list);
    }

    /**
     * Merge two sorted arrays into one larger array, keeping the sorted.
     *
     * @param target the array to merge source1 and source2 into.
     * @param source1 a sorted array
     * @param source2 a second sorted array.
     */
    private void merge(T[] target, T[] source1, T[] source2)
    {
        //Variables to keep track of the smallest unused element in each source array.
        int source1Index = 0;
        int source2Index = 0;

        //targetIndex keeps track of the next index to place the next smallest element into.
        for(int targetIndex = 0; targetIndex < target.length; targetIndex++)
        {
            //Choose the smallest element from the two source arrays to place into the target(sorted) array
            if(source1[source1Index].compareTo(source2[source2Index]) < 0)
            {
                target[targetIndex] = source1[source1Index];
                source1Index++;
            }
            else
            {
                target[targetIndex] = source2[source2Index++];
                source2Index++;
            }
        }
    }
}

我不知道为什么，但是我在拨打第38和42行时遇到了StackOverflow错误。

38 = T[] temp1 = copy(...) in the sort() method
42 = sort(temp1) in the sort() method.

这使我相信该错误是在复制函数中的某处，但我不知道如何解决该问题或寻求解决方案。

请问有人可以帮我解决这种通用合并排序的实现吗？

StackTrace用于对12个元素的数组进行排序。

https://docs.google.com/document/d/1Ig5p7TZF_eX0Q_rroORnZUWnXtep7x-7cmDiSAZWlj8/edit?usp=sharing

Answer 1

您的条件还不够好，您会在数组上收到无限的排序调用。

至少应包括大小等于2的数组：

if(array.length <= 2)

此外，必须改进您的复制方法。

无论如何，请复制/粘贴您的完整堆栈跟踪。

Answer 2

您的数组复制错误。

使用：

    private <T> T[] copy(T[] list, int from, int to) {
        return Arrays.copyOfRange(list, from, to);
    }

您的代码中存在更多错误（merge无法处理不同长度的数组），但这应该可以解决您的问题。

请参见List.toArray(T[])

...如果列表适合指定的数组，则会在其中返回。

即您将复制到原始阵列中，而不是创建新阵列，因此您的阵列实际上不会减小大小。

通用MergeSort Java实现堆栈溢出错误

2 个答案: