标签: qsort

我写了比较函数

int cmp(const int * a,const int * b)
 {
   if (*a==*b)
   return 0;
else
  if (*a < *b)
    return -1;
else
    return 1;
}

我有我的声明

int cmp (const int * value1,const int * value2);

我在我的程序中调用qsort就像这样

qsort(currentCases,round,sizeof(int),cmp);

当我编译它时,我收到以下警告

warning: passing argument 4 of ‘qsort’ from incompatible pointer type
/usr/include/stdlib.h:710: note: expected ‘__compar_fn_t’ but argument is of type ‘int
(*)(const int *, const int *)’

该程序工作正常,所以我唯一担心的是为什么它不喜欢我使用它的方式？

std::sort通过使用交换元素std::swap,而元素又使用复制构造函数和赋值运算符,保证在交换值时获得正确的语义.

qsort 通过简单地交换元素的基础位来交换元素,忽略与您交换的类型相关的任何语义.

即使qsort不知道你正在排序的类型的语义,它仍然非常适用于非平凡的类型.如果我没有弄错的话,它将适用于所有标准容器,尽管它们不是POD类型.

我想,对于先决条件qsort上的一种正常工作T是T为/平凡移动/.在我的脑海中,唯一不易移动的类型是具有内部指针的类型.例如:

struct NotTriviallyMovable
{
    NotTriviallyMovable() : m_someElement(&m_array[5]) {}

    int m_array[10];
    int* m_someElement;
};

如果你排序了一个数组,NotTriviallyMovable那么m_someElements最终会指向错误的元素.

我的问题是:还有哪些其他类型不适用qsort？

我不确定这是否可以与qsort一起使用，因为我要排序的内容（指向结构的指针数组）不是我要比较的内容（字符串）。

这是我程序的简化版本（假设所有学生数据在调用qsort（）之前都处于核心位置，而n是要排序的记录数）：

struct student {
        char lname[NAMESIZE + 1];
        char fname[NAMESIZE + 1];
        short mid;
        short final;
        short hmwks;
};

int cmp(const void *, const void *);

int
main(int argc, char **argv)
{
        int n;
        struct student *data[MAX];

        qsort(data, n, sizeof(struct student *), cmp);

        return 0;
}

int
cmp(const void *p0, const void *p1)
{
        return strcmp((*(struct student *) p0).lname,
                      (*(struct student *) p1).lname);
}

我的问题是下一个(这是一个显示问题的简单示例):

我有:

int* array1;
double* array2. 

array1=new int[10];
array2=new double[10];
array1=filledWithIntegers(random);
array2=filledWithDoubles(random);

//这里我想基于array2值对array1进行排序.我正在尝试使用stdlib的qsort函数.qsort(array1,6,sizeof(int),compare);

关键是如何基于array2为order1生成比较函数.

不可能使用std库数据结构,它必须直接在数组指针中完成.

谢谢.

首先,我定义了一个包含2列和10行的动态数组.number例如,这里整数设置为10.

int** array;
int number = 10;

array = malloc(number * sizeof(int*));

for (i = 0; i < number; i++)
    array[i] = malloc(2 * sizeof(int));

然后我尝试使用qsort()它.

qsort( array, number, sizeof array[0], compare );

这是我的比较功能.它按第一列中的整数值排序,然后按第二列排序,同时保留第一列中的顺序.例如,"0 2,1 7,0 1"将变为"0 1,0 2,1 7".

int compare ( const void *pa, const void *pb ) {
    int (*a)[1] = pa;
    int (*b)[1] = pb;
    if ( (a[0][0] < b[0][0]) || (a[0][0] == b[0][0])&&(a[1][0] < b[1][0]) ) return -1;
    if ( (a[0][0] …

我想使用qsort函数使用C++对字符串中的字符进行排序.

#include<iostream>
#include<string>
#include<cstdlib>

using namespace std;

int compare_str(void const *a,void const *b){
    char const *aa=(char const *)a;
    char const *bb=(char const *)b;

    if(*aa==*bb) return 0;
    else if(*aa>*bb) return 1;
    else return -1;
}
int main(){

    string str="cake";
    int len=str.length();

    qsort(str,len,sizeof(str[0]),compare_str);
    cout<<str;
    return 0;
}

但它抛出:

20 42 [Error] cannot convert 'std::string {aka std::basic_string<char>}' to 'void*' for argument '1' to 'void qsort(void*, size_t, size_t, int (*)(const void*, const void*))' 

如果有人能提供一种有效的方法来做到这一点会很棒.

我有一个看起来像这样的数组:

int array[] = {4.53, 3.65, 7.43, 9.54, 0.72, 0.0}

我只是想知道我可以用什么方法对这个数组进行部分排序,将前三个最大的双打带到前面.我正在寻找最有效的方法来获得这个数组中前三个最高的数字.

到目前为止,我一直在使用qsort,但我只是在寻找另一种方法,可以更快.我知道这qsort是O(nlogn)最好的情况和O(n^2)最坏的情况,但有没有更有效的方法来实现这个问题？我所说的高效是一种更快捷的方式,比这更好O(nlogn).

任何帮助都会很棒

我有一个指向Objective-C对象的数组.这些对象具有与之关联的排序键.我正在尝试使用qsort对指向这些对象的指针数组进行排序.但是,第一次调用比较器时,第一个参数指向数组中的第一个元素,但第二个参数指向垃圾,当我尝试访问其排序键时,给我一个EXC_BAD_ACCESS.

这是我的代码(转述):

- (void)foo:(int)numThingies {
    Thingie **array;
    array = malloc(sizeof(deck[0])*numThingies);

    for(int i = 0; i < numThingies; i++) {
        array[i] = [[Thingie alloc] initWithSortKey:(float)random()/RAND_MAX];
    }

    qsort(array[0], numThingies, sizeof(array[0]), thingieCmp);
}

int thingieCmp(const void *a, const void *b) {
    const Thingie *ia = (const Thingie *)a;
    const Thingie *ib = (const Thingie *)b;

    if (ia.sortKey > ib.sortKey) return 1; //ib point to garbage, so ib.sortKey produces the EXC_BAD_ACCESS
    else return -1;
}

任何想法为什么会这样？

qsort(3)库例程的联机帮助页给出了在命令行上对作为参数给出的单词进行排序的示例.比较函数如下:

static int
       cmpstringp(const void *p1, const void *p2)
       {
           /* The actual arguments to this function are "pointers to
              pointers to char", but strcmp(3) arguments are "pointers
              to char", hence the following cast plus dereference */

           return strcmp(* (char * const *) p1, * (char * const *) p2);
       }

但是这里排序的是元素argv.现在argv是指向字符指针的指针,它也可以被视为指向字符的指针表.

因此它的元素是指向字符的指针,所以不应该是指向字符的实际参数cmpstringp,而不是"指向char的指针"？

我正在使用内置函数qsort()来对class item指针向量进行排序.

class item {
int value;
vector<char> c;
...
...
};

//Declaration of vector
vector<item*> items;

//Function Call
qsort(&items, items.size(), sizeof(item*), value_sort);

int value_sort(const void* a, const void* b)
{
item* pa = *(item**) a;
item* pb = *(item**) b;

if (pb->value < pa->value)
    return 1;
else if (pa->value < pb->value)
    return -1;
return 0;
}

在调试器模式下,指针既不指向pa也不pb指向有效位置.由class items指向的所有数据成员集合pa或pb包含垃圾值.我哪里弄错了？我也不确定双指针的用法.

谢谢.