长方形去重排序

题目

描述
现在有很多长方形，每一个长方形都有一个编号，这个编号可以重复；还知道这个长方形的宽和长，编号、长、宽都是整数；现在要求按照一下方式排序（默认排序规则都是从小到大）；

• 按照编号从小到大排序
• 对于编号相等的长方形，按照长方形的长排序；
• 如果编号和长都相同，按照长方形的宽排序；
• 如果编号、长、宽都相同，就只保留一个长方形用于排序,删除多余的长方形；最后排好序按照指定格式显示所有的长方形；

输入
第一行有一个整数 0<n<10000,表示接下来有n组测试数据；
每一组第一行有一个整数 0<m<1000，表示有m个长方形；
接下来的m行，每一行有三个数 ，第一个数表示长方形的编号，

第二个和第三个数值大的表示长，数值小的表示宽，相等
说明这是一个正方形（数据约定长宽与编号都小于10000）；
输出
顺序输出每组数据的所有符合条件的长方形的 编号 长 宽
样例输入
1
8
1 1 1
1 1 1
1 1 2
1 2 1
1 2 2
2 1 1
2 1 2
2 2 1
样例输出
1 1 1
1 2 1
1 2 2
2 1 1
2 2 1

代码

#include <stdio.h>
struct Square {
    int num;
    int len;
    int wid;
};

void swap(Square* a, Square* b);
int compare(Square* a, Square* b);
int removeSame(Square* eles, int len);
void sort(Square* eles, int left, int right);

int main()
{
    int T, m;
    int len, wid;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &m);
        Square eles[1000];
        // input
        for(int i = 0; i < m; i++) {
            scanf("%d %d %d", &(eles[i].num), &len, &wid);
            eles[i].len = len > wid ? len : wid;
            eles[i].wid = len < wid ? len : wid;
        }
        // removeSame
        m = removeSame(eles, m);
        // sort
        sort(eles, 0, m - 1);
        // output
        for(int i = 0; i < m; i++) {
            printf("%d %d %d\n", eles[i].num, eles[i].len, eles[i].wid);
        }
    }
    return 0;
}

void swap(Square* a, Square* b)
{
    int num = a->num;
    int len = a->len;
    int wid = a->wid;
    a->num = b->num;
    a->len = b->len;
    a->wid = b->wid;
    b->num = num;
    b->len = len;
    b->wid = wid;
}

int compare(Square* a, Square* b)
{
    if(a->num != b->num)
        return a->num - b->num;
    if(a->len != b->len)
        return a->len - b->len;
    return a->wid - b->wid;
}

int removeSame(Square* eles, int len)
{
    for(int i = 1; i < len; i++) {
        for(int j = i; compare(&eles[j - 1], &eles[j]) >= 0 && j > 0; j--) {
            if(compare(&eles[j - 1], &eles[j]) > 0) {
                swap(&eles[j - 1], &eles[j]);

            } else {
                // j到i左移一位
                for(int k = j; k < i; k++) {
                    swap(&eles[k], &eles[k + 1]);
                }
                swap(&eles[i], &eles[len - 1]);
                len--;
                i--;
            }
        }
    }
    return len;
}

void sort(Square* eles, int left, int right)
{
    if(left < right) {
        Square* pivot = &eles[left];
        int l = left + 1, r = right;
        while(l <= r) {
            while(l <= r && compare(&eles[l], pivot) <= 0) {
                l++;
            }
            while(l <= r && compare(&eles[r], pivot) >= 0) {
                r--;
            }
            if(l <= r) {
                swap(&eles[l++], &eles[r--]);
            }
        }
        swap(&eles[r], pivot);
        sort(eles, left, r - 1);
        sort(eles, r + 1, right);
    }
}