Quicksort实现未在C中排序

Question

已经2天了，我试图用C编写一个quicksort实现，但是它不起作用。我的意思是，它确实可以编译，但是输出不是我期望的。

我一直在学习一本Data Struct书籍，无论如何，它都被翻译成葡萄牙语tho，我的母语……我将在下面的说明以及我的代码。

QuickSort Image Partition Image

//
//  Quick sort V2.c
//  IFTM Exercises
//
//  Created by Lelre Ferreira on 7/9/19.
//  Copyright © 2019 Lelre Ferreira. All rights reserved.
//

#define size 5
#include <stdio.h>

void printfArrays(int *array);
void receiveArray(int *array);
int QuickSortPartition(int *array, int begin, int end);
void QuickSortFunction(int *array, int begin, int end);


int main (int argc, const char * argv[]){

    int array[size];

    receiveArray(array);
    printfArrays(array);

    return 0;
}

void receiveArray(int* array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Insert value of [%d]: ", i);
        scanf("%d", &array[i]);
    }
}

void printfArrays(int *array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Value sorted: %d\n", array[i]);
    }
}

int QuickSortPartition(int *array, int begin, int end){


    int pivot = array[end];
    int i = (begin - 1), j = 0;

    for (j = begin; j <= end - 1; j++) {
        if (array[j] <= pivot) {
            i++;
            array[i] = array[j];
        }
    }
    array[i + 1] = array[end];
    return (i + 1);
}

void QuickSortFunction(int *array, int begin, int end){

    if (begin < end) {
        int pivot = QuickSortPartition(array, begin, end);
        QuickSortPartition(array, begin, pivot - 1);
        QuickSortPartition(array, pivot + 1, end);
    }

}

Answer 1

编写函数时，请先进行测试，然后再在程序中使用它。

函数QuickSortPartition显然是错误的。

请在您的函数实现中考虑以下演示程序

#include <stdio.h>

int QuickSortPartition(int *array, int begin, int end){


    int pivot = array[end];
    int i = (begin - 1), j = 0;

    for (j = begin; j <= end - 1; j++) {
        if (array[j] <= pivot) {
            i++;
            array[i] = array[j];
        }
    }
    array[i + 1] = array[end];
    return (i + 1);
}

int main( void )
{
    int a[] = { 5, 4, 2, 1, 3 };
    const size_t N = sizeof( a ) / sizeof( *a );

    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );

    QuickSortPartition( a, 0, ( int )( N - 1 ) );

    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );
}    

其输出为

5 4 2 1 3 
2 1 3 1 3 

您需要交换函数中的值，而不是使用简单的赋值。例如

#include <stdio.h>

size_t QuickSortPartition( int *array, size_t begin, size_t end )
{
    const int pivot = array[end];

    size_t i = begin - 1;

    for ( size_t j = begin; j < end; j++ ) 
    {
        if ( array[j] <= pivot ) 
        {
            int tmp = array[++i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    int tmp = array[++i];
    array[i] = array[end];
    array[end] = tmp;

    return i;
}

int main( void )
{
    int a[] = { 5, 4, 2, 1, 3 };
    const size_t N = sizeof( a ) / sizeof( *a );

    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );

    size_t partition = QuickSortPartition( a, 0, N - 1 );

    printf( "%zu: ", partition );
    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );
}    

其输出为

5 4 2 1 3 
2: 2 1 3 4 5

对于索引，我使用类型size_t（并且应该执行相同操作）而不是类型int。

在函数QuickSortFunction中，您需要调用它本身而不是函数QuickSortPartition。

void QuickSortFunction(int *array, size_t begin, size_t end){

    if (begin < end) {
        size_t pivot = QuickSortPartition(array, begin, end);
        QuickSortFunction(array, begin, pivot - 1);
        QuickSortFunction(array, pivot + 1, end);
    }

}

请注意，此初始化在函数QuickSortPartition的声明中

int i = (begin - 1), j = 0;
        ^^^^^^^^^^^

不好。 （似乎每个人都从一个不好的例子复制算法：）。当所有元素均小于或等于数据透视表的值时，该函数效率低下。

您还可以编写一个单独的函数来交换数组的两个元素。

下面有一个演示程序，显示了如何使函数QuickSortPartition的代码变得更好。

#include <stdio.h>

void swap( int *a, int *b )
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

size_t QuickSortPartition( int *array, size_t begin, size_t end )
{
    const int pivot = array[end];

    size_t i = begin;

    for ( size_t j = begin; j < end; j++ ) 
    {
        if ( array[j] <= pivot ) 
        {
            if ( i != j ) swap( &array[i], &array[j] );
            ++i;
        }
    }

    if ( i != end ) swap( &array[i], &array[end] );

    return i;
}

int main( void )
{
    int a[] = { 5, 4, 2, 1, 3 };
    const size_t N = sizeof( a ) / sizeof( *a );

    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );

    size_t partition = QuickSortPartition( a, 0, N - 1 );

    printf( "%zu: ", partition );
    for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
    putchar( '\n' );
}    

Answer 2

两件事不对：

1. 您永远不会调用排序功能。
2. 修复（1）后，您会发现分区功能已完全损坏。您正在尝试使用Lomuto partition scheme，但它与应有的位置都不匹配。

无论您为（2）的那个算法执行了什么翻译，都是错误的。始终在末尾具有固定枢轴选择的Lomuto分区的通用算法（一个糟糕的选择，但这超出了此问题的范围）如下：

