python实现栈（基于list与链表），队列(基于链表）

#!/usr/bin/env python
# encoding: utf-8
'''
@author: cc
'''

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

    def isEmpty(self):
        return len(self.items)==0

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

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

    def pop(self):
        if self.items == []:
            print('Stackunderflow')
        else:
            return self.items.pop()

    def top(self):
        if self.items == []:
            print('Stackunderflow')
        else:
            return self.items[-1]


my_stack = Stack()
my_stack.pop()
my_stack.push('a')
my_stack.push('b')
print(my_stack.pop())
print(my_stack.pop())

#!/usr/bin/env python
# encoding: utf-8
'''
@author: cc
'''


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

class Stack():
    def __init__(self):
        self.first=None
        self.N=0

    def isEmpty(self):
        return self.N==0

    def size(self):
        return self.N

    def push(self, item):
        oldfirst=self.first
        self.first=Node(item)
        self.first.item=item
        self.first.next=oldfirst
        self.N+=1

    def pop(self):
        if self.N==0:
            print('Stackunderflow')
        else:
            item=self.first.item
            self.first=self.first.next
            return item

    def top(self):
        if self.N==0:
            print('Stackunderflow')
        else: return self.first.item


my_stack = Stack()
my_stack.pop()
my_stack.push('h')
my_stack.push('a')
print(my_stack.pop())
print(my_stack.pop())

#!/usr/bin/env python
# encoding: utf-8
'''
@author: cc
'''
class Node():
    def __init__(self,item=None,next_=None):
        self.item=item
        self.next=next_
class QueueUnderflow(ValueError):
    pass


class _LinkListQueueIterator(object):
    def __init__(self, queueHead):
        self._curNode = queueHead

    def __iter__(self):
        return self

    def __next__(self):
        if self._curNode is None:
            raise StopIteration
        else:
            item = self._curNode.item
            self._curNode = self._curNode.next
            return item

class Queue(object):
    def __init__(self):
        self.first=None
        self.last=None
        self.N=0
    def isEmpty(self):
        return self.first is None
    def size(self):
        return self.N
    def enqueue(self,item):
        node=Node(item)
        if self.isEmpty():
            self.first=node
        else:
            self.last.next=node
        self.last=node
        self.N+=1
    def dequeue(self):
        if self.first is None:
            raise QueueUnderflow()
        elif self.first is self.last:
            self.last=None
        item = self.first.item
        self.first=self.first.next
        self.N-=1
        return item
    def __iter__(self):
        return _LinkListQueueIterator(self.first)


my_queue = Queue()
my_queue.enqueue('h')
my_queue.enqueue('a')


for char in my_queue:
    print(char)
print(my_queue.dequeue())
print(my_queue.dequeue())