B.数据结构（栈和队列）

一、栈

A、顺序存储结构

# 自定义异常
class StackUnderflow(ValueError): # 栈下溢（空栈访问）
    pass


# 列表头作为栈底，列表尾作为栈顶
# 缺点：1、扩大存储需要做一次高代价的操作 2、需要完整的大块存储区域

# 使用list作为栈来使用
# lst = []
# lst.append()  # 压入
# lst[-1]  # 访问栈顶
# lst.pop()     # 弹出
class SStack:
    def __init__(self):
        self._elems = []

    def is_empty(self):
        '''判断栈是否为空'''
        return self._elems == []
        # return  not self._elems

    def peek(self):
        '''返回栈顶元素'''
        if self._elems == []:
            raise StackUnderflow("空栈异常：in SStack.top()")
        return self._elems[-1]

    def push(self,elem):
        '''追加一个新的元素elem到栈顶'''
        self._elems.append(elem)
        # 从尾部添加时间复杂度为O（1）
        # self._elems.insert(0,elem)
        # 如果从列表第一个位置开始添加，时间复杂度是O（n）,链表正相反

    def pop(self):
        '''弹出栈顶元素'''
        if self._elems == []:
            raise StackUnderflow("空栈异常：in SStack.pop()")
        return self._elems.pop()

if __name__ == "__main__":

    st1 = SStack()
    st1.push(3)
    st1.push(7)
    st1.push(5)
    while not st1.is_empty():
        print(st1.pop()) # 5 7 3

B、链式存储结构

# 表头作为栈顶，表尾作为栈底
# 优点：解决了顺序表的缺点-->新增节点开销小，不需要连续锋内存
# 缺点：1、依赖解释器的存储管理   2、每个节点开销

class Node(object):
    def __init__(self,val):  # 定位的点的值和一个指向
        self.val=val    # 指向元素的值,原队列第二元素
        self.next=None

class stack(object):

    def __init__(self):
        self.__head=None  # 初始化最开始的位置

    def is_empty(self):
        '''判断栈是否为空'''
        return self.__head is None

    def peek(self):
        '''返回栈顶元素'''
        if self.__head!=None:  # 如果栈顶不为空
            return self.__head.val  # 返回栈顶元素的值
        else:
            return None

    def push(self,n):
        '''追加一个新的元素elem到栈顶'''
        node = Node(n)  # 实例化节点
        node.next = self.__head
        self.__head = node
        return node.val

    def pop(self):
        '''弹出栈顶元素'''
        if self.__head == None:
            return None
        else:
            tmp = self.__head.val
            self.__head = self.__head.next  #下移一位，进行
            return tmp


if __name__=="__main__":
    s=stack()
    s.push(1)
    s.push(2)
    s.push(3)

    print (s.pop())  # 3
    print (s.pop())  # 2
    print (s.pop())  # 1

二、队列

A.顺序存储结构实现

1.单端队列

# 入队操作频繁选择 列表尾部添加元素O(1) 列表头部弹出元素
# 出队操作频繁选择 列表尾部弹出元素O(1) 列表头部添加元素

class Queue(object):

    def __init__(self):
        self.__list = []

    def is_empty(self):
        '''判断一个队列是否为空'''
        return self.__list == []

    def enqueue(self, item):
        '''进入队列'''
        self.__list.append(item)

    def dequeue(self):
        '''退出队列'''
        return self.__list.pop(0)

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



if __name__=="__main__":
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)

    print(q.dequeue())
    print(q.dequeue())
    print(q.dequeue())

2.双端队列

class Deque(object):

    def __init__(self):
        self.__list = []

    def is_empty(self):
        '''判断一个队列是否为空'''
        return 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 size(self):
        return len(self.__list)



if __name__=="__main__":
    q = Deque()
    q.add_front(1)
    q.add_rear(2)
    q.add_rear(3)

    print(q.pop_front())
    print(q.pop_rear())

B.链式存储结构实现

class Node(object):
    def __init__(self,val):
        self.next = None  #指针的下一个，用于指向内容，先给初始化设置为空
        self.val = val   #val是它原本的值，

class Queue(object):

    def __init__(self, node=None):
        '''空队列，记录队头位置'''
        self.__head = node

    def is_empty(self):
        '''判断队列是否为空'''
        return self.__head == None

    def enqueue(self, item):
        '''入队列，链表尾部添加节点'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next:
                cur = cur.next
            cur.next = node

    def dequeue(self):
        '''出队列，删除头结点'''
        if self.is_empty():
            return None
        else:
            cur = self.__head
            self.__head = cur.next


    def travel(self):
        '''遍历队列'''
        if self.is_empty():
           return
        else:
           cur = self.__head
           while cur:
               print(cur.val,end=" ")
               cur = cur.next
           print("
")

if __name__=="__main__":
    q=Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)

    q.travel()