Question

所以我得到了这个问题。考虑具有标准操作集的Stack和Queue类。使用Stack和Queue类，在调用mysteryFunction之前调用mysteryFunction之前包含哪些项目？

以下是代码：

def mysteryFunction(s, q):
    q.enqueue('csc148')
    q.enqueue(True)
    q.enqueue(q.front())
    q.enqueue('abstract data type')

    for i in range(q.size()):
        s.push(q.dequeue())

    while not s.is_empty():
        q.enqueue(s.pop())


if __name__ == '__main__':
    s=Stack()
    q=Queue()

#About to call mysteryFunction
#What are contents of s and q at this point?
    mysteryFunction(s, q)
#mysteryFunction has been called.
#What are contents of s and q at this point?

我无法理解面向对象编程，因为我对此主题不熟悉。是否有任何链接可以分解堆栈和队列以及它们的作用？

Answer 1

通常，堆栈是LIFO，队列是FIFO。

在Python中，您可以使用集合模块来试验堆栈和队列：

>>> from collections import deque
>>> stack = deque()
>>> stack.append(10)
>>> stack.append(20)
>>> stack.append(30)
>>> stack
deque([10, 20, 30])
>>> stack.pop()           # LIFO
30
>>> stack.pop()
20
>>> 
>>> queue = deque()
>>> queue.append(10)
>>> queue.append(20)
>>> queue.append(30)
>>> queue
deque([10, 20, 30])
>>> queue.popleft()       # FIFO
10
>>> queue.popleft()
20

Answer 2

有关详细信息，请参阅以下链接：

Stack
Queue

通过以下方式可以看到这两种数据结构：

堆叠：

说明

此数据结构有各种变化。但是，简单来说 - 正如您可以在提供的图像中观察到的那样，当您添加到此数据结构时，您将放置在已存在的内容之上，当您删除时，您也从顶部开始。你可以把它看成一堆书，从顶部开始一直一个接一个地向下看。

<强>队列

说明

此特定数据结构也有变化，但简单来说 - 正如您在提供的图像中看到的那样，当您添加到此数据结构时，新元素将在开始时以及从中删除最后一个元素时要删除的列表。你可以把它想象成一个你在商店里排队的队列，你站在很多人的后面等着你来柜台支付你的物品。

Answer 3

要逐行测试，这里是任务中使用的类（deque周围的包装器）的实现：

from collections import deque

class Queue(deque):
    enqueue = deque.append
    dequeue = deque.popleft
    def front(self):
        return self[-1]
    def size(self):
        return len(self)

class Stack(deque):
    push = deque.append
    def is_empty(self):
        return not self

Answer 4

STACK #LIFO

class stack(object):
 def __init__(self):
    self.items = []
 def isEmpty(self):
    return self.items==[]
 def push(self,item):
    self.items.append(item)
 def pop (self):
    return self.items.pop()
 def peek(self):
    return self.items[len(self.items) - 1]
 def size(self):
    return (len(self.items))
s = stack()
print (s.isEmpty())
>> True
s.push(1)
s.push('3')
s.peek()
>>'3'
s.size()
>> 2

队列#FIFO

class Queue(object):
 def __init__(self):
    self.items = []
 def isEmpty(self):
    return self.items==[]
 def enqueue(self,item):
    self.items.insert(0,item)
 def dequeue(self):
     return self.items.pop()
 def size(self):
    return (len(self.items))
q = Queue()
q.isEmpty()
>>True
q.enqueue(1)
q.enqueue(2)
q.dequeue()
>>1

Answer 5

第一个代码说明有关堆栈的信息，我们需要创建一个列表，并在使用元素添加和填充列表的同时推送元素，类似于数组堆栈中的内容。弹出时，从推入的位置弹出末端。

class Stack:

def __init__(self):
    self.stack = []

def push_element(self,dataval):
    self.stack.append(dataval)
    return self.stack


def pop_element(self):
    if len(self.stack) ==0:
        print("Stack is empty")
    else:
        self.stack.pop()
    return self.stack

def peek_element(self):
    return self.stack[0]

class Queue:

 def __init__(self):
   self.stack = []

 def push_ele(self,data):
   self.stack.append(data)

def pop_ele(self):
   self.stack.pop(0)

def display(self):
   print(self.stack)

Answer 6

类栈：

def __init__(self,n):##constructor

    self.no = n ##size of stack

    self.Stack = [] ##list for store stack items

    self.top = -1

def push(self):##push method
    if self.top == self.no - 1 :##check full condition
        print("Stack Overflow.....")
    else:
        n = int(input("enter an element :: "))
        self.Stack.append(n) ## in list add stack items use of append method
        self.top += 1##increment top by 1

def pop(self):## pop method

    if self.top == -1: #check empty condition
        print("Stack Underflow....")
    else:
        self.Stack.pop()## delete item from top of stack using pop method
        self.top -= 1 ## decrement top by 1

def peep(self): ##peep method
    print(self.top,"\t",self.Stack[-1]) ##display top item

def disp (self): #display method
    if self.top == -1:# check empty condition
        print("Stack Underflow....")
    else:
        print("TOP \tELEMENT")
        for i in range(self.top,-1,-1): ## print items and top
            print(i," \t",self.Stack[i])

n = int(input("Enter Size :: ")) # 栈的大小

stk = stack(n) ## 对象并将 n 作为大小传递

while(True): ## 循环选择作为 switch case

print(" 1: PUSH ")
print(" 2: POP ")
print(" 3: PEEP ")
print(" 4: PRINT ")
print(" 5: EXIT ")

option = int(input("enter your choice :: "))

if option == 1:
    stk.push()

elif option == 2:
    stk.pop()

elif option == 3:
    stk.peep()

elif option == 4:
    stk.disp()

elif option == 5:
    print("you are exit!!!!!")
    break
else:
    print("Incorrect option")

理解python中的堆栈和队列

6 个答案: