Question

假设我有以下结构：

struct Pair {
    int x;
    int y;
}

我想通过对中的第一个元素对数组进行排序，即x，然后是第二个元素，如果给出以下内容：

input:  [(1,2), (1,0), (2,3), (1,4), (2,2)]
output: [(1,0), (1,2), (1,4), (2,2), (2,3)]

现在我有两个函数，其中一个按第一个元素对数组进行排序，第二个按第二个元素对它进行排序，但效率较低。如何迭代数组一次并获得所需的结果？

void sort1(Pair ps[], int size) {
    int i, j;

    for (i = 0; i < size; i++) {
        for (j = i + 1; j < size; j++) {
            if (ps[j].x > ps[j+1].x) {
                Pair temp = ps[j+1];
                ps[j+1] = ps[j];
                ps[j] = temp;
            }
        }
    }
}

void sort2(Pair ps[], int size) {
    int i, j;

    for (i = 0; i < size; i++) {
        for (j = i + 1; j < size; j++) {
            if (ps[j].y > ps[j+1].y) {
                Pair temp = ps[j+1];
                ps[j+1] = ps[j];
                ps[j] = temp;
            }
        }
    }
}

另外，使用内置排序功能有没有快速的方法呢？

Answer 1

你只需要一个合适的功能来比较两对：

int comparePairs (const void * a, const void * b)
{
  const Pair* A = (const Pair*) a;
  const Pair* B = (const Pair*) b;
  return (A.x == B.x) ? (A.y - B.y) : (A.x - B.x);
}

然后您可以使用内置函数qsort。

Answer 2

您可以使用qsort()这是quicksort的C库实现。

为了使用此功能，您需要设计一个cmp函数，将两个x值相互比较，如果它们是关系，则按y排序。< / p>

为了使它不会混乱到一个cmp函数中，你可以首先创建一个较小的函数来测试两个整数的相等性：

int compare_int(const int a , const int b) {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    }
    return 0;
}

然后，您可以将其集成到cmp将要调用的主qsort()函数中。这个功能可以简单地是：

int cmp_func(const void *a, const void *b) {
    const pair_t *num1 = (pair_t *)a;
    const pair_t *num2 = (pair_t *)b;

    if (num1->x == num2->x) {
        return compare_int(num1->y, num2->y);
    } else if (num1->x > num2->x) {
        return +1;
    }
    return -1;
}

然后，您只需按以下方式拨打qsort()：

qsort(ps, sizeof(ps)/sizeof(ps[0]), sizeof(pair_t), cmp_func);

以下是一些示例代码：

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

#define ARRAYSIZE(x) ((sizeof(x))/sizeof(x[0])) 

typedef struct {
    int x;
    int y;
} pair_t;

int compare_int(const int a , const int b) {
    if ( a < b ) {
        return -1;
    } else if ( a > b ) {
        return 1;
    }
    return 0;
}

int cmp_func(const void *a, const void *b) {
    const pair_t *num1 = (pair_t *)a;
    const pair_t *num2 = (pair_t *)b;

    if (num1->x == num2->x) {
        return compare_int(num1->y, num2->y);
    } else if (num1->x > num2->x) {
        return +1;
    }
    return -1;
}

void print_array(pair_t ps[], size_t n) {
    printf("[");
    for (size_t i = 0; i < n; i++) {
        printf("(%d,%d)", ps[i].x, ps[i].y);
        if (i != n-1) {
            printf(", ");
        }
    }
    printf("]\n");
}  

int main(void) {
    pair_t ps[] = {{1,2}, {1,0}, {2,3}, {1,4}, {2,2}};

    printf("Input: ");
    print_array(ps, ARRAYSIZE(ps));

    qsort(ps, ARRAYSIZE(ps), sizeof(pair_t), cmp_func);

    printf("Output: ");
    print_array(ps, ARRAYSIZE(ps));

    return 0;
}

哪个输出：

Input: [(1,2), (1,0), (2,3), (1,4), (2,2)]
Output: [(1,0), (1,2), (1,4), (2,2), (2,3)]

注意：您正在实施冒泡排序的原始代码平均有 O（n ^ 2）运行时。但是，如果您使用qsort()，则可以实现 O（logN）运行时更快的平均值。如果n变大，这种差异将有助于实现更快的结果。

如何使用quicksort对一对整数的结构进行排序？

2 个答案: