Segment Tree

1. PRESENTED BY: MUZAMIL AMIN
Computer Science and Engineering
M.Tech CSE (ist sem)
Subject: Algorithms and Algorithmic complexity
topic: Segment tree

2. Segment tree
 Segment Tree is a basically a binary tree used for storing
the intervals or segments. Each node in the Segment Tree
represents an interval. Consider an array A of size N and
a corresponding Segment Tree T:
 The root of T will represent the whole array A[0:N−1].
 Each leaf in the Segment Tree T will represent a single
element A[i] such that 0≤i<N.
 The internal nodes in the Segment Tree T represents the
union of elementary intervals A[i:j] where 0≤i<j<N.

3. Continue
 The root of the Segment Tree represents the whole
array A[0:N−1]. Then it is broken down into two half intervals
or segments and the two children of the root in turn represent
the A[0:(N−1)/2] and A[(N−1)/2+1:(N−1)]. So in each step,
the segment is divided into half and the two children represent
those two halves. So the height of the segment tree will
be log2N. There are N leaves representing the N elements of
the array. The number of internal nodes is N−1. So, a total
number of nodes are 2×N−1.
 Once the Segment Tree is built, its structure cannot be
changed. We can update the values of nodes but we cannot
change its structure. Segment tree provides two operations:

4. Continue
 Update: To update the element of the array A and
reflect the corresponding change in the Segment
tree.
 Query: In this operation we can query on an
interval or segment and return the answer to the
problem (say minimum/maximum/summation in
the particular segment).

5. Segment Tree
 Construction.
 Implementation.
 Update.
 Range Sum Query.

6. overview
1 2 3 4 5
inde
x
0 1 2 3 4
Sum(2,4) = 12
Sum(1,3) = 9
Sum(0,4) = 15
1) Bruteforce
Time = O(N.Q)
2) Efficient
Time = O(1)
Time = O(Q)
Sum(L,R) = Sum(L-1) - Sum(R)
1 3 6 10 15

7. Comparison
Range sum for Q
queries
update time
Bruteforce O(N.Q) O(1)
Efficient O(Q) O(N)

8. Construction (Segment Tree)

9. Full Binary Tree: Internal nodes have 0 or 2 children & all level till 2nd last level is
completely filled
Continue

10. Implementation
 Implementation using array
 If current node = I
then LC = 2*i+1
RC = 2*i+2
p = [(i-1)/2]

11. Code for construction
int const( st, si,arr,l,r)
{
if(l==r) // leaf node
{
st[si] = arr[l];
return arr[L];
}
mid = (l+r)/2;
st[si] =const(st,2*si+1,arr,l,mid)+ const(st,2*si+2,arr,mid+1,r);
return st[si];
}

12. Find Range Sum
1 2 5 6 7 9
Getsum(0,0,5,2,4)

13. Continue

14. Code getsum
int getsum(si,sl,sr,l,r)
{
if (l<= sl && r>= sr) //case1: Total overlap
return st[si];
if (sr < l || sl > r) //case2: no overlap
return 0;
mid =(sl+sr)/2; //case 3:partial overlap
return getsum(st,2*si+1,arr,l,mid)+ getsum(st,2*si+2,arr,mid+1,r)
}

15. Update
 Update org. array
 Update seg. Tree array
1 2 5 6 7 9

16. Code for update
void update(si,sl,sr,pos,diff)
{
if (sl>pos || se<pos)
return;
s[si] +=diff;
if (sl!=sr)
{
mid = (sl+sr)/2;
update(2*si+1,sl,mid,pos,diff);
update(2*si+2,mid+1,pos,diff);
}
}

17. Time
 Construction = O(n)
 Query =O(log n)
 Update = O(log n)
 Note: segment tree is useful only if updates
are frequent. Otherwise use array