Question

我正在尝试理解比较器在处理数组时处理的元素的顺序。

它是否随机选择任意两个索引，并保持数组按排序顺序保持一致，并且一旦匹配所有可能的索引对，就继续这样做，这是我在想的。或者指数取决于Arrays.sort使用的内部排序算法，这些是我正在考虑的事情。

另外，比较器是否在内部使用Heap，因为对我来说，看起来，在输出中的某个点，比如说，数组看起来像这样

4 3 1 2 5

在比较元素2,1时，突然数组看起来如下，这意味着它不仅仅是在比较的值2和1之间进行交换，而且还影响了数组中的其他元素。这是通过使用堆来实现的吗？

1 3 4 2 5

我尝试打印索引如下

public class HowComparatorsWork {
    public static void main(String[] args) {
        HowComparatorsWork obj = new HowComparatorsWork();

        obj.understandHowComparatorsWork();
    }

    public void understandHowComparatorsWork()
    {
        Integer[] a = {4,3,1,2,5};

        Arrays.sort(a, new Comparator<Integer>()
            {
                @Override
                public int compare(Integer a1, Integer a2)
                {
                    print(a);

                    System.out.println("");
                    System.out.println(a1 + "," + a2);
                    return a1 - a2;
                }
            });
        print(a);
    }

    public void print(Integer[] a)
    {
        for(int i = 0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println("");
    }
}

输出如下

编辑：我觉得，这不仅仅是排序，而是“按照任何顺序排列”可以使用比较器完成。例如，我可以让我的比较方法在奇数之前排列（排序？）所有偶数。即使在这种情况下，Java中的处理元素也是如此与TimSort的顺序相同，因为我们使用的是Arrays.sort？

public void evenOddComparator()
    {
        Integer[] a = {4,3,1,2,5,6,8,9,7,10};

        Arrays.sort(a, new Comparator<Integer>()
            {
                final int BEFORE = -1;
                final int EQUAL = 0;
                final int AFTER = 1;

                @Override
                public int compare(Integer o1, Integer o2) {
                    if (o1 % 2 == 0 && o2 % 2 != 0) {
                        return BEFORE;
                    } else if (o1 % 2 != 0 && o2 % 2 == 0) {
                        return AFTER;
                    } else if (o1 % 2 == 0 && o2 % 2 == 0) {
                        return o1.compareTo(o2);
                    } else if (o1 % 2 != 0 && o2 % 2 != 0) {
                        return o2.compareTo(o1);
                    }
                    return EQUAL;
                }
            });
        print(a);   
    }

这是否意味着，与自定义Comparator一起使用的Arrays.sort可用于按照compare（）方法逻辑定义的任何顺序排列元素，但处理的元素的顺序将始终与TimSort相同，因为我们正在使用Arrays.sort？

请澄清

比较器是否在内部使用堆

0 个答案: