华为 简易内存池 Python

查了一遍，很多都要钱，所以自己磕了一个出来，用的双向链表。本人水平一般，仅供参考。

'''
简易内存池
题目描述：根据指令完成分配和释放，REQUEST和RELEASE
REQUEST=请求的内存大小
如果成功，返回分配到的内存首地址；如果内存不足或者，指定大小为0，输出error
RELEASE=释放的内存首地址
释放成功无需输出(为了方便记录，自定义了一个输出），如果给的首地址不存在，输出error

注意：
内存池总大小为100字节
内存池地址分配连续，优先从低开始
释放操作值只针对首地址对应的单个内存块，不影响其他内存块

输入：
首行为整数N，表示操作命令的个数，0<N<=100
接下来，每行一个命令，命令和参数之间用‘=’分割
样例：
2
REQUEST=10
REQUEST=20
0
10

12
REQUEST=10
REQUEST=20
REQUEST=10
RELEASE=10
RELEASE=0
REQUEST=20
REQUEST=5
REQUEST=10
RELEASE=40
RELEASE=10
REQUEST=0
REQUEST=100


0
10
30
release
release #释放时空余的融合
0
20
40 #前面的空余空间不够，向后寻找
release
error # release 不存在
error # request 0
error # request 超过内存

'''



class MemoryBlock():
    def __init__(self,size,addr,state=True,next_node=None,last_node=None):
        self.size=size
        self.addr=addr
        self.next=next_node
        self.state=state
        self.last=last_node

    def getNext(self):
        return self.next
class MemoryList():
    def __init__(self):
        # 设置内存大小
        self.head=MemoryBlock(size=100,addr=0)

    def mergeBlockAndAfter(self, a):
        w=self.head
        while w:
            if w and w.addr==a:
                wn=w.next
                w.size=w.size+wn.size
                w.next=w.next.next
                return w.last
            w=w.next

    def request(self,m_size):
        if not m_size:
            return -1
        w = self.head
        while w:
            if w.state==False:
                if w.addr < 100:
                    w=w.next
                else:
                    return -1
            if w.state and w.size>=m_size:
                if w.size>m_size:
                    p=w.next
                    w.next=MemoryBlock(w.size-m_size,addr=w.addr+m_size,state=True,next_node=p,last_node=w)
                w.size = m_size
                w.state = False
                return w.addr
            w = w.next
        return -1

    def release(self,addr):
        w=self.head
        while w:
            if w.addr == addr:
                w.state = True
                if w.next and w.next.state == True:
                    w=self.mergeBlockAndAfter(w.addr)
                    if w and w.state == True:
                        w=self.mergeBlockAndAfter(w.addr)
                    return -2
                if w.last and w.last.state == True:
                    w=self.mergeBlockAndAfter(w.last.addr)
                return -2
            else:
                w = w.getNext()

        return -1


import sys
for line in sys.stdin:
    N=int(line.strip('/n'))
    m_list = MemoryList()
    res=[]
    while N>0:
        l=sys.stdin.readline().strip('/n')
        l=l.split('=')
        ml=l[0]
        m=int(l[1])
        if ml=='REQUEST':
            res.append(m_list.request(m))
        if ml=='RELEASE':
            res.append(m_list.release(m))
        N-=1
    for r in res:
        if r>=0:
            print(r)
        if r==-1:
            print('error')
        if r==-2:
            print('release')
    head = None