快速排序思想、实例与错误定位实例

基本思想：

Step 1：选取列表的第一个元素pivotkey，将列表分为一小一大的两个子列表a、b。其中a 列表元素都比pivotkey 小, b 列表元素都比pivotkey 大。 Step 2：对子列表 a 应用 Step1； Step 3：对子列表 b 应用 Step1；

代码清单1.1。

public class QuickSort_a {

public static int[] quickSort(int[] unSortList, int leftSide, int rightSide) {
// 递归划分子列表
if (leftSide < rightSide) {
int pivotPosition = partition(unSortList, leftSide, rightSide);
quickSort(unSortList, leftSide, pivotPosition - 1);
quickSort(unSortList, pivotPosition + 1, rightSide);
}
return unSortList;
}

private static int partition(int[] list, int low, int high) {
// 以第一个元素作为pivot，划分为2个子列表
int pivot = list[low];
int leftPointer = low;
int rightPointer = high+1;   // 后面while循环中 list[--rightPointer] 正好指向最后一个列表元素
while (true) {
while (list[++leftPointer] <= pivot) {
if (leftPointer == high)
break;
}
while (list[--rightPointer] >= pivot) {   // 对应与前面 high+1，使得起始点是最后一个元素
if (rightPointer == low)
break;
}
if (leftPointer >= rightPointer)
break;
exchange(list, leftPointer, rightPointer);
}
exchange(list, low, rightPointer);
return rightPointer;
}

private static void exchange(int[] list, int i, int j) {
// 将列表中指定位置的元素互换，其中: list[i] > pivot，list[j]< pivot
int tmp = list[i];
list[i] = list[j];
list[j] = tmp;
}
}

代码清单1.2 （如果将上面代码中方法 partition，其余不变）

private static int partition(int[] list, int low, int high) { ...

}

替换为：

private static int partition(int[] list, int low, int high) {
int pivot = list[low];
int leftPointer = low;
int rightPointer = high;    // Seeded Fault
while (true) {
while (list[++leftPointer] < pivot) {
if (leftPointer == high)
break;
}
while (list[--rightPointer] > pivot) {
if (rightPointer == low)
break;
}
if (leftPointer >= rightPointer)
break;
exchange(list, leftPointer, rightPointer);
}
exchange(list, low, rightPointer);
return rightPointer;
}

运行30个测试用例，如下：

public class TestQuickSort_a {

@Test
public void test1() {
int[] A = {};
QuickSort_a.quickSort(A, 0, 0);
int[] result = {};
assertArrayEquals(result,A);
}

@Test
public void test2() {
int[] A = { 1 };
QuickSort_a.quickSort(A, 0, 0);
int[] result = { 1 };
assertArrayEquals(result,A);
}

@Test
public void test3() {
int A[] = { 1, 2, 3, 4 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test4() {
int A[] = { 2, 5, 1, 3, 6, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test5() {
int A[] = { 2, 5, 1, 1, 3, 6 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test6() {
int A[] = { 2, 5, 1, 1, 6, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test7() {
int A[] = { 2, 5, 1, 6, 1, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test8() {
int A[] = { 2, 5, 1, 6, 3, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test9() {
int A[] = { 2, 5, 1, 1, 3, 6 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test10() {
int A[] = { 2, 1, 4, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test11() {
int A[] = { 2, 3, 1, 4 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test12() {
int A[] = { 2, 3, 4, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test13() {
int A[] = { 2, 4, 3, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test14() {
int A[] = { 2, 1, 5, 1, 6, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test15() {
int A[] = { 2, 1, 5, 6, 1, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test16() {
int A[] = { 2, 1, 3, 1, 5, 6 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test17() {
int A[] = { 3, 1, 2, 4 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test18() {
int A[] = { 3, 1, 4, 2 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test19() {
int A[] = { 3, 4, 1, 2 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test20() {
int A[] = { 3, 4, 2, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test21() {
int A[] = { 4, 2, 3, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test22() {
int A[] = { 4, 2, 1, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 2, 3, 4 };
assertArrayEquals(result,A);
}

@Test
public void test23() {
int A[] = { 2, 1, 6, 1, 5, 3 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test24() {
int A[] = { 2, 1, 6, 5, 3, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test25() {
int A[] = { 2, 1, 6, 3, 1, 5 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test26() {
int A[] = { 2, 1, 6, 3, 5, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test27() {
int A[] = { 2, 1, 5, 3, 1, 6 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test28() {
int A[] = { 2, 1, 5, 3, 6, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test29() {
int A[] = { 2, 1, 5, 6, 3, 1 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}

@Test
public void test30() {
int A[] = { 2, 1, 1, 5, 3, 6 };
QuickSort_a.quickSort(A, 0, A.length - 1);
int[] result = { 1, 1, 2, 3, 5, 6 };
assertArrayEquals(result,A);
}
}

运行结果，Passed 9， Failed 21

依据上述测试结果，分别采用 Ochia、Jaccard、Tarantula、Naish2 算法对 清单1.2 进行错误定位，并标示可疑代码，如下图：

可见，错误定位指向的可疑代码，并不是真正的错误代码（浅蓝色阴影语句）