Fatal编程技术网
  • c/
  • C qsort不能在长时间内正常工作

C qsort不能在长时间内正常工作

c

C qsort不能在长时间内正常工作,c,qsort,long-long,C,Qsort,Long Long,我对二维数组a[n][2]进行排序，关于a[I][0]，a[I+1][0]与非递减的a[I][1]，a[I+1][1]断开联系。 qsort可以很好地处理整数数组，但不能处理长数组 整数数组代码 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <limits.h> int cmpfunc(const void*

我对二维数组a[n][2]进行排序，关于a[I][0]，a[I+1][0]与非递减的a[I][1]，a[I+1][1]断开联系。 qsort可以很好地处理整数数组，但不能处理长数组

整数数组代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>

int cmpfunc(const void* a, const void* b)
{
    int x = ((int*)a)[0] - ((int*)b)[0];
    if (x != 0) {
        return x;
    }
    return ((int*)a)[1] - ((int*)b)[1];
}

int main(int argc, char const* argv[])
{
    int n, i, j;
    scanf("%d", &n);
    int a[n][2];
    for (i = 0; i < n; i = i + 1) {
        scanf("%d %d", &a[i][0], &a[i][1]);
    }
    qsort(a, n, sizeof(a[0]), cmpfunc);
    for (i = 0; i < n; i = i + 1) {
        printf("%d %d\n", a[i][0], a[i][1]);
    }
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>

int cmpfunc(const void* a, const void* b)
{
    int x = ((int*)a)[0] - ((int*)b)[0];
    if (x != 0) {
        return x;
    }
    return ((int*)a)[1] - ((int*)b)[1];
}

int main(int argc, char const* argv[])
{
    int n, i, j;
    scanf("%d", &n);
    long long a[n][2];
    for (i = 0; i < n; i = i + 1) {
        scanf("%I64d %I64d", &a[i][0], &a[i][1]);
    }
    qsort(a, n, sizeof(a[0]), cmpfunc);
    for (i = 0; i < n; i = i + 1) {
        printf("%I64d %I64d\n", a[i][0], a[i][1]);
    }
    return 0;
}
第一个代码的输出：

4 1
4 1
4 1
4 2
4 3
第二个代码的输出：

4 2
4 1
4 1
4 1
4 3
即使将数据类型更改为
long-long
，您仍然可以在比较函数中强制转换为
int*
，即使在编译时启用了警告，您仍然可以在比较函数中强制转换为
int*
，即使将数据类型更改为
long
（
-Wall-pedantic
用于gcc）您应该注意到，
long-long-int
需要不同的占位符，并且不能假定它是
64位的
。您还错误地转换了compare函数的参数。 请注意，两个
long-long-int
之间的差异可能超出
int
的范围，因此您不能使用（我编写的那一个）
qsort（）
比较实现。下面是代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
int cmpfunc(const void *a,const void *b){
    long long int x=((long long int *)a)[0]-((long long int *)b)[0];
    if(x!=0){
        return x;
    }
    return ((long long int *)a)[1]-((long long int *)b)[1];
    }


int main(int argc, char const *argv[]){
    int n,i;
    scanf("%d",&n);
    long long a[n][2];
    for(i=0;i<n;i=i+1){
        scanf("%lld %lld",&a[i][0],&a[i][1]);
    }
    qsort(a,n,sizeof(a[0]),cmpfunc);
    for(i=0;i<n;i=i+1){
        printf("%lld %lld\n",a[i][0],a[i][1]);
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
int cmpfunc（常数无效*a，常数无效*b）{
长整型x=（（长整型*）a）[0]-（（长整型*）b）[0]；
如果（x！=0）{
返回x；
}
返回（（长整型*）a）[1]-（（长整型*）b）[1]；
}
int main（int argc，char const*argv[]{
int n，i；
scanf（“%d”和“&n”）；
长a[n][2]；

对于（i=0；i如果您在编译（
-Wall-pedantic
for gcc）时启用警告，您应该注意，
long-long int
需要不同的占位符，并且不能假定它是
64位的
。您还错误地转换了compare函数的参数。
请注意，两个
long-long-int
之间的差异可能超出
int
的范围，因此您不能使用（我编写的那一个）
qsort（）
比较实现。下面是代码：


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
int cmpfunc(const void *a,const void *b){
    long long int x=((long long int *)a)[0]-((long long int *)b)[0];
    if(x!=0){
        return x;
    }
    return ((long long int *)a)[1]-((long long int *)b)[1];
    }


int main(int argc, char const *argv[]){
    int n,i;
    scanf("%d",&n);
    long long a[n][2];
    for(i=0;i<n;i=i+1){
        scanf("%lld %lld",&a[i][0],&a[i][1]);
    }
    qsort(a,n,sizeof(a[0]),cmpfunc);
    for(i=0;i<n;i=i+1){
        printf("%lld %lld\n",a[i][0],a[i][1]);
    }
    return 0;
}



#包括
#包括
#包括
#包括
#包括
int cmpfunc（常数无效*a，常数无效*b）{
长整型x=（（长整型*）a）[0]-（（长整型*）b）[0]；
如果（x！=0）{
返回x；
}
返回（（长整型*）a）[1]-（（长整型*）b）[1]；
}
int main（int argc，char const*argv[]{
int n，i；
scanf（“%d”和“&n”）；
长a[n][2]；
对于（i=0；i你实际上有两个问题：第一个是无效施法的问题。第二个也是关于无效施法的问题，但还有另一个原因

如我的一条评论所述，
qsort
函数将指向元素的指针传递给比较函数。如果您有数组
arr
，则
qsort
将使用类似
&arr[0]的内容
用于参数。这意味着如果数组的数据本身是数组，那么参数将是指向数组的指针。在您的特定情况下，参数类型实际上是
long（*）[2]
，而不仅仅是
long*

因此，比较函数应该如下所示：


int cmpfunc(const void* a_, const void* b_)
{
    long long (*a)[2] = (long long (*)[2]) a_;
    long long (*b)[2] = (long long (*)[2]) b_;

    long long result;

    if ((*a)[0] - (*b)[0] != 0)
        result = (*a)[0] - (*b)[0];
    else
        result = (*a)[1] - (*b)[1];

    if (result < 0)
        return -1;
    else if (result > 0)
        return 1;
    else
        return 0;
}



int-cmpfunc（常量无效*a\u，常量无效*b\u）
{
长长（*a）[2]=（长长（*）[2]）a；
长长（*b）[2]=（长长（*）[2]）b；
长期结果；
如果（（*a）[0]-（*b）[0]！=0）
结果=（*a）[0]-（*b）[0]；
其他的
结果=（*a）[1]-（*b）[1]；
如果（结果<0）
返回-1；
否则，如果（结果>0）
返回1；
其他的
返回0；
}

您实际上有两个问题：第一个问题是无效的施法。第二个问题也是关于无效的施法，但还有另一个原因

如我的一条评论所述，
qsort
函数将指向元素的指针传递给比较函数。如果您有数组
arr
，则
qsort
将使用类似
&arr[0]的内容
用于参数。这意味着如果数组的数据本身是数组，那么参数将是指向数组的指针。在您的特定情况下，参数类型实际上是
long（*）[2]
，而不仅仅是
long*

因此，比较函数应该如下所示：


int cmpfunc(const void* a_, const void* b_)
{
    long long (*a)[2] = (long long (*)[2]) a_;
    long long (*b)[2] = (long long (*)[2]) b_;

    long long result;

    if ((*a)[0] - (*b)[0] != 0)
        result = (*a)[0] - (*b)[0];
    else
        result = (*a)[1] - (*b)[1];

    if (result < 0)
        return -1;
    else if (result > 0)
        return 1;
    else
        return 0;
}



int-cmpfunc（常量无效*a\u，常量无效*b\u）
{
长长（*a）[2]=（长长（*）[2]）a；
长长（*b）[2]=（长长（*）[2]）b；
长期结果；
如果（（*a）[0]-（*b）[0]！=0）
结果=（*a）[0]-（*b）[0]；
其他的
结果=（*a）[1]-（*b）[1]；
如果（结果<0）
返回-1；
否则，如果（结果>0）
返回1；
其他的
返回0；
}

在使用
long-long
的情况下，您没有忘记什么吗？尤其是在比较函数中？
a
和
b
的实际类型是什么？我建议您学习如何调试代码。从添加
printf（）开始
语句以查看变量的值。@某个编程人员知道这有什么关系？输入仍然在int范围内，它应该可以与int*cast一起工作，对吗？您的代码没有意义。您不理解如何
qsort（）
工作。还有一个问题是
qsort
将指向元素的指针传递给比较函数，即它传递
&a[0]
（使用
主
函数中的
a
数组），该数组的类型为
long（*）[2]
。如果您使用
long-long
，您没有忘记什么吗？尤其是在比较函数中？
a
和
b
的实际类型是什么？我建议您学习如何调试代码。从添加
printf（）开始
语句以查看变量的值。@某个编程人员知道这有什么关系？输入仍然在int范围内，它应该可以与int*cast一起工作，对吗？您的代码没有意义。您不理解如何
qsort（）
有效。还有一个问题是
qsort
将指向元素的指针传递给比较函数，即它传递
&a[0]
（u