编程题目： 两个队列实现栈（Python）

感觉两个队列实现栈 比 两个栈实现队列 麻烦

1.栈为空：当两个队列都为空的时候，栈为空

2.入栈操作：当队列2为空的时候，将元素入队到队列1；当队列1位空的时候，将元素入队到队列2；

　　如果队列1 和 队列2 都为空的时候，那就选择入队到队列1.

3.出队操作：当两个队列都为空的时候，引发错误“栈为空”；

　　　　　　当队列2位空的时候，如果队列1中只有一个元素，则直接将队列1中的元素出队；

　　　　　　如果队列1不止一个元素的时候，就将队列1的元素出队然后入队到队列2，知道队列1中只有一个元素，然后将队列1中的元素出队即可。

　　　　　　当队列1位空的时候，如果队列2中只有一个元素，则直接将队列2中的元素出队；

　　　　　　如果队列2不止一个元素的时候，就将队列2的元素出队然后入队到队列1，知道队列2中只有一个元素，然后将队列2中的元素出队即可。

代码如下：

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-

 class Stack(object):
         def __init__(self):
                 self.q1 = Queue()
                 self.q2 = Queue()

         def is_empty(self):
                 result = self.q1.is_empty() and self.q2.is_empty()
                 return result

         def push(self, elem):
                 if self.q2.is_empty():
                         self.q1.enqueue(elem)
                 elif self.q1.is_empty():
                         self.q2.enqueue(elem)
                 else:
                         self.q1.enqueue(elem)

         def pop(self):
                 if self.q1.is_empty() and self.q2.is_empty():
                         raise ValueError("Stack is Empty")
                 if self.q2.is_empty():
                         if self.q1.head.next is None:
                                 return self.q1.dequeue()
                         while not self.q1.head.next is None:
                                 self.q2.enqueue(self.q1.dequeue())
                         return self.q1.dequeue()
                 if self.q1.is_empty():
                         if self.q2.head.next is None:
                                 return self.q2.dequeue()
                         while not self.q2.head.next is None:
                                 self.q1.enqueue(self.q2.dequeue())
                         return self.q2.dequeue()

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

 class Queue(object):
         def __init__(self):
                 self.head = None
                 self.rear = None

         def is_empty(self):
                 return self.head is None

         def enqueue(self, elem):
                 if self.is_empty():
                         self.head = Node(elem)
                         self.rear = self.head
                 else:
                         self.rear.next = Node(elem)
                         self.rear = self.rear.next

         def dequeue(self):
                 if self.is_empty():
                         raise ValueError("Queue is Empty")
                 if self.head.next is None:
                         e = self.head.elem
                         self.head = None
                         self.rear = None
                         return e
                 else:
                         e = self.head.elem
                         self.head = self.head.next
                         return e

         def peek(self):
                 if self.is_empty():
                         raise ValueError("Queue is Empty")
                 return self.head.elem

         def bianli(self):
                 p = self.head
                 li = []
                 while p:
                         li.append(p.elem)
                         p = p.next
                 return li

 if __name__ == "__main__":
         s = Stack()
         for i in range(5):
                 s.push(i)
         while not s.is_empty():
                 print(s.pop())