Fix bugs

Author: habedi

src/ordered/btree_map.zig

@@ -77,14 +77,28 @@ pub fn BTreeMap(
             return null;
         }
 
-        /// Inserts a key-value pair. If the key exists, the value is updated.
-        pub fn put(self: *Self, key: K, value: V) !void {
-            // Check if key exists and just update the value in place
-            if (self.get(key) != null) {
-                _ = self.remove(key);
-                // Don't increment len here, it will be incremented below
+        /// Retrieves a mutable pointer to the value associated with `key`.
+        pub fn getPtr(self: *Self, key: K) ?*V {
+            var current = self.root;
+            while (current) |node| {
+                const res = std.sort.binarySearch(K, node.keys[0..node.len], key, compareFn);
+                if (res) |index| return &node.values[index];
+
+                if (node.is_leaf) return null;
+
+                const insertion_point = std.sort.lowerBound(K, node.keys[0..node.len], key, compareFn);
+                current = node.children[insertion_point];
             }
+            return null;
+        }
+
+        /// Returns true if the map contains the given key.
+        pub fn contains(self: *const Self, key: K) bool {
+            return self.get(key) != null;
+        }
 
+        /// Inserts a key-value pair. If the key exists, the value is updated.
+        pub fn put(self: *Self, key: K, value: V) !void {
             var root_node = if (self.root) |r| r else {
                 const new_node = try self.createNode();
                 new_node.keys[0] = key;
@@ -104,8 +118,10 @@ pub fn BTreeMap(
                 root_node = new_root;
             }
 
-            self.insertNonFull(root_node, key, value);
-            self.len += 1;
+            const is_new = self.insertNonFull(root_node, key, value);
+            if (is_new) {
+                self.len += 1;
+            }
         }
 
         fn splitChild(self: *Self, parent: *Node, index: u16) void {
@@ -153,25 +169,47 @@ pub fn BTreeMap(
             parent.len += 1;
         }
 
-        fn insertNonFull(self: *Self, node: *Node, key: K, value: V) void {
+        fn insertNonFull(self: *Self, node: *Node, key: K, value: V) bool {
             var i = node.len;
             if (node.is_leaf) {
+                // Check if key already exists
+                var j: u16 = 0;
+                while (j < node.len) : (j += 1) {
+                    if (compare(key, node.keys[j]) == .eq) {
+                        // Update existing value
+                        node.values[j] = value;
+                        return false; // Not a new insertion
+                    }
+                }
+
+                // Insert new key
                 while (i > 0 and compare(key, node.keys[i - 1]) == .lt) : (i -= 1) {
                     node.keys[i] = node.keys[i - 1];
                     node.values[i] = node.values[i - 1];
                 }
                 node.keys[i] = key;
                 node.values[i] = value;
                 node.len += 1;
+                return true; // New insertion
             } else {
+                // Check if key exists in current node
+                var j: u16 = 0;
+                while (j < node.len) : (j += 1) {
+                    if (compare(key, node.keys[j]) == .eq) {
+                        // Update existing value
+                        node.values[j] = value;
+                        return false; // Not a new insertion
+                    }
+                }
+
                 while (i > 0 and compare(key, node.keys[i - 1]) == .lt) : (i -= 1) {}
                 if (node.children[i].?.len == BRANCHING_FACTOR - 1) {
                     self.splitChild(node, i);
                     if (compare(node.keys[i], key) == .lt) {
                         i += 1;
                     }
                 }
-                self.insertNonFull(node.children[i].?, key, value);
+                return self.insertNonFull(node.children[i].?, key, value);
             }
         }
 
@@ -227,18 +265,23 @@ pub fn BTreeMap(
                 const pred = self.getPredecessor(node, index);
                 node.keys[index] = pred.key;
                 node.values[index] = pred.value;
+                // deleteFromNode already decremented self.len, so increment it back
+                // because we're replacing, not actually removing
+                const old_len = self.len;
                 _ = self.deleteFromNode(node.children[index].?, pred.key);
-                self.len += 1;
+                self.len = old_len;
             } else if (node.children[index + 1].?.len > MIN_KEYS) {
                 const succ = self.getSuccessor(node, index);
                 node.keys[index] = succ.key;
                 node.values[index] = succ.value;
+                const old_len = self.len;
                 _ = self.deleteFromNode(node.children[index + 1].?, succ.key);
-                self.len += 1;
+                self.len = old_len;
             } else {
                 self.merge(node, index);
+                const old_len = self.len;
                 _ = self.deleteFromNode(node.children[index].?, key);
-                self.len += 1;
+                self.len = old_len;
             }
         }
 

src/ordered/cartesian_tree.zig

@@ -220,36 +220,36 @@ pub fn CartesianTree(comptime K: type, comptime V: type) type {
             stack: std.ArrayList(*Node),
             allocator: Allocator,
 
-            pub fn init(allocator: Allocator, root: ?*Node) Iterator {
+            pub fn init(allocator: Allocator, root: ?*Node) !Iterator {
                 var it = Iterator{
-                    .stack = .{},
+                    .stack = std.ArrayList(*Node){},
                     .allocator = allocator,
                 };
-                it.pushLeft(root);
+                try it.pushLeft(root);
                 return it;
             }
 
             pub fn deinit(self: *Iterator) void {
                 self.stack.deinit(self.allocator);
             }
 
-            fn pushLeft(self: *Iterator, node: ?*Node) void {
+            fn pushLeft(self: *Iterator, node: ?*Node) !void {
                 var current = node;
                 while (current) |n| {
-                    self.stack.append(self.allocator, n) catch return; // Handle potential allocation failure
+                    try self.stack.append(self.allocator, n);
                     current = n.left;
                 }
             }
 
             // src/cartesian_tree.zig
 
-            pub fn next(self: *Iterator) ?struct { key: K, value: V } {
+            pub fn next(self: *Iterator) !?struct { key: K, value: V } {
                 // self.stack.pop() returns `?*Node`.
                 // The `if` statement correctly handles the optional, unwrapping it into `node`.
                 if (self.stack.pop()) |node| {
                     // 'node' is now a valid `*Node` pointer.
                     if (node.right) |right_node| {
-                        self.pushLeft(right_node);
+                        try self.pushLeft(right_node);
                     }
                     return .{ .key = node.key, .value = node.value };
                 } else {
@@ -259,7 +259,7 @@ pub fn CartesianTree(comptime K: type, comptime V: type) type {
         };
 
         /// Create iterator for in-order traversal
-        pub fn iterator(self: *const Self, allocator: Allocator) Iterator {
+        pub fn iterator(self: *const Self, allocator: Allocator) !Iterator {
             return Iterator.init(allocator, self.root);
         }
     };
@@ -424,14 +424,14 @@ test "CartesianTree: iterator traversal" {
     try tree.putWithPriority(20, 20, 20);
     try tree.putWithPriority(5, 5, 5);
 
-    var iter = tree.iterator(testing.allocator);
+    var iter = try tree.iterator(testing.allocator);
     defer iter.deinit();
 
     // Should iterate in sorted key order (BST property)
     const expected = [_]i32{ 5, 10, 20, 30 };
     var idx: usize = 0;
 
-    while (iter.next()) |entry| : (idx += 1) {
+    while (try iter.next()) |entry| : (idx += 1) {
         try testing.expectEqual(expected[idx], entry.key);
     }
     try testing.expectEqual(@as(usize, 4), idx);

src/ordered/sorted_set.zig

@@ -16,7 +16,7 @@ pub fn SortedSet(
 
         pub fn init(allocator: std.mem.Allocator) Self {
             return .{
-                .items = .{},
+                .items = std.ArrayList(T){},
                 .allocator = allocator,
             };
         }
@@ -29,10 +29,16 @@ pub fn SortedSet(
             return compare(key, item);
         }
 
-        /// Adds a value to the vector, maintaining sort order.
-        pub fn add(self: *Self, value: T) !void {
+        /// Adds a value to the set, maintaining sort order.
+        /// Returns true if the value was added, false if it already existed.
+        pub fn add(self: *Self, value: T) !bool {
             const index = std.sort.lowerBound(T, self.items.items, value, compareFn);
+            // Check if value already exists
+            if (index < self.items.items.len and compare(self.items.items[index], value) == .eq) {
+                return false;
+            }
             try self.items.insert(self.allocator, index, value);
+            return true;
         }
 
         /// Removes an element at a given index.
@@ -61,9 +67,9 @@ test "SortedSet basic functionality" {
     var vec = SortedSet(i32, i32Compare).init(allocator);
     defer vec.deinit();
 
-    try vec.add(100);
-    try vec.add(50);
-    try vec.add(75);
+    _ = try vec.add(100);
+    _ = try vec.add(50);
+    _ = try vec.add(75);
 
     try std.testing.expectEqualSlices(i32, &.{ 50, 75, 100 }, vec.items.items);
     try std.testing.expect(vec.contains(75));
@@ -89,7 +95,7 @@ test "SortedSet: single element" {
     var vec = SortedSet(i32, i32Compare).init(allocator);
     defer vec.deinit();
 
-    try vec.add(42);
+    _ = try vec.add(42);
     try std.testing.expect(vec.contains(42));
     try std.testing.expectEqual(@as(usize, 1), vec.items.items.len);
 
@@ -98,28 +104,31 @@ test "SortedSet: single element" {
     try std.testing.expectEqual(@as(usize, 0), vec.items.items.len);
 }
 
-test "SortedSet: duplicate values" {
+test "SortedSet: duplicate values rejected" {
     const allocator = std.testing.allocator;
     var vec = SortedSet(i32, i32Compare).init(allocator);
     defer vec.deinit();
 
-    try vec.add(10);
-    try vec.add(10);
-    try vec.add(10);
+    const added1 = try vec.add(10);
+    const added2 = try vec.add(10);
+    const added3 = try vec.add(10);
 
-    // Duplicates are allowed in this implementation
-    try std.testing.expectEqual(@as(usize, 3), vec.items.items.len);
+    // Duplicates should be rejected in a proper Set
+    try std.testing.expect(added1);
+    try std.testing.expect(!added2);
+    try std.testing.expect(!added3);
+    try std.testing.expectEqual(@as(usize, 1), vec.items.items.len);
 }
 
 test "SortedSet: negative numbers" {
     const allocator = std.testing.allocator;
     var vec = SortedSet(i32, i32Compare).init(allocator);
     defer vec.deinit();
 
-    try vec.add(-5);
-    try vec.add(-10);
-    try vec.add(0);
-    try vec.add(5);
+    _ = try vec.add(-5);
+    _ = try vec.add(-10);
+    _ = try vec.add(0);
+    _ = try vec.add(5);
 
     try std.testing.expectEqualSlices(i32, &.{ -10, -5, 0, 5 }, vec.items.items);
 }
@@ -132,7 +141,7 @@ test "SortedSet: large dataset" {
     // Insert in reverse order
     var i: i32 = 100;
     while (i >= 0) : (i -= 1) {
-        try vec.add(i);
+        _ = try vec.add(i);
     }
 
     // Verify sorted
@@ -147,11 +156,11 @@ test "SortedSet: remove boundary cases" {
     var vec = SortedSet(i32, i32Compare).init(allocator);
     defer vec.deinit();
 
-    try vec.add(1);
-    try vec.add(2);
-    try vec.add(3);
-    try vec.add(4);
-    try vec.add(5);
+    _ = try vec.add(1);
+    _ = try vec.add(2);
+    _ = try vec.add(3);
+    _ = try vec.add(4);
+    _ = try vec.add(5);
 
     // Remove first
     _ = vec.remove(0);