栈的实现--python

1. 使用顺序表实现 栈

class Stack(object):
    def __init__(self):
        self.__list=[]

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

    def push(self,item):
        self.__list.append(item)

    def pop(self):
        return self.__list.pop()

    def peek(self):
        #返回栈顶元素
        if self.__list:
            return self.__list[-1]
        else:
            return None
    def size(self):
        return len(self.__list)


if __name__ == '__main__':
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

2. 使用链表实现 栈

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

class Stack(object):
    def __init__(self,node=None):
        self.__head=node

    def is_empty(self):
        return self.__head==None

    def push(self,item):
        node=Node(item)
        cur=self.__head
        if self.is_empty():
            self.__head=node
        else:
            while cur.next!=None:
                cur=cur.next
            cur.next=node

    def pop(self):
        if self.is_empty():
            return
        else:
            cur=self.__head
            pre=None
            while cur.next!=None:
                pre=cur
                cur=cur.next
            pre.next=cur.next



    def size(self):
        cur=self.__head
        cound=0
        while cur.next!=None:
            cound+=1
            cur=cur.next
        return cound


if __name__ == '__main__':
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.pop()

    print(s.size())