谈谈华为OD机试真题（C卷）：堆内存申请

前端

2023-09-19 12:44:12

堆内存申请算法：原理与应用

在计算机系统中，内存管理是一项至关重要的任务，它决定着程序的执行效率和系统的稳定性。堆内存申请算法 是一种高效的内存管理算法，用于分配和释放堆内存，以满足程序的动态内存需求。

堆内存申请算法的原理

堆内存申请算法基于以下原则：

优先原则： 当需要分配内存时，优先分配最接近所申请内存大小且满足要求的空闲内存块。
后备原则： 如果找不到满足要求的空闲内存块，则在堆的末尾分配一块新的内存块。

堆内存申请算法的实现

Python

def allocate_memory(memory_size, allocated_memory):
    """
    Allocates memory in a heap according to the given allocation principle.

    Args:
        memory_size: The size of the memory to be allocated in bytes.
        allocated_memory: A list of tuples representing the allocated memory blocks, where each tuple contains the starting address and the size of the block.

    Returns:
        A tuple containing the starting address and the size of the allocated memory block.
    """

    # Sort the allocated memory blocks by their starting addresses.
    allocated_memory.sort(key=lambda x: x[0])

    # Find the first available memory block that is large enough to fit the requested memory size.
    for start_address, size in allocated_memory:
        if size >= memory_size:
            return start_address, memory_size

    # If no such block is found, allocate a new block at the end of the heap.
    start_address = allocated_memory[-1][0] + allocated_memory[-1][1]
    return start_address, memory_size

C++

#include <iostream>
#include <vector>

using namespace std;

struct MemoryBlock {
    int start_address;
    int size;
};

bool compare_memory_blocks(const MemoryBlock& a, const MemoryBlock& b) {
    return a.start_address < b.start_address;
}

pair<int, int> allocate_memory(int memory_size, vector<MemoryBlock>& allocated_memory) {
    // Sort the allocated memory blocks by their starting addresses.
    sort(allocated_memory.begin(), allocated_memory.end(), compare_memory_blocks);

    // Find the first available memory block that is large enough to fit the requested memory size.
    for (auto& block : allocated_memory) {
        if (block.size >= memory_size) {
            return make_pair(block.start_address, memory_size);
        }
    }

    // If no such block is found, allocate a new block at the end of the heap.
    int start_address = allocated_memory.back().start_address + allocated_memory.back().size;
    return make_pair(start_address, memory_size);
}

int main() {
    int memory_size;
    cout << "Enter the size of the memory to be allocated: ";
    cin >> memory_size;

    // Read the allocated memory blocks from the user.
    vector<MemoryBlock> allocated_memory;
    cout << "Enter the allocated memory blocks (start_address size): ";
    while (true) {
        int start_address, size;
        cin >> start_address >> size;
        if (start_address == -1 && size == -1) {
            break;
        }
        allocated_memory.push_back({start_address, size});
    }

    // Allocate the memory and print the result.
    pair<int, int> allocated_block = allocate_memory(memory_size, allocated_memory);
    cout << "Allocated memory block: " << allocated_block.first << " " << allocated_block.second << endl;

    return 0;
}

Java

import java.util.*;

class MemoryBlock {
    private int startAddress;
    private int size;

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

    public int getStartAddress() {
        return startAddress;
    }

    public int getSize() {
        return size;
    }
}

class AllocateMemory {

    private static List<MemoryBlock> allocatedMemory = new ArrayList<>();

    public static MemoryBlock allocate(int memorySize) {
        // Sort the allocated memory blocks by their starting addresses.
        Collections.sort(allocatedMemory, (a, b) -> Integer.compare(a.getStartAddress(), b.getStartAddress()));

        // Find the first available memory block that is large enough to fit the requested memory size.
        for (MemoryBlock block : allocatedMemory) {
            if (block.getSize() >= memorySize) {
                return new MemoryBlock(block.getStartAddress(), memorySize);
            }
        }

        // If no such block is found, allocate a new block at the end of the heap.
        int startAddress = allocatedMemory.get(allocatedMemory.size() - 1).getStartAddress() + allocatedMemory.get(allocatedMemory.size() - 1).getSize();
        return new MemoryBlock(startAddress, memorySize);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Read the size of the memory to be allocated.
        System.out.print("Enter the size of the memory to be allocated: ");
        int memorySize = scanner.nextInt();

        // Read the allocated memory blocks.
        System.out.println("Enter the allocated memory blocks (start_address size): ");
        while (true) {
            int startAddress = scanner.nextInt();
            int size = scanner.nextInt();
            if (startAddress == -1 && size == -1) {
                break;
            }
            allocatedMemory.add(new MemoryBlock(startAddress, size));
        }

        // Allocate the memory and print the result.
        MemoryBlock allocatedBlock = allocate(memorySize);
        System.out.println("Allocated memory block: " + allocatedBlock.getStartAddress() + " " + allocatedBlock.getSize());
    }
}

const allocateMemory = (memorySize, allocatedMemory) => {
  // Sort the allocated memory blocks by their starting addresses.
  allocatedMemory.sort((a, b) => a.startAddress - b.startAddress);

  // Find the first available memory block that is large enough to fit the requested memory size.
  for (const block of allocatedMemory) {
    if (block.size >= memorySize) {
      return {
        startAddress: block.startAddress,
        size: memorySize,
      };
    }
  }

  // If no such block is found, allocate a new block at the end of the heap.
  const startAddress = allocatedMemory[allocatedMemory.length - 1].startAddress + allocatedMemory[allocatedMemory.length - 1].size;
  return {
    startAddress,
    size: memorySize,
  };
};

const main = () => {
  // Read the size of the memory to be allocated.
  const memorySize = parseInt(prompt("Enter the size of the memory to be allocated: "));

  // Read the allocated memory blocks.
  const allocatedMemory = [];
  while (true) {
    const startAddress = parseInt(prompt("Enter the starting address of the allocated memory block: "));
    const size = parseInt(prompt("Enter the size of the allocated memory block: "));
    if (startAddress === -1 && size === -1) {
      break;
    }
    allocatedMemory.push({
      startAddress,
      size,
    });
  }

  // Allocate the memory and print the result.
  const allocatedBlock = allocateMemory(memorySize, allocatedMemory);
  console.log(`Allocated memory block: ${allocatedBlock.startAddress} ${allocatedBlock.size}`);
};

main();