华为OD机试_2025 B卷_磁盘容量排序（Python，100分）（附详细解题思路）

题目描述

磁盘的容量单位常用的有M，G，T这三个等级，

它们之间的换算关系为1T = 1024G，1G = 1024M，

现在给定n块磁盘的容量，请对它们按从小到大的顺序进行稳定排序，

例如给定5块盘的容量，1T，20M，3G，10G6T，3M12G9M

排序后的结果为20M，3G，3M12G9M，1T，10G6T。

注意单位可以重复出现，上述3M12G9M表示的容量即为3M+12G+9M，和12M12G相等。

输入描述

输入第一行包含一个整数n(2 <= n <= 100)，表示磁盘的个数，

接下的n行，每行一个字符串(长度大于2，小于30)，

表示磁盘的容量，由一个或多个格式为mv的子串组成，

其中m表示容量大小，v表示容量单位，例如20M，1T，30G，10G6T，3M12G9M。

磁盘容量m的范围为1到1024的正整数，

容量单位v的范围只包含题目中提到的M，G，T三种，换算关系如题目描述。

输出描述

输出n行，表示n块磁盘容量排序后的结果。

用例

|----|---------------------------------------------|
| 输入 | 3 1G 2G 1024M |
| 输出 | 1G 1024M 2G |
| 说明 | 1G和1024M容量相等，稳定排序要求保留它们原来的相对位置，故1G在1024M之前。 |

|----|----------------------------|
| 输入 | 3 2G4M 3M2G 1T |
| 输出 | 3M2G 2G4M 1T |
| 说明 | 1T的容量大于2G4M，2G4M的容量大于3M2G。 |

磁盘容量排序算法详解

核心解题思路

本题目要求对多种格式的磁盘容量字符串进行排序，核心思路是将所有容量转换为统一单位后再比较。解题分为三个关键步骤：

1. 容量字符串解析 ：将复合格式如3M12G9M拆分为多个容量单位子串
2. 单位统一转换：将所有容量值转换为最小单位M（兆字节）
3. 稳定排序：按转换后的数值排序，值相同时保持原始输入顺序

关键点说明

• 单位换算：1T = 1024G = 1024×1024M
• 复合容量处理 ：如3M12G9M = 3M + 12×1024M + 9M
• 稳定排序：当容量相等时，保持输入原始顺序

完整代码实现

def convert_to_m(capacity_str):
    """
    将容量字符串转换为以M为单位的总容量
    """
    total = 0  # 总容量（单位：M）
    num_str = ""  # 临时存储数字字符串
    
    for char in capacity_str:
        if char.isdigit():
            # 数字字符，累积到数字字符串
            num_str += char
        else:
            # 单位字符，处理累积的数字
            if num_str:
                num = int(num_str)
                if char == 'T':
                    total += num * 1024 * 1024
                elif char == 'G':
                    total += num * 1024
                elif char == 'M':
                    total += num
                num_str = ""  # 重置数字字符串
    return total

def main():
    n = int(input().strip())
    capacities = [input().strip() for _ in range(n)]
    
    # 存储（原始字符串，M单位容量）元组
    converted = []
    for cap in capacities:
        m_value = convert_to_m(cap)
        converted.append((cap, m_value))
    
    # 稳定排序（容量相同时保持原始顺序）
    converted.sort(key=lambda x: x[1])
    
    # 输出结果
    for cap, _ in converted:
        print(cap)

if __name__ == "__main__":
    main()

算法原理解析

1. 容量转换函数

def convert_to_m(capacity_str):
    total = 0
    num_str = ""
    for char in capacity_str:
        if char.isdigit():
            num_str += char
        else:
            if num_str:
                num = int(num_str)
                if char == 'T':
                    total += num * 1024 * 1024
                # ...其他单位处理
                num_str = ""
    return total

• 数字累积：遍历字符串，累积连续数字字符
• 单位转换：遇到单位字符时，将累积数字转换为对应单位的M值
• 累加求和：将所有子串的值累加得到总容量

2. 单位换算系数

单位	换算为M的系数
T	1024×1024 = 1,048,576
G	1024
M	1

3. 稳定排序实现

converted.sort(key=lambda x: x[1])

• 使用Python内置的TimSort算法（稳定排序）
• 仅比较转换后的M值
• 当M值相等时，自动保持列表中原有顺序

示例解析

示例1：输入3\n1G\n2G\n1024M

1. 容量转换：

   • 1G → 1×1024 = 1024M
   • 2G → 2×1024 = 2048M
   • 1024M → 1024×1 = 1024M

2. 转换后数据：

   [('1G', 1024), ('2G', 2048), ('1024M', 1024)]

3. 排序过程：

   • 1024M和1G值相等(1024)，保持输入顺序（1G先出现）
   • 2G值最大(2048)

4. 输出结果：

   1G
   1024M
   2G

示例2：输入3\n2G4M\n3M2G\n1T

1. 容量转换：

   • 2G4M → 2×1024 + 4×1 = 2048 + 4 = 2052M
   • 3M2G → 3×1 + 2×1024 = 3 + 2048 = 2051M
   • 1T → 1×1,048,576 = 1,048,576M

2. 转换后数据：

   [('2G4M', 2052), ('3M2G', 2051), ('1T', 1048576)]

3. 排序结果：

   3M2G  (2051M)
   2G4M  (2052M)
   1T    (1048576M)

示例3：复合格式3M12G9M

1. 解析过程：

   • 3M → 3×1 = 3M
   • 12G → 12×1024 = 12,288M
   • 9M → 9×1 = 9M
   • 总和：3 + 12,288 + 9 = 12,300M

2. 等效计算：12,300M = 12G12M (∵12×1024=12,288, 12,288+12=12,300)

总结与拓展

关键知识点

1. 字符串解析：分离数字和单位字符
2. 单位换算：不同存储单位间的转换关系
3. 稳定排序：保持相等元素的原始顺序
4. 复合值处理：多部分数值的累加计算

本解法通过以下步骤高效解决问题：

1. 精确解析复合容量字符串
2. 统一转换为最小单位比较
3. 利用稳定排序保持原始顺序
4. 输出原始格式结果

初学者可从中学习：

1. 字符串遍历和数字累积技巧
2. 单位换算的核心算法
3. 稳定排序的实际应用
4. 复合数值的处理方法

核心启示：将复杂格式的数据转换为统一可比较的数值，是解决此类排序问题的通用思路。