4_栈

4_栈

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

4.0 栈顺序表实现和链表实现的区别

顺序表实现：

1. 扩大存储需要做一次高代价操作
2. 需要完整的大块存储区

链表实现：

1. 更多依赖于解释器的存储管理
2. 每个节点的链接开销，以及链接点在实践计算机内存中任意散布可能带来操作开销

4.1 栈的操作

• Stack() 创建一个新的空栈
• push(item) 添加一个新的元素item到栈顶
• pop() 弹出栈顶元素
• peek() 返回栈顶元素
• is_empty() 判断栈是否为空
• size() 返回栈的元素个数

4.2代码实现

4.2.1栈的顺序表实现

$用线性表实现时，操作只在表的一端进行$

• 对于顺序表，后端插入和删除是O(1)操作，应该用尾端作为栈顶

class Stack(object):
    '''栈'''
    def __init__(self):
        '''列表的尾部进行操作'''
        self.items=[]   
        
    def is_empty(self):
        '''判断是否为空'''
        return self.items == []
        
    def push(self, item):
        '''加入元素'''
        return self.items.append(item)
        
    def pop(self):
        '''弹出元素'''
        return self.items.pop()
    
    def size(self):
        '''返回栈的大小'''
        return len(self.items)
        
    def peek(self):
        '''返回栈顶元素'''
        return self.items[len(self.items)-1]     
    
if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    
    print('是否为空：{}'.format(stack.is_empty()))
    print('链表大小：{}'.format(stack.size()))
    print(stack.pop())
    print(stack.pop())

4.2.2 栈链表的实现

class LNode(object):
    def __init__(self,item):
        self.item = item
        self.next = None
    
class LStack(object):
    def __init__(self):
        self._head = None
        
    def is_empty(self):
        return self._head == None
    
    def peek(self):
        '''返回栈顶元素'''
        return self._head.item
    
    def push(self, item):
        '''加入元素'''
        node = LNode(item)    
        node.next = self._head
        self._head = node
        
    def pop(self):
        if self.is_empty():
            return
        cur = self._head
        self._head = cur.next
        return cur.item
        
    def size(self):
        cur = self._head
        count = 0
        while cur:
            count += 1
            cur = cur.next
        return count
    
if __name__ == '__main__':
    lstack = LStack()
    lstack.push(1)
    lstack.push(2)   
    print('是否为空：{}'.format(lstack.is_empty()))
    print('链表长度：{}'.format(lstack.size()))
    print(lstack.pop())
    print('栈顶元素为：{}'.format(lstack.peek()))

4.2.3 编程模拟实现一个浏览器的前进、后退功能???

'''利用双向链表实现，怎么用到？？？栈？？？'''
class page(object):
    '''加载一个页面'''
    def __init__(self, item, prev_=None, next_=None):
        self.item = item
        self.prev = prev_
        self.next = next_
        
        
class History(object):
    def __init__(self):
        self._cur = page(None)
        
    def loadPage(self,newPage):
        '''加载新的页面'''
        p = page(newPage, self._cur,None)
        self._cur.next = p
        self._cur = self._cur.next
        return self._cur.item
    
    def back(self):
        '''返回上一个页面'''
        if self._cur.prev is None:
            return
        self._cur = self._cur.prev
        return self._cur.item
    
    def forward(self):
        '''前进一个页面'''
        if self._cur.next is None:
            return
        self._cur = self._cur.next
        return self._cur.item
    
if __name__ == '__main__':
    h = History()
    print('加载页面:{}'.format(h.loadPage('网页1')))
    print('加载页面:{}'.format(h.loadPage('网页2')))
    print('返回页面:{}'.format(h.back()))
    print('前进页面:{}'.format(h.forward()))