Question

我目前正在研究排序算法，需要实现HeapSort和Introspective Sort。

我认为我已经成功实现了HeapSort（代码可以工作，尝试了数百万随机大小的随机数组，总是有效），这是我的代码：

  public static <T extends Comparable<? super T>> void hsort(T[] a) {
    int n = a.length;
    if(n < 2) return;
    /* Heapify */
    for(int i = (n-2)/2; i >= 0; i--)
      moveDown(a, i, n);
    for(int i = n-1; i > 0; i--) {
      swap(a, 0, i);
      moveDown(a, 0, i);
    }
  }

moveDown代码是：

private static <T extends Comparable <? super T>> void moveDown(T[] a, int i, int max) {
    T e = a[i];
    int j;  /* Son index */
    while((j = (2*i)+1) < max) {
      if(j+1 < max && a[j+1].compareTo(a[j]) > 0) j++; /* Biggest son */
      if(e.compareTo(a[j]) >= 0) break;
      a[i] = a[j];
      i = j;
    }
    a[i] = e;
  }

这两种方法完全没问题，我已经多次测试了，我从未遇到任何问题。

我也尝试从这两种方法开始并实现Introspective Sort，我的代码是这样的：

public static <T extends Comparable<? super T>> void introSort(T[] a) {
    int size = a.length;
    if(size < 2) return;
    int log = Integer.SIZE - Integer.numberOfLeadingZeros(size);
    introSort(a, 0, size-1, 2*log);
  }

private static <T extends Comparable<? super T>> void introSort(T[] a, int min, int max, int lev) {
    if(max - min < ISORT_THRESHOLD) isort(a, min, max); // Small intervall
    else if(lev == 0) hsortAux(a, min, max); // HeapSort on Array Portion
    else {
      // QuickSort
      while (min < max) {
        lev--;
        /* Tukey approximation */
        int t = tukeyApproximation(a, min, max-1);
        //t = min; Ignore this for now and read below this code
        T p = a[t];
        int i = min, j = max;
        do {
          while(a[i].compareTo(p) < 0) i++;
          while(a[j].compareTo(p) > 0) j--;
          if(i <= j) {
            swap(a, i, j);
            i++; j--;
          }
        } while(i <= j);
        introSort(a, min, j, lev);
        min = i;
      }
    }
  }

我认为上面的代码也很好，假设方法isort和hsortAux工作正常。在我的测试中，我注意到只有在调用heapsort时它才会失败。代码应该工作（目标是让它工作）当我使用tukey近似来确定枢轴索引时，以及当我选择一个随机数据集时，例如总是数组的第一个元素。使用QuickSort进行分区应该是正确的，因为我已经尝试了许多快速分类实现，它们都可以工作，正如我已经说过的，代码在没有调用heapsort时有效。分区实际上是另一种方法中快速排序的复制品，效果很好。

我确信方法isort和tukeyApproximation按预期工作，因为我已经单独测试了它们并且在quicksort实现上它们工作得很好。

但是，我似乎无法实现一个heapsort（称为hsortAux的方法），它只在min和max之间的数组部分上完成它的工作。我花了几个小时在这里寻找答案，在谷歌上，我试图通过查看其他人的代码来实现我自己的版本，但我多次失败，在这里我浪费你的时间:)。一旦我设法创建一个有效的heapSort，但是当tukey近似没有选择数据时它似乎不起作用（例如数组的第一个元素或部分中的随机元素）。

这是我目前的hsortAux代码，源自origianl hsortAux：

private static <T extends Comparable<? super T>> void hsortAux(T[] a, int min, int max) {
    for(int i = (min + max - 1)/2 ; i >= min; i--)
      moveDownAux(a, min, i, max+1);
    for(int i = max; i > min; i--) {
      swap(a, min, i);
      moveDownAux(a, min, min, i);
    }
  }

moveDownAux应该是只能在数组部分工作的moveDown方法但是我真的不知道如何实现它，我试图使用之前的moveDown方法，但它显然根本不起作用。在实现moveDownAux时，我甚至不确定我是否需要名为 min 的变量。

这是我目前的moveDownAux方法：

private static <T extends Comparable<? super T>> void moveDownAux(T[] a, int min, int i, int max) {
    T e = a[i];
    int j;  /* Son */
    while((j = (2*i)+1) < max-1) {
      if(j+1 < max && a[j+1].compareTo(a[j]) > 0) j++; /* Biggest Son */
      if(e.compareTo(a[j]) >= 0) break;
      a[i] = a[j];
      i = j;
    }
    a[i] = e;
  }

提前感谢您的时间和答案

Answer 1

因此，经过几周的痛苦，我设法理解了什么是错的。使用以下 moveDownAux 方法，一切似乎都能正常工作：

private static <T extends Comparable<? super T>> void moveDownAux(T[] a, int min, int i, int max) {
    T e = a[i];
    int j;
    while((j = (2*i)+1 - min) < max) {
      if(j+1 < max && a[j+1].compareTo(a[j]) > 0) j++; /* Biggest son */
      if(e.compareTo(a[j]) >= 0) break;
      a[i] = a[j];
      i = j;
    }
    a[i] = e;
  }

我最后所做的只是改变了条件，我仍然试图弄清楚为什么它现在有效并且之前没有。

感谢所有人

关于Array部分Java实现的HeapSort / IntrospectiveSort

1 个答案: