python数据结构与算法(3)--栈与队列

一.栈

栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。

由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。（随入随处）

1.顺序结构实现栈

'''
思路：
1、列表自己就是顺序存储，但列表功很多，不符合栈的特性
2.利用列表，将他封装，写定自己的类，这个类只满足添加数据 访问数据 删除 后进先出特性
优点：存储效率高
缺点：如果存的数据过于大，内存空间的利用不够的灵活
'''

class Stack:
    def __init__(self):
        self.__list = []  #容器  私有属性


    # 添加数据（入栈） list尾部作为操作端（效率高）
    def push(self, item):
        self.__list.append(item)


    # 删除（出栈）  从尾部取数据
    def pop(self):
        if self.__list == []:
            raise Exception('pop from empty list')
        return self.__list.pop(-1)
        
    # 判空
    def is_empty(self):
        return self.__list == []  # 只会返回两种结果 TRUE和FALSE

    # 访问数据
    def peek(self):
        if self.is_empty():
            raise Exception('stack is empty')
        return self.__list[-1]

if __name__ == '__main__':
    s = Stack()
    s.push('w')
    s.push('e')
    s.push('r')
    print(s.is_empty()) # False
    print(s.peek()) # r
    print(s.pop()) # r
    print(s.pop()) # e
    print(s.pop()) # w
    print(s.is_empty()) # True

2.链表结构实现栈

'''
思考：链表的头还是尾作为操作端更好
链表特性：头可以找到尾  尾部不可以找头 遍历的过程耗时
所以把链表的头部作为操作端


思路：
1.通过节点存储数据
2.生成top变量，永远代表栈顶，top可以移动
'''

# 节点类
class Node():
    def __init__(self, val , next=None):
        self.val = val
        self.next = next

# 栈类
class Lstack():
    def __init__(self):
        # 标记栈顶位置  栈顶的位置才是你要操作的数据
        self._top = None

    # 判空
    def is_empty(self):
        return self._top is None

    # 入栈
    def push(self, val):
        # 1.生成一个节点
        node = Node(val)
        # 2.把node节点和top建立关联
        node.next = self._top
        # top移动到新节点身上
        self._top = node  # top永远指向栈顶

    # 出栈
    def pop(self):
        if self._top is None:
            raise Exception("stack is empty")
        # 1. 获取栈元素
        value = self._top.val
        # 2.更新top所指向的元素
        self._top = self._top.next
        return value

    # 获取栈顶元素
    def top(self):
        if self._top is None:
            raise Exception("stack is empty")
        return self._top.val

if __name__ == '__main__':
    ls = Lstack()
    ls.push(1)
    ls.push(2)
    ls.push(3)
    print(ls.is_empty()) # False
    print(ls.pop()) # 3
    print(ls.pop()) # 2
    print(ls.pop()) # 1

二.队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。

1.顺序结构实现队列

'''
list = []
1.基于list完成数据的存储  尾部添加 头部取出
2.需要对list做已封装

自己实现头部入队 尾部出队
'''
class Queue:
    def __init__(self):
        self.__list = []

    # 入队
    def append_queue(self, item):
        return self.__list.append(item)

    # 出队
    def del_quque(self):
        return self.__list.pop(0)

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

    # 查看队列元素个数
    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    q = Queue()
    q.append_queue(1)
    q.append_queue(2)
    q.append_queue(3)
    print(q.is_empty()) # False
    print(q.del_quque()) # 1
    print(q.del_quque()) # 2
    print(q.del_quque()) # 3

2.链表结构实现队列

'''
假定头部作为出队方 尾就是入对方
1.基于链表构建队列 （先进先出）、
2.链表的头作为开端  让新的元素以尾部形式加入
3.队头和队尾想办法用变量标记  避免每一次一一遍历
4. start和end遇上  意味队列为空

'''
# 节点类
class Node():
    def __init__(self, val , next=None):
        self.val = val
        self.next = next

# 栈类
class Lqueue():
    def __init__(self):
        # 定义两个可以移动的变量  变量标记了队尾和队头
        self.start = self.end = Node(None)

    # 入队时start往后移
    def append_queue(self, item):
        # 入队的时候先有节点 再让start往后移
        # node = Node(item)
        self.start.next = Node(item)
        # start往后移
        self.start = self.start.next
        return self.start.val

    # 出队时end往后移
    def del_quque(self):
        if self.start == self.end:
            raise Exception("queue is empty")
        # end查询后一个元素
        self.end = self.end.next
        return self.end.val

    # 判空
    def is_empty(self):
       return self.start == self.end

if __name__ == '__main__':
    l = Lqueue()
    l.append_queue(1)
    l.append_queue(2)
    l.append_queue(3)
    print(l.del_quque()) # 1
    print(l.del_quque()) # 2
    print(l.del_quque()) # 3

总结

1.栈：先进后出
2.队列：先进先出