python基础篇--day22

栈

push() 圧栈、进栈
pop() 弹栈、出栈 （弹出栈顶）

'''
Node
Stack
'''

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __str__(self):
        return str(self.data)


class Stack:
    def __init__(self):
        self._head = None

    # 压栈
    def push(self, item):
        node = Node(item)
        node.next = self._head
        self._head = node
        return node.data

    # 弹栈
    def pop(self):
        if self._head == None:
            return None
        else:
            data = self._head.data
            self._head = self._head.next
            return data

    # peek 取出栈顶元素
    def peek(self):
        if self._head != None:
            return self._head.data
        else:
            raise ValueError('stack is empty')

    def print_all(self):
        cur = self._head
        while cur != None:
            print(cur)
            cur = cur.next


if __name__ == '__main__':
    s = Stack()
    s.push(6)
    s.push(1)
    s.push(8)
    s.push(10)

    s.print_all()

    print('--------pop-------------')
    s.pop()
    s.print_all()

队

先进先出，FIFO

class Node:
    def __init__(self, data):

        self.data = data
        self.next = None


class Queue:
    def __init__(self,maxsize=-1):
        self.maxsize=maxsize
        self._heard = None
        self._tail = None

    def enter(self, itme):
        node = Node(itme)
        if self.maxsize!=-1 and self.len()<self.maxsize or self.maxsize==-1:
            if self._heard == None and self._tail == None:
                self._tail = node
                self._heard = node
            else:
                self._tail.next = node
                self._tail = node
        else:
            raise ValueError("满了")

    def exit(self):
        if self._heard == None and self._tail == None:
            raise ValueError("empty")
        date = self._heard.data
        if self._heard == self._tail:
            self._heard = None
            self._tail = None
        else:
            self._heard = self._heard.next
        return date

    def print_all(self):
        if self._heard == None and self._tail == None:
            return ""
        else:
            cur = self._heard
            while cur != None:
                print(cur.data)
                cur = cur.next
    def len(self):
        count=0
        cur=self._heard
        while cur!=None:
            count+=1
            cur=cur.next
        return count
if __name__ == '__main__':
    q = Queue(10)
    q.enter(3)
    q.enter(6)
    q.enter(5)
    q.enter(5)
    q.len()
    q.print_all()
    print("------------")
    q.exit()
    q.print_all()

双端队列

双端队列:（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。
双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

from collections import deque

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

    def isEmpty(self):
        return self.items == []

    def add_front(self, item):
        # 从头部添加
        self.items.insert(0, item)

    def add_rear(self, item):
        self.items.append(item)

    def remove_front(self):
        return self.items.pop(0)

    def remove_rear(self):
        return self.items.pop()

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

    def print_all(self):
        for item in self.items:
            print(item)


if __name__ == '__main__':
    dq = Deque()
    dq.add_front(8)
    dq.add_front(9)
    dq.add_front(0)

    dq.print_all()

    dq.add_rear(6)
    dq.print_all()

    print('-----------remove---------')
    dq.remove_front()

    dq.print_all()