华为OD机试 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

已于 2024-09-06 07:54:15 修改
阅读量896 收藏
点赞数
分类专栏： 华为OD机试真题（Python/JS/C/C++） 文章标签： python 华为od java c c++ javascript
于 2024-09-01 10:40:20 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/141780852
版权

在这里插入图片描述

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

专栏导读

本专栏收录于《华为OD机试真题（Java/Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

请实现一个简易内存池,根据请求命令完成内存分配和释放。

内存池支持两种操作命令，REQUEST和RELEASE，其格式为：

1、REQUEST

请求的内存大小表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。

2、RELEASE

释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。

注意：

1.内存池总大小为100字节。
2.内存池地址分配必须是连续内存，并优先从低地址分配。
3.内存释放后可被再次分配，已释放的内存在空闲时不能被二次释放。
4.不会释放已申请的内存块的中间地址。
5.释放操作只是针对首地址所对应的单个内存块进行操作，不会影响其它内存块。

二、输入描述

首行为整数N，表示操作命令的个数。

接下来的N行，每行将给出一个操作命令，操作命令和参数之间用“=”分割

三、输出描述

输出最后请求的内存的首地址。

如果位置已满，则输出-1。

样例：

2
REQUEST=10
REQUEST=20

输出样例：

0
10

四、解题思路

  1. 定义一个map，存储内存的分配情况（key：内存的首地址，value：内存的尾地址）；
  2. 请求内存时
    • 如果map是空，放在首地址0处；
    • 如果map不为空，遍历已经存入的首地址；
      • 已经存入的首地址 - 第一个空闲区域的首地址 大于 请求的内存值；
      • 将当前请求的内存的首地址和内存的尾地址存入map；
      • 反之，重置前一个空闲区域的首地址；
    • 判断剩余内存是否可以容下当前请求值；
      • 如果可以容下，将当前请求的内存的首地址和内存的尾地址存入map；
      • 如果容不下，输出error；
  3. 释放内存时，将其首地址的key移除map；
  4. 最后输出最后一次请求的首地址。

注意：如果最后发起的命令是RELEASE，也是可以的，会返回最后一次REQUEST的首地址。

五、测试用例

1、输入

4
REQUEST=20
REQUEST=30
RELEASE=0
REQUEST=30

2、输出

50

3、说明

  • 第一次请求20
  • 第二请求30
  • 第三次释放首地址为0的内存
  • 第四次请求30，第一个空闲区域的首地址是0，但空闲长度只有20，放不下当前请求的地址，因此消耗剩余内存，输出最后一次请求的首地址为50。

在这里插入图片描述

4、再输入

6
REQUEST=20
REQUEST=30
RELEASE=0
REQUEST=30
REQUEST=10
REQUEST=10

5、再说明

  • 第一次请求20
  • 第二请求30
  • 第三次释放首地址为0的内存
  • 第四次请求30，第一个空闲区域的首地址是0，但空闲长度只有20，放不下当前请求的地址，因此消耗剩余内存。
  • 第五次请求10，第一个空闲区域的首地址是0，长度20，可以容下当前请求的内存10。
  • 第六次请求10，第一个空闲区域的首地址是10，长度10，可以容下当前请求的内存10。
  • 输出最后一次请求的首地址为10。

在这里插入图片描述

在这里插入图片描述

6、如果走后一次请求的是20，会怎么样呢？

在这里插入图片描述

六、Python算法源码

class MemoryManager:
    REQUEST = "REQUEST"
    RELEASE = "RELEASE"
    ERROR = "error"
    MAX = 100

    def __init__(self):
        self.memory_map = {}

    def main(self):
        try:
            # 操作命令的个数
            N = int(input().strip())
            # 每一行的操作命令和参数
            line_arr = [input().strip().split('=') for _ in range(N)]

            for command, value_str in line_arr:
                value = int(value_str)
                if command.startswith(self.REQUEST):  # 请求
                    # 非法输入（内存池总大小为100字节）
                    if value > self.MAX or value <= 0:
                        print(self.ERROR)
                        return
                    self.request(value)
                elif command.startswith(self.RELEASE):  # 释放
                    self.memory_map.pop(value, None)
                else:  # 非法输入
                    print(self.ERROR)
        except Exception as e:
            # 非法输入
            print(self.ERROR)

    def request(self, value):
        zero = 0
        before_head_address = 0

        if not self.memory_map:  # 如果memory_map是空，放在首地址0处
            self.memory_map[zero] = value
            print(zero)
        else:
            head_list = sorted(self.memory_map.keys())

            for requested_head in head_list:
                if requested_head - before_head_address >= value:
                    self.memory_map[before_head_address] = before_head_address + value
                    print(before_head_address)
                    return
                else:
                    before_head_address = self.memory_map[requested_head]

            if self.MAX - before_head_address >= value:
                self.memory_map[before_head_address] = before_head_address + value
                print(before_head_address)
            else:
                print("-1")


