Python内存分配与回收程序：使用链表模拟动态分区存储管理

下面是一个简单的内存分配与回收程序的实现，使用链表模拟内存存储空间，并利用动态分区存储管理方法来给进程分配内存和回收内存。

import random

class MemoryBlock:
    def __init__(self, start, end, process_id=None):
        self.start = start
        self.end = end
        self.process_id = process_id
        self.next = None

class MemoryManager:
    def __init__(self, memory_size):
        self.memory_size = memory_size
        self.free_memory = MemoryBlock(0, memory_size)
        self.allocated_memory = None

    def allocate_memory(self, process_id, size):
        # 检查是否有足够的空闲内存
        current_block = self.free_memory
        while current_block:
            if current_block.end - current_block.start >= size:
                break
            current_block = current_block.next

        if current_block is None:
            print('无法为进程' + str(process_id) + '分配' + str(size) + '大小的内存空间')
            return

        # 分配内存
        new_block = MemoryBlock(current_block.start, current_block.start + size, process_id)
        current_block.start += size

        if self.allocated_memory is None:
            self.allocated_memory = new_block
        else:
            current_block = self.allocated_memory
            while current_block.next:
                current_block = current_block.next
            current_block.next = new_block

        print('为进程' + str(process_id) + '成功分配' + str(size) + '大小的内存空间')

    def deallocate_memory(self, process_id):
        # 回收内存
        previous_block = None
        current_block = self.allocated_memory
        while current_block:
            if current_block.process_id == process_id:
                if previous_block is None:
                    self.allocated_memory = current_block.next
                else:
                    previous_block.next = current_block.next

                # 将回收的内存块插入到空闲内存链表中
                current_block.next = None
                free_block = self.free_memory
                while free_block.next and current_block.start > free_block.next.start:
                    free_block = free_block.next
                current_block.next = free_block.next
                free_block.next = current_block

                print('成功回收进程' + str(process_id) + '的内存空间')
                return
            previous_block = current_block
            current_block = current_block.next

        print('进程' + str(process_id) + '没有被分配内存空间')

    def print_memory_status(self):
        # 打印内存使用情况
        print('空闲内存空间:')
        current_block = self.free_memory
        while current_block:
            print('[{} - {}]'.format(current_block.start, current_block.end), end=' -> ')
            current_block = current_block.next
        print('None')

        print('已分配内存空间:')
        current_block = self.allocated_memory
        while current_block:
            print('[{} - {}] (进程ID: {})'.format(current_block.start, current_block.end, current_block.process_id), end=' -> ')
            current_block = current_block.next
        print('None')


# 测试程序
if __name__ == '__main__':
    memory_size = 1000
    manager = MemoryManager(memory_size)

    # 随机分配和回收内存
    for i in range(1, 6):
        process_id = i
        memory_size = random.randint(50, 200)
        manager.allocate_memory(process_id, memory_size)
        manager.print_memory_status()

    for i in range(1, 6):
        process_id = i
        manager.deallocate_memory(process_id)
        manager.print_memory_status()

上述代码中，我们定义了MemoryBlock类来表示内存块，每个内存块包含起始地址、结束地址和进程ID。MemoryManager类是内存管理器，它包含一个空闲内存链表和一个已分配内存链表。allocate_memory方法用于为进程分配内存空间，deallocate_memory方法用于回收进程的内存空间，print_memory_status方法用于打印当前的内存使用情况。

在测试部分，我们通过循环模拟随机分配和回收内存空间的过程，并打印每次操作后的内存使用情况。

请注意，以上只是一个简单的实现示例，实际的内存管理算法可能更加复杂，如首次适应、最佳适应、最坏适应等。此外，本示例中的内存分配是首次匹配，只从空闲内存链表的开头查找可用的内存块，实际情况中可能需要使用其他的分配算法。