Question

如果我有一个结构数组，有两个字段我想排序，我怎么能实现这样的东西？我已经编写了一个修改的冒泡排序算法来排序数组。

它们应按升序排列，以便左侧的值较小。它们都是整数值，我只是使用一些字母来希望它更清晰。

让我们说一个结构

typedef struct {
    int top;
    int left;
    int right;
    int bottom;
}box;

box** boxes = calloc(1, sizeof(box) * 20);

让我们说所有这些方框都有-100的随机值，每个位置有100个。

我可以通过任何一个角来对它进行排序。假设我们有像这样的顶部和左边的方框，我会使用左边的字母，但是这样就可以让数组最终排列成这样。

start top, 0,1,2,3,4,5
start left a,b,c,d,e,f

从这样的事情开始：

start top, 5,3,1,2,4,0
start left f,d,a,b,e,c

阵列的布局如下：

0,1,2,3,4,5,a,b,c,d,e,f

这是我目前使用的排序算法：

static void obj_swap_func(box** a, box** b) {
    box* tp = *a;
    *a = *b;
    *b = tp;
}

void back_2_front(box** a, int count) {
    cg_sprite* l, *r;

    for (int i = 0; i < count; i++) {
        int swap = 0;
        for (int j = 0; j < (count - i - 1); j++) {
            if (a[j]->l_value > a[j + 1]->l_value) {
                obj_swap_func(&a[j], &a[j + 1]);
                swap++;
            }
        }
        if (swap == 0) {
            break;
        }
    }
}

尝试实施以下答案，我写了这个函数。

static int greater(box* a, box* b) {
    if(a->top < b->top) {
        return 0;
    }
    else if (a->top > b->top) {
        return 1;
    }
    if(a->left < b->left) {
        return 0;
    }
    else if(a->left > b->left) {
        return 1;
    }
    return -1;
}

然后将它添加到循环中，如下所示： void back_2_front（box ** a，int count）{ cg_sprite * l，* r;

for (int i = 0; i < count; i++) {
    int swap = 0;
    for (int j = 0; j < (count - i - 1); j++) {
        if(greater(a[j], a[j+1])) {
            box_swap_func(&a[j], &a[j + 1]);
            swap++;
        }
    }
    if (swap == 0) {
        break;
    }
}

}

交换功能如下所示：

static void box_swap_func(box** a, box** b) {
    box* tp = *a;
    *a = *b;
    *b = tp;
}

在一组50个盒子上运行它，这会产生如下输出：

box top:-48 box left: 3
box top:-47 box left: 3
box top:-46 box left: 3
box top:-45 box left: 3
box top:-44 box left: 3
box top:-43 box left: 3
box top:-42 box left: 3
box top:-41 box left: 2
box top:-40 box left: 2
box top:-39 box left: 2
box top:-38 box left: 2
box top:-37 box left: 2
box top:-36 box left: 2
box top:-35 box left: 2
box top:-34 box left: 1
box top:-33 box left: 1
box top:-32 box left: 1
box top:-31 box left: 1
box top:-30 box left: 1
box top:-29 box left: 1
box top:-28 box left: 1
box top:-27 box left: 4
box top:-26 box left: 4
box top:-25 box left: 4
box top:-24 box left: 4
box top:-23 box left: 4
box top:-22 box left: 4
box top:-21 box left: 4
box top:-20 box left: 3
box top:-19 box left: 3
box top:-18 box left: 3
box top:-17 box left: 3
box top:-16 box left: 3
box top:-15 box left: 3
box top:-14 box left: 3
box top:-13 box left: 2
box top:-12 box left: 2
box top:-11 box left: 2
box top:-10 box left: 2
box top:-9 box left: 2
box top:-8 box left: 2
box top:-7 box left: 2
box top:-6 box left: 1
box top:-5 box left: 1
box top:-4 box left: 1
box top:-3 box left: 1
box top:-2 box left: 1
box top:-1 box left: 1
box top:0 box left: 1
box top:2 box left: 4

它按顶部进行排序就好了，但正如您所看到的那样，它们正在按顶部值正确排序，而不是按左值排序。

我是否正确编写了算法？

Answer 1

您必须进行的关键修改是替换

行

if (a[j]->l_value > a[j + 1]->l_value) {

通过

if ( is_greater(a[j], a[j+1]) ) {

其中

int is_greater(box a1, box a2)
{
   // Make the logic as simple or as complex as needed.
}

最简单的实现，与您所拥有的相同，是：

int is_greater(object* a1, object* a2)
{
   return (a1->l_value > a2->l_value);
}

从您的帖子中不清楚box和object是如何相关的。没有这些信息，我无法建议任何进一步的改进。

更新，以回应OP的评论

您is_greater的实施是错误的。

如果您的排序算法可以使用返回值：

小于零
零
大于零

而不是

-1
0
1

您可以使用：

static int greater(box* a, box* b) {

    if(a->top != b->top) {
       return (a->top - b->top);
    }

    return (a->left - b->left);
}

如果排序算法需要-1,0和1，则可以使用：

static int greater(box* a, box* b) {

    if(a->top != b->top) {
       if(a->top < b->top) {
          return -1;
       else
          return 1;
    }

    if (a->left < b->left) {
       return -1;
    }
    else if (a->left > b->left) {
       return 1;
    }

    return 0;
}

Answer 2

看起来back_2_front函数对一组object结构进行排序，其中每个实例都有一个l_value字段。

对box个实例进行必要的更改而不是object个实例的最简单方法是定义一个为您进行比较的函数：

int compareBoxes(box * a, box* b)
{
    if(a==NULL or b==NULL) return 0; //do your preferred method of error handling

    //check by top first
    if(a->top < b->top) 
    {
        return 0; //returns false if first object has smaller top
    }
    else if (a->top > b->top)
    {
        return 1; //returns true if first object has greater top
    } 

    //at this point the tops are equal, feel free to compare by other fields...

}

然后在你的内部for循环内而不是a[j]->l_value > a[j + 1]->l_value你可以拥有compareBoxes(a[j], a[j+1])

请记住，您需要为框而不是对象编写交换函数。

按两个不同的值排序

2 个答案: