Question

我已更改为快速排序代码，以对从 tutorialgatway.org 获得的浮点数进行排序。但是我需要排序的索引。我知道qsort库函数可用于获取排序后的索引，我可以实现它。但是，我想避免使用标准库（我不建议这样做）。不使用标准库的原因是我需要在循环中对大量数组进行排序，我需要使用openMP进行并行化，因此显式地编写函数将允许我在循环中并行化quicksort函数。 / p>

/* C Program for Quick Sort */
#include <stdio.h>

void Swap(float *x, float *y) {
    float Temp;
    Temp = *x;
    *x = *y;
    *y = Temp;
}

void quickSort(float a[], int first, int last) {
    int i, j;
    int pivot;
    if (first < last) {
        pivot = first;
        i = first;
        j = last;
        while (i < j) {
            while (a[i] <= a[pivot] && i < last)
                i++;
            while (a[j] > a[pivot])
                j--;
            if (i < j) {
                Swap(&a[i], &a[j]);
            }
        }
        Swap(&a[pivot], &a[j]);
        quickSort(a, first, j - 1);
        quickSort(a, j + 1, last);
    }
}

int main() {
    int number, i;
    float a[100];
    printf("\n Please Enter the total Number of Elements  :  ");
    scanf("%d", &number);
    printf("\n Please Enter the Array Elements  :  ");
    for (i = 0; i < number; i++)
        scanf("%f", &a[i]);

    quickSort(a, 0, number - 1);
    printf("\n Selection Sort Result : ");
    for (i = 0; i < number; i++)  {
        printf(" %f \t", a[i]);
    }
    printf("\n");
    return 0;
}

如何返回代码中的排序索引？

Answer 1

您需要生成一个从0到size-1的索引数组，然后根据该数组值对索引数组进行排序。因此，代码确实使用array [index [...]]进行比较，并且确实交换了index [...]。

另一种方法是生成一个从＆array [0]到＆array [size-1]的指针数组。指针排序后，可以使用以下方法将它们转换为索引：index [i] =指针[i]-＆array [0]（可以为索引和指针使用并集）。

具有标准版本的Hoare分区方案的示例程序，用于根据A []中的浮点对I []中的索引数组进行排序：

#include <stdio.h>
#include <stdlib.h>

void QuickSort(float A[], size_t I[], size_t lo, size_t hi)
{
    if (lo < hi)
    {
        float pivot = A[I[lo + (hi - lo) / 2]];
        size_t t;
        size_t i = lo - 1;
        size_t j = hi + 1;
        while (1)
        {
            while (A[I[++i]] < pivot);
            while (A[I[--j]] > pivot);
            if (i >= j)
                break;
            t = I[i];
            I[i] = I[j];
            I[j] = t;
        }
        QuickSort(A, I, lo, j);
        QuickSort(A, I, j + 1, hi);
    }
}

#define COUNT (4*1024*1024)             // number of values to sort

int main(int argc, char**argv)
{
    int  r;                             // random number
    size_t i;

    float  * A = (float *)  malloc(COUNT*sizeof(float));
    size_t * I = (size_t *) malloc(COUNT*sizeof(size_t));

    for(i = 0; i < COUNT; i++){         // random floats
        r  = (((rand()>>4) & 0xff)<< 0);
        r += (((rand()>>4) & 0xff)<< 8);
        r += (((rand()>>4) & 0xff)<<16);
        r += (((rand()>>4) & 0xff)<<24);
        A[i] = (float)r;
    }

    for(i = 0; i < COUNT; i++)          // array of indexes
        I[i] = i;

    QuickSort(A, I, 0, COUNT-1);

    for(i = 1; i < COUNT; i++){
        if(A[I[i-1]] > A[I[i]]){
            printf("error\n");
            break;
        }
    }

    free(I);
    free(A);

    return(0);
}

此版本的quicksort仅通过使用分区较小侧的递归来避免堆栈溢出。在最坏的情况下，时间复杂度仍为O（n ^ 2），但堆栈空间的复杂度仅限于O（log（n））。

void QuickSort(float A[], size_t I[], size_t lo, size_t hi)
{
    while (lo < hi)
    {
        float pivot = A[I[lo + (hi - lo) / 2]];
        size_t t;
        size_t i = lo - 1;
        size_t j = hi + 1;
        while (1)
        {
            while (A[I[++i]] < pivot);
            while (A[I[--j]] > pivot);
            if (i >= j)
                break;
            t = I[i];
            I[i] = I[j];
            I[j] = t;
        }
        /* avoid stack overflow */
        if((j - lo) < (hi - j)){
            QuickSort(A, I, lo, j);
            lo = j+1;
        } else {
            QuickSort(A, I, j + 1, hi);
            hi = j;
        }
    }
}

使用quicksort获取数组的排序索引

1 个答案: