栈python(数据结构与算法)--顺序栈+链表栈

栈的原理

是由一系列对象组成的一个集合，这些对象的插入和删除操作遵循后进先出的原则（LIFO），可以在任何时刻向栈中插入一个对象，但只能取得或者删除最后一个插入的对象，（即栈顶）。

两种常见的操作：

出栈：将取出最后一个插入的对象；

入栈：在栈顶压入对象；

栈数据结构图解

出栈和入栈的操作：因为入栈和出栈都在栈顶进行，所以增加变量top来指示栈顶的位置；如下图所示：

 

按照实现方式栈可以分为

• 顺序栈 ：即使用数组实现的栈数据结构。
• 链表栈：即使用链表实现的栈数据结构。

顺序栈：在基于数组的栈的实现：

#栈的删除和插入只能在数组的尾部进行，

#在允许插入、删除的操作的一端为栈顶，另一端称为栈底

下面程序中实现了栈常用的几种操作：

# -*- coding: utf-8 -*-
"""
Created on Wed Dec 18 22:41:02 2019

@author: dell
"""


#栈的抽象数据描述
#栈的删除和插入只能在表的尾部进行
#在允许插入、删除的操作的一端为栈顶，另一端称为栈底
#栈是一种后进先出的线性表

#线性表的顺序存储

"""
描述：
因为入栈和出栈都是在栈顶进行，
所以增加变量top来指示栈顶元素的位置
top指向栈顶元素储存的位置的下一个储存单元的位置，
空栈时为top 为0

"""   
class SqStack():
    
    def __init__(self,maxsize):
        self.maxsize = maxsize
        self.stackElem = [None] * self.maxsize
        self.top = 0#指向栈顶元素的下一个储存单元位置
        
    def clear(self):
        self.top = 0
        
    def isEmpty(self):
        return self.top == 0
    
    def length(self):
        return self.top
    
    def peek(self):
        
        if not self.isEmpty():
            return self.stackElem[self.top -1]
        else:
            return None
        
    def push(self,x):
        if self.top == self.maxsize:
            raise Exception("栈已经满了")
        self.stackElem[self.top] = x
        self.top += 1
        
    
    def pop(self):
        if self.isEmpty():
            return None
        self.top -= 1
        return self.stackElem[self.top]
    
    def display(self):
        for i in range(self.top-1,-1,-1):
            print(self.stackElem[i],end=' ')

示例： 

ArrayStack = SqStack(10)     #设置栈的大小为10
#依次向栈中添加10,15,21,23，
ArrayStack.push(10)
ArrayStack.push(15)
ArrayStack.push(21)
ArrayStack.push(23)  
#取出栈顶的元素，应23，因为后进先出
print(ArrayStack.pop())
print("-----"*10)
ArrayStack.display()
23
--------------------------------------------------
21 15 10 

链表栈：在基于链表的栈的实现：

https://blog.csdn.net/qq_38038143/article/details/89361096?ops_request_misc=&request_id=&biz_id=102&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1，参考

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

class AbstractCollection(object):
    """An abstract collection implementation."""

    # Constructor
    def __init__(self, sourceCollection = None):
        """Sets the initial state of self, which includes the
        contents of sourceCollection, if it's present."""
        self._size = 0
        if sourceCollection:
            for item in sourceCollection:
                self.add(item)

    # Accessor methods
    def isEmpty(self):
        """Returns True if len(self) == 0, or False otherwise."""
        return len(self) == 0
    
    def __len__(self):
        """Returns the number of items in self."""
        return self._size

    def __str__(self):
        """Returns the string representation of self."""
        return "[" + ", ".join(map(str, self)) + "]"

    def __add__(self, other):
        """Returns a new bag containing the contents
        of self and other."""
        result = type(self)(self)
        for item in other:
            result.add(item)
        return result

    def __eq__(self, other):
        """Returns True if self equals other,
        or False otherwise."""
        if self is other: return True
        if type(self) != type(other) or \
           len(self) != len(other):
            return False
        otherIter = iter(other)
        for item in self:
            if item != next(otherIter):
                return False
        return True

class AbstractStack(AbstractCollection):
    """An abstract stack implementation."""

    # Constructor
    def __init__(self, sourceCollection = None):
        """Sets the initial state of self, which includes the
        contents of sourceCollection, if it's present."""
        AbstractCollection.__init__(self, sourceCollection)

    # Mutator methods
    def add(self, item):
        """Adds item to self."""
        self.push(item)

"""
linkedstack.py
"""


class LinkedStack(AbstractStack):
    """基于单链表实现栈-链表头部为栈顶"""

    def __init__(self, source_collection=None):
        self._items = None#元素的位置
        AbstractStack.__init__(self, source_collection)

    def __iter__(self):
        """迭代-使用一个列表实现, 列表第一项为单链表的最后一项"""
        def visit_nodes(node):
            if node != None:
                visit_nodes(node.next)
                temp_list.append(node.data)
        temp_list = []
        visit_nodes(self._items)
        return iter(temp_list)

    def peek(self):
        """返回栈顶元素"""
        self._prior_condition()
        return self._items.data

    def clear(self):
        """清空列表"""
        self._size = 0
        self._items = None

    def push(self, item):
        """入栈"""
        self._items = Node(item, self._items)
        self._size += 1

    def pop(self):
        """出栈"""
        self._prior_condition()
        old_item = self._items.data
        self._items = self._items.next
        self._size -= 1
        return old_item

    def _prior_condition(self):
        if self._size == 0:
            raise KeyError("The stack is empty.")
            
stack = LinkedStack()
stack.isEmpty()            
stack.push(12)
stack.push(13)
#
print(stack)
stack.pop()

stack.isEmpty()
Out[15]: True

stack.push(12)
stack.push(13)

print(stack)
[12, 13]

stack.pop()
Out[18]: 13