更新的分区功能

// added to make the partition algorithm easier to understand.
void swap_int(int *a, int *b)
{
    int tmp = *a;
    *a  = *b;
    *b = tmp;
}

int QuickSortPartition(int *array, int begin, int end){

    int i=begin, j;

    for (j = begin; j <= end; j++)
    {
        if (array[j] < array[end])
            swap_int(array+j, array + i++);
    }
    swap_int(array+i, array+end);

    return i;
}

此处i表示枢轴值最终将驻留的活动插槽。最初，枢轴存储在array[end]。 for-loop扫描完成后，i坐在插槽中，最后的交换将把枢轴放置到位。它也是函数的返回值，调用方使用它来表示要在以后的递归中包含的 not （因为它的值已经是home）了。

最终结果如下：

#include <stdio.h>

void printfArrays(int *array);
void receiveArray(int *array);
int QuickSortPartition(int *array, int begin, int end);
void QuickSortFunction(int *array, int begin, int end);

#define size 5

int main (int argc, const char * argv[]){

    int array[size];

    receiveArray(array);
    QuickSortFunction(array, 0, size-1);
    printfArrays(array);

    return 0;
}

void receiveArray(int* array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Insert value of [%d]: ", i);
        scanf("%d", array+i);
    }
}

void printfArrays(int *array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Value sorted: %d\n", array[i]);
    }
}

static void swap_int(int *a, int *b)
{
    int tmp = *a;
    *a  = *b;
    *b = tmp;
}

int QuickSortPartition(int *array, int begin, int end){

    int i=begin, j;

    for (j = begin; j <= end; j++)
    {
        if (array[j] < array[end])
            swap_int(array+j, array + i++);
    }
    swap_int(array+i, array+end);

    return i;
}

void QuickSortFunction(int *array, int begin, int end){

    if (begin < end) {
        int pivot = QuickSortPartition(array, begin, end);
        QuickSortFunction(array, begin, pivot - 1);
        QuickSortFunction(array, pivot + 1, end);
    }
}

输入

 4 1 3 5 2

输出

Value sorted: 1
Value sorted: 2
Value sorted: 3
Value sorted: 4
Value sorted: 5

此代码中还有许多其他不相关的内容可以解决（检查IO，更好的数据透视选择方案（例如三位数）等），但是基本问题已在上面解决。

Answer 3

谢谢大家！我已解决了先前代码中的问题，最终又用了一段时间，我将两者都留在这里。

//
//  Quick sort V2 fixed.c
//  IFTM Exercises
//
//  Created by Lelre Ferreira on 7/11/19.
//  Copyright © 2019 Lelre Ferreira. All rights reserved.
//

#define size 5
#include <stdio.h>

void printArray(int *array);
void receiveArray(int *array);

void QuickSwap(int* a, int* b);
void QuickSort(int *array, int begin, int end);
int  QuickSortPartition(int *array, int begin, int end);

int main (int argc, const char * argv[]){

    int array[size];

    receiveArray(array);
    QuickSort(array, 0, size-1);
    printArray(array);

    return 0;
}

void printArray(int *array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Value sorted: %d\n", array[i]);
    }
}

void receiveArray(int *array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Insert value of [%d]: ", i);
        scanf("%d", &array[i]);
    }
}

void QuickSwap(int* a, int* b){

    int x = *a;
    *a = *b;
    *b = x;
}

void QuickSort(int *array, int begin, int end){

    if (begin < end) {
        int pivot = QuickSortPartition(array, begin, end);
        QuickSort(array, begin, pivot - 1);
        QuickSort(array, pivot + 1, end);
    }
}

int QuickSortPartition(int *array, int begin, int end){

    int pivot = array[end];
    int i = begin - 1, j = 0;

    for (j = begin; j <= end - 1; j++) {
        if (array[j] <= pivot) {
            i++;
            QuickSwap(&array[i], &array[j]);
        }
    }
    QuickSwap(&array[i + 1], &array[j]);
    return (i + 1);
}

第二个版本：

//
//  Quick sort V1.c
//  IFTM Exercises
//
//  Created by Lelre Ferreira on 7/8/19.
//  Copyright © 2019 Lelre Ferreira. All rights reserved.
//

#define size 5
#include <stdio.h>

void printArray(int *array);
void QuickSortFunction(int *array, int begin, int end);
int QuickSortPartition(int *array, int begin, int end);

int main (int argc, const char * argv[]){

    int array[] = {2, 3, 1, 5, 4};

        QuickSortFunction (array, 0, size-1);
        printArray(array);

    return 0;
}

void printArray(int* array){

    int i = 0;
    for (i = 0; i < size; i++) {
        printf("Value sorted: %d\n", array[i]);
    }
}

int QuickSortPartition(int *array, int begin, int end){

    int left, right;
    int pivot, aux;

    right = end;
    left = begin;
    pivot = array[begin];

    while (left < right) {
        while (array[left] <= pivot)
            left++;
        while (array[right] > pivot)
                right--;
                if (left < right) {
                    aux = array[left];
                    array[left] = array[right];
                    array[right] = aux;
                }
            }

            array[begin] = array[right];
            array[right] = pivot;
            return right;
}

void QuickSortFunction(int *array, int begin, int end){

    if (begin < end) {
        int pivot = QuickSortPartition(array, begin, end);
        QuickSortFunction(array, begin, pivot - 1);
        QuickSortFunction(array, pivot + 1, end);
    }
}