华为OD机试 - 堆内存申请（Java 2024 D卷 100分）

news2024/11/13 10:53:27

在这里插入图片描述

华为OD机试 2024D卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（D卷+C卷+A卷+B卷）》。

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

有一个总空间为100字节的堆，现要从中新申请一块内存，内存分配原则为:

优先分配紧接着前一块已使用的内存，分配空间足够时分配最接近申请大小的空闲内存。

二、输入描述

第1行是1个整数，表示期望申请的内存字节数。

第2到第N行是用空格分割的两个整数，表示当前已分配的内存的情况，每一行表示一块已分配的连续内存空间，每行的第1个和第2个整数分别表示偏移地址和内存块大小，如: 0 1 3 2 表示0偏移地址开始的1个字节和3偏移地址开始的2个字节已被分配，其余内存空闲。

三、输出描述

若申请成功，输出申请到内存的偏移若申请失败，输出-1。

备注：

若输入信息不合法或无效，则申请失败
若没有足够的空间供分配，则申请失败
堆内存信息有区域重叠或有非法值等都是无效输入

四、解题思路

输入解析：
- 第一行输入是期望申请的内存字节数。
- 后续输入是已分配的内存块，用偏移地址和大小表示。
检查输入合法性：
- 确保输入的内存块不重叠且偏移和大小均为有效值。
计算空闲内存块：
- 遍历所有可能的空闲区域，计算其大小。
- 记录每个空闲区域的起始地址和大小。
选择合适的内存块：
- 优先选择紧接着已使用内存块后的空闲区域。
- 如果空闲区域足够大，则选择最接近申请大小的内存块。
返回结果：
- 如果找到合适的内存块，返回其起始地址。
- 如果未找到合适的内存块，返回 -1。

五、Java算法源码

public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr1 = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        // 读取期望申请的内存字节数
        int requestSize = arr1[0];
        // N行
        int n = arr1[1];

        // 用于存储已分配的内存块
        List<MemoryBlock> allocatedBlocks = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            int[] arr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            int start = arr[0];
            int size = arr[1];
            allocatedBlocks.add(new MemoryBlock(start, size));
        }

        // 对已分配的内存块进行排序，按照偏移地址排序
        allocatedBlocks.sort(Comparator.comparingInt(block -> block.start));

        // 计算空闲内存块
        List<MemoryBlock> freeBlocks = calculateFreeBlocks(allocatedBlocks, 100);

        // 找到最合适的空闲块
        int allocationStart = findSuitableBlock(freeBlocks, requestSize);

        // 输出结果
        System.out.println(allocationStart);
    }

    // 内存块类，用于存储起始地址和大小
    static class MemoryBlock {
        int start;
        int size;

        MemoryBlock(int start, int size) {
            this.start = start;
            this.size = size;
        }
    }

    // 计算空闲内存块
    private static List<MemoryBlock> calculateFreeBlocks(List<MemoryBlock> allocatedBlocks, int totalSize) {
        List<MemoryBlock> freeBlocks = new ArrayList<>();

        // 检查起始位置是否有空闲块
        if (allocatedBlocks.isEmpty() || allocatedBlocks.get(0).start > 0) {
            int end = allocatedBlocks.isEmpty() ? totalSize : allocatedBlocks.get(0).start;
            freeBlocks.add(new MemoryBlock(0, end));
        }

        // 检查已分配块之间的空闲区域
        for (int i = 0; i < allocatedBlocks.size() - 1; i++) {
            int endCurrent = allocatedBlocks.get(i).start + allocatedBlocks.get(i).size;
            int startNext = allocatedBlocks.get(i + 1).start;
            if (startNext > endCurrent) {
                freeBlocks.add(new MemoryBlock(endCurrent, startNext - endCurrent));
            }
        }

        // 检查最后一个已分配块后面的空闲区域
        if (!allocatedBlocks.isEmpty()) {
            int endLast = allocatedBlocks.get(allocatedBlocks.size() - 1).start + allocatedBlocks.get(allocatedBlocks.size() - 1).size;
            if (endLast < totalSize) {
                freeBlocks.add(new MemoryBlock(endLast, totalSize - endLast));
            }
        }

        return freeBlocks;
    }

    // 找到最合适的空闲块
    private static int findSuitableBlock(List<MemoryBlock> freeBlocks, int requestSize) {
        MemoryBlock bestFit = null;

        for (MemoryBlock block : freeBlocks) {
            if (block.size >= requestSize) {
                if (bestFit == null || block.size < bestFit.size) {
                    bestFit = block;
                }
            }
        }

        return (bestFit != null) ? bestFit.start : -1;
    }
}