lua实现循环队列

function Queue:ctor(capacity)
    self.capacity = capacity or 5
    self.queue = {}
    self.size_ = 0
    self.head = -1
    self.rear = -1
end

function Queue:EnQueue(element)
    if self.size_ == 0 then
        self.head = 0
        self.rear = 1
        self.size_ = 1
        self.queue[self.rear] = element
    else
        local temp = (self.rear + 1) % self.capacity 
        
        if temp == self.head then
            print("Error: capacity is full.")
            return 
        else
            self.rear = temp
        end
 
        self.queue[self.rear] = element
        self.size_ = self.size_ + 1
    end
end

2.function Queue:DeQueue() 
    if self:IsEmpty() then
        print("Error: The Queue is empty.")
        return
    end
    
    self.size_ = self.size_ - 1
    self.head = (self.head + 1) % self.capacity
    local value = self.queue[self.head]
    return value
end

function Queue:clear()
    self.queue = nil
    self.queue = {}
    self.size_ = 0
    self.head = -1
    self.rear = -1
end


function Queue:IsEmpty()
    if self:Size() == 0 then
        return true

    end

    return false
end


function Queue:Size()
    return self.size_
end

function Queue:Peek()
    if self:IsEmpty() then
        print("Error: The Queue is empty.")
        return
    end

    return self.queue[(self.head + 1) % self.capacity]
end

 

function cyclic_queue:ctor(size)
    self._first =  0;
    self._last  = 0;
    self._size = size;
    self._count = 0;
    self._value = { };
end

function cyclic_queue:push(value)
    local pos = self._last% self._size + 1
    if self._count == self._size then
        self:pop()
    end
    self._value[pos] = value;
    self._count = self._count + 1
    self._last = pos;
end

function cyclic_queue:pop()
    local value = nil;

    if self._count ~= 0 then
        local pos = self._first % self._size + 1
        value = self._value[pos];
        self._value[pos] = nil;

        self._count = self._count - 1
        self._first = pos;
    end

    return value;
end

function cyclic_queue:ipairs()
    local i = self._first

    return function()
        if i - self._first == self._count then
            return nil
        end
        local pos = i%self._size + 1
        i = i + 1

        return pos, self._value[pos]
    end
end