Question

我正在使该程序中的交换计数和比较计数成为快速排序函数，并且我们必须将交换数和comps传递给该函数。我不太确定该怎么做。我有它，因此无需传递任何内容即可完成，如下所示。

#include <iostream>
#include <ctime>
#include <stdlib.h>
#include <math.h>

using namespace std;

struct SwapandComp {
    int swaps;
    int comps;
};

const long ARRAY_SIZE = 5000;
int totalSwaps = 0;
int totalComps = 0;

int partition(int[], int, int) //add parameters int& swap and int& comp
SwapandComp quickSort(int[], int, int) //also add parameters for int& swap and int& comp

int main() {

SwapandComp qui;
long masterAry[ARRAY_SIZE] = {0};
int quickAry[ARRAY_SIZE] = {0};
int start = 0;
int end = 0;
double difference = 0;
int size = ARRAY_SIZE;

srand(time(NULL));

for (int i = 0; i < ARRAY_SIZE; i++) {
masterAry[i] = rand();
}

for (int a = 0; a < ARRAY_SIZE; a++) {
quickAry[a] = masterAry[a];
}

start = clock();
qui = quickSort(quickAry, 0, ARRAY_SIZE - 1);
    end = clock();
    difference = end - start;
    double f = difference / CLOCKS_PER_SEC;

    cout << "Quick: " << f << " " << qui.swaps << " " << qui.comps << endl;
}

这是主要的。在这里，将值分配给要由quickSort函数排序的数组，这将在下面定义。

int partition(int numbers[], int i, int k) { //add parameters int& swap and int& comp
    int l = 0;
    int h = 0;
    int midpoint = 0;
    int pivot = 0;
    int temp = 0;
    bool done = false;

    // Pick middle element as pivot
    midpoint = i + (k - i) / 2;
    pivot = numbers[midpoint];

    l = i;
    h = k;

    while (!done) {

        // Increment l while numbers[l] < pivot
        while (numbers[l] < pivot) {
            ++l;
            totalComps++;
        }

        // Decrement h while pivot < numbers[h]
        while (pivot < numbers[h]) {
            --h;
            totalComps++;
        }

        // If there are zero or one elements remaining,
        // all numbers are partitioned. Return h
        if (l >= h) {
            totalComps++;
            done = true;
        }
        else {
            // Swap numbers[l] and numbers[h],
            // update l and h
            temp = numbers[l];
            numbers[l] = numbers[h];
            numbers[h] = temp;
            totalSwaps++;

            ++l;
            --h;
        }
    }

    //cout << totalSwaps << " " << totalComps << endl;
    return h;
}

这是分区功能，用于找到下一个分区点的位置

SwapandComp quickSort(int numbers[], int i, int k) { //add parameters int& swap and int& comp
    SwapandComp quick = { 0 };
    //quick.swaps = quick.comps = 0;
    int j = 0;
    int z = 0;


    // Base case: If there are 1 or zero elements to sort,
    // partition is already sorted
    if (i >= k) {
        return quick;
    }

    // Partition the data within the array. Value j returned
    // from partitioning is location of last element in low partition.
    j = partition(numbers, i, k);

    // Recursively sort low partition (i to j) and
    // high partition (j + 1 to k)
    quickSort(numbers, i, j);
    quickSort(numbers, j + 1, k);

    quick.swaps = totalSwaps;
    quick.comps = totalComps;



    //totalSwaps = 0;
    //totalComps = 0;

    return quick;
}

最后，这是快速排序功能，其中所有交换和comps都将加在一起并放入结构中。同样，我不太确定如何为传递和补偿添加传递引用变量。任何帮助表示赞赏！（也对代码格式感到抱歉，它在我的屏幕上有点疯狂。）

将掉期和比较传递到快速排序功能

0 个答案: