栈、队列、双端队列实现（python）

一. 栈的实现

只有一个端口作为进出口

class Stack(object):
    def __init__(self):
        self.__list = []

    def push(self, item):
        self.__list.append(item)          # 尾加

    def pop(self):
        """该元素弹出后，不存在该数列中"""
        return self.__list.pop()

    def peek(self):
        """返回栈顶元素,该元素仍然存在"""
        if self.__list:
            return self.__list[-1]
            # return self.__list[len(self.__list) - 1]
        else:
            return None

    def is_empty(self):
        return self.__list == []
        # return not self.__list

    def size(self):
        return len(self.__list)


if __name__ == "__main__":
    ss = Stack()
    print(ss.is_empty())
    ss.push(78)
    ss.push(28)
    ss.push(18)
    ss.push(7)
    print(ss.peek())
    print(ss.pop())
    print(ss.peek())
    print(ss.size())

测试结果

True
7
7
18
3

二. 队列的实现

1）代码实现
一端进，另一端必为出

class Queue(object):
    def __init__(self):
        self.__list = []

    def enqueue(self, item):
        """往队列中添加一个元素"""
        self.__list.append(item)    # 尾部添加
        # self.__list.insert(0, item)    # 头部添加

    def dequeue(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)      # 头部弹出
        # return self.__list.pop()     # 尾部弹出

    def is_empty(self):
        return self.__list == []

    def size(self):
        return len(self.__list)


if __name__ == "__main__":
    qq = Queue()
    print(qq.is_empty())
    qq.enqueue(11)
    qq.enqueue(22)
    qq.enqueue(33)
    print(qq.dequeue())
    print(qq.size())
   

测试结果

True
11
2

2)增加删除元素的两种方式

append追加，先追加的下标小，后追加的下标大。下标大的相当于栈顶，pop()弹出的位置；下标小的相当于栈底，pop(0)栈底弹出的位置

三. 用两个栈实现一个队列

入队的三种情况，出队的略
stack1非空，stack2空

stack1空，stack2非空

stack1空，stack2空（可以合并到第二中情况中）

class Queue(object):
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    #入队(先考虑stack1是否有数据)
    def enqueue(self,element):
        if self.stack1:     # 如果1非空，直接1中加数
            self.stack1.append(element)
        else:
            while self.stack2:   # 如果1空2不空,如果直接往1中加数，在出队时，会将刚加入的数直接弹出，
                self.stack1.append(self.stack2.pop())  # 导致2中的数被压住，无法先弹出
            self.stack1.append(element)   #将stack2中的加入stack1后，再入队（此句还包含第三种情况：如果1、2都是空的，直接往1中加数）
    #出队(先考虑stack2是否有数据)
    def dequeue (self):
        if self.stack2:    # 如果堆栈2还有数，直接弹出
            return self.stack2.pop()
        elif self.stack1:  # 如果堆栈1有数，2没有，先要将1内所有的数依次放入到2中
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()
        else:              # 如果1和2一个数都没有，弹个屁
            return None

if __name__=='__main__':
    queue = Queue()
    queue.enqueue(11)
    queue.enqueue(22)
    queue.enqueue(33)
    queue.enqueue(44)
    print(queue.dequeue())
    print(queue.dequeue())
    print(queue.dequeue())
    print(queue.dequeue())

结果

11
22
33
44

四. 双端队列

两个端口皆可进出

class Deque(object):
    def __init__(self):
        self.__list = []

    def add_front(self, item):
        """往队列头部添加元素"""
        self.__list.insert(0, item)

    def add_rear(self, item):
        """往队列尾部添加元素"""
        self.__list.append(item)

    def pop_front(self):
        """从队列头部删除"""
        return self.__list.pop(0)

    def pop_rear(self):
        """从队列尾部删除"""
        return self.__list.pop()

    def is_empty(self):
        return self.__list == []

    def size(self):
        return len(self.__list)


if __name__=="__main__":
    dq = Deque()
    print(dq.is_empty())
    dq.add_front(5)
    dq.add_front(58)
    dq.add_rear(2)
    dq.add_rear(23)
    print(dq.pop_front())
    print(dq.pop_rear())
    print(dq.size())

测试结果

True
58
23
2