if __name__ == "__main__":
    MemoryManager().main()

七、JavaScript算法源码

class MemoryManager {
    constructor() {
        this.REQUEST = "REQUEST";
        this.RELEASE = "RELEASE";
        this.ERROR = "error";
        this.MAX = 100;
        this.memoryMap = new Map(); // 用于存储内存的分配情况
    }

    main() {
        try {
            const input = require('readline-sync');
            // 操作命令的个数
            const N = parseInt(input.question().trim());
            // 每一行的操作命令和参数
            const lineArr = [];
            for (let i = 0; i < N; i++) {
                lineArr.push(input.question().trim().split('='));
            }

            for (let i = 0; i < N; i++) {
                const [command, valueStr] = lineArr[i];
                const value = parseInt(valueStr);
                if (command.startsWith(this.REQUEST)) { // 请求
                    // 非法输入（内存池总大小为100字节）
                    if (value > this.MAX || value <= 0) {
                        console.log(this.ERROR);
                        return;
                    }
                    this.request(value);
                } else if (command.startsWith(this.RELEASE)) { // 释放
                    this.memoryMap.delete(value);
                } else { // 非法输入
                    console.log(this.ERROR);
                }
            }
        } catch (e) {
            // 非法输入
            console.log(this.ERROR);
        }
    }

    request(value) {
        let zero = 0;
        let beforeHeadAddress = 0;

        if (this.memoryMap.size === 0) { // 如果memoryMap是空，放在首地址0处
            this.memoryMap.set(zero, value);
            console.log(zero);
        } else {
            const headList = Array.from(this.memoryMap.keys()).sort((a, b) => a - b);

            for (let requestedHead of headList) {
                if (requestedHead - beforeHeadAddress >= value) {
                    this.memoryMap.set(beforeHeadAddress, beforeHeadAddress + value);
                    console.log(beforeHeadAddress);
                    return;
                } else {
                    beforeHeadAddress = this.memoryMap.get(requestedHead);
                }
            }

            if (this.MAX - beforeHeadAddress >= value) {
                this.memoryMap.set(beforeHeadAddress, beforeHeadAddress + value);
                console.log(beforeHeadAddress);
            } else {
                console.log("-1");
            }
        }
    }
}

// 执行内存管理器
const memoryManager = new MemoryManager();
memoryManager.main();

八、C算法源码

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

#define REQUEST "REQUEST"
#define RELEASE "RELEASE"
#define ERROR "error"
#define MAX 100

typedef struct MemoryBlock {
    int start;
    int end;
    struct MemoryBlock* next;
} MemoryBlock;

MemoryBlock* head = NULL;

void request(int value);
void release(int value);
void print_error();
void print_memory_address(int address);

int main() {
    int N;
    scanf("%d", &N);

    for (int i = 0; i < N; i++) {
        char command[10];
        int value;
        scanf("%s=%d", command, &value);

        if (strncmp(command, REQUEST, strlen(REQUEST)) == 0) {
            if (value > MAX || value <= 0) {
                print_error();
                return 0;
            }
            request(value);
        } else if (strncmp(command, RELEASE, strlen(RELEASE)) == 0) {
            release(value);
        } else {
            print_error();
            return 0;
        }
    }

    return 0;
}

void request(int value) {
    int beforeHeadAddress = 0;

    if (head == NULL) {
        // 如果链表为空，放在首地址0处
        MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
        newBlock->start = 0;
        newBlock->end = value;
        newBlock->next = NULL;
        head = newBlock;
        print_memory_address(0);
    } else {
        MemoryBlock* current = head;
        MemoryBlock* prev = NULL;

        while (current != NULL) {
            if (current->start - beforeHeadAddress >= value) {
                MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
                newBlock->start = beforeHeadAddress;
                newBlock->end = beforeHeadAddress + value;
                newBlock->next = current;

                if (prev == NULL) {
                    head = newBlock;
                } else {
                    prev->next = newBlock;
                }
                print_memory_address(newBlock->start);
                return;
            }
            beforeHeadAddress = current->end;
            prev = current;
            current = current->next;
        }

        if (MAX - beforeHeadAddress >= value) {
            MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
            newBlock->start = beforeHeadAddress;
            newBlock->end = beforeHeadAddress + value;
            newBlock->next = NULL;
            prev->next = newBlock;
            print_memory_address(newBlock->start);
        } else {
            print_memory_address(-1);
        }
    }
}

void release(int value) {
    MemoryBlock* current = head;
    MemoryBlock* prev = NULL;

    while (current != NULL) {
        if (current->start == value) {
            if (prev == NULL) {
                head = current->next;
            } else {
                prev->next = current->next;
            }
            free(current);
            return;
        }
        prev = current;
        current = current->next;
    }
}

void print_error() {
    printf("%s\n", ERROR);
}

void print_memory_address(int address) {
    printf("%d\n", address);
}

九、C++算法源码

#include <iostream>
#include <map>
#include <string>

using namespace std;

class MemoryManager {
public:
    static const int MAX = 100;
    const string REQUEST = "REQUEST";
    const string RELEASE = "RELEASE";
    const string ERROR = "error";

    void main() {
        try {
            int N;
            cin >> N;
            cin.ignore(); // 忽略换行符

            string lineArr[N][2];
            for (int i = 0; i < N; ++i) {
                string command;
                getline(cin, command);

                size_t pos = command.find('=');
                if (pos != string::npos) {
                    lineArr[i][0] = command.substr(0, pos);
                    lineArr[i][1] = command.substr(pos + 1);
                }
            }

            for (int i = 0; i < N; ++i) {
                int value = stoi(lineArr[i][1]);
                if (lineArr[i][0].find(REQUEST) == 0) { // 请求
                    if (value > MAX || value <= 0) {
                        cout << ERROR << endl;
                        return;
                    }
                    request(value);
                } else if (lineArr[i][0].find(RELEASE) == 0) { // 释放
                    memoryMap.erase(value);
                } else { // 非法输入
                    cout << ERROR << endl;
                }
            }
        } catch (...) {
            // 非法输入
            cout << ERROR << endl;
        }
    }

private:
    map<int, int> memoryMap;

    void request(int value) {
        int beforeHeadAddress = 0;

        if (memoryMap.empty()) { // 如果memoryMap是空，放在首地址0处
            memoryMap[0] = value;
            cout << 0 << endl;
        } else {
            for (auto it = memoryMap.begin(); it != memoryMap.end(); ++it) {
                if (it->first - beforeHeadAddress >= value) {
                    memoryMap[beforeHeadAddress] = beforeHeadAddress + value;
                    cout << beforeHeadAddress << endl;
                    return;
                }
                beforeHeadAddress = it->second;
            }

            if (MAX - beforeHeadAddress >= value) {
                memoryMap[beforeHeadAddress] = beforeHeadAddress + value;
                cout << beforeHeadAddress << endl;
            } else {
                cout << "-1" << endl;
            }
        }
    }
};

int main() {
    MemoryManager memoryManager;
    memoryManager.main();
    return 0;
}

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
订阅专栏
【华为OD机试】简易内存池（python, java, c++, js）
A_D_I_D_A_S的博客
07-06 305
请实现一个简易内存池，根据请求命令完成内存分配和释放。内存池支持两种操作命令，REQUEST和RELEASE，其格式为：REQUEST=请求的内存大小，表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输error。 RELEASE=释放的内存首地址，表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
华为OD机试 - 简易内存池（Java & JS & Python & C & C++）.html
04-20
华为OD机试 - 简易内存池（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
华为OD机试 - 简易内存池 - 逻辑分析（Java 2024 E卷 200分）
学Java，找哪吒
08-10 3951
刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
【华为OD机试真题 C++】简易内存池
A_D_I_D_A_S的博客
12-25 449
请实现一个简易内存池，根据请求命令完成内存分配和释放。内存池支持两种操作命令，REQUEST和RELEASE，其格式为：REQUEST=请求的内存大小，表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输error。 RELEASE=释放的内存首地址，表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
华为机试：简易内存池
OceanStar的博客
09-11 693
【代码】华为机试：简易内存池。
华为OD机试 - 简易内存池（Python）
m0_46181452的博客
07-16 303
当REQUEST申请size大小的内存时，我们从start=0位置开始申请，即申请[start, start+size-1]区间，接下来看该区间是否和used[i]区间存在交叉，如果存在交xian叉，则说明申请的内存区间中部分内存已被使用，因此我们应该更新 start = used[i][1] + 1位置，重新申请一个区间，这样就必然不和used[i]区间交叉了，但是要继续和used[i+1]区间比较。第三条指令，释放首地址为0的内存申请，0~9地址内存被释放，变为空闲，释放成功，无需输出。
简易内存池
qq_47406941的博客
07-01 1149
目录 一、内存池基础知识 1、什么是内存池 1.1 池化技术 1.2 内存池 2、内存池的作用 2.1 效率问题 2.2 内存碎片 3、内存池技术的演进 二、简易内存池原理 1、整体设计 2、细节剖析 2.1 内存块如何用链表链接 3、性能比较 三、简易内存池完整源码 一、内存池基础知识 1、什么是内存池 1.1 池化技术 池化技术是计算机中的一种设计模式，主要是指：将程序中经常要使用的计算机资源预先申请出来，由程序自己管理，程序在使用时直接从“池”中获取，不仅保证了程序
【免费题库】华为OD机试 - 模拟数据序列化传输（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 模拟数据序列化传输（Java & JS & Python & C & C++）.html
华为OD机试 - 智能驾驶（Java & JS & Python & C & C++）.html
最新发布
04-20
华为OD机试 - 智能驾驶（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
简易的内存池实现
07-16
简单的内存池实现,已经应用到一个小项目中,使用方法看头文件吧,代码也不多.
华为OD机试 - 伐木工（Java & JS & Python & C & C++）.html
04-20
华为OD机试 - 伐木工（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
【免费题库】华为OD机试 - 虚拟理财游戏（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 虚拟理财游戏（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
华为OD机试真题Python实现【内存池】真题+解题思路+代码（2022&2023）
码莎拉蒂
02-26 1398
有一个简易内存池，内存按照大小粒度分类，每个粒度有若干个可用内存资源。用户会进行一系列内存申请，需要按需分配内存池中的资源，返回申请结果成功失败列表。truefalse。
【LeetCode-内存池】
qq_20386411的博客
01-28 922
【代码】【LeetCode-内存池】
2023华为od机试真题【简易内存池】C语言
MISAYAONE的博客
06-26 1148
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
华为OD机试 - 简易内存池 2（C++） | 附带编码思路 【2023】
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-22 3585
简易内存池 2 | 华为OD机试 题目 请实现一个简易内存池 根据请求命令完成内存分配和释放 内存池支持两种操作命令 REQUEST和RELEASE其格式为 REQUEST=请求的内存大小 表示请求分配指定大小内存 如果分配成功，返回分配到的内存首地址 如果内存不足，或指定的大小为零则输出error RELEASE=释放的内存首地址 表示释放掉之前分配的内存 释放成功无需输出 如果释放不存在的首地址 则输出error
华为od机试-2023真题-考点分类
07-27
华为OD机试-2023真题的考点主要分为以下几个分类： 1. 数据结构与算法：考察对各种常用数据结构（如数组、链表、栈、队列、树、图等）和算法（如排序、查找、递归、动态规划等）的理解和应用能力，以及对时间复杂度和空间复杂度的分析和优化。 2. 编程语言和语法：考察对编程语言（如C++、Python等）的基本语法和特性的掌握程度，包括变量、运算符、控制流程、函数、类等。同时还要求考生熟练运用相关的标准库和常用的数据结构和算法。 3. 网络与操作系统：考察对计算机网络和操作系统的基本原理和常用技术的了解，包括网络通信、TCP/IP协议、进程管理、内存管理、文件系统等。要求考生理解并能解决相关的问题。 4. 数据库与SQL：考察对数据库的基本概念和原理的理解，包括数据模型、关系代数、SQL语言等内容。要求考生能够编写和优化SQL查询语句，处理常见的数据库操作和性能问题。 5. 系统设计与架构：考察对大型系统的设计和架构的理解，包括系统需求分析、模块划分、接口设计等。要求考生能够根据需求或场景提出可行的系统设计方案，并能解决相关的实际问题。 总体来说，华为OD机试-2023真题的考点比较全面，涵盖了计算机科学与技术的多个方面。考生需要具备扎实的数据结构与算法基础，熟悉常用编程语言和标准库的使用，了解网络和操作系统的基本原理，掌握数据库和SQL语言的基本知识，同时具备系统设计和架构的能力。只有在这些方面的基础上才能够应对各种考题，并取得优异的表现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值