mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 05:44:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge e8fda15fb8 into 9082b004b6

Browse source
This commit is contained in:
saurabh 2025-11-23 22:57:06 +00:00 • committed by GitHub
commit 68d929efca
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 1439 additions and 1286 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1115
lib/std/priority_deque.zig Normal file
View file

File diff suppressed because it is too large Load diff

1027
lib/std/priority_dequeue.zig
View file

File diff suppressed because it is too large Load diff

581
lib/std/priority_queue.zig
View file

@ -7,49 +7,84 @@ const expect = testing.expect;
const expectEqual = testing.expectEqual;
const expectError = testing.expectError;
/// Priority queue for storing generic data. Initialize with `init`.
/// Provide `compareFn` that returns `Order.lt` when its second
/// argument should get popped before its third argument,
/// `Order.eq` if the arguments are of equal priority, or `Order.gt`
/// if the third argument should be popped first.
/// For example, to make `pop` return the smallest number, provide
/// `fn lessThan(context: void, a: T, b: T) Order { _ = context; return std.math.order(a, b); }`
/// A priority queue for storing generic data.
///
/// If a priority queue is constructed from slice `{5, 8, 2, 9, 7, 1, 4, 4}`, then
/// a `compareFn` returning:
///
/// + `Order.lt` will create a min heap, in which the smallest value will have the highest
/// priority. The values will be popped in the sequence: 1, 2, 4, 4, 5, 7, 8, 9.
///
/// A `compareFn` implementing this kind of functionality will look like:
///
/// ```
/// fn lessThan(context: void, a: T, b: T) Order {
/// _ = context;
/// return std.math.order(a, b);
/// }
/// ```
///
/// + `Order.gt` will create a max heap, in which the largest value will have the highest
/// priority. The values will be popped in sequence: 9, 8, 7, 5, 4, 4, 2, 1.
///
/// A `compareFn` implementing this kind of functionality will look like:
///
/// ```
/// fn greaterThan(context: void, a: T, b: T) Order {
/// _ = context;
/// return std.math.order(a, b).invert(); // or, return std.math.order(b, a);
/// }
/// ```
///
pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareFn: fn (context: Context, a: T, b: T) Order) type {
return struct {
const Self = @This();
/// A slice of generic data.
items: []T,
cap: usize,
allocator: Allocator,
/// The number of values that can be stored without allocating new memory.
capacity: usize,
/// The priority order of elements in the queue.
context: Context,
/// Initialize and return a priority queue.
pub fn init(allocator: Allocator, context: Context) Self {
/// A priority queue containing no elements.
pub const empty: Self = .{
.items = &.{},
.capacity = 0,
.context = undefined,
};
/// Initialize a priority queue with priority order.
pub fn withContext(context: Context) Self {
return Self{
.items = &[_]T{},
.cap = 0,
.allocator = allocator,
.items = &.{},
.capacity = 0,
.context = context,
};
}
/// Free memory used by the queue.
pub fn deinit(self: Self) void {
self.allocator.free(self.allocatedSlice());
/// Free memory used by the priority queue.
pub fn deinit(self: Self, allocator: Allocator) void {
allocator.free(self.allocatedSlice());
}
/// Insert a new element, maintaining priority.
pub fn add(self: *Self, elem: T) !void {
try self.ensureUnusedCapacity(1);
/// Insert a new element into the priority queue by ensuring it has enough
/// capacity and maintaining priority of elements.
pub fn push(self: *Self, allocator: Allocator, elem: T) !void {
try self.ensureUnusedCapacity(allocator, 1);
addUnchecked(self, elem);
}
/// Insert a new element to the end of the queue by maintaining the priority
/// element at root.
fn addUnchecked(self: *Self, elem: T) void {
self.items.len += 1;
self.items[self.items.len - 1] = elem;
siftUp(self, self.items.len - 1);
}
/// Ensure that the highest priority element is at the root of the queue
/// while inserting.
fn siftUp(self: *Self, start_index: usize) void {
const child = self.items[start_index];
var child_index = start_index;
@ -63,35 +98,32 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
self.items[child_index] = child;
}
/// Add each element in `items` to the queue.
pub fn addSlice(self: *Self, items: []const T) !void {
try self.ensureUnusedCapacity(items.len);
/// Add each element in the `items` slice to the queue.
pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void {
try self.ensureUnusedCapacity(allocator, items.len);
for (items) |e| {
self.addUnchecked(e);
}
}
/// Look at the highest priority element in the queue. Returns
/// `null` if empty.
/// Returns `true` if the priority queue is empty and `false` if not.
pub fn isEmpty(self: Self) bool {
return self.items.len == 0;
}
/// Return the highest priority element from the queue, or `null` if empty.
pub fn peek(self: *Self) ?T {
return if (self.items.len > 0) self.items[0] else null;
return if (!self.isEmpty()) self.items[0] else null;
}
/// Pop the highest priority element from the queue. Returns
/// `null` if empty.
pub fn removeOrNull(self: *Self) ?T {
return if (self.items.len > 0) self.remove() else null;
/// Remove and return the highest priority element from the queue, or `null`
/// if empty.
pub fn pop(self: *Self) ?T {
return if (!self.isEmpty()) self.removeIndex(0) else null;
}
/// Remove and return the highest priority element from the
/// queue.
pub fn remove(self: *Self) T {
return self.removeIndex(0);
}
/// Remove and return element at index. Indices are in the
/// same order as iterator, which is not necessarily priority
/// order.
/// Remove and return the element at index. Indices are in the same order as
/// the iterator, which is not necessarily priority order.
pub fn removeIndex(self: *Self, index: usize) T {
assert(self.items.len > index);
const last = self.items[self.items.len - 1];
@ -116,25 +148,26 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
return item;
}
/// Return the number of elements remaining in the priority
/// queue.
/// Return the number of elements present in the priority queue.
pub fn count(self: Self) usize {
return self.items.len;
}
/// Return the number of elements that can be added to the
/// queue before more memory is allocated.
pub fn capacity(self: Self) usize {
return self.cap;
/// Return the number of elements that can be added to the priority queue
/// before more memory is allocated.
pub fn getCapacity(self: Self) usize {
return self.capacity;
}
/// Returns a slice of all the items plus the extra capacity, whose memory
/// contents are `undefined`.
fn allocatedSlice(self: Self) []T {
// `items.len` is the length, not the capacity.
return self.items.ptr[0..self.cap];
return self.items.ptr[0..self.capacity];
}
/// Ensure that the highest priority element is at the root of the queue
/// while removing.
fn siftDown(self: *Self, target_index: usize) void {
const target_element = self.items[target_index];
var index = target_index;
@ -155,14 +188,13 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
self.items[index] = target_element;
}
/// PriorityQueue takes ownership of the passed in slice. The slice must have been
/// allocated with `allocator`.
/// Deinitialize with `deinit`.
pub fn fromOwnedSlice(allocator: Allocator, items: []T, context: Context) Self {
/// PriorityQueue takes ownership of the passed in slice. The slice must have
/// been allocated with `allocator`.
/// Deinitialize with `deinit(allocator)`
pub fn fromOwnedSlice(items: []T, context: Context) Self {
var self = Self{
.items = items,
.cap = items.len,
.allocator = allocator,
.capacity = items.len,
.context = context,
};
@ -174,59 +206,61 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
return self;
}
/// Ensure that the queue can fit at least `new_capacity` items.
pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
var better_capacity = self.cap;
/// Ensure that the priority queue can fit at least `new_capacity` items.
pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) !void {
var better_capacity = self.capacity;
if (better_capacity >= new_capacity) return;
while (true) {
better_capacity += better_capacity / 2 + 8;
if (better_capacity >= new_capacity) break;
}
try self.ensureTotalCapacityPrecise(better_capacity);
}
pub fn ensureTotalCapacityPrecise(self: *Self, new_capacity: usize) !void {
if (self.capacity() >= new_capacity) return;
const old_memory = self.allocatedSlice();
const new_memory = try self.allocator.realloc(old_memory, new_capacity);
const new_memory = try allocator.realloc(old_memory, better_capacity);
self.items.ptr = new_memory.ptr;
self.cap = new_memory.len;
self.capacity = new_memory.len;
}
/// Ensure that the queue can fit at least `additional_count` **more** item.
pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
return self.ensureTotalCapacity(self.items.len + additional_count);
/// Ensure that the queue can fit at least `additional_count` **more** items.
pub fn ensureUnusedCapacity(self: *Self, allocator: Allocator, additional_count: usize) !void {
return self.ensureTotalCapacity(
allocator,
self.items.len + additional_count,
);
}
/// Reduce allocated capacity to `new_capacity`.
pub fn shrinkAndFree(self: *Self, new_capacity: usize) void {
assert(new_capacity <= self.cap);
pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_capacity: usize) void {
assert(new_capacity <= self.capacity);
// Cannot shrink to smaller than the current queue size without invalidating the heap property
assert(new_capacity >= self.items.len);
const old_memory = self.allocatedSlice();
const new_memory = self.allocator.realloc(old_memory, new_capacity) catch |e| switch (e) {
const new_memory = allocator.realloc(old_memory, new_capacity) catch |e| switch (e) {
error.OutOfMemory => { // no problem, capacity is still correct then.
return;
},
};
self.items.ptr = new_memory.ptr;
self.cap = new_memory.len;
self.capacity = new_memory.len;
}
/// Remove all elements from the items slice.
pub fn clearRetainingCapacity(self: *Self) void {
self.items.len = 0;
}
pub fn clearAndFree(self: *Self) void {
self.allocator.free(self.allocatedSlice());
self.items.len = 0;
self.cap = 0;
/// Invalidates all element pointers.
pub fn clearAndFree(self: *Self, allocator: Allocator) void {
allocator.free(self.allocatedSlice());
self.items = &.{};
self.capacity = 0;
self.context = undefined;
}
/// Replace an element in the queue with a new element, maintaining priority.
/// If the element being updated doesn't exist, return `error.ElementNotFound`.
pub fn update(self: *Self, elem: T, new_elem: T) !void {
const update_index = blk: {
var idx: usize = 0;
@ -283,7 +317,7 @@ pub fn PriorityQueue(comptime T: type, comptime Context: type, comptime compareF
print("{}, ", .{e});
}
print("len: {} ", .{self.items.len});
print("capacity: {}", .{self.cap});
print("capacity: {}", .{self.capacity});
print(" }}\n", .{});
}
};
@ -295,184 +329,201 @@ fn lessThan(context: void, a: u32, b: u32) Order {
}
fn greaterThan(context: void, a: u32, b: u32) Order {
return lessThan(context, a, b).invert();
_ = context;
return std.math.order(a, b).invert();
}
const PQlt = PriorityQueue(u32, void, lessThan);
const PQgt = PriorityQueue(u32, void, greaterThan);
const MinHeap = PriorityQueue(u32, void, lessThan);
const MaxHeap = PriorityQueue(u32, void, greaterThan);
test "add and remove min heap" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(54);
try queue.add(12);
try queue.add(7);
try queue.add(23);
try queue.add(25);
try queue.add(13);
try expectEqual(@as(u32, 7), queue.remove());
try expectEqual(@as(u32, 12), queue.remove());
try expectEqual(@as(u32, 13), queue.remove());
try expectEqual(@as(u32, 23), queue.remove());
try expectEqual(@as(u32, 25), queue.remove());
try expectEqual(@as(u32, 54), queue.remove());
try queue.push(allocator, 54);
try queue.push(allocator, 12);
try queue.push(allocator, 7);
try queue.push(allocator, 23);
try queue.push(allocator, 25);
try queue.push(allocator, 13);
try expectEqual(@as(u32, 7), queue.pop());
try expectEqual(@as(u32, 12), queue.pop());
try expectEqual(@as(u32, 13), queue.pop());
try expectEqual(@as(u32, 23), queue.pop());
try expectEqual(@as(u32, 25), queue.pop());
try expectEqual(@as(u32, 54), queue.pop());
}
test "add and remove same min heap" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(1);
try queue.add(1);
try queue.add(2);
try queue.add(2);
try queue.add(1);
try queue.add(1);
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 2);
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
}
test "removeOrNull on empty" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
test "remove from empty" {
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try expect(queue.removeOrNull() == null);
try expect(queue.pop() == null);
}
test "edge case 3 elements" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(9);
try queue.add(3);
try queue.add(2);
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 3), queue.remove());
try expectEqual(@as(u32, 9), queue.remove());
try queue.push(allocator, 9);
try queue.push(allocator, 3);
try queue.push(allocator, 2);
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 3), queue.pop());
try expectEqual(@as(u32, 9), queue.pop());
}
test "peek" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try expect(queue.peek() == null);
try queue.add(9);
try queue.add(3);
try queue.add(2);
try queue.push(allocator, 9);
try queue.push(allocator, 3);
try queue.push(allocator, 2);
try expectEqual(@as(u32, 2), queue.peek().?);
try expectEqual(@as(u32, 2), queue.peek().?);
}
test "sift up with odd indices" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
for (items) |e| {
try queue.add(e);
try queue.push(allocator, e);
}
const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
for (sorted_items) |e| {
try expectEqual(e, queue.remove());
try expectEqual(e, queue.pop());
}
}
test "addSlice" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
try queue.addSlice(items[0..]);
try queue.addSlice(allocator, items[0..]);
const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
for (sorted_items) |e| {
try expectEqual(e, queue.remove());
try expectEqual(e, queue.pop());
}
}
test "fromOwnedSlice trivial case 0" {
const allocator = std.testing.allocator;
const items = [0]u32{};
const queue_items = try testing.allocator.dupe(u32, &items);
var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});
defer queue.deinit();
const queue_items = try allocator.dupe(u32, &items);
var queue = MinHeap.fromOwnedSlice(queue_items[0..], {});
defer queue.deinit(allocator);
try expectEqual(@as(usize, 0), queue.count());
try expect(queue.removeOrNull() == null);
try expect(queue.pop() == null);
}
test "fromOwnedSlice trivial case 1" {
const allocator = std.testing.allocator;
const items = [1]u32{1};
const queue_items = try testing.allocator.dupe(u32, &items);
var queue = PQlt.fromOwnedSlice(testing.allocator, queue_items[0..], {});
defer queue.deinit();
const queue_items = try allocator.dupe(u32, &items);
var queue = MinHeap.fromOwnedSlice(queue_items[0..], {});
defer queue.deinit(allocator);
try expectEqual(@as(usize, 1), queue.count());
try expectEqual(items[0], queue.remove());
try expect(queue.removeOrNull() == null);
try expectEqual(items[0], queue.pop());
try expect(queue.pop() == null);
}
test "fromOwnedSlice" {
const allocator = std.testing.allocator;
const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
const heap_items = try testing.allocator.dupe(u32, items[0..]);
var queue = PQlt.fromOwnedSlice(testing.allocator, heap_items[0..], {});
defer queue.deinit();
const heap_items = try allocator.dupe(u32, items[0..]);
var queue = MinHeap.fromOwnedSlice(heap_items[0..], {});
defer queue.deinit(allocator);
const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
for (sorted_items) |e| {
try expectEqual(e, queue.remove());
try expectEqual(e, queue.pop());
}
}
test "add and remove max heap" {
var queue = PQgt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MaxHeap = .empty;
defer queue.deinit(allocator);
try queue.add(54);
try queue.add(12);
try queue.add(7);
try queue.add(23);
try queue.add(25);
try queue.add(13);
try expectEqual(@as(u32, 54), queue.remove());
try expectEqual(@as(u32, 25), queue.remove());
try expectEqual(@as(u32, 23), queue.remove());
try expectEqual(@as(u32, 13), queue.remove());
try expectEqual(@as(u32, 12), queue.remove());
try expectEqual(@as(u32, 7), queue.remove());
try queue.push(allocator, 54);
try queue.push(allocator, 12);
try queue.push(allocator, 7);
try queue.push(allocator, 23);
try queue.push(allocator, 25);
try queue.push(allocator, 13);
try expectEqual(@as(u32, 54), queue.pop());
try expectEqual(@as(u32, 25), queue.pop());
try expectEqual(@as(u32, 23), queue.pop());
try expectEqual(@as(u32, 13), queue.pop());
try expectEqual(@as(u32, 12), queue.pop());
try expectEqual(@as(u32, 7), queue.pop());
}
test "add and remove same max heap" {
var queue = PQgt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MaxHeap = .empty;
defer queue.deinit(allocator);
try queue.add(1);
try queue.add(1);
try queue.add(2);
try queue.add(2);
try queue.add(1);
try queue.add(1);
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 2);
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
}
test "iterator" {
var queue = PQlt.init(testing.allocator, {});
var map = std.AutoHashMap(u32, void).init(testing.allocator);
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
var map = std.AutoHashMap(u32, void).init(allocator);
defer {
queue.deinit();
queue.deinit(allocator);
map.deinit();
}
const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
for (items) |e| {
_ = try queue.add(e);
_ = try queue.push(allocator, e);
try map.put(e, {});
}
@ -485,12 +536,13 @@ test "iterator" {
}
test "remove at index" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
const items = [_]u32{ 2, 1, 8, 9, 3, 4, 5 };
for (items) |e| {
_ = try queue.add(e);
_ = try queue.push(allocator, e);
}
var it = queue.iterator();
@ -500,19 +552,21 @@ test "remove at index" {
break idx;
idx += 1;
} else unreachable;
const sorted_items = [_]u32{ 1, 3, 4, 5, 8, 9 };
try expectEqual(queue.removeIndex(two_idx), 2);
var i: usize = 0;
while (queue.removeOrNull()) |n| : (i += 1) {
while (queue.pop()) |n| : (i += 1) {
try expectEqual(n, sorted_items[i]);
}
try expectEqual(queue.removeOrNull(), null);
try expectEqual(queue.pop(), null);
}
test "iterator while empty" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
var it = queue.iterator();
@ -520,110 +574,120 @@ test "iterator while empty" {
}
test "shrinkAndFree" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.ensureTotalCapacity(4);
try expect(queue.capacity() >= 4);
try queue.ensureTotalCapacity(allocator, 4);
try expect(queue.getCapacity() >= 4);
try queue.add(1);
try queue.add(2);
try queue.add(3);
try expect(queue.capacity() >= 4);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 3);
try expect(queue.getCapacity() >= 4);
try expectEqual(@as(usize, 3), queue.count());
queue.shrinkAndFree(3);
try expectEqual(@as(usize, 3), queue.capacity());
queue.shrinkAndFree(allocator, 3);
try expectEqual(@as(usize, 3), queue.getCapacity());
try expectEqual(@as(usize, 3), queue.count());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 3), queue.remove());
try expect(queue.removeOrNull() == null);
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 3), queue.pop());
try expect(queue.pop() == null);
}
test "update min heap" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(55);
try queue.add(44);
try queue.add(11);
try queue.push(allocator, 55);
try queue.push(allocator, 44);
try queue.push(allocator, 11);
try queue.update(55, 5);
try queue.update(44, 4);
try queue.update(11, 1);
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 4), queue.remove());
try expectEqual(@as(u32, 5), queue.remove());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 4), queue.pop());
try expectEqual(@as(u32, 5), queue.pop());
}
test "update same min heap" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(1);
try queue.add(1);
try queue.add(2);
try queue.add(2);
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 2);
try queue.update(1, 5);
try queue.update(2, 4);
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 4), queue.remove());
try expectEqual(@as(u32, 5), queue.remove());
try expectEqual(@as(u32, 1), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 4), queue.pop());
try expectEqual(@as(u32, 5), queue.pop());
}
test "update max heap" {
var queue = PQgt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MaxHeap = .empty;
defer queue.deinit(allocator);
try queue.add(55);
try queue.add(44);
try queue.add(11);
try queue.push(allocator, 55);
try queue.push(allocator, 44);
try queue.push(allocator, 11);
try queue.update(55, 5);
try queue.update(44, 1);
try queue.update(11, 4);
try expectEqual(@as(u32, 5), queue.remove());
try expectEqual(@as(u32, 4), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 5), queue.pop());
try expectEqual(@as(u32, 4), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
}
test "update same max heap" {
var queue = PQgt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MaxHeap = .empty;
defer queue.deinit(allocator);
try queue.add(1);
try queue.add(1);
try queue.add(2);
try queue.add(2);
try queue.push(allocator, 1);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 2);
try queue.update(1, 5);
try queue.update(2, 4);
try expectEqual(@as(u32, 5), queue.remove());
try expectEqual(@as(u32, 4), queue.remove());
try expectEqual(@as(u32, 2), queue.remove());
try expectEqual(@as(u32, 1), queue.remove());
try expectEqual(@as(u32, 5), queue.pop());
try expectEqual(@as(u32, 4), queue.pop());
try expectEqual(@as(u32, 2), queue.pop());
try expectEqual(@as(u32, 1), queue.pop());
}
test "update after remove" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.add(1);
try expectEqual(@as(u32, 1), queue.remove());
try queue.push(allocator, 1);
try expectEqual(@as(u32, 1), queue.pop());
try expectError(error.ElementNotFound, queue.update(1, 1));
}
test "siftUp in remove" {
var queue = PQlt.init(testing.allocator, {});
defer queue.deinit();
const allocator = std.testing.allocator;
var queue: MinHeap = .empty;
defer queue.deinit(allocator);
try queue.addSlice(&.{ 0, 1, 100, 2, 3, 101, 102, 4, 5, 6, 7, 103, 104, 105, 106, 8 });
try queue.addSlice(
allocator,
&.{ 0, 1, 100, 2, 3, 101, 102, 4, 5, 6, 7, 103, 104, 105, 106, 8 },
);
_ = queue.removeIndex(std.mem.indexOfScalar(u32, queue.items[0..queue.count()], 102).?);
const sorted_items = [_]u32{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 100, 101, 103, 104, 105, 106 };
for (sorted_items) |e| {
try expectEqual(e, queue.remove());
try expectEqual(e, queue.pop());
}
}
@ -631,26 +695,27 @@ fn contextLessThan(context: []const u32, a: usize, b: usize) Order {
return std.math.order(context[a], context[b]);
}
const CPQlt = PriorityQueue(usize, []const u32, contextLessThan);
const MinHeapCTX = PriorityQueue(usize, []const u32, contextLessThan);
test "add and remove min heap with context comparator" {
const allocator = std.testing.allocator;
const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
var queue = CPQlt.init(testing.allocator, context[0..]);
defer queue.deinit();
var queue: MinHeapCTX = .withContext(context[0..]);
defer queue.deinit(allocator);
try queue.add(0);
try queue.add(1);
try queue.add(2);
try queue.add(3);
try queue.add(4);
try queue.add(5);
try queue.add(6);
try expectEqual(@as(usize, 6), queue.remove());
try expectEqual(@as(usize, 4), queue.remove());
try expectEqual(@as(usize, 3), queue.remove());
try expectEqual(@as(usize, 1), queue.remove());
try expectEqual(@as(usize, 2), queue.remove());
try expectEqual(@as(usize, 0), queue.remove());
try expectEqual(@as(usize, 5), queue.remove());
try queue.push(allocator, 0);
try queue.push(allocator, 1);
try queue.push(allocator, 2);
try queue.push(allocator, 3);
try queue.push(allocator, 4);
try queue.push(allocator, 5);
try queue.push(allocator, 6);
try expectEqual(@as(usize, 6), queue.pop());
try expectEqual(@as(usize, 4), queue.pop());
try expectEqual(@as(usize, 3), queue.pop());
try expectEqual(@as(usize, 1), queue.pop());
try expectEqual(@as(usize, 2), queue.pop());
try expectEqual(@as(usize, 0), queue.pop());
try expectEqual(@as(usize, 5), queue.pop());
}

2
lib/std/std.zig
View file

@ -23,7 +23,7 @@ pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
pub const Io = @import("Io.zig");
pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;
pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;
pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;
pub const PriorityDeque = @import("priority_deque.zig").PriorityDeque;
pub const Progress = @import("Progress.zig");
pub const Random = @import("Random.zig");
pub const SemanticVersion = @import("SemanticVersion.zig");