Comparison between Fenwick Tree vs Segment Tree – with Similarities and Differences
Last Updated :
15 Sep, 2023
Fenwick Tree (Binary Indexed Tree) and Segment Tree are both data structures used for efficient range query and update operations on an array. Here’s a tabular comparison of these two data structures.
Similarities between the Fenwick tree and Segment tree
Here are some of the areas where Fenwick Tree is similar to Segment Tree:
- Array type: Both Fenwick Tree and Segment Tree are based on 1D arrays.
- Construction time: Both structures require O(N * log(N)) time to construct.
- Query time (range sum): Both structures offer O(log(N)) time complexity for range sum queries.
- Update time (point): Both structures support point updates in O(log(N)) time.
Let us see these in the form of a table.
1D array |
1D array |
O(N*log(N)) |
O(N*log(N)) |
O(log(N)) |
O(log(N)) |
O(log(N)) |
O(log(N)) |
Difference between Fenwick tree and Segment tree
Now let us look into the areas where Fenwick tree is different from Segment Tree:
- Purpose: Fenwick Tree is primarily used for efficient prefix sum queries and point updates, while Segment Tree is more versatile and can be used for a wide range of range query and update operations.
- Space complexity: Fenwick Tree has a space complexity of O(N), whereas Segment Tree typically requires O(4*N) space.
- Update time (range): Segment Tree efficiently supports range updates with O(log(N) + K) time complexity, where K is the size of the range.
- Query range type: Fenwick Tree is primarily used for prefix sum queries, whereas Segment Tree can handle arbitrary range queries.
- Range updates: Segment Tree supports efficient range updates, while Fenwick Tree does not.
- Lazy propagation: Segment Tree supports lazy propagation for efficient range updates, which Fenwick Tree does not require.
- Additional operations: Segment Trees can be customized for various operations beyond simple range queries and updates, whereas Fenwick Trees are typically used for prefix sum calculations.
- Memory-efficient: Fenwick Trees are more memory-efficient than Segment Trees.
Let us see these in the form of table:
Primarily used for efficient range queries (sums) and point updates. |
Primarily used for efficient range queries and updates. |
O(N) |
O(4*N) |
Not efficient |
O(log(N) + K) |
Prefix sum queries |
Arbitrary range |
Not efficient |
Supported |
Not applicable |
Supported |
Not common |
Customizable |
Yes |
No |
Conclusion:
In summary, Fenwick Trees are more memory-efficient and are suitable for prefix sum queries with point updates, while Segment Trees are more versatile and support a wider range of operations, including efficient range updates and custom operations. The choice between them depends on the specific requirements of your application.
Share your thoughts in the comments
Please Login to comment...