HDOJ 2020 尝试结构体的归并排序，正常只要abs排嘛我知道...

最新推荐文章于 2024-07-18 14:14:45 发布

原创最新推荐文章于 2024-07-18 14:14:45 发布 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

ACM 专栏收录该内容

16 篇文章

订阅专栏

本文介绍了一种针对整数集合的排序算法，该算法能够根据整数的绝对值进行从大到小的排序，并确保所有数值的绝对值不相等。通过使用结构体存储原始值及其符号来实现这一目标，利用归并排序方法完成排序过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Problem Description

输入n(n<=100)个整数，按照绝对值从大到小排序后输出。题目保证对于每一个测试实例，所有的数的绝对值都不相等。

Input

输入数据有多组，每组占一行，每行的第一个数字为n,接着是n个整数，n=0表示输入数据的结束，不做处理。

Output

对于每个测试实例，输出排序后的结果，两个数之间用一个空格隔开。每个测试实例占一行。

Sample Input

3 3 -4 2
4 0 1 2 -3
0

Sample Output

-4 3 2
-3 2 1 0

已AC：
#include <iostream>
#include <cmath>
struct node
{
    int a;
    int b;
};
void Merge(node *ps, int p, int q, int r);
void MergeSort(node * ps, int a, int b);

int main()
{
    using namespace std;
    int n;

    while(cin >> n && n)
    {
        node * ptr = new node [n];
        for(int i=0; i<n; ++i)
        {
            int m;
            cin >> m;
            ptr[i].a = abs(m);
            if(m>=0)
                ptr[i].b = 1;
            else
                ptr[i].b = -1;
        }
        MergeSort(ptr, 0, n-1);
        for(int i=0; i<n; ++i)
        {
            if(!i)
                cout << ptr[i].a*ptr[i].b;
            else
                cout << " " << ptr[i].a*ptr[i].b;
        }
        cout << endl;
        delete [] ptr;
    }
    return 0;
}


void Merge(node *ps, int p, int q, int r)
{
    int l = q-p+1;
    int k = r-q;
    node *L = new node [l+1];//不能node L[l+1]
    node *R = new node [k+1];//IDE上都可以过，OJ上居然ＣＥ，注意点！！
    int i, j;

    for(i=p,j=0; i<=q; ++i,++j)
        L[j] = ps[i];
    for(i=q+1,j=0; i<=r; ++i,++j)
        R[j] = ps[i];
    L[l].a = R[k].a = -1;

    i = j = 0;
    for(int m=p; m<=r; ++m)
    {
        if(L[i].a>R[j].a)
            ps[m] = L[i++];
        else
            ps[m] = R[j++];
    }
    delete [] L;
    delete [] R;
}

void MergeSort(node * ps, int a, int b)
{
    if(a<b)
    {
        int mid = (a+b)/2;
        MergeSort(ps, a, mid);
        MergeSort(ps, mid+1, b);
        Merge(ps, a, mid, b);
    }
}