Question

我编写了一个mergesort算法。当我运行以下测试时：

public static void main(String[] args){
    Integer[] arr = {3,7,9,11,0,-5,2,5,8,8,1};
    List<Integer> list = new ArrayList<>();
    list.addAll(Arrays.asList(arr)); // asList() returns fixed size list, so can't pass to mergesort()
    List<Integer> result = mergesort(list);
    System.out.println(result);
  }

我得到[-5, 0, 1, 2, 3, 5, 7, 8, 8, 9, 11]，这是正确的。但是，我知道mergesort是一个稳定的类型，所以我怎么能编写一个测试来证明这两个8是按照它们原来的顺序？

编辑：由于我使用的是Integer类，而不是原始的整数，我认为我可以得到hashCode()，因为Integer扩展了基类Object类。 / p>

然而，当我尝试

时

Integer[] arr = {3,7,9,11,0,-5,2,5,8,8,1};
System.out.println(arr[8].hashCode());
System.out.println(arr[9].hashCode());

我只得到：

8
8

Answer 1

我能想到的最佳方法是将数字包装在包装器Integer类中。如果您执行以下操作：

Integer eight = new Integer(8);
Integer anotherEight = new Integer(8);

a == b; //Returns false
a.equals(b); //Returns true

另外，正如评论中所建议的那样，您可以在课程中添加一个额外的字段进行比较。

编辑：要回答您的编辑，Integer.hashcode()文档说明密码是

等于此Integer对象表示的原始int值。

Answer 2

我认为使用简单的键值结构，例如某些this或某些that

使用此（简称）：

public class Tuple<X, Y> { 
  public final X x; 
  public final Y y; 
  public Tuple(X x, Y y) { 
    this.x = x; 
    this.y = y; 
  } 
}

你可以这样做：

  public static void main(String[] args)
  {
    Integer[] arr = {new Tuple(3,0),new Tuple(7,1),new Tuple(9,2) ,new Tuple(11,3), new Tuple(0,4), new Tuple(-5,5), new Tuple(2,6), new Tuple(5,7), new Tuple(8,8), new Tuple(8,9), new Tuple(1,10)};
    List<Tuple<Integer,Integer>> list = new ArrayList<>();
    list.addAll(Arrays.asList(arr)); // asList() returns fixed size list, so can't pass to mergesort()
    List<Integer> result = mergesort(list);
    System.out.println(result);
  }

在合并排序的代码中，只合并第一个项目，让第二个项目相同，你应该首先看到（8,8），然后看到（8,9）

Answer 3

稳定性证明将涉及分析合并排序算法，而不是创建稳定性测试未失败的测试用例。首先分析自下而上的合并排序可能更简单。首先，将n个元素的数组视为长度为1的n次运行的数组，然后重复合并这些运行，直到生成单个排序的运行。在k-way合并排序中，如果来自k次运行的当前元素相等，则最左侧运行的元素将移动到输出数组，从而保持稳定性。

对于自上而下的合并排序（通常为2路），同样的规则适用，遇到相同的元素时，左边的元素会被移动，从而保持稳定。

证明mergesort是稳定的

3 个答案: