長方形去重排序

題目

描述
現在有很多長方形，每一個長方形都有一個編號，這個編號可以重複；還知道這個長方形的寬和長，編號、長、寬都是整數；現在要求按照一下方式排序（默認排序規則都是從小到大）；

• 按照編號從小到大排序
• 對於編號相等的長方形，按照長方形的長排序；
• 如果編號和長都相同，按照長方形的寬排序；
• 如果編號、長、寬都相同，就只保留一個長方形用於排序,刪除多餘的長方形；最後排好序按照指定格式顯示所有的長方形；

輸入
第一行有一個整數 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);
    }
}