Question

只是练习一些排序算法。我尝试实现递归合并排序，但是为每个递归调用获取新的透视图似乎存在问题。

我觉得我的代码应该正常工作......但我是新手使用ArrayList作为数据结构......并且只有数组经验。我需要一个动态大小的数组，所以我使用的是ArrayList。

它只是继续吐出pivot = 1直到它溢出：

pivot: 1
pivot: 1
pivot: 1
pivot: 1
pivot: 1
...
Exception in thread "main" java.lang.StackOverflowError

码

      import java.util.*;

public class Sorts{
    static Sorts run;               
    List<Integer> initialList = new ArrayList<Integer>();

    public Sorts() {

        //List<Integer> initialList = new ArrayList<Integer>();


        initialList.add(1);
        initialList.add(4);
        initialList.add(8);
        initialList.add(2);
        initialList.add(3);
        initialList.add(7);
        initialList.add(9);


        System.out.print("List of values: (");
        for (int value: initialList) {
            System.out.print(value);
        }
        System.out.println(")");

        //output sorted array
        System.out.println("Sorted list: " + mergeSort(initialList));                                                          
    }

    public List<Integer> mergeSort(List<Integer> list) {                               
        if (list.size() <= 1) {
            return list;
        }

        //after each recursion, generate two new sub lists
        List<Integer> left = new ArrayList<Integer>();
        List<Integer> right = new ArrayList<Integer>(); 

        //generate new pivot for each new list
        int middle = list.size()/2;
        System.out.println("middle: " + middle);

        int i = 0;
        for (int x: list) {
            if (i < middle) {
                left.add(x);
            }
            else {
                right.add(x);
            }
            i++;
        }

        //call mergeSort, passing in each new sublist (left, right)
      left = mergeSort(left);
      right = mergeSort(right);

       return mergeLists(left, right);
     }

    public List<Integer> mergeLists (List<Integer> left, List<Integer> right) {
        List<Integer> sortedList = new ArrayList<Integer>();
        int i = 0;
        while (left.size() > 0 || right.size() > 0) {
            if (left.size() > 0 && right.size() > 0) {
                if (left.get(i) <= right.get(i)) {
                    sortedList.add(left.get(i));
                }
                else {
                    sortedList.add(right.get(i));
                }
            }
            else if (left.size() > 0) {
                sortedList.add(left.get(i));
            }
            else if (right.size() > 0) {
                sortedList.add(right.get(i));
            }
        }

        for (int value : sortedList) {
            System.out.println(value);
        }
        return sortedList;
    }

    public static void main(String []args){
        run = new Sorts();
    }
}

有什么想法？我是否错误地使用了ArrayList？

谢谢！

Answer 1

问题在于您以错误的方式拆分列表：

for (int i: initialList) {
    if (i < pivot) {
        left.add(i);
    }
    else {
        right.add(i);
    }
}

i是initialList中的元素，而不是元素的索引。将其更改为：

int i = 0;
for (int x: initialList) {
    if (i < pivot) {
        left.add(x);
    }
    else {
        right.add(x);
    }
    i++;
}

对于任何downvoter：我已经测试了这个并且工作了:)。

此外，您的merge算法存在问题。您应该在对元素进行排序时合并两个列表，但是您只需插入左侧的值，然后插入右侧的值（但可能是出于测试目的）。

根据您的编辑，现在您在获取数据透视时遇到了新问题：

int pivot = list.get(list.size()/2);

这应该是您在原始代码中发布的内容：

int pivot = initialList.size()/2;

请注意，人们可能会告诉您一些奇怪的建议，因为QuickSort中使用的是pivot，您只需在MergeSort中使用middle或mid

Answer 2

查看http://en.wikipedia.org/wiki/Merge_sort

您不需要与pivot进行比较，它不是您正在实施的分区排序。只需将列表拆分为两个，就像这样。

left = list.sublist(0, pivot);
right = list.sublist(pivot, list.length())

Java - Mergesort没有正确选择枢轴

2 个答案: