合并排序的Java实现不起作用

Question

I am trying to implement this version of merge sort, as seen in Introduction to Algorithms by Cormen.

public static void merge(int[] A, int p, int q, int r) {
    int lengthOfLeftSubarray = q - p + 1;
    int lengthOfRightSubarray = r - q;

    int[] L = new int[lengthOfLeftSubarray + 1];
    int[] R = new int[lengthOfRightSubarray + 1];

    for(int i=0; i<lengthOfLeftSubarray; i++) 
        L[i] = A[p + i];

    for(int i=0; i<lengthOfRightSubarray; i++) 
        R[i] = A[q + i];

    L[lengthOfLeftSubarray] = -1;
    R[lengthOfRightSubarray] = -1;

    int i = 0, j = 0;
    for(int k=p; k<r; k++) {
        if(L[i] <= R[j]) {****
            A[k] = L[i];
            i++;
        }
        else {
            A[k] = R[j];
            j++;
        }
    }
}

public static void mergesort(int[] A, int p, int r) {
    if(p < r){
        int q = (p + r) / 2;
        mergesort(A, p, q);
        mergesort(A, q + 1, r);
        merge(A, p, q, r);
    }       
}

public static void main(String[] args) {
    int[] unsorted = {12, 16, 4, 2, 7, 6};
    Sorting.mergesort(unsorted, 0, unsorted.length - 1);
    System.out.println(Arrays.toString(unsorted));
}

There are two issues that I have:

1. In the book, a sentinel card is mentioned, which is supposed to be some sort of special value to put in an array, which won't interfere with the sorting. I have used -1 because I couldn't think of a way to use infinite , as suggested in the book. Could anyone explain what a sentinel is?
2. The code is throwing an ArrayOutOfBounds exception in the merge method, where the four stars are ( * *). Any ideas as to why this is happening?

Answer 1

On a cursory glance (ie I did not fix the code and run it locally to confirm the test case works), it looks like there's two bugs:

1)

for(int i=0; i<lengthOfRightSubarray; i++) 
    R[i] = A[q + i];

The right subarray should start at q + 1 just like it did when you did the recursive call:

mergesort(A, q + 1, r);

2) In the OP comments it looks like you sorted this out, but your choice of sentinel value doesn't work. The point of the sentinel value depends on the algorithm. In this case, the point of the sentinel value was that it was supposed to be larger than any element in the input array unsorted . In particular, when you do the merge the entire point is that you have two sorted sub arrays and want to merge them into one bigger, and still sorted , array. So quick example:

---- At the beginning ----
LEFT: {4, 12 16, INFINITY}
       ^
RIGHT: {2, 6, 7, INFINITY}
        ^
MERGED ARRAY: { }
               ^

---- After one iteration of the for loop ----
LEFT: {4, 12 16, INFINITY}
       ^
RIGHT: {2, 6, 7, INFINITY}
           ^
MERGED ARRAY: {2}
               ^

---- After second iteration of the for loop ----
LEFT: {4, 12 16, INFINITY}
          ^
RIGHT: {2, 6, 7, INFINITY}
           ^
MERGED ARRAY: {2, 4}
                  ^

---- After third iteration of the for loop ----
LEFT: {4, 12 16, INFINITY}
          ^
RIGHT: {2, 6, 7, INFINITY}
              ^
MERGED ARRAY: {2, 4, 6}
                     ^

---- After fourth iteration of the for loop ----
LEFT: {4, 12 16, INFINITY}
          ^
RIGHT: {2, 6, 7, INFINITY}
                 ^
MERGED ARRAY: {2, 4, 6, 7}
                        ^

And you can see why the sentinel value is important here. Since the right index is pointing at INFINITY , the elements in the left sub array will be merged appropriately. It is easy to put -1 in place of INFINITY and watch your merge trigger an ArrayOutOfBounds exception.

The entire reason the sentinel value is useful just because we don't want to handle the case when one sub array runs out of values. You could easily implement the algorithm and check when aa sub array runs out of elements (at which point you'd just fill it in with the rest of the other sub array), but it's slightly less clean and harder to reason about. Putting a sentinel value ensures that neither sub array will run out of elements which allows you to write the proof (the the algorithm works!) in a simpler way.