Question

我正在构建一个可排序的ArrayLists类，它扩展了ArrayList。目标是能够在SortDoubleArray上调用sort方法，并通过所描述的方法对该数组进行排序。我得到了Quicksort，插入排序，冒泡排序和选择排序都按我的意愿工作。但是，我在使用Merge Sort时遇到了一些困难。

排序有效，但是由于所涉及的递归的工作方式，我被强制重置列表的内容作为应用于自身的方法。

首先，这是测试人员类。它显示了其他种类的实施方式。如果我在解释我的问题时做得不好，希望你会看到必须使用mergeSort（）方法的区别。

public class SortTester
{
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        SortDoubleArray list = new SortDoubleArray();

        // Code to fill an array with random values.

        //list.quickSort();
        //list.insertionSort();
        //list.selectionSort();
        //list.bubbleSort();
        list = list.mergeSort();

        // Code to print the sorted array.
    }
}

接下来，这是SortDoubleArray类。所有其他排序，但insertSort（作为一个以我想要的方式工作的例子）已被删除，以简洁。

public class SortDoubleArray extends ArrayList<Double>
{ // Start of class.
    private static final long serialVersionUID = 1271821028912510404L;

    /**
     * Progresses through the elements one at a time inserting them in their proper place
     * via swaps.
     */
    public void insertionSort()
    { // Start of insertionSort.
        int current = 1;

        while (current < size())
        {
            int i = current;
            boolean placeFound = false;

            while(i > 0 && !placeFound)
            {
                if (get(i) < get(i - 1))
                {
                    double temp = get(i);
                    set(i, get(i - 1));
                    set(i - 1, temp);
                    i -= 1;
                }
                else
                {
                    placeFound = true;
                }
            }
            current += 1;
        }
    } // End of insertionSort.

    /**
     * Triggers the recursive mSort method.
     * @return 
     */
    public SortDoubleArray mergeSort()
    { // start of mergeSort.
        return mSort(this);
    } // End of mergeSort.

    /**
     * Separates the values each into their own array.
     */
    private SortDoubleArray mSort(SortDoubleArray list)
    { // Start of mSort.
        if (list.size() <= 1)
        {
            return list;
        }

        SortDoubleArray left = new SortDoubleArray();
        SortDoubleArray right = new SortDoubleArray();

        int middle = list.size() / 2;

        for (int i = 0; i < middle; i += 1)
        {
            left.add(list.get(i));
        }

        for (int j = middle; j < list.size(); j += 1)
        {
            right.add(list.get(j));
        }

        left = mSort(left);
        right = mSort(right);

        return merge(left, right);
    } // End of mSort.

     /**
     * Merges the separated values back together in order.
     */
    private SortDoubleArray merge(SortDoubleArray left, SortDoubleArray right)
    { // Start of merge.
        SortDoubleArray result = new SortDoubleArray();

        while (left.size() > 0 || right.size() > 0)
        {
            if (left.size() > 0 && right.size() > 0)
            {
                if (left.get(0) <= right.get(0))
                {
                    result.add(left.get(0));
                    left.remove(0);
                }
                else
                {
                    result.add(right.get(0));
                    right.remove(0);
                }
            }
            else if (left.size() > 0)
            {
                result.add(left.get(0));
                left.remove(0);
            }
            else if (right.size() > 0)
            {
                result.add(right.get(0));
                right.remove(0);
            }
        }

        return result;
    } // End of merge.
} // End of class.

请告诉我如何改变SortDoubleArray类中的mergeSort（）/ mSort（）函数，使其具有与其他类别相同的实现。

谢谢！

Answer 1

鉴于mSort和merge方法是正确的，这个怎么样？

public void mergeSort()
{ // start of mergeSort.
    SortDoubleArray result = mSort(this);
    clear();
    addAll(result);
} // End of mergeSort.

您测试中的相关行将是：

    list.mergeSort();

祝你好运！

Answer 2

目前，您的mergeSort()和merge()个函数都在创建新的SortedDoubleArray个对象。理想情况下，您可以在不创建新数组的情况下就地执行所有操作，创建和复制的数量将为您的算法创造相当大的性能。

所以你的方法会有这样的原型：

private SortDoubleArray mSort(SortDoubleArray list, int startIndex, int length)

private SortDoubleArray merge(SortDoubleArray list, 
                              int leftIndex, int leftlength,
                              int rightIndex, int rightlength)

然后使用ArrayList.set和.get与临时变量进行就地交换。这意味着您只需要处理单个阵列而不会创建任何新的不必要的阵列。

这有帮助吗？如果我理解了这个问题或者您需要更多解释，请告诉我。

请注意，int endIndex也可以代替int length

需要帮助简化我的Merge Sort实现

2 个答案: