python 数据结构与算法——队列

队列的 python 实现

class Queue:
    def __init__(self):
        self.array = []

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

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

    def front(self):
        if self.isEmpty():
            return None
        return self.array[0]

    def dequeue(self):
        if self.isEmpty():
            raise IndexError("Queue Underflow")
        data = self.array[0]
        self.array.remove(data)
        return data

    def enqueue(self, data):
        self.array.append(data)

常见问题

1. 用栈实现队列

class Queue:
    def __init__(self):
        self.s1 = Stack()
        self.s2 = Stack()
    
    def enqueue(self, data):
        self.s1.push(data)

    def dequeue(self):
		if (not self.s2.isEmpty()):
			return self.s2.pop()
		while(not self.s1.isEmpty()):
			self.s2.push(self.s1.pop())
		return self.s2.pop()

2. 用队列实现栈

class Stack: 
	def __init__(self): 
		self.Q1 = Queue() 
		self.Q2 = Queue() 
		
	def isEmpty(self): 
		return self.Q1.isEmpty() and self.Q2.isEmpty() 
		
	def push(self, item): 
		if self.Q2.isEmpty(): 
			self.Q1.enqueue(item) 
		else: 
			self.Q2.enqueue(item) 
			
	def pop(self): 
		if self.isEmpty(): 
			raise IndexError('stack is empty') 
		elif self.Q2.isEmpty(): 
			while not self.Q1.isEmpty(): 
				cur = self.Q1.dequeue() 
				if self.Q1.isEmpty(): 
					return cur 
				self.Q2.enqueue(cur) 
		else: 
			while not self.Q2.isEmpty(): 
				cur = self.Q2.dequeue() 
				if self.Q2.isEmpty(): 
					return cur 
				self.Q1.enqueue(cur)

3. 队列倒序

queue = Queue()  # to be reversed
...
stack = Stack()
while not queue.isEmpty():
    stack.push(queue.deQueue())

while not stack.isEmpty():
    queue.enQueue(stack.pop())

4. 生产者-消费者模型

import threading
import random
import time

class ProduceToQueue(threading.Thread):
   def __init__(self, threadName, queue):
      threading.Thread.__init__(self, name=threadName)
      self.sharedObject = queue
      
   def run(self):
      for i in range(11, 21):
         time.sleep(random.randrange(2))
         print("%s adding %s to queue" % (self.getName(), i))
         self.sharedObject.enqueue(i)

      print(self.getName(), "finished producing values")
      print("Terminating", self.getName())

class ConsumeFromQueue(threading.Thread):
   def __init__(self, threadName, queue):
      threading.Thread.__init__(self, name=threadName)
      self.sharedObject = queue

   def run(self):
      sum = 0
      current = 10

      for i in range(10):

         get = False
         while not get:
            try:
               print("%s attempting to read %s..." % (self.getName(), current + 1))
               current = self.sharedObject.dequeue()
               get = True
            except IndexError:
               time.sleep(1)
         print("%s read %s" % (self.getName(), current))
         sum += current

      print("%s retrieved values totaling: %d" % (self.getName(), sum))
      print("Terminating", self.getName())

queue = Queue()
producer = ProduceToQueue("Producer", queue)
consumer = ConsumeFromQueue("Consumer", queue)

producer.start()
consumer.start()

producer.join()
consumer.join()