class KthLargest(object):
    def __init__(self, k):
        self.k = k
        self.min_pq = PriorityQueue(k, MIN_PQ)

    def insert(self, element):
        if self.min_pq.get_size() < self.k:
            self.min_pq.insert(element)
            return

        if element <= self.min_pq.peek():
            return

        self.min_pq.delete_top()
        self.min_pq.insert(element)

    def get_kth_largest(self):
        return self.min_pq.peek()


# k = KthLargest(3)
# k.insert(2)
# k.insert(3)
# k.insert(1)
# print k.get_kth_largest()
# k.insert(0)
# print k.get_kth_largest()
# k.insert(4)
# k.insert(7)
# print k.get_kth_largest()
Ejemplo n.º 2
0
class KMostFrequentWords:
    def __init__(self, words, k):
        self.words = words
        self.trie = TrieDS()
        self.min_heap = PriorityQueue(k, MIN_PQ)
        self.k = k
        self.pre_process()

    def pre_process(self):
        # inserting first k words
        li = []
        for i in range(self.k):
            w = self.words[i]
            if self.trie.get(w) is None:
                obj = WordFreq(w, 0)
                self.trie.put(w, obj)
                li.append(obj)

            obj = self.trie.get(w)
            obj.freq += 1

        for ob in li:
            self.min_heap.insert(ob)

        # adding remaining items
        for i in range(self.k, len(self.words)):
            w = self.words[i]
            obj = self.trie.get(w)

            if obj is None:
                obj = WordFreq(w, 1)
                self.trie.put(obj)

            if obj.freq <= self.min_heap.peek().freq:
                continue

            else:
                self.min_heap.delete_top()
                self.min_heap.insert(obj)

    def get_k_most_freq(self):
        return self.min_heap.array