调试HeapSort Java代码

Question

I have a test program to randomly generate data are randomly generated, and then pass them to the class constructor of class Sorter. Then Sorter will sort the data and pass it back through a method to the main function. I have also implemented several other sorting method as the subclass of the Sorter class, and they work just fine. So I think there're no problems in my Sorter class. Below is the output of my test program when using heapsort.

Data:

48 96 71 81 78 72 93 52 67 70

Sorted Data:

48 71 81 78 72 67 52 93 70 96

As you can see, data is not sorted after going through the following code. And below is the code.

public class HeapSort extends Sorter{
    private int[] heap;
    private int size;

    public HeapSort(int[] data){
        super(data);
    }

    public void sort(){
        constructHeap();

        for(int i = size - 1; i >= 0; i--){
            numbers[i] = extractMax();
        }
    }

    public void constructHeap(){
        size = numbers.length;
        heap = new int[size];
        for(int j = 0; j < size; j++) heap[j] = numbers[j];

        for(int i = size/2 - 1; i >= 0; i--){
            fixHeap(i, heap[i]);
        }
    }

    public int extractMax(){
        int max = heap[0];
        fixHeap(0, heap[--size]);
        return max;
    }

    public void fixHeap(int pos, int key){
        if(left(pos) > size) heap[pos] = key; // if current position is leaf
        else{
            int largest = pos;
            int r = right(pos);
            int l = left(pos);
            if(r < size && heap[largest] < heap[r]) largest = r;
            if(l < size && heap[largest] < heap[l]) largest = l;

            if(largest == pos) heap[pos] = key;
            else{
                heap[pos] = heap[largest];
                fixHeap(largest, key);
            }
        }
    }

    public int left(int i){return 2*i+1;}

    public int right(int i){return 2*i+2;}
}

Edited: Below is the debugged code. Hopefully someone would find it useful.

public class HeapSort extends Sorter{

  private int[] heap;
  private int size;

  public HeapSort(int[] data){
    super(data);
  }

  public void sort(){
    constructHeap();

    for(int i = size - 1; i >= 0; i--){
      numbers[i] = extractMax();
    }
  }

  public void constructHeap(){
    size = numbers.length;
    heap = new int[size];
    for(int j = 0; j < size; j++) heap[j] = numbers[j];

    for(int i = size/2 - 1; i >= 0; i--){
      fixHeap(i);
    }
  }

  public int extractMax(){
    int max = heap[0];
    heap[0] = heap[--size];
    fixHeap(0);
    return max;
  }

  public void fixHeap(int pos){
    if(left(pos) < size){               // if current position is not leaf
      int largest = pos;
      int r = right(pos);
      int l = left(pos);
      if(r < size && heap[largest] < heap[r]) largest = r;
      if(l < size && heap[largest] < heap[l]) largest = l;

      if(largest != pos){
        exchange(pos, largest);
        fixHeap(largest);
      }
    }
  }

  public int left(int i){return 2*i+1;}

  public int right(int i){return 2*i+2;}

  public void exchange(int a, int b){
    int temp = heap[a];
    heap[a] = heap[b];
    heap[b] = temp;
  }

}

Answer 1

I assume you have a debugger, and know how to use it.

In my opinion, the best way to debug complex code is what I call "divide and conquer debugging". Pseudocode:

void debug(Time beforeTheBug, Time afterTheBug) {
    do {
        Time pivot = between(beforeTheBug, afterTheBug);
        if (stateIsAsExceptedAt(pivot)) {
            afterTheBug = pivot;
        } else {
           beforetheBug = pivot;
        }
    } while (amountOfCodeExecutedBetween(beforeTheBug, afterTheBug) is not trivial);
}

In your case, my first check was the output. Indeed, it was not sorted, so the bug is in this class.

My next check was whether the heap invariant was satisfied after constructHeap. At that time, heap is [96, 48, 93, 81, 78, 72, 71, 52, 67, 70], so the heap invariant is not satisfied (48 is not greater than 78), and a bug occurs during construction of the heap.

Looking at constructHeap() reveals no useful break point, because the first loop is quite simpe, and very unlikely to be wrong, while the second loop (with its call to fixHeap) contains all the complexity.

The first iteration of the loop finds nothing to change, which is correct, as the subtree already satisfies the heap invariant. Same for the second iteration.

The third iteration correctly identifies that the right child is greater than the root, and swaps the two.

The forth iteration finds nothing to change, which is correct.

So it is the very last iteration of the loop that contains the problem. Both children are greater than the parent. fixHeap correctly moves the greater child into the root, and invokes itself recursively. That invocation finds the heap invariant satisfied, and returns. But the invariant is not satisfied after the return.

So the problem is somewhere from detection of the heap invariant to the return. The detection checks:

        if (r < size && heap[largest] < heap[r])
            largest = r;
        if (l < size && heap[largest] < heap[l])
            largest = l;

where heap is [96, 96, 93, 81, 78, 72, 71, 52, 67, 70]. Yes, 96 is greater than 81 and 78. But actually, shouldn't heap[pos] == key ? Ah, that's what the next statement does...

Put differently, we were checking the heap invariant before completing the previous update, and then finishing that update, which broke the invariant in this case ...