Question

将Node放入最低优先级队列时，我收到此编译器错误。

TypeError: '<' not supported between instances of 'Node' and 'Node'

这是失败的地方

from queue import PriorityQueue

def huffman(text):
    A = frequency(text) # returns a dictionary {(frequency, character),...}
    q = PriorityQueue()
    heap = build_min_heap(A) # builds min heap 
    while heap:
        temp = pop_heap(heap) # format (frequency, character)
---->   q.put(Node(temp[1],temp[0],None,None))
        # Node(character, frequency, left child, right child)

def min_heapify(A, i, key=lambda a: a):
    lefti = 2 * i + 1
    righti = 2 * i + 2
    heap_size = len(A)
--->if lefti < heap_size and key(A[lefti]) < key(A[i]):

    /anaconda3/lib/python3.6/queue.py in put(self, item, block, timeout)
    141                             raise Full
    142                         self.not_full.wait(remaining)
--> 143             self._put(item)
    144             self.unfinished_tasks += 1
    145             self.not_empty.notify()

    /anaconda3/lib/python3.6/queue.py in _put(self, item)
    225 
    226     def _put(self, item):
--> 227         heappush(self.queue, item)
    228 
    229     def _get(self):

我通过在Node类中添加“ lt”函数找到了解决方法。

def __lt__(self, other):
    return self.frequency < other.frequency

但是，还有另一种方法可以使用lambda表达式或以某种方式修改min-priority队列来解决此问题？

也许是关键功能？我了解键（值）在做什么，但是我不知道如何将其解释为节点。我尝试了类似以下的方法，但是没有用。

def key(item):
    if instanceof(item, Node):
        return item.frequency

还要注意，堆函数还处理int值和其他类型。这是稍后在代码中将节点传递到堆/队列的方式。

注意：节点按频率排序。

这是我的Node类

class Node():

    def __init__(self, character=None, frequency=None, left=None, right=None):
        self.character = character
        self.frequency = frequency
        self.left = left
        self.right = right

    def isLeaf(self):
        return self.left is None and self.right is None

    def __lt__(self, other):
        return self.frequency < other.frequency

    def __repr__(self):
        return 'Node({}, {}, {}, {})'.format(self.character,
                                         self.frequency,
                                         self.left, self.right)

def min_heapify(A, i, key=lambda a: a):
    lefti = 2 * i + 1
    righti = 2 * i + 2
    heap_size = len(A)
    if lefti < heap_size and key(A[lefti]) < key(A[i]):
        smallesti = lefti
    else:
        smallesti = i
    if righti < heap_size and key(A[righti]) < key(A[smallesti]):
        smallesti = righti
    if smallesti != i:
        A[i], A[smallesti] = A[smallesti], A[i]
        min_heapify(A, smallesti, key)

def build_min_heap(A, key=lambda a: a):
    for i in range(len(A) // 2 - 1, -1, -1):
        swaps = min_heapify(A, i, key)
    return A

最后一句话，我了解到“ lt”在Node类中起作用，但是我试图找出另一种不涉及修改Node类的解决方案，因为其他站点都有使用lambda表达式的注释。（例如key函数应该将存储在参数中的频率返回给key，后者应该是一个Node 。；我们需要编写key函数吗？是的。它可以是一个简单的lambda表达式。）但是它们在如何完成。

返回lambda节点<节点

0 个答案: