From d297f7b8f2f598967a8b91a45df1b1932dd3c81d Mon Sep 17 00:00:00 2001 From: Saurabh Mishra Date: Wed, 18 Feb 2026 11:20:32 -0800 Subject: [PATCH 1/5] make priority dequeue an unmanaged container and ensure tests pass --- lib/std/priority_dequeue.zig | 410 ++++++++++++++++++++--------------- 1 file changed, 236 insertions(+), 174 deletions(-) diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index e2a01696e595948639496dd97ac4307be54b88b9..33cf0eadbb44b3b3099c48a60575b5c298dca187 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -21,33 +21,31 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar items: []T, len: usize, - allocator: Allocator, context: Context, /// Initialize and return a new priority dequeue. - pub fn init(allocator: Allocator, context: Context) Self { + pub fn init(context: Context) Self { return Self{ .items = &[_]T{}, .len = 0, - .allocator = allocator, .context = context, }; } /// Free memory used by the dequeue. - pub fn deinit(self: Self) void { - self.allocator.free(self.items); + pub fn deinit(self: Self, allocator: Allocator) void { + allocator.free(self.items); } /// Insert a new element, maintaining priority. - pub fn add(self: *Self, elem: T) !void { - try self.ensureUnusedCapacity(1); + pub fn add(self: *Self, allocator: Allocator, elem: T) !void { + try self.ensureUnusedCapacity(allocator, 1); addUnchecked(self, elem); } /// Add each element in `items` to the dequeue. - pub fn addSlice(self: *Self, items: []const T) !void { - try self.ensureUnusedCapacity(items.len); + pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void { + try self.ensureUnusedCapacity(allocator, items.len); for (items) |e| { self.addUnchecked(e); } @@ -333,14 +331,12 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar return self.items.len; } - /// Dequeue takes ownership of the passed in slice. The slice must have been - /// allocated with `allocator`. - /// De-initialize with `deinit`. - pub fn fromOwnedSlice(allocator: Allocator, items: []T, context: Context) Self { + /// Dequeue takes ownership of the passed in slice. The slice must be de-initialize + /// with `deinit`. + pub fn fromOwnedSlice(items: []T, context: Context) Self { var queue = Self{ .items = items, .len = items.len, - .allocator = allocator, .context = context, }; @@ -356,29 +352,29 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar } /// Ensure that the dequeue can fit at least `new_capacity` items. - pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void { + 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; } - self.items = try self.allocator.realloc(self.items, better_capacity); + self.items = try allocator.realloc(self.items, better_capacity); } /// Ensure that the dequeue can fit at least `additional_count` **more** items. - pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void { - return self.ensureTotalCapacity(self.len + additional_count); + pub fn ensureUnusedCapacity(self: *Self, allocator: Allocator, additional_count: usize) !void { + return self.ensureTotalCapacity(allocator, self.len + additional_count); } /// Reduce allocated capacity to `new_len`. - pub fn shrinkAndFree(self: *Self, new_len: usize) void { + pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_len: usize) void { assert(new_len <= self.items.len); // Cannot shrink to smaller than the current queue size without invalidating the heap property assert(new_len >= self.len); - self.items = self.allocator.realloc(self.items[0..], new_len) catch |e| switch (e) { + self.items = allocator.realloc(self.items[0..], new_len) catch |e| switch (e) { error.OutOfMemory => { // no problem, capacity is still correct then. self.items.len = new_len; return; @@ -468,15 +464,16 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order { const PDQ = PriorityDequeue(u32, void, lessThanComparison); test "add and remove min" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + var queue = PDQ.init({}); + defer queue.deinit(gpa); - 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 queue.add(gpa, 54); + try queue.add(gpa, 12); + try queue.add(gpa, 7); + try queue.add(gpa, 23); + try queue.add(gpa, 25); + try queue.add(gpa, 13); try expectEqual(@as(u32, 7), queue.removeMin()); try expectEqual(@as(u32, 12), queue.removeMin()); @@ -487,6 +484,8 @@ test "add and remove min" { } test "add and remove min structs" { + const gpa = std.testing.allocator; + const S = struct { size: u32, }; @@ -495,15 +494,15 @@ test "add and remove min structs" { _ = context; return std.math.order(a.size, b.size); } - }.order).init(testing.allocator, {}); - defer queue.deinit(); + }.order).init({}); + defer queue.deinit(gpa); - try queue.add(.{ .size = 54 }); - try queue.add(.{ .size = 12 }); - try queue.add(.{ .size = 7 }); - try queue.add(.{ .size = 23 }); - try queue.add(.{ .size = 25 }); - try queue.add(.{ .size = 13 }); + try queue.add(gpa, .{ .size = 54 }); + try queue.add(gpa, .{ .size = 12 }); + try queue.add(gpa, .{ .size = 7 }); + try queue.add(gpa, .{ .size = 23 }); + try queue.add(gpa, .{ .size = 25 }); + try queue.add(gpa, .{ .size = 13 }); try expectEqual(@as(u32, 7), queue.removeMin().size); try expectEqual(@as(u32, 12), queue.removeMin().size); @@ -514,15 +513,17 @@ test "add and remove min structs" { } test "add and remove max" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.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); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 54); + try queue.add(gpa, 12); + try queue.add(gpa, 7); + try queue.add(gpa, 23); + try queue.add(gpa, 25); + try queue.add(gpa, 13); try expectEqual(@as(u32, 54), queue.removeMax()); try expectEqual(@as(u32, 25), queue.removeMax()); @@ -533,15 +534,17 @@ test "add and remove max" { } test "add and remove same min" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.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); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 1); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 2); + try queue.add(gpa, 1); + try queue.add(gpa, 1); try expectEqual(@as(u32, 1), queue.removeMin()); try expectEqual(@as(u32, 1), queue.removeMin()); @@ -552,15 +555,17 @@ test "add and remove same min" { } test "add and remove same max" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.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); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 1); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 2); + try queue.add(gpa, 1); + try queue.add(gpa, 1); try expectEqual(@as(u32, 2), queue.removeMax()); try expectEqual(@as(u32, 2), queue.removeMax()); @@ -571,20 +576,24 @@ test "add and remove same max" { } test "removeOrNull empty" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); try expect(queue.removeMinOrNull() == null); try expect(queue.removeMaxOrNull() == null); } test "edge case 3 elements" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(9); - try queue.add(3); - try queue.add(2); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 9); + try queue.add(gpa, 3); + try queue.add(gpa, 2); try expectEqual(@as(u32, 2), queue.removeMin()); try expectEqual(@as(u32, 3), queue.removeMin()); @@ -592,12 +601,14 @@ test "edge case 3 elements" { } test "edge case 3 elements max" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(9); - try queue.add(3); - try queue.add(2); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 9); + try queue.add(gpa, 3); + try queue.add(gpa, 2); try expectEqual(@as(u32, 9), queue.removeMax()); try expectEqual(@as(u32, 3), queue.removeMax()); @@ -605,39 +616,46 @@ test "edge case 3 elements max" { } test "peekMin" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); try expect(queue.peekMin() == null); - try queue.add(9); - try queue.add(3); - try queue.add(2); + try queue.add(gpa, 9); + try queue.add(gpa, 3); + try queue.add(gpa, 2); try expect(queue.peekMin().? == 2); try expect(queue.peekMin().? == 2); } test "peekMax" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); try expect(queue.peekMin() == null); - try queue.add(9); - try queue.add(3); - try queue.add(2); + try queue.add(gpa, 9); + try queue.add(gpa, 3); + try queue.add(gpa, 2); try expect(queue.peekMax().? == 9); try expect(queue.peekMax().? == 9); } test "sift up with odd indices, removeMin" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); + 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.add(gpa, e); } const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; @@ -647,11 +665,14 @@ test "sift up with odd indices, removeMin" { } test "sift up with odd indices, removeMax" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); + 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.add(gpa, e); } const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; @@ -661,10 +682,13 @@ test "sift up with odd indices, removeMax" { } test "addSlice min" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); + 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(gpa, 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| { @@ -673,10 +697,13 @@ test "addSlice min" { } test "addSlice max" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); + 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(gpa, items[0..]); const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; for (sorted_items) |e| { @@ -685,19 +712,26 @@ test "addSlice max" { } test "fromOwnedSlice trivial case 0" { + const gpa = std.testing.allocator; + const items = [0]u32{}; - const queue_items = try testing.allocator.dupe(u32, &items); - var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {}); - defer queue.deinit(); + const queue_items = try gpa.dupe(u32, &items); + + var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + defer queue.deinit(gpa); + try expectEqual(@as(usize, 0), queue.len); try expect(queue.removeMinOrNull() == null); } test "fromOwnedSlice trivial case 1" { + const gpa = std.testing.allocator; + const items = [1]u32{1}; - const queue_items = try testing.allocator.dupe(u32, &items); - var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {}); - defer queue.deinit(); + const queue_items = try gpa.dupe(u32, &items); + + var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + defer queue.deinit(gpa); try expectEqual(@as(usize, 1), queue.len); try expectEqual(items[0], queue.removeMin()); @@ -705,10 +739,13 @@ test "fromOwnedSlice trivial case 1" { } test "fromOwnedSlice" { + const gpa = 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 queue_items = try testing.allocator.dupe(u32, items[0..]); - var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {}); - defer queue.deinit(); + const queue_items = try gpa.dupe(u32, items[0..]); + + var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + defer queue.deinit(gpa); 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| { @@ -717,12 +754,14 @@ test "fromOwnedSlice" { } test "update min queue" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(55); - try queue.add(44); - try queue.add(11); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 55); + try queue.add(gpa, 44); + try queue.add(gpa, 11); try queue.update(55, 5); try queue.update(44, 4); try queue.update(11, 1); @@ -732,13 +771,15 @@ test "update min queue" { } test "update same min queue" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(1); - try queue.add(1); - try queue.add(2); - try queue.add(2); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 1); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 2); try queue.update(1, 5); try queue.update(2, 4); try expectEqual(@as(u32, 1), queue.removeMin()); @@ -748,12 +789,14 @@ test "update same min queue" { } test "update max queue" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(55); - try queue.add(44); - try queue.add(11); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 55); + try queue.add(gpa, 44); + try queue.add(gpa, 11); try queue.update(55, 5); try queue.update(44, 1); try queue.update(11, 4); @@ -764,13 +807,15 @@ test "update max queue" { } test "update same max queue" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(1); - try queue.add(1); - try queue.add(2); - try queue.add(2); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 1); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 2); try queue.update(1, 5); try queue.update(2, 4); try expectEqual(@as(u32, 5), queue.removeMax()); @@ -780,25 +825,29 @@ test "update same max queue" { } test "update after remove" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(1); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 1); try expectEqual(@as(u32, 1), queue.removeMin()); try expectError(error.ElementNotFound, queue.update(1, 1)); } test "iterator" { - var queue = PDQ.init(testing.allocator, {}); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); var map = std.AutoHashMap(u32, void).init(testing.allocator); defer { - queue.deinit(); + queue.deinit(gpa); map.deinit(); } const items = [_]u32{ 54, 12, 7, 23, 25, 13 }; for (items) |e| { - _ = try queue.add(e); + _ = try queue.add(gpa, e); _ = try map.put(e, {}); } @@ -811,12 +860,14 @@ test "iterator" { } test "remove at index" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.add(3); - try queue.add(2); - try queue.add(1); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.add(gpa, 3); + try queue.add(gpa, 2); + try queue.add(gpa, 1); var it = queue.iterator(); var elem = it.next(); @@ -834,8 +885,10 @@ test "remove at index" { } test "iterator while empty" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; + + var queue = PDQ.init({}); + defer queue.deinit(gpa); var it = queue.iterator(); @@ -843,19 +896,21 @@ test "iterator while empty" { } test "shrinkAndFree" { - var queue = PDQ.init(testing.allocator, {}); - defer queue.deinit(); + const gpa = std.testing.allocator; - try queue.ensureTotalCapacity(4); + var queue = PDQ.init({}); + defer queue.deinit(gpa); + + try queue.ensureTotalCapacity(gpa, 4); try expect(queue.capacity() >= 4); - try queue.add(1); - try queue.add(2); - try queue.add(3); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 3); try expect(queue.capacity() >= 4); try expectEqual(@as(usize, 3), queue.len); - queue.shrinkAndFree(3); + queue.shrinkAndFree(gpa, 3); try expectEqual(@as(usize, 3), queue.capacity()); try expectEqual(@as(usize, 3), queue.len); @@ -879,11 +934,12 @@ test "fuzz testing min" { } fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void { - const allocator = testing.allocator; - const items = try generateRandomSlice(allocator, rng, queue_size); + const gpa = std.testing.allocator; - var queue = PDQ.fromOwnedSlice(allocator, items, {}); - defer queue.deinit(); + const items = try generateRandomSlice(gpa, rng, queue_size); + + var queue = PDQ.fromOwnedSlice(items, {}); + defer queue.deinit(gpa); var last_removed: ?u32 = null; while (queue.removeMinOrNull()) |next| { @@ -908,11 +964,12 @@ test "fuzz testing max" { } fn fuzzTestMax(rng: std.Random, queue_size: usize) !void { - const allocator = testing.allocator; - const items = try generateRandomSlice(allocator, rng, queue_size); + const gpa = std.testing.allocator; - var queue = PDQ.fromOwnedSlice(testing.allocator, items, {}); - defer queue.deinit(); + const items = try generateRandomSlice(gpa, rng, queue_size); + + var queue = PDQ.fromOwnedSlice(items, {}); + defer queue.deinit(gpa); var last_removed: ?u32 = null; while (queue.removeMaxOrNull()) |next| { @@ -937,11 +994,12 @@ test "fuzz testing min and max" { } fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void { - const allocator = testing.allocator; - const items = try generateRandomSlice(allocator, rng, queue_size); + const gpa = std.testing.allocator; - var queue = PDQ.fromOwnedSlice(allocator, items, {}); - defer queue.deinit(); + const items = try generateRandomSlice(gpa, rng, queue_size); + + var queue = PDQ.fromOwnedSlice(items, {}); + defer queue.deinit(gpa); var last_min: ?u32 = null; var last_max: ?u32 = null; @@ -983,18 +1041,20 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order { const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison); test "add and remove" { + const gpa = std.testing.allocator; + const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 }; - var queue = CPDQ.init(testing.allocator, context[0..]); - defer queue.deinit(); + var queue = CPDQ.init(context[0..]); + defer queue.deinit(gpa); - 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 queue.add(gpa, 0); + try queue.add(gpa, 1); + try queue.add(gpa, 2); + try queue.add(gpa, 3); + try queue.add(gpa, 4); + try queue.add(gpa, 5); + try queue.add(gpa, 6); try expectEqual(@as(usize, 6), queue.removeMin()); try expectEqual(@as(usize, 5), queue.removeMax()); try expectEqual(@as(usize, 3), queue.removeMin()); @@ -1007,20 +1067,22 @@ test "add and remove" { var all_cmps_unique = true; test "don't compare a value to a copy of itself" { + const gpa = std.testing.allocator; + var depq = PriorityDequeue(u32, void, struct { fn uniqueLessThan(_: void, a: u32, b: u32) Order { all_cmps_unique = all_cmps_unique and (a != b); return std.math.order(a, b); } - }.uniqueLessThan).init(testing.allocator, {}); - defer depq.deinit(); + }.uniqueLessThan).init({}); + defer depq.deinit(gpa); - try depq.add(1); - try depq.add(2); - try depq.add(3); - try depq.add(4); - try depq.add(5); - try depq.add(6); + try depq.add(gpa, 1); + try depq.add(gpa, 2); + try depq.add(gpa, 3); + try depq.add(gpa, 4); + try depq.add(gpa, 5); + try depq.add(gpa, 6); _ = depq.removeIndex(2); try expectEqual(all_cmps_unique, true); -- 2.54.0 From 535722b37419f821650a3765e20880a3186ceff3 Mon Sep 17 00:00:00 2001 From: Saurabh Mishra Date: Wed, 18 Feb 2026 11:43:57 -0800 Subject: [PATCH 2/5] rename `add` to `push` and `remove` to `pop` in methods and tests --- lib/std/priority_dequeue.zig | 390 +++++++++++++++++------------------ 1 file changed, 195 insertions(+), 195 deletions(-) diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 33cf0eadbb44b3b3099c48a60575b5c298dca187..a69f2bcb9aa53daabca77a8cda515d96ccfda8b8 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -38,20 +38,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar } /// Insert a new element, maintaining priority. - pub fn add(self: *Self, allocator: Allocator, elem: T) !void { + pub fn push(self: *Self, allocator: Allocator, elem: T) !void { try self.ensureUnusedCapacity(allocator, 1); - addUnchecked(self, elem); + pushUnchecked(self, elem); } /// Add each element in `items` to the dequeue. - pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void { + pub fn pushSlice(self: *Self, allocator: Allocator, items: []const T) !void { try self.ensureUnusedCapacity(allocator, items.len); for (items) |e| { - self.addUnchecked(e); + self.pushUnchecked(e); } } - fn addUnchecked(self: *Self, elem: T) void { + fn pushUnchecked(self: *Self, elem: T) void { self.items[self.len] = elem; if (self.len > 0) { @@ -151,32 +151,32 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar /// Pop the smallest element from the dequeue. Returns /// `null` if empty. - pub fn removeMinOrNull(self: *Self) ?T { - return if (self.len > 0) self.removeMin() else null; + pub fn popMinOrNull(self: *Self) ?T { + return if (self.len > 0) self.popMin() else null; } /// Remove and return the smallest element from the /// dequeue. - pub fn removeMin(self: *Self) T { - return self.removeIndex(0); + pub fn popMin(self: *Self) T { + return self.popIndex(0); } /// Pop the largest element from the dequeue. Returns /// `null` if empty. - pub fn removeMaxOrNull(self: *Self) ?T { - return if (self.len > 0) self.removeMax() else null; + pub fn popMaxOrNull(self: *Self) ?T { + return if (self.len > 0) self.popMax() else null; } /// Remove and return the largest element from the /// dequeue. - pub fn removeMax(self: *Self) T { - return self.removeIndex(self.maxIndex().?); + pub fn popMax(self: *Self) T { + return self.popIndex(self.maxIndex().?); } /// Remove and return element at index. Indices are in the /// same order as iterator, which is not necessarily priority /// order. - pub fn removeIndex(self: *Self, index: usize) T { + pub fn popIndex(self: *Self, index: usize) T { assert(self.len > index); const item = self.items[index]; const last = self.items[self.len - 1]; @@ -391,8 +391,8 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar } return error.ElementNotFound; }; - _ = self.removeIndex(old_index); - self.addUnchecked(new_elem); + _ = self.popIndex(old_index); + self.pushUnchecked(new_elem); } pub const Iterator = struct { @@ -463,27 +463,27 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order { const PDQ = PriorityDequeue(u32, void, lessThanComparison); -test "add and remove min" { +test "push and pop min" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 54); - try queue.add(gpa, 12); - try queue.add(gpa, 7); - try queue.add(gpa, 23); - try queue.add(gpa, 25); - try queue.add(gpa, 13); + try queue.push(gpa, 54); + try queue.push(gpa, 12); + try queue.push(gpa, 7); + try queue.push(gpa, 23); + try queue.push(gpa, 25); + try queue.push(gpa, 13); - try expectEqual(@as(u32, 7), queue.removeMin()); - try expectEqual(@as(u32, 12), queue.removeMin()); - try expectEqual(@as(u32, 13), queue.removeMin()); - try expectEqual(@as(u32, 23), queue.removeMin()); - try expectEqual(@as(u32, 25), queue.removeMin()); - try expectEqual(@as(u32, 54), queue.removeMin()); + try expectEqual(@as(u32, 7), queue.popMin()); + try expectEqual(@as(u32, 12), queue.popMin()); + try expectEqual(@as(u32, 13), queue.popMin()); + try expectEqual(@as(u32, 23), queue.popMin()); + try expectEqual(@as(u32, 25), queue.popMin()); + try expectEqual(@as(u32, 54), queue.popMin()); } -test "add and remove min structs" { +test "push and pop min structs" { const gpa = std.testing.allocator; const S = struct { @@ -497,92 +497,92 @@ test "add and remove min structs" { }.order).init({}); defer queue.deinit(gpa); - try queue.add(gpa, .{ .size = 54 }); - try queue.add(gpa, .{ .size = 12 }); - try queue.add(gpa, .{ .size = 7 }); - try queue.add(gpa, .{ .size = 23 }); - try queue.add(gpa, .{ .size = 25 }); - try queue.add(gpa, .{ .size = 13 }); - - try expectEqual(@as(u32, 7), queue.removeMin().size); - try expectEqual(@as(u32, 12), queue.removeMin().size); - try expectEqual(@as(u32, 13), queue.removeMin().size); - try expectEqual(@as(u32, 23), queue.removeMin().size); - try expectEqual(@as(u32, 25), queue.removeMin().size); - try expectEqual(@as(u32, 54), queue.removeMin().size); + try queue.push(gpa, .{ .size = 54 }); + try queue.push(gpa, .{ .size = 12 }); + try queue.push(gpa, .{ .size = 7 }); + try queue.push(gpa, .{ .size = 23 }); + try queue.push(gpa, .{ .size = 25 }); + try queue.push(gpa, .{ .size = 13 }); + + try expectEqual(@as(u32, 7), queue.popMin().size); + try expectEqual(@as(u32, 12), queue.popMin().size); + try expectEqual(@as(u32, 13), queue.popMin().size); + try expectEqual(@as(u32, 23), queue.popMin().size); + try expectEqual(@as(u32, 25), queue.popMin().size); + try expectEqual(@as(u32, 54), queue.popMin().size); } -test "add and remove max" { +test "push and pop max" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 54); - try queue.add(gpa, 12); - try queue.add(gpa, 7); - try queue.add(gpa, 23); - try queue.add(gpa, 25); - try queue.add(gpa, 13); - - try expectEqual(@as(u32, 54), queue.removeMax()); - try expectEqual(@as(u32, 25), queue.removeMax()); - try expectEqual(@as(u32, 23), queue.removeMax()); - try expectEqual(@as(u32, 13), queue.removeMax()); - try expectEqual(@as(u32, 12), queue.removeMax()); - try expectEqual(@as(u32, 7), queue.removeMax()); + try queue.push(gpa, 54); + try queue.push(gpa, 12); + try queue.push(gpa, 7); + try queue.push(gpa, 23); + try queue.push(gpa, 25); + try queue.push(gpa, 13); + + try expectEqual(@as(u32, 54), queue.popMax()); + try expectEqual(@as(u32, 25), queue.popMax()); + try expectEqual(@as(u32, 23), queue.popMax()); + try expectEqual(@as(u32, 13), queue.popMax()); + try expectEqual(@as(u32, 12), queue.popMax()); + try expectEqual(@as(u32, 7), queue.popMax()); } -test "add and remove same min" { +test "push and pop same min" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 2); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 2), queue.removeMin()); - try expectEqual(@as(u32, 2), queue.removeMin()); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 2); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 2), queue.popMin()); + try expectEqual(@as(u32, 2), queue.popMin()); } -test "add and remove same max" { +test "push and pop same max" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 2); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - - try expectEqual(@as(u32, 2), queue.removeMax()); - try expectEqual(@as(u32, 2), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 2); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + + try expectEqual(@as(u32, 2), queue.popMax()); + try expectEqual(@as(u32, 2), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); } -test "removeOrNull empty" { +test "popOrNull empty" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try expect(queue.removeMinOrNull() == null); - try expect(queue.removeMaxOrNull() == null); + try expect(queue.popMinOrNull() == null); + try expect(queue.popMaxOrNull() == null); } test "edge case 3 elements" { @@ -591,13 +591,13 @@ test "edge case 3 elements" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 9); - try queue.add(gpa, 3); - try queue.add(gpa, 2); + try queue.push(gpa, 9); + try queue.push(gpa, 3); + try queue.push(gpa, 2); - try expectEqual(@as(u32, 2), queue.removeMin()); - try expectEqual(@as(u32, 3), queue.removeMin()); - try expectEqual(@as(u32, 9), queue.removeMin()); + try expectEqual(@as(u32, 2), queue.popMin()); + try expectEqual(@as(u32, 3), queue.popMin()); + try expectEqual(@as(u32, 9), queue.popMin()); } test "edge case 3 elements max" { @@ -606,13 +606,13 @@ test "edge case 3 elements max" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 9); - try queue.add(gpa, 3); - try queue.add(gpa, 2); + try queue.push(gpa, 9); + try queue.push(gpa, 3); + try queue.push(gpa, 2); - try expectEqual(@as(u32, 9), queue.removeMax()); - try expectEqual(@as(u32, 3), queue.removeMax()); - try expectEqual(@as(u32, 2), queue.removeMax()); + try expectEqual(@as(u32, 9), queue.popMax()); + try expectEqual(@as(u32, 3), queue.popMax()); + try expectEqual(@as(u32, 2), queue.popMax()); } test "peekMin" { @@ -623,9 +623,9 @@ test "peekMin" { try expect(queue.peekMin() == null); - try queue.add(gpa, 9); - try queue.add(gpa, 3); - try queue.add(gpa, 2); + try queue.push(gpa, 9); + try queue.push(gpa, 3); + try queue.push(gpa, 2); try expect(queue.peekMin().? == 2); try expect(queue.peekMin().? == 2); @@ -639,15 +639,15 @@ test "peekMax" { try expect(queue.peekMin() == null); - try queue.add(gpa, 9); - try queue.add(gpa, 3); - try queue.add(gpa, 2); + try queue.push(gpa, 9); + try queue.push(gpa, 3); + try queue.push(gpa, 2); try expect(queue.peekMax().? == 9); try expect(queue.peekMax().? == 9); } -test "sift up with odd indices, removeMin" { +test "sift up with odd indices, popMin" { const gpa = std.testing.allocator; var queue = PDQ.init({}); @@ -655,16 +655,16 @@ test "sift up with odd indices, removeMin" { 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(gpa, e); + try queue.push(gpa, 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.removeMin()); + try expectEqual(e, queue.popMin()); } } -test "sift up with odd indices, removeMax" { +test "sift up with odd indices, popMax" { const gpa = std.testing.allocator; var queue = PDQ.init({}); @@ -672,42 +672,42 @@ test "sift up with odd indices, removeMax" { 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(gpa, e); + try queue.push(gpa, e); } const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; for (sorted_items) |e| { - try expectEqual(e, queue.removeMax()); + try expectEqual(e, queue.popMax()); } } -test "addSlice min" { +test "pushSlice min" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; - try queue.addSlice(gpa, items[0..]); + try queue.pushSlice(gpa, 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.removeMin()); + try expectEqual(e, queue.popMin()); } } -test "addSlice max" { +test "pushSlice max" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; - try queue.addSlice(gpa, items[0..]); + try queue.pushSlice(gpa, items[0..]); const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 }; for (sorted_items) |e| { - try expectEqual(e, queue.removeMax()); + try expectEqual(e, queue.popMax()); } } @@ -721,7 +721,7 @@ test "fromOwnedSlice trivial case 0" { defer queue.deinit(gpa); try expectEqual(@as(usize, 0), queue.len); - try expect(queue.removeMinOrNull() == null); + try expect(queue.popMinOrNull() == null); } test "fromOwnedSlice trivial case 1" { @@ -734,8 +734,8 @@ test "fromOwnedSlice trivial case 1" { defer queue.deinit(gpa); try expectEqual(@as(usize, 1), queue.len); - try expectEqual(items[0], queue.removeMin()); - try expect(queue.removeMinOrNull() == null); + try expectEqual(items[0], queue.popMin()); + try expect(queue.popMinOrNull() == null); } test "fromOwnedSlice" { @@ -749,7 +749,7 @@ test "fromOwnedSlice" { 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.removeMin()); + try expectEqual(e, queue.popMin()); } } @@ -759,15 +759,15 @@ test "update min queue" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 55); - try queue.add(gpa, 44); - try queue.add(gpa, 11); + try queue.push(gpa, 55); + try queue.push(gpa, 44); + try queue.push(gpa, 11); try queue.update(55, 5); try queue.update(44, 4); try queue.update(11, 1); - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 4), queue.removeMin()); - try expectEqual(@as(u32, 5), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 4), queue.popMin()); + try expectEqual(@as(u32, 5), queue.popMin()); } test "update same min queue" { @@ -776,16 +776,16 @@ test "update same min queue" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 2); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 2); try queue.update(1, 5); try queue.update(2, 4); - try expectEqual(@as(u32, 1), queue.removeMin()); - try expectEqual(@as(u32, 2), queue.removeMin()); - try expectEqual(@as(u32, 4), queue.removeMin()); - try expectEqual(@as(u32, 5), queue.removeMin()); + try expectEqual(@as(u32, 1), queue.popMin()); + try expectEqual(@as(u32, 2), queue.popMin()); + try expectEqual(@as(u32, 4), queue.popMin()); + try expectEqual(@as(u32, 5), queue.popMin()); } test "update max queue" { @@ -794,16 +794,16 @@ test "update max queue" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 55); - try queue.add(gpa, 44); - try queue.add(gpa, 11); + try queue.push(gpa, 55); + try queue.push(gpa, 44); + try queue.push(gpa, 11); try queue.update(55, 5); try queue.update(44, 1); try queue.update(11, 4); - try expectEqual(@as(u32, 5), queue.removeMax()); - try expectEqual(@as(u32, 4), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 5), queue.popMax()); + try expectEqual(@as(u32, 4), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); } test "update same max queue" { @@ -812,26 +812,26 @@ test "update same max queue" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 1); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 2); + try queue.push(gpa, 1); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 2); try queue.update(1, 5); try queue.update(2, 4); - try expectEqual(@as(u32, 5), queue.removeMax()); - try expectEqual(@as(u32, 4), queue.removeMax()); - try expectEqual(@as(u32, 2), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); + try expectEqual(@as(u32, 5), queue.popMax()); + try expectEqual(@as(u32, 4), queue.popMax()); + try expectEqual(@as(u32, 2), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); } -test "update after remove" { +test "update after pop" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 1); - try expectEqual(@as(u32, 1), queue.removeMin()); + try queue.push(gpa, 1); + try expectEqual(@as(u32, 1), queue.popMin()); try expectError(error.ElementNotFound, queue.update(1, 1)); } @@ -847,7 +847,7 @@ test "iterator" { const items = [_]u32{ 54, 12, 7, 23, 25, 13 }; for (items) |e| { - _ = try queue.add(gpa, e); + _ = try queue.push(gpa, e); _ = try map.put(e, {}); } @@ -859,15 +859,15 @@ test "iterator" { try expectEqual(@as(usize, 0), map.count()); } -test "remove at index" { +test "pop at index" { const gpa = std.testing.allocator; var queue = PDQ.init({}); defer queue.deinit(gpa); - try queue.add(gpa, 3); - try queue.add(gpa, 2); - try queue.add(gpa, 1); + try queue.push(gpa, 3); + try queue.push(gpa, 2); + try queue.push(gpa, 1); var it = queue.iterator(); var elem = it.next(); @@ -878,10 +878,10 @@ test "remove at index" { idx += 1; } else unreachable; - try expectEqual(queue.removeIndex(two_idx), 2); - try expectEqual(queue.removeMin(), 1); - try expectEqual(queue.removeMin(), 3); - try expectEqual(queue.removeMinOrNull(), null); + try expectEqual(queue.popIndex(two_idx), 2); + try expectEqual(queue.popMin(), 1); + try expectEqual(queue.popMin(), 3); + try expectEqual(queue.popMinOrNull(), null); } test "iterator while empty" { @@ -904,9 +904,9 @@ test "shrinkAndFree" { try queue.ensureTotalCapacity(gpa, 4); try expect(queue.capacity() >= 4); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 3); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 3); try expect(queue.capacity() >= 4); try expectEqual(@as(usize, 3), queue.len); @@ -914,10 +914,10 @@ test "shrinkAndFree" { try expectEqual(@as(usize, 3), queue.capacity()); try expectEqual(@as(usize, 3), queue.len); - try expectEqual(@as(u32, 3), queue.removeMax()); - try expectEqual(@as(u32, 2), queue.removeMax()); - try expectEqual(@as(u32, 1), queue.removeMax()); - try expect(queue.removeMaxOrNull() == null); + try expectEqual(@as(u32, 3), queue.popMax()); + try expectEqual(@as(u32, 2), queue.popMax()); + try expectEqual(@as(u32, 1), queue.popMax()); + try expect(queue.popMaxOrNull() == null); } test "fuzz testing min" { @@ -942,7 +942,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void { defer queue.deinit(gpa); var last_removed: ?u32 = null; - while (queue.removeMinOrNull()) |next| { + while (queue.popMinOrNull()) |next| { if (last_removed) |last| { try expect(last <= next); } @@ -972,7 +972,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void { defer queue.deinit(gpa); var last_removed: ?u32 = null; - while (queue.removeMaxOrNull()) |next| { + while (queue.popMaxOrNull()) |next| { if (last_removed) |last| { try expect(last >= next); } @@ -1006,13 +1006,13 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void { var i: usize = 0; while (i < queue_size) : (i += 1) { if (i % 2 == 0) { - const next = queue.removeMin(); + const next = queue.popMin(); if (last_min) |last| { try expect(last <= next); } last_min = next; } else { - const next = queue.removeMax(); + const next = queue.popMax(); if (last_max) |last| { try expect(last >= next); } @@ -1040,7 +1040,7 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order { const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison); -test "add and remove" { +test "push and pop" { const gpa = std.testing.allocator; const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 }; @@ -1048,20 +1048,20 @@ test "add and remove" { var queue = CPDQ.init(context[0..]); defer queue.deinit(gpa); - try queue.add(gpa, 0); - try queue.add(gpa, 1); - try queue.add(gpa, 2); - try queue.add(gpa, 3); - try queue.add(gpa, 4); - try queue.add(gpa, 5); - try queue.add(gpa, 6); - try expectEqual(@as(usize, 6), queue.removeMin()); - try expectEqual(@as(usize, 5), queue.removeMax()); - try expectEqual(@as(usize, 3), queue.removeMin()); - try expectEqual(@as(usize, 0), queue.removeMax()); - try expectEqual(@as(usize, 4), queue.removeMin()); - try expectEqual(@as(usize, 2), queue.removeMax()); - try expectEqual(@as(usize, 1), queue.removeMin()); + try queue.push(gpa, 0); + try queue.push(gpa, 1); + try queue.push(gpa, 2); + try queue.push(gpa, 3); + try queue.push(gpa, 4); + try queue.push(gpa, 5); + try queue.push(gpa, 6); + try expectEqual(@as(usize, 6), queue.popMin()); + try expectEqual(@as(usize, 5), queue.popMax()); + try expectEqual(@as(usize, 3), queue.popMin()); + try expectEqual(@as(usize, 0), queue.popMax()); + try expectEqual(@as(usize, 4), queue.popMin()); + try expectEqual(@as(usize, 2), queue.popMax()); + try expectEqual(@as(usize, 1), queue.popMin()); } var all_cmps_unique = true; @@ -1077,13 +1077,13 @@ test "don't compare a value to a copy of itself" { }.uniqueLessThan).init({}); defer depq.deinit(gpa); - try depq.add(gpa, 1); - try depq.add(gpa, 2); - try depq.add(gpa, 3); - try depq.add(gpa, 4); - try depq.add(gpa, 5); - try depq.add(gpa, 6); + try depq.push(gpa, 1); + try depq.push(gpa, 2); + try depq.push(gpa, 3); + try depq.push(gpa, 4); + try depq.push(gpa, 5); + try depq.push(gpa, 6); - _ = depq.removeIndex(2); + _ = depq.popIndex(2); try expectEqual(all_cmps_unique, true); } -- 2.54.0 From 23252c27beda48df95beb7bcf53b900e93fc7441 Mon Sep 17 00:00:00 2001 From: Saurabh Mishra Date: Wed, 18 Feb 2026 11:58:13 -0800 Subject: [PATCH 3/5] merge `popMinOrNull` into `popMin` and `popMaxOrNull` into `popMax`, and update tests --- lib/std/priority_dequeue.zig | 58 ++++++++++++++---------------------- 1 file changed, 22 insertions(+), 36 deletions(-) diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index a69f2bcb9aa53daabca77a8cda515d96ccfda8b8..53cb65d98e273618310341336f6fc8d8b1397ac8 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -149,28 +149,14 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar return self.bestItemAtIndices(1, 2, .gt).index; } - /// Pop the smallest element from the dequeue. Returns - /// `null` if empty. - pub fn popMinOrNull(self: *Self) ?T { - return if (self.len > 0) self.popMin() else null; + /// Remove and return the smallest element from the dequeue, or `null` if empty + pub fn popMin(self: *Self) ?T { + return if (self.len > 0) self.popIndex(0) else null; } - /// Remove and return the smallest element from the - /// dequeue. - pub fn popMin(self: *Self) T { - return self.popIndex(0); - } - - /// Pop the largest element from the dequeue. Returns - /// `null` if empty. - pub fn popMaxOrNull(self: *Self) ?T { - return if (self.len > 0) self.popMax() else null; - } - - /// Remove and return the largest element from the - /// dequeue. - pub fn popMax(self: *Self) T { - return self.popIndex(self.maxIndex().?); + /// Remove and return the largest element from the dequeue, or `null` if empty + pub fn popMax(self: *Self) ?T { + return if (self.len > 0) self.popIndex(self.maxIndex().?) else null; } /// Remove and return element at index. Indices are in the @@ -504,12 +490,12 @@ test "push and pop min structs" { try queue.push(gpa, .{ .size = 25 }); try queue.push(gpa, .{ .size = 13 }); - try expectEqual(@as(u32, 7), queue.popMin().size); - try expectEqual(@as(u32, 12), queue.popMin().size); - try expectEqual(@as(u32, 13), queue.popMin().size); - try expectEqual(@as(u32, 23), queue.popMin().size); - try expectEqual(@as(u32, 25), queue.popMin().size); - try expectEqual(@as(u32, 54), queue.popMin().size); + try expectEqual(@as(u32, 7), queue.popMin().?.size); + try expectEqual(@as(u32, 12), queue.popMin().?.size); + try expectEqual(@as(u32, 13), queue.popMin().?.size); + try expectEqual(@as(u32, 23), queue.popMin().?.size); + try expectEqual(@as(u32, 25), queue.popMin().?.size); + try expectEqual(@as(u32, 54), queue.popMin().?.size); } test "push and pop max" { @@ -581,8 +567,8 @@ test "popOrNull empty" { var queue = PDQ.init({}); defer queue.deinit(gpa); - try expect(queue.popMinOrNull() == null); - try expect(queue.popMaxOrNull() == null); + try expect(queue.popMin() == null); + try expect(queue.popMax() == null); } test "edge case 3 elements" { @@ -721,7 +707,7 @@ test "fromOwnedSlice trivial case 0" { defer queue.deinit(gpa); try expectEqual(@as(usize, 0), queue.len); - try expect(queue.popMinOrNull() == null); + try expect(queue.popMin() == null); } test "fromOwnedSlice trivial case 1" { @@ -735,7 +721,7 @@ test "fromOwnedSlice trivial case 1" { try expectEqual(@as(usize, 1), queue.len); try expectEqual(items[0], queue.popMin()); - try expect(queue.popMinOrNull() == null); + try expect(queue.popMin() == null); } test "fromOwnedSlice" { @@ -881,7 +867,7 @@ test "pop at index" { try expectEqual(queue.popIndex(two_idx), 2); try expectEqual(queue.popMin(), 1); try expectEqual(queue.popMin(), 3); - try expectEqual(queue.popMinOrNull(), null); + try expectEqual(queue.popMin(), null); } test "iterator while empty" { @@ -917,7 +903,7 @@ test "shrinkAndFree" { try expectEqual(@as(u32, 3), queue.popMax()); try expectEqual(@as(u32, 2), queue.popMax()); try expectEqual(@as(u32, 1), queue.popMax()); - try expect(queue.popMaxOrNull() == null); + try expect(queue.popMax() == null); } test "fuzz testing min" { @@ -942,7 +928,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void { defer queue.deinit(gpa); var last_removed: ?u32 = null; - while (queue.popMinOrNull()) |next| { + while (queue.popMin()) |next| { if (last_removed) |last| { try expect(last <= next); } @@ -972,7 +958,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void { defer queue.deinit(gpa); var last_removed: ?u32 = null; - while (queue.popMaxOrNull()) |next| { + while (queue.popMax()) |next| { if (last_removed) |last| { try expect(last >= next); } @@ -1006,13 +992,13 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void { var i: usize = 0; while (i < queue_size) : (i += 1) { if (i % 2 == 0) { - const next = queue.popMin(); + const next = queue.popMin().?; if (last_min) |last| { try expect(last <= next); } last_min = next; } else { - const next = queue.popMax(); + const next = queue.popMax().?; if (last_max) |last| { try expect(last >= next); } -- 2.54.0 From 293710c1cd3160787e882113014c022ce665d16d Mon Sep 17 00:00:00 2001 From: Saurabh Mishra Date: Wed, 18 Feb 2026 12:38:26 -0800 Subject: [PATCH 4/5] use `.empty` for default field values intead of `init()` and introduce `initContext()` --- lib/std/priority_dequeue.zig | 64 ++++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 28 deletions(-) diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 53cb65d98e273618310341336f6fc8d8b1397ac8..414c9428387fff401c4d58e0e5b6827081a7b2bb 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -23,10 +23,17 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar len: usize, context: Context, - /// Initialize and return a new priority dequeue. - pub fn init(context: Context) Self { + /// A priority dequeue containing no elements. + pub const empty: Self = .{ + .items = &.{}, + .len = 0, + .context = undefined, + }; + + /// Initialize and return a new priority dequeue with context. + pub fn initContext(context: Context) Self { return Self{ - .items = &[_]T{}, + .items = &.{}, .len = 0, .context = context, }; @@ -451,7 +458,8 @@ const PDQ = PriorityDequeue(u32, void, lessThanComparison); test "push and pop min" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 54); @@ -480,7 +488,7 @@ test "push and pop min structs" { _ = context; return std.math.order(a.size, b.size); } - }.order).init({}); + }.order).initContext({}); defer queue.deinit(gpa); try queue.push(gpa, .{ .size = 54 }); @@ -501,7 +509,7 @@ test "push and pop min structs" { test "push and pop max" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 54); @@ -522,7 +530,7 @@ test "push and pop max" { test "push and pop same min" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -543,7 +551,7 @@ test "push and pop same min" { test "push and pop same max" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -564,7 +572,7 @@ test "push and pop same max" { test "popOrNull empty" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try expect(queue.popMin() == null); @@ -574,7 +582,7 @@ test "popOrNull empty" { test "edge case 3 elements" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 9); @@ -589,7 +597,7 @@ test "edge case 3 elements" { test "edge case 3 elements max" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 9); @@ -604,7 +612,7 @@ test "edge case 3 elements max" { test "peekMin" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try expect(queue.peekMin() == null); @@ -620,7 +628,7 @@ test "peekMin" { test "peekMax" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try expect(queue.peekMin() == null); @@ -636,7 +644,7 @@ test "peekMax" { test "sift up with odd indices, popMin" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -653,7 +661,7 @@ test "sift up with odd indices, popMin" { test "sift up with odd indices, popMax" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -670,7 +678,7 @@ test "sift up with odd indices, popMax" { test "pushSlice min" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -685,7 +693,7 @@ test "pushSlice min" { test "pushSlice max" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -742,7 +750,7 @@ test "fromOwnedSlice" { test "update min queue" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 55); @@ -759,7 +767,7 @@ test "update min queue" { test "update same min queue" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -777,7 +785,7 @@ test "update same min queue" { test "update max queue" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 55); @@ -795,7 +803,7 @@ test "update max queue" { test "update same max queue" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -813,7 +821,7 @@ test "update same max queue" { test "update after pop" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -824,7 +832,7 @@ test "update after pop" { test "iterator" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; var map = std.AutoHashMap(u32, void).init(testing.allocator); defer { queue.deinit(gpa); @@ -848,7 +856,7 @@ test "iterator" { test "pop at index" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.push(gpa, 3); @@ -873,7 +881,7 @@ test "pop at index" { test "iterator while empty" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); var it = queue.iterator(); @@ -884,7 +892,7 @@ test "iterator while empty" { test "shrinkAndFree" { const gpa = std.testing.allocator; - var queue = PDQ.init({}); + var queue: PDQ = .empty; defer queue.deinit(gpa); try queue.ensureTotalCapacity(gpa, 4); @@ -1031,7 +1039,7 @@ test "push and pop" { const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 }; - var queue = CPDQ.init(context[0..]); + var queue: CPDQ = .initContext(context[0..]); defer queue.deinit(gpa); try queue.push(gpa, 0); @@ -1060,7 +1068,7 @@ test "don't compare a value to a copy of itself" { all_cmps_unique = all_cmps_unique and (a != b); return std.math.order(a, b); } - }.uniqueLessThan).init({}); + }.uniqueLessThan).initContext({}); defer depq.deinit(gpa); try depq.push(gpa, 1); -- 2.54.0 From 5140455264347f8bf869edae71faa8848e92dabd Mon Sep 17 00:00:00 2001 From: Saurabh Mishra Date: Wed, 18 Feb 2026 13:24:03 -0800 Subject: [PATCH 5/5] min heap is formed with less than comparison --- lib/std/priority_dequeue.zig | 115 ++++++++++++++++++----------------- 1 file changed, 59 insertions(+), 56 deletions(-) diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 414c9428387fff401c4d58e0e5b6827081a7b2bb..04182206c53a4a2953d4a063be838ae761287eb8 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -449,17 +449,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar }; } +/// If a min heap is constructed from slice `{5, 8, 2, 9, 7, 1, 4, 4}` using this +/// method, then the elements will be in order: {1, 2, 4, 4, 5, 7, 8, 9} fn lessThanComparison(context: void, a: u32, b: u32) Order { _ = context; return std.math.order(a, b); } -const PDQ = PriorityDequeue(u32, void, lessThanComparison); +/// Elements with lower priority will be removed first +const MinHeap = PriorityDequeue(u32, void, lessThanComparison); -test "push and pop min" { +test "push and pop min in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 54); @@ -506,10 +509,10 @@ test "push and pop min structs" { try expectEqual(@as(u32, 54), queue.popMin().?.size); } -test "push and pop max" { +test "push and pop max in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 54); @@ -527,10 +530,10 @@ test "push and pop max" { try expectEqual(@as(u32, 7), queue.popMax()); } -test "push and pop same min" { +test "push and pop same min in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -548,10 +551,10 @@ test "push and pop same min" { try expectEqual(@as(u32, 2), queue.popMin()); } -test "push and pop same max" { +test "push and pop same max in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -569,20 +572,20 @@ test "push and pop same max" { try expectEqual(@as(u32, 1), queue.popMax()); } -test "popOrNull empty" { +test "pop empty in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try expect(queue.popMin() == null); try expect(queue.popMax() == null); } -test "edge case 3 elements" { +test "edge case 3 elements popMin in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 9); @@ -594,10 +597,10 @@ test "edge case 3 elements" { try expectEqual(@as(u32, 9), queue.popMin()); } -test "edge case 3 elements max" { +test "edge case 3 elements popmax in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 9); @@ -609,10 +612,10 @@ test "edge case 3 elements max" { try expectEqual(@as(u32, 2), queue.popMax()); } -test "peekMin" { +test "peekMin in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try expect(queue.peekMin() == null); @@ -625,10 +628,10 @@ test "peekMin" { try expect(queue.peekMin().? == 2); } -test "peekMax" { +test "peekMax in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try expect(queue.peekMin() == null); @@ -641,10 +644,10 @@ test "peekMax" { try expect(queue.peekMax().? == 9); } -test "sift up with odd indices, popMin" { +test "sift up with odd indices and popMin in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -658,10 +661,10 @@ test "sift up with odd indices, popMin" { } } -test "sift up with odd indices, popMax" { +test "sift up with odd indices and popMax in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -675,10 +678,10 @@ test "sift up with odd indices, popMax" { } } -test "pushSlice min" { +test "pushSlice in min heap and popMin" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -690,10 +693,10 @@ test "pushSlice min" { } } -test "pushSlice max" { +test "pushSlice in min heap and popMax" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 }; @@ -705,26 +708,26 @@ test "pushSlice max" { } } -test "fromOwnedSlice trivial case 0" { +test "fromOwnedSlice trivial case 0 min heap" { const gpa = std.testing.allocator; const items = [0]u32{}; const queue_items = try gpa.dupe(u32, &items); - var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {}); defer queue.deinit(gpa); try expectEqual(@as(usize, 0), queue.len); try expect(queue.popMin() == null); } -test "fromOwnedSlice trivial case 1" { +test "fromOwnedSlice trivial case 1 min heap" { const gpa = std.testing.allocator; const items = [1]u32{1}; const queue_items = try gpa.dupe(u32, &items); - var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {}); defer queue.deinit(gpa); try expectEqual(@as(usize, 1), queue.len); @@ -732,13 +735,13 @@ test "fromOwnedSlice trivial case 1" { try expect(queue.popMin() == null); } -test "fromOwnedSlice" { +test "fromOwnedSlice min heap" { const gpa = 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 queue_items = try gpa.dupe(u32, items[0..]); - var queue = PDQ.fromOwnedSlice(queue_items[0..], {}); + var queue: MinHeap = .fromOwnedSlice(queue_items[0..], {}); defer queue.deinit(gpa); const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 }; @@ -747,10 +750,10 @@ test "fromOwnedSlice" { } } -test "update min queue" { +test "update and popMin in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 55); @@ -764,10 +767,10 @@ test "update min queue" { try expectEqual(@as(u32, 5), queue.popMin()); } -test "update same min queue" { +test "update same element and popMin in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -782,10 +785,10 @@ test "update same min queue" { try expectEqual(@as(u32, 5), queue.popMin()); } -test "update max queue" { +test "update and popMax in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 55); @@ -800,10 +803,10 @@ test "update max queue" { try expectEqual(@as(u32, 1), queue.popMax()); } -test "update same max queue" { +test "update same element and popMax in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -818,10 +821,10 @@ test "update same max queue" { try expectEqual(@as(u32, 1), queue.popMax()); } -test "update after pop" { +test "update after pop in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 1); @@ -829,10 +832,10 @@ test "update after pop" { try expectError(error.ElementNotFound, queue.update(1, 1)); } -test "iterator" { +test "min heap iterator" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; var map = std.AutoHashMap(u32, void).init(testing.allocator); defer { queue.deinit(gpa); @@ -853,10 +856,10 @@ test "iterator" { try expectEqual(@as(usize, 0), map.count()); } -test "pop at index" { +test "pop at index in min heap" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.push(gpa, 3); @@ -878,10 +881,10 @@ test "pop at index" { try expectEqual(queue.popMin(), null); } -test "iterator while empty" { +test "min heap iterator while empty" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); var it = queue.iterator(); @@ -889,10 +892,10 @@ test "iterator while empty" { try expectEqual(it.next(), null); } -test "shrinkAndFree" { +test "min heap shrinkAndFree" { const gpa = std.testing.allocator; - var queue: PDQ = .empty; + var queue: MinHeap = .empty; defer queue.deinit(gpa); try queue.ensureTotalCapacity(gpa, 4); @@ -932,7 +935,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void { const items = try generateRandomSlice(gpa, rng, queue_size); - var queue = PDQ.fromOwnedSlice(items, {}); + var queue: MinHeap = .fromOwnedSlice(items, {}); defer queue.deinit(gpa); var last_removed: ?u32 = null; @@ -962,7 +965,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void { const items = try generateRandomSlice(gpa, rng, queue_size); - var queue = PDQ.fromOwnedSlice(items, {}); + var queue: MinHeap = .fromOwnedSlice(items, {}); defer queue.deinit(gpa); var last_removed: ?u32 = null; @@ -992,7 +995,7 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void { const items = try generateRandomSlice(gpa, rng, queue_size); - var queue = PDQ.fromOwnedSlice(items, {}); + var queue: MinHeap = .fromOwnedSlice(items, {}); defer queue.deinit(gpa); var last_min: ?u32 = null; @@ -1032,14 +1035,14 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order { return std.math.order(context[a], context[b]); } -const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison); +const MinHeapWithContext = PriorityDequeue(usize, []const u32, contextLessThanComparison); test "push and pop" { const gpa = std.testing.allocator; const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 }; - var queue: CPDQ = .initContext(context[0..]); + var queue: MinHeapWithContext = .initContext(context[0..]); defer queue.deinit(gpa); try queue.push(gpa, 0); -- 2.54.0