如何计算和返回算法中的交换 - MergeSort 和 QuickSort？答案

【问题标题】：How to count and return swaps in algorithms - MergeSort and QuickSort?如何计算和返回算法中的交换 - MergeSort 和 QuickSort？
【发布时间】：2020-09-26 17:01:13
【问题描述】：

我有这个快速排序的代码

int sum = 0;
int partition(int *L, int left, int right) {
        int pivot = left;
        int p_val = L[pivot];
        while (left < right) {
            while (L[left] <= p_val)
                left++;
            while (L[right] > p_val)
                right--;
            if (left < right) {
                swap(&L[left], &L[right]);
                sum++;
                }
            }
        swap(&L[pivot], &L[right]);
        sum++;
        return right;
        }

    void quicksort(int *L, int start, int end) {
        if (start >= end)
            return;
        int splitPoint = partition(L, start, end);
        quicksort(L, start, splitPoint - 1);
        quicksort(L, splitPoint + 1, end);
        }

我认为它工作正常。对于给定的数组{8,4,2,1}，我知道已经进行了 3 次交换。但是，我需要修改代码，以便函数返回交换次数。这可能吗？如果可以，怎么做？请尽可能简单地解释，因为我是这方面的新手。我需要对 mergeSort 做同样的事情，但我仍然没有找到不太复杂的工作代码。当我这样做时，我会更新问题。谢谢你。

【问题讨论】：

在函数中传递一个 int 指针并在每次交换操作后递增它的值
很抱歉，我不知道该怎么做。
我这样做了，但我不明白函数如何返回该值，在这种情况下签名应该是int，但分区不会返回所需的值。
这能回答你的问题吗？ recursive quicksort, count swap and comparison issue

标签： c algorithm sorting quicksort mergesort

【解决方案1】：

您可以使用int 指针作为partition 和quicksort 函数的参数：

int partition(int *num, int *L, int left, int right) {
    ...
    if (left < right) {
       swap(&L[left], &L[right]);
       (*num)++; // increment number of swap
       sum++;
       }
    }
    ...
    swap(&L[pivot], &L[right]);
    (*num)++;
    sum++;
    return right;
}

在quicksort函数中：

void quicksort(int *num, int *L, int start, int end) {
  if (start >= end)
      return;
  int splitPoint = partition(num, L, start, end);
  quicksort(num, L, start, splitPoint - 1);
  quicksort(num, L, splitPoint + 1, end);
}

然后在主函数中：

int main() 
{ 
    int arr[] = {8, 4, 2, 4, 5, 7, 8, 9, 1}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    int num = 0;
    quicksort(&num, arr, 0, n-1); 
    printf("sum = %d num = %d\n", sum, num);
    return 0; 
}

【讨论】：

我使用 sum 作为全局变量，它就是这样工作的，但它特别说它必须返回让我感到困惑的交换次数。据我所知，返回意味着在return 部分之后有一些东西，比如return sum。

【解决方案2】：

好的，现在我有这个了：

int sum = 0;
int partition(int *L, int left, int right) {
    int pivot = left;
    int p_val = L[pivot];

    while (left < right) {
        while (L[left] <= p_val)
            left++;
        while (L[right] > p_val)
            right--;
        if (left < right) {
            swap(&L[left], &L[right]);
            sum++;
            }
        }
    swap(&L[pivot], &L[right]);
    sum++;
    return right;
    }

int quicksort(int *L, int start, int end) {
    if (start >= end)
        return;
    int splitPoint = partition(L, start, end);
    quicksort(L, start, splitPoint - 1);
    quicksort(L, splitPoint + 1, end);
    return sum;
    }

对于快速排序，这个：

int sumMerge = 0;
void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

int mergeSort(int arr[], int l, int r){
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);


    }
return sumMerge;
}

用于合并排序。它是否正确？我的意思是，如果我将sumMerge++ 放在代码中的某个位置，这样可以吗？另外，代码的哪一部分实际上交换了合并中的值？在快速排序中，我认为这很明显，无论swap 被调用，这就是我增加计数器的地方。但是合并呢？

【讨论】：