Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/python-heapq-heapreplace-method/ below:

Python heapq.heapreplace() Method - GeeksforGeeks

Last Updated : 23 Jul, 2025

The heapq.heapreplace() function removes and returns the smallest element from a heap (the root) and inserts a new item into the heap, all while maintaining the heap property. This is more efficient than performing separate heappop() and heappush() operations because it minimizes the number of heap adjustments.

Example:

import heapq

# Create a list and convert it to a heap
a = [3, 5, 7, 10]
heapq.heapify(a)

# Replace the smallest element with 4
smallest = heapq.heapreplace(a, 4)
print("Removed item:", smallest)  
print("Updated heap:", a)      

Removed item: 3
Updated heap: [4, 5, 7, 10]

Explanation: The smallest item (3) is removed and returned and the new item (4) is inserted, and the heap adjusts itself.

heapq.heapreplace(heap, item)

• heap: A list that has been transformed into a heap using heapq.heapify() or built incrementally with heapq.heappush().
• item: The new item to be inserted into the heap.

The method returns the smallest element that was removed from the heap.

A heap in Python is a binary tree represented as a list where the smallest element is always at index 0 (min-heap property). When you call heapreplace():

• The smallest element (at the root) is removed and returned.
• The new item is inserted into the heap.
• The heap is restructured to maintain the heap property, ensuring the smallest element is again at the root.

Suppose you’re tracking the 3 highest scores in a game, but you only want to store the top 3 at any time:

import heapq

# Initialize a heap with the first 3 scores
s = [50, 60, 70]
heapq.heapify(s)

# New score comes in
ns = 65
smallest = heapq.heapreplace(s, ns)
print("Removed:", smallest)  
print("Top 3 scores:", s)  

Removed: 50
Top 3 scores: [60, 65, 70]

Explanation:

• The code initializes a heap with scores [50, 60, 70] and uses heapq.heapify() to convert it into a heap.
• A new score 65 is added using heapq.heapreplace(), which replaces the smallest element (50).
• The removed smallest element is printed, and the updated heap is shown: [60, 65, 70].

Use heapreplace() when:

• You need to update a heap by replacing the smallest element with a new value.
• Efficiency is critical, and you want to avoid separate pop and push operations.
• You’re maintaining a fixed-size heap (e.g., tracking the top k elements) and need to replace the smallest item with a new candidate.

heapreplace() is more efficient because it performs the replacement in one step, avoiding unnecessary heap adjustments.

Example of separate operations:

smallest = heapq.heappop(heap) # O(log n)
heapq.heappush(heap, 4) # O(log n)

This takes two O(log n) steps, while heapreplace() does it in one.

• heappushpop(heap, item) pushes the new item first and then pops the smallest item. If the new item is smaller, it gets popped immediately.
• heapreplace() always removes the smallest item and adds the new one, regardless of the new item’s value.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4