Question

我需要计算在四种不同排序方法中出现的循环次数和比较次数。我正在使用选择，气泡，插入和快速排序方法。理想情况下，我每次循环/比较时都会放置一个诸如loopCounter和++之类的int。虽然，对于所有这些都是一个全新的，但我很难区分何时需要包含这样的计数器。正如您将能够在以下代码中看到的那样，我尝试创建多个计数器。虽然，我认为到目前为止只有选择计数器是正确的。

此外，我需要计算值移位的次数。换句话说，交换了整数的次数。

非常感谢任何帮助！

由于

    ArrayList<Integer> list = new ArrayList<Integer>();

    //Counters for Selection Sort
    int loopCounter = 0;
    int compCounter = 0;
    //Counters for Bubble Sort
    int loopCounter2 = 0;
    int compCounter2 = 0;
    //Counters for Insertion Sort
    int loopCounter3 = 0;
    int compCounter3 = 0;
    //Counters for Quick Sort
    int loopCounter4 = 0;
    int compCounter4 = 0;

public void selectionSort(Integer[] a) {

    for(int i = 0; i < a.length; i++) {
        int smallestValue = a[i];
        int smallestIndex = i;
        if(ascButton.isSelected()){
            for(int j = i+1; j < a.length; j++) {
                if (smallestValue > a[j]) {
                    smallestValue = a[j];
                    smallestIndex = j;
                    loopCounter++;
                    compCounter++;
                }
            }
        a[smallestIndex] = a[i];
        a[i] = smallestValue;
        } else if(desButton.isSelected()){
            for(int j = i+1; j < a.length; j++) {
                if (smallestValue < a[j]) {
                    smallestValue = a[j];
                    smallestIndex = j;
                    loopCounter++;
                    compCounter++;
                }
        }
        a[smallestIndex] = a[i];
        a[i] = smallestValue;
        }
    }
}

public void bubbleSort(Integer[] a) {

    int temp;

    for (int i = a.length - 1; i > 0; i--) {
        if(ascButton.isSelected()) {
            for(int j = 0; j < i; j++) {
                loopCounter2++;
                compCounter2++;
                if(a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
            } else if(desButton.isSelected()) {
                for(int j = 0; j < i; j++) {
                    loopCounter2++;
                    compCounter2++;
                    if(a[j] < a[j + 1]) {
                        temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp; 
                    }
                }
            }

    }
}

public void insertionSort(Integer[] a) {
    for(int i = 1; i < a.length; i++) {
        loopCounter3++;
        compCounter3++;
        int temp = a[i];
        int j = i - 1;

        if(ascButton.isSelected()) {
            while(j >= 0 && a[j] > temp) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = temp;
        } else if(desButton.isSelected()) {
            while(j >= 0 && a[j] < temp) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = temp;
        }

    }
}

public void quickSort(Integer[] a, int left, int right) {
    int i = left;
    int j = right;
    int temp;
    int pivot = a[(left + right)/2];
    while(i <= j) {
    if(ascButton.isSelected()) {
        while(a[i] < pivot)
            i++;
        while(a[j] > pivot)
            j--;
    } else if(desButton.isSelected()) {
        while(a[i] > pivot)
            i++;
        while(a[j] < pivot)
            j--;
    }
        if(i <= j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            i++;
            j--;
        }
    }
    if(left < j) {
        quickSort(a,left,j);
    }  
    if(i < right) {
        quickSort(a, i, right);
    }            
}

Answer 1

使用计数器时，您只想在计算某些内容时进行“计数”。因此，如果您不了解自己的代码，那么很难知道您何时想要“计算”某些内容。我建议你弄清楚交换何时发生，当你的代码发生这种情况时，就是你想做某种事情：

    swapCount++;//Each time a swap happens increment by 1
    iterationCount++//A full pass has happened increment by 1

注意：上面只是因为在很多种类中发生了完整传递，你可能知道，这并不意味着它已被排序，它只是说已经完成了1次传递。

我不确定这个理论是否会对你有所帮助。给我一些关于你仍然遇到问题的反馈，我会看看我是否可以改变我的答案，以更好地反映你的想法。

Answer 2

正如@Andreas建议的那样，你的循环和比较计数器正确就位。就交换计数器而言，以这种方式考虑它 - 没有临时变量就不能交换。因此，每当涉及临时变量时，您都希望增加交换计数器。例如，对于您的快速排序，它看起来像这样：

public void quickSort(Integer[] a, int left, int right) {
    int i = left;
    int j = right;
    int temp;
    int pivot = a[(left + right)/2];
    while(i <= j) {
    if(ascButton.isSelected()) {
        while(a[i] < pivot)
            i++;
        while(a[j] > pivot)
            j--;
    } else if(desButton.isSelected()) {
        while(a[i] > pivot)
            i++;
        while(a[j] < pivot)
            j--;
    }
        if(i <= j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            i++;
            j--;
            swapCounterForQuickSort++;
        }
    }
    if(left < j) {
        quickSort(a,left,j);
    }  
    if(i < right) {
        quickSort(a, i, right);
    }            
}

对你的其他种类采用相同的逻辑。

另外，一些一般性建议：

始终为变量命名，以便它们告诉您它们的用途。而不是loopCounter1尝试使用loopCounterForSelectionSort等。不要害怕长变量名。信息就是力量！
尽可能缩短您的功能并重复使用。例如，您在代码中交换了很多整数。也许您只需复制交换代码并将其粘贴到swapIntegers（）函数中即可。然后每当你想要交换时，你只需要调用这个函数！另外，请注意这是如何使您的交换计数器问题更容易回答，因为您可以在交换方法中放置一个计数器来为您进行计数。（虽然要注意，因为多个方法将调用交换计数器，因此您可能希望将其作为参数传递等。）

计算循环和比较

2 个答案: