Add tests for Fenwick tree + remove bug

jakobkogler · jakobkogler · commit fc63bb61aeb9 · 2020-02-28T15:43:26.000+01:00
diff --git a/src/data_structures/fenwick.md b/src/data_structures/fenwick.md
@@ -127,7 +127,7 @@ This is handled in the `sum(int l, int r)` method.
 Also this implementation supports two constructors.
 You can create a Fenwick tree initialized with zeros, or you can convert an existing array into the Fenwick form.
 
-```cpp
+```cpp fenwick_sum
 struct FenwickTree {
     vector<int> bit;  // binary indexed tree
     int n;
@@ -166,7 +166,7 @@ It is obvious that there is no easy way of finding minimum of range $[l; r]$ usi
 Additionally, each time a value is `update`'d, the new value has to be smaller than the current value (because the $min$ function is not reversible).
 These, of course, are significant limitations.
 
-```cpp
+```cpp fenwick_min
 struct FenwickTreeMin {
     vector<int> bit;
     int n;
@@ -266,7 +266,7 @@ As you can see, the main benefit of this approach is that the binary operations
 
 The following implementation can be used like the other implementations, however it uses one-based indexing internally.
 
-```cpp
+```cpp fenwick_sum_onebased
 struct FenwickTreeOneBasedIndexing {
     vector<int> bit;  // binary indexed tree
     int n;
@@ -278,7 +278,6 @@ struct FenwickTreeOneBasedIndexing {
 
     FenwickTreeOneBasedIndexing(vector<int> a)
         : FenwickTreeOneBasedIndexing(a.size()) {
-        init(a.size());
         for (size_t i = 0; i < a.size(); i++)
             add(i, a[i]);
     }
diff --git a/test/test_fenwick_tree.cpp b/test/test_fenwick_tree.cpp
@@ -0,0 +1,95 @@
+#include <cassert>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+namespace Fenwick_Sum {
+#include "fenwick_sum.h"
+}
+
+namespace Fenwick_Min {
+#include "fenwick_min.h"
+}
+
+namespace Fenwick_Sum_Onebased {
+#include "fenwick_sum_onebased.h"
+}
+
+
+void test_fenwick_sum() {
+    using namespace Fenwick_Sum;
+    vector<int> a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    int n = a.size();
+    FenwickTree tree(a);
+    for (int i = 0; i < n; i++) {
+        int expected_sum = 0;
+        for (int j = i; j < n; j++) {
+            expected_sum += a[j];
+            assert(expected_sum == tree.sum(i, j));
+        }
+    }
+    for (int k = 0; k < n; k++) {
+        tree.add(k, 100);
+        a[k] += 100;
+        for (int i = 0; i < n; i++) {
+            int expected_sum = 0;
+            for (int j = i; j < n; j++) {
+                expected_sum += a[j];
+                assert(expected_sum == tree.sum(i, j));
+            }
+        }
+    }
+}
+
+void test_fenwick_min() {
+    using namespace Fenwick_Min;
+    vector<int> a = {36, 22, 69, 86, 9, 30, 69, 91, 94, 64};
+    int n = a.size();
+    FenwickTreeMin tree(a);
+    int expected_min = std::numeric_limits<int>::max();
+    for (int j = 0; j < n; j++) {
+        expected_min = min(expected_min, a[j]);
+        assert(expected_min == tree.getmin(j));
+    }
+    vector<int> b = {10, 10, 9, 4, 4, 8, 0, 4, 9, 1};
+    for (int k = 0; k < n; k++) {
+        tree.update(k, b[k]);
+        a[k] = b[k];
+        int expected_min = std::numeric_limits<int>::max();
+        for (int j = 0; j < n; j++) {
+            expected_min = min(expected_min, a[j]);
+            assert(expected_min == tree.getmin(j));
+        }
+    }
+}
+
+void test_fenwick_sum_onebased() {
+    using namespace Fenwick_Sum_Onebased;
+    vector<int> a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    int n = a.size();
+    FenwickTreeOneBasedIndexing tree(a);
+    for (int i = 0; i < n; i++) {
+        int expected_sum = 0;
+        for (int j = i; j < n; j++) {
+            expected_sum += a[j];
+            assert(expected_sum == tree.sum(i, j));
+        }
+    }
+    for (int k = 0; k < n; k++) {
+        tree.add(k, 100);
+        a[k] += 100;
+        for (int i = 0; i < n; i++) {
+            int expected_sum = 0;
+            for (int j = i; j < n; j++) {
+                expected_sum += a[j];
+                assert(expected_sum == tree.sum(i, j));
+            }
+        }
+    }
+}
+
+int main() {
+    test_fenwick_sum();
+    test_fenwick_min();
+    test_fenwick_sum_onebased();
+}
diff --git a/test/test_segment_tree.cpp b/test/test_segment_tree.cpp
@@ -53,7 +53,7 @@ void test_section_implementation() {
             assert(expected_sum == sum(1, 0, n-1, i, j));
         }
     }
-    for (int k = 0; k < 0; k++) {
+    for (int k = 0; k < n; k++) {
         update(1, 0, n-1, k, 100);
         for (int i = 0; i < n; i++) {
             int expected_sum = 0;

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ void test_section_implementation() {`
`53`	`53`	`assert(expected_sum == sum(1, 0, n-1, i, j));`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`- for (int k = 0; k < 0; k++) {`
	`56`	`+ for (int k = 0; k < n; k++) {`
`57`	`57`	`update(1, 0, n-1, k, 100);`
`58`	`58`	`for (int i = 0; i < n; i++) {`
`59`	`59`	`int expected_sum = 0;`