在 Python 中使用相同功能以不同方式打印堆栈或行

Question

我的任务是以不同的方式打印堆栈和队列。

我用单链表实现了堆栈，用双链表实现了队列。

这是我将元素推入 Stog(Stack) 和 Red(Queue) 的主要功能。

stavi 函数与 enqueue 相同，这是在 Queue 类中。

def stavi(self, data):

        if self.head == None:
            self.head = Node(data)

        else:
            newnode = Node(data)
            newnode.next  = self.head
            self.head = newnode

我不能改变主要部分！

L = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 
S = Stog() 
R = Red() 
for element in L: 
   R.stavi(element)

这就是我调用函数 ispis(print) 的方式：

ispis(S)
ispis(R)

这就是我制作函数 ispis 的方式：

def ispis(self):
 
    
    current = self.head
    if (self.head == None):
        print ("Lista je prazna")
        return

    print("<-- ", end= "")
    while(current != None):
        if (current.next is None):
            print(current.data)
        else:
            print (current.data, end = ", ")
        current = current.next
    return

结果应该是：

ispis(S) <-- 9 6 14 22 5 5

ispis(R) # 10 9 8 7 6 5 4 3 2 1 -->

我的结果是：

<-- 9, 6, 14, 22, 5, 5

<-- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

我知道如何为 Stack 制作它，但是我的代码如何“理解”Stack 和 Queue 之间的区别。 或者我应该以某种方式从 tail 在 Queue 中添加元素？

Answer 1

所提供信息中的一些问题：

• 不需要用双向链表来实现队列。 你只需要一个单向链表，但同时引用它的头部和尾部。

• 您的代码只填充队列，而不是堆栈

• 当输入是“1, 2, 3, 4, 5, 6, 7, 8, 9, 10”时，期望“9 6 14 22 5 5”作为输出是没有意义的

• 使用打印方法不是最佳做法。 打印是一个应该与堆栈/队列实现逻辑分开的问题。 而是定义一个迭代列表中值的方法——例如通过实现__iter__ ，如果你需要一个格式化的字符串， __str__或__repr__ 。

• 如果一个函数对于不同类的实例有不同的行为，那么最好在每个类上分别定义它。

这是一个实现的想法，其中Queue继承自Stack 。 由于我不明白打印“#”符号的逻辑，我将使用“-->”代替，这样指向列表的箭头表示将添加未来值的一侧，远离列表的箭头表示将从列表中删除值的一侧。

class Node:
    def __init__(self, value, nxt=None):
        self.value = value
        self.next = nxt
    
class Stack:
    def __init__(self, values=None):
        self.head = None
        if values:
            self.insert(*values)

    def insert(self, *values):
        for value in values:
            self.head = Node(value, self.head)

    def extract(self):
        if self.head:
            value = self.head.value
            self.head = self.head.next
            return value

    def __iter__(self):
        node = self.head
        while node:
            yield node.value
            node = node.next

    def join(self):
        return " ".join(map(str, self)) or "(empty)"

    def __str__(self):
        return "<--> " + self.join()

class Queue(Stack):
    def __init__(self, values=None):
        self.tail = None
        super().__init__(values)

    def insert(self, *values):
        if values and not self.tail:
            self.head = self.tail = Node(values[0])
            values = values[1:]
        for value in values:
            self.tail.next = self.tail = Node(value)

    def __str__(self):
        return "<-- " + self.join() + " <--"

values = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
s = Stack(values)
q = Queue(values)

print("Stack", s)
print("Queue", q)

由于Queue从Stack继承，添加/删除值的方法对于这两个类都称为insert和extract 。 Queue覆盖了insert的Stack实现， insert FILO 更改为 FIFO 逻辑。