Question

我已经实现了三种不同的排序算法，现在我想确认我的计算总比较数的方法是正确的。在我看来，比较的数量不应该与条件分支相关联，因为如果条件不满足，则仍然进行比较以比较这些值。我也使用相同的思考过程将一个添加到退出循环条件的比较计数中。

我的算法的实现如下。我是否在每种情况下正确设置了计数器？

插入排序

int insertionSort(double* A, int arrayLength) {
    int count = 1; // Initialized 1 to count for exit conditions of for loop
    for (int j = 1; j < arrayLength; j++) {
        count++;
        double key = A[j];
        int i = j - 1;

        while (i > -1 && A[i] > key) {
            count++;
            A[i + 1] = A[i];
            i = i - 1;
        }

        count+=2 // Plus 2 for the while loop exit condition

        A[i + 1] = key;
    }

return count;
}

堆排序

void heapSort(double* A, int arrayLength, int* c) {
    int heapSize = 0;
    buildMaxHeap(A, arrayLength, &heapSize, c);

    for (int i = arrayLength - 1; i > 0; i--) {
        swap(A[0], A[i]);
        heapSize = heapSize - 1;
        maxHeapify(A, 0, &heapSize, c);
    }
}

void buildMaxHeap(double* A, int arrayLength, int* heapSize, int* c) {
    *heapSize = arrayLength - 1;
    *c = *c + 1; // Counts comparison of loop for exit condition
    for (int i = floor((arrayLength)/ 2); i > -1; i--) {
        *c = *c + 1;
        maxHeapify(A, i, heapSize, c);
    }
}
void maxHeapify(double* A, int i, int* heapSize, int* c) {
    int l = (2 * i) + 1;
    int r = (2 * i) + 2;
    int largest;

    if (l <= *heapSize && A[l] > A[i])
        largest = l;
    else largest = i;

    if (r <= *heapSize && A[r] > A[largest])
        largest = r;

    if (largest != i) {
        swap(A[i], A[largest]);
        maxHeapify(A, largest, heapSize, c);
    }

    *c = *c + 5;
}

快速排序

void quickSort(double* A, int p, int r, int* c) {

    if (p < r) {
        int q = partition(A, p, r, c);
        quickSort(A, p, q - 1, c);
        quickSort(A, q + 1, r, c);
        }
    *c = *c + 1;
}

int partition(double* A, int p, int r, int* c) {
    double x = A[r];
    int i = p - 1;

    for (int j = p; j < r; j++) {
        if (A[j] <= x) {
            i = i + 1;
            swap(A[i], A[j]);
        }
        *c = *c + 2;
    }

    *c = *c + 1 // Adding 1 for for loop exit condition

    swap(A[i + 1], A[r]);
    return i + 1;
}

Answer 1

如果你看一下你的插入分类

因为你已经把count = 1，因为for循环的退出条件退出了。

出于同样的原因然后它也有意义，当while循环取消计数时，++内部不会被执行但是进行了比较。但是你做了一个计数+ = 2。为什么2？这是有道理的，因为你在while循环中进行2次比较时添加了2

(i > -1 && A[i] > key)

我-1个
A [i]＆gt;键

然后你需要在每次循环时将计数器增加2，同时正确进行2次比较。

int insertionSort(double* A, int arrayLength) {
    int count = 1; // Initialized 1 to count for exit conditions of for loop
    for (int j = 1; j < arrayLength; j++) {
        count++;
        double key = A[j];
        int i = j - 1;

        while (i > -1 && A[i] > key) {
            count++;
            A[i + 1] = A[i];
            i = i - 1;
        }

        count+2 // Plus 2 for the while loop exit condition

        A[i + 1] = key;
    }

return count;
}

同样可以检查其他算法。

仍然是一个更好的方法我建议你阅读任何关于算法分析的书中的一些起始章节。他们通常会解释如何估算算法的运行时间，这将有助于您了解如何更好地分析。

检查循环条件是否应计入总比较数？

1 个答案: