HJ68 成绩排序

华为od机考题目-HJ68-成绩排序(比较难) 华为od机考真题 阅读详情
描述
查找和排序

题目:输入任意(用户,成绩)序列,可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。

例示:
jack      70
peter     96
Tom       70
smith     67

从高到低  成绩
peter     96
jack      70
Tom       70
smith     67

从低到高

smith     67

jack      70

Tom       70
peter     96

注:0代表从高到低,1代表从低到高

本题含有多组输入数据!
输入描述:
输入多行,先输入要排序的人的个数,然后分别输入他们的名字和成绩,以一个空格隔开

输出描述:
按照指定方式输出名字和成绩,名字和成绩之间以一个空格隔开

示例1
输入:
3
0
fang 90
yang 50
ning 70
复制
输出:
fang 90
ning 70
yang 50
复制
示例2
输入:
3
1
fang 90
yang 50
ning 70
3
0
moolgouua 43
aebjag 87
b 67
复制
输出:
yang 50
ning 70
fang 90
aebjag 87
b 67
moolgouua 43
复制
说明:
第一组用例:
3
1
fang 90
yang 50
ning 70
升序排序为:
yang 50
ning 70
fang 90
第二组降序为:
aebjag 87
b 67
moolgouua 43  

在判断升序和降序逻辑方面混乱

#include <stdio.h>
#include <stdlib.h>

#if 0
#define dbg printf
#else
#define dbg
#endif

struct list
{
    char name[32];
    int val;
    struct list *former;
    struct list *next;
};

void former_insert(struct list *a, struct list *b)
{
    b->former = a->former;
    a->former = b;
    b->next = a;
    if(b->former)
    {
        b->former->next = b;
    }
}

void next_insert(struct list *a, struct list *b)
{
    b->next = a->next;
    a->next = b;
    b->former = a;
    if(b->next)
    {
        b->next->former = b;
    }
}

int main(void)
{
    int cnt, index;
    int i, j;
    char out[256][32] = {0};
    char tmp[32] = {0};
    struct list *p, *q;
    struct list *head;
    
    j = 0;
    while(scanf("%d", &cnt) != EOF)
    {
        head = (struct list* )malloc(sizeof(struct list));
        scanf("%d", &index);
        scanf("%s", head->name);
        scanf("%d", &head->val);
        head->former = NULL;
        head->next = NULL;

        for(i=1; i<cnt; i++)
        {
            p = (struct list* )malloc(sizeof(struct list));
            scanf("%s", p->name);
            scanf("%d", &p->val);
            if(p->val < head->val)
            {
                former_insert(head, p);
                head = p;
            }
            else if(p->val == head->val)
            {
                if(index == 1)
                {
                    next_insert(head, p);
                }
                else
                {
                    former_insert(head, p);
                    head = p;
                }
            }
            else
            {
                q = head;
                if(index == 1)
                {
                    while(q && q->val<=p->val)
                    {
                        q = q->next;
                    }
                }
                else
                {
                    while(q && q->val<p->val)
                    {
                        q = q->next;
                    }
                }
                if(q != NULL)
                {
                    former_insert(q, p);
                }
                else
                {
                    q = head;
                    while(q->next)
                    {
                        q = q->next;
                    }
                    next_insert(q, p);
                }
            }
        }
        
        
        p = head;
        if(index == 1)
        {
            while(p)
            {
                dbg("(%d):%s %d\n", __LINE__, p->name, p->val);
                memset(tmp, 0, sizeof(tmp));
                snprintf(tmp, sizeof(tmp), "%s %d\n", p->name, p->val);
                strncpy(out[j], tmp, strlen(tmp));
                j++;
                q = p->next;
                free(p);
                p = q;
            }
        }
        else
        {
            p = head;
            while(p->next)
            {
                p = p->next;
            }
            while(p)
            {
                dbg("(%d):%s %d\n", __LINE__, p->name, p->val);
                memset(tmp, 0, sizeof(tmp));
                snprintf(tmp, sizeof(tmp), "%s %d\n", p->name, p->val);
                strncpy(out[j], tmp, strlen(tmp));
                j++;
                q = p->former;
                free(p);
                p = q;
            }
        }
    }
    for(i=0; i<j; i++)
    {
        printf("%s", out[i]);
    }
    return 0;
}

完善版本

#include <stdio.h>
#include <stdlib.h>

#if 0
#define dbg printf
#else
#define dbg
#endif

struct list
{
    char name[32];
    int val;
    struct list *former;
    struct list *next;
};

void former_insert(struct list *a, struct list *b)
{
    b->former = a->former;
    a->former = b;
    b->next = a;
    if(b->former)
    {
        b->former->next = b;
    }
}

void next_insert(struct list *a, struct list *b)
{
    b->next = a->next;
    a->next = b;
    b->former = a;
    if(b->next)
    {
        b->next->former = b;
    }
}

int main(void)
{
    int cnt, index;
    int i, j;
    char out[256][32] = {0};
    char tmp[32] = {0};
    struct list *p, *q;
    struct list *head;
    
    j = 0;
    while(scanf("%d", &cnt) != EOF)
    {
        head = (struct list* )malloc(sizeof(struct list));
        scanf("%d", &index);
        scanf("%s", head->name);
        scanf("%d", &head->val);
        head->former = NULL;
        head->next = NULL;

        for(i=1; i<cnt; i++)
        {
            p = (struct list* )malloc(sizeof(struct list));
            scanf("%s", p->name);
            scanf("%d", &p->val);
            if(index == 1)
            {
                if(p->val < head->val)
                {
                    former_insert(head, p);
                    head = p;
                }
                else
                {
                    q = head;
                    while(q && q->val<=p->val)
                    {
                        q = q->next;
                    }
                    if(q == NULL)
                    {
                        q = head;
                        while(q->next)
                        {
                            q = q->next;
                        }
                        next_insert(q, p);
                    }
                    else
                    {
                        former_insert(q, p);
                    }
                }
            }
            else
            {
                if(p->val > head->val)
                {
                    former_insert(head, p);
                    head = p;
                }
                else
                {
                    q = head;
                    while(q && q->val>=p->val)
                    {
                        q = q->next;
                    }
                    if(q == NULL)
                    {
                        q = head;
                        while(q->next)
                        {
                            q = q->next;
                        }
                        next_insert(q, p);
                    }
                    else
                    {
                        former_insert(q, p);
                    }
                }
            }
        }
        
        p = head;
       
        while(p)
        {
            dbg("(%d):%s %d\n", __LINE__, p->name, p->val);
            memset(tmp, 0, sizeof(tmp));
            snprintf(tmp, sizeof(tmp), "%s %d\n", p->name, p->val);
            strncpy(out[j], tmp, strlen(tmp));
            j++;
            q = p->next;
            free(p);
            p = q;
        }
    }
    for(i=0; i<j; i++)
    {
        printf("%s", out[i]);
    }
    return 0;
}
【牛客网华为机试】HJ68 成绩排序 题目 描述 查找和排序 题目:输入任意(用户,成绩)序列,可以获得成绩从高到低或从低到高的排列,相同成绩 都按先录入排列在前的规则处理。 例示: jack70 peter96 Tom70 smith67 从高到低成绩 peter96 jack70 Tom70 smith67 从低到高 smith67 jack70 Tom70 peter96 ... 阅读详情

相关推荐

深度强化学习-D3QN算法原理与代码

Dueling Double Deep Q Network(D3QN)算法结合了Double DQN和Dueling DQN算法的思想,进一步提升了算法的性能。如果对Doubel DQN和Dueling DQN算法还不太了解的话,可以参考我的这两篇博文:深度强化学习-Doubel DQN算法原理与代码和深度强化学习-Dueling DQN算法原理与代码,分别详细讲述了这两个算法的原理以及代码实现。本文就带领大家了解一下D3QN算法,代码链接见下方。 代码:https://github.com/indigo

weixin_46133643的博客 2万+

华为机试HJ68:成绩排序

C++实现——成绩排序

翟天保的博客 1万+

FPGA:UART串口接收(高干扰情况)

在上一篇文章中介绍过UART串口接收模块,其中一个需要优化的方向就是在高干扰情况下,如何实现可靠的UART串口接收任务。

weixin_50164178的博客 1671

【HJ68】成绩排序(stable_sort)

1.题目 2.思路 成绩排序题,定义一个学生结构体vector数组vector<student>stu(n)再进行sort。题目说了相同成绩的按照先录入的顺序排列,可以用stable_sort保证两个结构体的内容相同时不交换次序。 从C++ 使用const 引用传递参数这篇可知:c++使用引用传递节省内存开销。 (1)引用传递是双向的,当在函数中对于形参的数据进行改变后,实参的值也会进行相应的改变。 (2)如果我们既不想改变传入参数的值,也不想因为值传递产生太大的开销,如:可以将void D

发现问题,并解决问题,批判性思维 1310

ROS2与Gazebo协同实现多机器人避障仿真

本文详细介绍了如何利用ROS2与Gazebo协同搭建多机器人避障仿真环境。通过创建SDF机器人模型、编写多机器人启动文件以及集成基础避障算法,构建了一个低成本、高效率的虚拟测试平台,为AGV编队、机器人集群等项目的算法验证与迭代提供了完整解决方案。

weixin_29065659的博客 293

从UE4到Unity:双叶高光技术在角色皮肤渲染中的移植全流程

本文详细解析了将UE4中的双叶高光技术移植到Unity引擎的全流程。该技术通过模拟皮肤油脂层和真皮层的不同反射特性,能显著提升角色皮肤渲染的真实感。文章从核心原理、贴图资产处理、Shader代码重构到参数调校,提供了完整的跨引擎移植实战指南,帮助开发者实现高质量的皮肤质感还原。

alice7model的博客 476

华为机试-068-较难-HJ68.成绩排序

【代码】华为机试-068-较难-HJ68.成绩排序

tttzzzqqq2018的博客 454

Veritas NetBackup8.1.1客户端安装

1.在客户机打开安装包运行Browser 2.选择NetBackup Client Software Installation 3.下一步 4.接受,下一步 5.我选择自定义安装,下一步 6.我选择安装到D盘 7.默认下一步 8.使用域管理账户 9.输入服务器安装了服务端的那一台名称 10.输入服务端生成的令牌,选择“I recognize the fingerprint for this host.Proceed with the certificate deploymen”下一步

万物皆可学 2万+

(每日一题)HJ68成绩排序

给定一些同学的信息(名字,成绩)序列,请你将他们的信息按照成绩从高到低或从低到高的排列,相同成绩 都按先录入排列在前的规则处理。

TS5218的博客 589

【教培管家】小程序实战(五):体验课预约——从流量到转化的闭环

本节我们通过变量状态管理和数据联动,实现了孩子选择和日期选定。下一篇我们继续讲解预约页面,根据选择的日期来筛选排课,供用户进行预约。

低代码布道师的博客 1562

如何使用Agent框架来模拟群体智能?

Agent 框架作为人工智能领域的重要工具,可以模拟复杂的群体智能行为,广泛应用于社会科学、经济学和行为学等领域。

333

【华为机试】HJ68 成绩排序

该题目要求对n名学生的成绩进行排序,并根据op参数决定升序或降序。关键点在于处理成绩相同的学生时,需保持其原始输入顺序。使用稳定排序算法实现,通过自定义比较函数,先按成绩排序,成绩相同时按输入顺序排序。时间复杂度为O(n log n),空间复杂度为O(n)。测试案例验证了排序的正确性和稳定性,适用于成绩管理等多种场景。 (149字)

qq_32019341的博客 1059

VMware16虚拟机:下载和安装教程

VMware16 虚拟机 下载和安装教程

MQ0522的博客 20万+

HJ68 成绩排序【牛客网】

这是一道关于成绩排序的编程题目,要求按照指定方式排序并保持稳定性。解题思路是使用C++的stable_sort()函数配合lambda表达式实现自定义比较,根据输入标志位决定升序或降序。算法时间复杂度为O(nlogn),空间复杂度O(n)。参考代码通过vector存储学生数据,利用stable_sort的稳定性特点完成排序,最后输出结果。该解法简洁高效,适合处理这类需要稳定排序的场景。

yyh520025的博客 516

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

java-HJ68_成绩排序

java-HJ68 成绩排序。

d3y1`5 81_09 168

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

HJ68 成绩排序 ●●

HJ68 成绩排序 ●●、归并排序、稳定排序 stable_sort

chenyfan_blog 640

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

华为机试:HJ68 成绩排序-解析

∙ ∙一个长度为 1≦len(si)≦201≦len(si​)≦20、由大小写字母构成的字符串 sisi​ 代表第 ii 个学生的姓名;第二行输入一个整数 op(0≦op≦1)op(0≦op≦1) 代表排序方式,其中,00 表示按成绩降序,11 表示按成绩升序。根据输入的排序方式,按照成绩升序或降序输出所有学生的姓名和成绩。∙ ∙一个整数 ai(0≦ai≦100)ai​(0≦ai​≦100) 代表这个学生的成绩。第一行输入一个整数 n(1≦n≦200)n(1≦n≦200) 代表学生人数。

cherry6868的博客 327

每日两题记录day7---HJ51 输出单向链表中倒数第k个结点 与 HJ68 成绩排序

HJ51 输出单向链表中倒数第k个结点 while(n=readline(),s=readline(),k=readline()){ let len=Number(n); let arr=s.trim().split(' ') let key=Number(k); if(key>0){ print(arr[len-key]); } if(key===0){ print(0); } } 倒数第k个节点:也就是正

wind的博客 206

华为机试HJ68 成绩排序

首先看一下题。

bingw0114的博客 1070

牛客刷题 | HJ68 成绩排序, HJ69 矩阵乘法,HJ70 矩阵乘法计算量估算

本篇重点 1. 成绩排序: key要为名字+编号(固定的位数),熟练掌握lambda函数在sorted中的应用。2. 矩阵乘法: 直接按照公式计算,注意输出格式。3. 矩阵乘法计算量估算:对于有括号的运算,想到用栈解决。

Huiwen18的博客 371

hj68成绩排序python

输入描述: 第一行输入要排序的人的个数n,第二行输入一个整数表示排序的方式,之后n行分别输入他们的名字和成绩,以空格隔开。描述: 给定一些同学的信息(名字,成绩),序列,请你将他们的信息按照成绩从高到低或从低到高排列,相同。进阶: 时间复杂度:O(nlogn) ,空间复杂度:O(n)数据范围: 人数:1<=n<=200。的成绩都按先录入排列在前的规则处理。注:0代表从高到低;

weixin_44774246的博客 285
上一篇: HJ67 24点游戏算法
下一篇: HJ69 矩阵乘法(一把过)
你板子冒烟了
博客等级 码龄8年 1278粉丝 582原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值