- detailed extensive tests with breakdown on number of elements

README.md

@@ -1142,7 +1142,7 @@ Thread safety is not a concern of this project, this should be handled at a high
 
 ### Testing and Benchmarking
 
-`go test -v -bench . -benchmem  -benchtime 1s ./...`
+`go test -run=NO_TEST -bench . -benchmem  -benchtime 5s ./...`
 
 ### Contributing
 

lists/arraylist/arraylist_test.go

@@ -426,14 +426,155 @@ func TestListIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkList(b *testing.B) {
+func benchmarkGet(b *testing.B, list *List, size int) {
 	for i := 0; i < b.N; i++ {
-		list := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			list.Get(n)
-			list.Add(i)
 		}
-		for !list.Empty() {
+	}
-			list.Remove(0)
+}
+
+func benchmarkAdd(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Add(n)
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Remove(n)
 		}
 	}
 }
+
+func BenchmarkArrayListGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkArrayListGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkArrayListGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkArrayListGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkArrayListAdd100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkArrayListAdd1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkArrayListAdd10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkArrayListAdd100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkArrayListRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkArrayListRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkArrayListRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkArrayListRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}

lists/doublylinkedlist/doublylinkedlist_test.go

@@ -426,14 +426,155 @@ func TestListIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkList(b *testing.B) {
+func benchmarkGet(b *testing.B, list *List, size int) {
 	for i := 0; i < b.N; i++ {
-		list := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			list.Get(n)
-			list.Add(i)
 		}
-		for !list.Empty() {
+	}
-			list.Remove(0)
+}
+
+func benchmarkAdd(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Add(n)
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Remove(n)
 		}
 	}
 }
+
+func BenchmarkDoublyLinkedListGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListAdd100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListAdd1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListAdd10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListAdd100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkDoublyLinkedListRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}

lists/singlylinkedlist/singlylinkedlist_test.go

@@ -345,14 +345,155 @@ func TestListIteratorFirst(t *testing.T) {
 	}
 }
 
-func BenchmarkList(b *testing.B) {
+func benchmarkGet(b *testing.B, list *List, size int) {
 	for i := 0; i < b.N; i++ {
-		list := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			list.Get(n)
-			list.Add(i)
 		}
-		for !list.Empty() {
+	}
-			list.Remove(0)
+}
+
+func benchmarkAdd(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Add(n)
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, list *List, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			list.Remove(n)
 		}
 	}
 }
+
+func BenchmarkSinglyLinkedListGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListAdd100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListAdd1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListAdd10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListAdd100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}
+
+func BenchmarkSinglyLinkedListRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	list := New()
+	for n := 0; n < size; n++ {
+		list.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, list, size)
+}

maps/hashbidimap/hashbidimap_test.go

@@ -169,14 +169,155 @@ func sameElements(a []interface{}, b []interface{}) bool {
 	return true
 }
 
-func BenchmarkMap(b *testing.B) {
+func benchmarkGet(b *testing.B, m *Map, size int) {
 	for i := 0; i < b.N; i++ {
-		m := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			m.Get(n)
+		}
+	}
+}
+
+func benchmarkPut(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkRemove(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Remove(n)
 		}
 	}
 }
+
+func BenchmarkHashBidiMapGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashBidiMapGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashBidiMapGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashBidiMapGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashBidiMapPut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashBidiMapPut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashBidiMapPut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashBidiMapPut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashBidiMapRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashBidiMapRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashBidiMapRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashBidiMapRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}

maps/hashmap/hashmap_test.go

@@ -137,14 +137,155 @@ func sameElements(a []interface{}, b []interface{}) bool {
 	return true
 }
 
-func BenchmarkMap(b *testing.B) {
+func benchmarkGet(b *testing.B, m *Map, size int) {
 	for i := 0; i < b.N; i++ {
-		m := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			m.Get(n)
-			m.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkPut(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			m.Put(n, struct{}{})
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Remove(n)
 		}
 	}
 }
+
+func BenchmarkHashMapGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashMapGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashMapGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashMapGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkHashMapPut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashMapPut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashMapPut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashMapPut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkHashMapRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashMapRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashMapRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkHashMapRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := New()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}

maps/treebidimap/treebidimap_test.go

@@ -473,14 +473,155 @@ func TestMapIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkMap(b *testing.B) {
+func benchmarkGet(b *testing.B, m *Map, size int) {
 	for i := 0; i < b.N; i++ {
-		m := NewWithIntComparators()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			m.Get(n)
+		}
+	}
+}
+
+func benchmarkPut(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkRemove(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Remove(n)
 		}
 	}
 }
+
+func BenchmarkTreeBidiMapGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeBidiMapGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeBidiMapGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeBidiMapGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeBidiMapPut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparators()
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeBidiMapPut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeBidiMapPut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeBidiMapPut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeBidiMapRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeBidiMapRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeBidiMapRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeBidiMapRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparators()
+	for n := 0; n < size; n++ {
+		m.Put(n, n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}

maps/treemap/treemap_test.go

@@ -440,14 +440,155 @@ func TestMapIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkMap(b *testing.B) {
+func benchmarkGet(b *testing.B, m *Map, size int) {
 	for i := 0; i < b.N; i++ {
-		m := NewWithIntComparator()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			m.Get(n)
-			m.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkPut(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			m.Put(n, struct{}{})
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, m *Map, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			m.Remove(n)
 		}
 	}
 }
+
+func BenchmarkTreeMapGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeMapGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeMapGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeMapGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, m, size)
+}
+
+func BenchmarkTreeMapPut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparator()
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeMapPut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeMapPut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeMapPut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, m, size)
+}
+
+func BenchmarkTreeMapRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeMapRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeMapRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}
+
+func BenchmarkTreeMapRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	m := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		m.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, m, size)
+}

sets/hashset/hashset_test.go

@@ -62,14 +62,155 @@ func TestSetRemove(t *testing.T) {
 	}
 }
 
-func BenchmarkSet(b *testing.B) {
+func benchmarkContains(b *testing.B, set *Set, size int) {
 	for i := 0; i < b.N; i++ {
-		set := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			set.Contains(n)
-			set.Add(i)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkAdd(b *testing.B, set *Set, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			set.Add(n)
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, set *Set, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			set.Remove(n)
 		}
 	}
 }
+
+func BenchmarkHashSetContains100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkHashSetContains1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkHashSetContains10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkHashSetContains100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkHashSetAdd100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := New()
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkHashSetAdd1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkHashSetAdd10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkHashSetAdd100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkHashSetRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkHashSetRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkHashSetRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkHashSetRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := New()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}

sets/treeset/treeset_test.go

@@ -327,14 +327,155 @@ func TestSetIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkSet(b *testing.B) {
+func benchmarkContains(b *testing.B, set *Set, size int) {
 	for i := 0; i < b.N; i++ {
-		set := NewWithIntComparator()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			set.Contains(n)
-			set.Add(i)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkAdd(b *testing.B, set *Set, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			set.Add(n)
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, set *Set, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			set.Remove(n)
 		}
 	}
 }
+
+func BenchmarkTreeSetContains100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkTreeSetContains1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkTreeSetContains10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkTreeSetContains100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkContains(b, set, size)
+}
+
+func BenchmarkTreeSetAdd100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := NewWithIntComparator()
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkTreeSetAdd1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkTreeSetAdd10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkTreeSetAdd100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkAdd(b, set, size)
+}
+
+func BenchmarkTreeSetRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkTreeSetRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkTreeSetRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}
+
+func BenchmarkTreeSetRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	set := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		set.Add(n)
+	}
+	b.StartTimer()
+	benchmarkRemove(b, set, size)
+}

stacks/arraystack/arraystack_test.go

@@ -231,14 +231,103 @@ func TestStackIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkStack(b *testing.B) {
+func benchmarkPush(b *testing.B, stack *Stack, size int) {
 	for i := 0; i < b.N; i++ {
-		stack := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			stack.Push(n)
-			stack.Push(i)
 		}
-		for !stack.Empty() {
+	}
+}
+
+func benchmarkPop(b *testing.B, stack *Stack, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			stack.Pop()
 		}
 	}
 }
+
+func BenchmarkArrayStackPop100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkArrayStackPop1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkArrayStackPop10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkArrayStackPop100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkArrayStackPush100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	stack := New()
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkArrayStackPush1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkArrayStackPush10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkArrayStackPush100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}

stacks/linkedliststack/linkedliststack_test.go

@@ -147,14 +147,103 @@ func TestStackIteratorFirst(t *testing.T) {
 	}
 }
 
-func BenchmarkStack(b *testing.B) {
+func benchmarkPush(b *testing.B, stack *Stack, size int) {
 	for i := 0; i < b.N; i++ {
-		stack := New()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			stack.Push(n)
-			stack.Push(i)
 		}
-		for !stack.Empty() {
+	}
+}
+
+func benchmarkPop(b *testing.B, stack *Stack, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			stack.Pop()
 		}
 	}
 }
+
+func BenchmarkLinkedListStackPop100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPop1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPop10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPop100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPush100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	stack := New()
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPush1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPush10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}
+
+func BenchmarkLinkedListStackPush100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	stack := New()
+	for n := 0; n < size; n++ {
+		stack.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, stack, size)
+}

trees/binaryheap/binaryheap_test.go

@@ -246,15 +246,103 @@ func TestBinaryHeapIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkBinaryHeap(b *testing.B) {
+func benchmarkPush(b *testing.B, heap *Heap, size int) {
 	for i := 0; i < b.N; i++ {
-		heap := NewWithIntComparator()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			heap.Push(n)
-			heap.Push(i)
 		}
-		for !heap.Empty() {
+	}
+}
+
+func benchmarkPop(b *testing.B, heap *Heap, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			heap.Pop()
 		}
 	}
+}
+
+func BenchmarkBinaryHeapPop100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPop1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPop10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPop100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPop(b, heap, size)
+}
 
+func BenchmarkBinaryHeapPush100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	heap := NewWithIntComparator()
+	b.StartTimer()
+	benchmarkPush(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPush1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPush10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, heap, size)
+}
+
+func BenchmarkBinaryHeapPush100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	heap := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		heap.Push(n)
+	}
+	b.StartTimer()
+	benchmarkPush(b, heap, size)
 }

trees/btree/btree.go

@@ -355,7 +355,6 @@ func (tree *Tree) splitNonRoot(node *Node) {
 	insertPosition, _ := tree.search(parent, node.Entries[middle].Key)
 
 	// Insert middle key into parent
-	// TODO check for memory leaks: node should be nilled and all its entries
 	parent.Entries = append(parent.Entries, nil)
 	copy(parent.Entries[insertPosition+1:], parent.Entries[insertPosition:])
 	parent.Entries[insertPosition] = node.Entries[middle]

trees/btree/btree_test.go

@@ -1074,14 +1074,155 @@ func assertValidTreeNode(t *testing.T, node *Node, expectedEntries int, expected
 	}
 }
 
-func BenchmarkBTree(b *testing.B) {
+func benchmarkGet(b *testing.B, tree *Tree, size int) {
 	for i := 0; i < b.N; i++ {
-		tree := NewWithIntComparator(32)
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			tree.Get(n)
-			tree.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkPut(b *testing.B, tree *Tree, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			tree.Put(n, struct{}{})
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, tree *Tree, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			tree.Remove(n)
 		}
 	}
 }
+
+func BenchmarkBTreeGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkBTreeGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkBTreeGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkBTreeGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkBTreePut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator(128)
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkBTreePut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkBTreePut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkBTreePut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkBTreeRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkBTreeRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkBTreeRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkBTreeRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator(128)
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}

trees/redblacktree/redblacktree_test.go

@@ -557,14 +557,155 @@ func TestRedBlackTreeIteratorLast(t *testing.T) {
 	}
 }
 
-func BenchmarkRedBlackTree(b *testing.B) {
+func benchmarkGet(b *testing.B, tree *Tree, size int) {
 	for i := 0; i < b.N; i++ {
-		tree := NewWithIntComparator()
+		for n := 0; n < size; n++ {
-		for n := 0; n < 1000; n++ {
+			tree.Get(n)
-			tree.Put(n, n)
 		}
-		for n := 0; n < 1000; n++ {
+	}
+}
+
+func benchmarkPut(b *testing.B, tree *Tree, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
+			tree.Put(n, struct{}{})
+		}
+	}
+}
+
+func benchmarkRemove(b *testing.B, tree *Tree, size int) {
+	for i := 0; i < b.N; i++ {
+		for n := 0; n < size; n++ {
 			tree.Remove(n)
 		}
 	}
 }
+
+func BenchmarkRedBlackTreeGet100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeGet1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeGet10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeGet100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkGet(b, tree, size)
+}
+
+func BenchmarkRedBlackTreePut100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator()
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkRedBlackTreePut1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkRedBlackTreePut10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkRedBlackTreePut100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkPut(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeRemove100(b *testing.B) {
+	b.StopTimer()
+	size := 100
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeRemove1000(b *testing.B) {
+	b.StopTimer()
+	size := 1000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeRemove10000(b *testing.B) {
+	b.StopTimer()
+	size := 10000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}
+
+func BenchmarkRedBlackTreeRemove100000(b *testing.B) {
+	b.StopTimer()
+	size := 100000
+	tree := NewWithIntComparator()
+	for n := 0; n < size; n++ {
+		tree.Put(n, struct{}{})
+	}
+	b.StartTimer()
+	benchmarkRemove(b, tree, size)
+}