Question

我正在尝试使用4种不同的标准之一来实现快速排序算法来对填充了“电影”类型的对象的数组进行排序。每个电影对象包含排名，投票数，评级和电影名称。我还在类定义中编写了4个静态bool函数，它们接受两个电影对象引用，如果第一个较小则返回true，如果较大则返回false。

例如：

bool Movie::GetLowerRank(const Movie& x, const Movie& y){
    if (x.rank < y.rank)
        return true;
    else
        return false;
}

就像我说的那样，我正在尝试实现一种快速排序算法，该算法将根据用户偏好对数组进行排序。我想将我的4个排序函数之一传递给我的快速排序函数，类似于向量排序的工作方式。我的问题是我有两个quicksort函数，递归和基数：

void quickSort(Movie array[], int min, int max, bool (*compare_function)(Movie&, Movie&)){
    if (min < max) {
        int pivot_i = (min + max)/2;
        int pivot_i2 = quickSort(array, min, max, pivot_i, compare_function);
        quickSort(array, min, pivot_i2 - 1);
        quickSort(array, pivot_i2 +1, max);
    }   
}

int quickSort(Movie array[], int min, int max, int pivot, bool (*compare_function)(Movie& a, Movie& b)){
    Movie pivot_entry = array[pivot];
    swap (array[pivot], array[max]);
    int pivot_final_index = min;
    for (int i = min; i < max; i++) {
        if(compare_function(array[i], pivot_entry)){
            swap(array[i], array[pivot_final_index]);
            ++pivot_final_index;
        }
    }
    swap(array[max], array[pivot_final_index]);
    return pivot_final_index;
}

我试图将函数参数添加到参数列表中，但我无法弄清楚如何让void quickSort将函数（在main中获得）传递给实际使用它的int quickSort。 / p>

Answer 1

首先将GetLowerRank简化为

bool Movie::GetLowerRank(const Movie& x, const Movie& y) {
    return x.rank < y.rank;
}

compare_function只是作为quickSort的最后一个参数传递。由于void quickSort(...)调用int quickSort(...)，您必须先声明或定义int quickSort()。否则void quickSort()会试图调用自己，并会抱怨参数数量不匹配

int quickSort(Movie array[], int min, int max, int pivot, bool (*compare_function)(Movie& a, Movie& b)){
    Movie pivot_entry = array[pivot];
    swap (array[pivot], array[max]);
    int pivot_final_index = min;
    for (int i = min; i < max; i++) {
        if(compare_function(array[i], pivot_entry)){
            swap(array[i], array[pivot_final_index]);
            ++pivot_final_index;
        }
    }
    swap(array[max], array[pivot_final_index]);
    return pivot_final_index;
}

void quickSort(Movie array[], int min, int max, bool (*compare_function)(Movie&, Movie&)){
    if (min < max) {
        int pivot_i = (min + max)/2;
        int pivot_i2 = quickSort(array, min, max, pivot_i, compare_function);
        quickSort(array, min, pivot_i2 - 1, compare_function);
        quickSort(array, pivot_i2 +1, max, compare_function);
    }   
}

Answer 2

第一个quickSort中的递归调用似乎是在不使用函数指针的情况下调用的：

    quickSort(array, min, pivot_i2 - 1);
    quickSort(array, pivot_i2 +1, max);

<小时/>

下面的代码使用函数指针并编译：

注意：int已替换为电影：

如果Movie仍然存在错误，那么这是个好主意如果没有严格要求验证

(1) the assignment operator and 
(2) copy constructor and 
(3) equality operator

（全部三个）都是为Movie定义的（你可能已经知道了）。

void quickSort(int array[], int min, int max, bool (*compare_function)(int&, int&));

int quickSort(int array[], int min, int max, int pivot, bool (*compare_function)(int& a, int& b));

void swap(int array[], int a, int b);


void swap(int array[], int a, int b) {
    int temp;
    if (array != NULL) {
        temp = array[a];
        array[a] = array[b];
        array[b] = temp;

    }

}

void quickSort(int array[], int min, int max, bool (*compare_function)(int&, int&)){

    if (min < max) {

        int pivot_i = (min + max)/2;
        int pivot_i2 = quickSort(array, min, max, pivot_i, compare_function);
        quickSort(array, min, pivot_i2 - 1, compare_function);
        quickSort(array, pivot_i2 +1, max, compare_function);
    }   
}

int quickSort(int array[], int min, int max, int pivot, 
    bool (*compare_function)(int& a, int& b)){

    int pivot_entry = array[pivot];

    swap (array, pivot, max);

    int pivot_final_index = min;

    for (int i = min; i < max; i++) {
        if(compare_function(array[i], pivot_entry)){
            swap(array, i, pivot_final_index);
            ++pivot_final_index;
        }
    }
    swap(array, max, pivot_final_index);
    return pivot_final_index;
}

C ++：将函数从一个函数传递给另一个函数

2 个答案: