Lazy Segment tree in CPP

cpp/binary tree/Fenwick_Tree.cpp

@@ -0,0 +1,89 @@
+// C++ code to demonstrate operations of Fenwick Tree
+#include <iostream> 
+
+using namespace std; 
+
+/*		 n --> No. of elements present in input array. 
+	BITree[0..n] --> Array that represents Binary Indexed Tree. 
+	arr[0..n-1] --> Input array for which prefix sum is evaluated. */
+
+// Returns sum of arr[0..index]. This function assumes 
+// that the array is preprocessed and partial sums of 
+// array elements are stored in BITree[]. 
+int getSum(int BITree[], int index) 
+{ 
+	int sum = 0; // Iniialize result 
+
+	// index in BITree[] is 1 more than the index in arr[] 
+	index = index + 1; 
+
+	// Traverse ancestors of BITree[index] 
+	while (index>0) 
+	{ 
+		// Add current element of BITree to sum 
+		sum += BITree[index]; 
+
+		// Move index to parent node in getSum View 
+		index -= index & (-index); 
+	} 
+	return sum; 
+} 
+
+// Updates a node in Binary Index Tree (BITree) at given index 
+// in BITree. The given value 'val' is added to BITree[i] and 
+// all of its ancestors in tree. 
+void updateBIT(int BITree[], int n, int index, int val) 
+{ 
+	// index in BITree[] is 1 more than the index in arr[] 
+	index = index + 1; 
+
+	// Traverse all ancestors and add 'val' 
+	while (index <= n) 
+	{ 
+	// Add 'val' to current node of BI Tree 
+	BITree[index] += val; 
+
+	// Update index to that of parent in update View 
+	index += index & (-index); 
+	} 
+} 
+
+// Constructs and returns a Binary Indexed Tree for given 
+// array of size n. 
+int *constructBITree(int arr[], int n) 
+{ 
+	// Create and initialize BITree[] as 0 
+	int *BITree = new int[n+1]; 
+	for (int i=1; i<=n; i++) 
+		BITree[i] = 0; 
+
+	// Store the actual values in BITree[] using update() 
+	for (int i=0; i<n; i++) 
+		updateBIT(BITree, n, i, arr[i]); 
+
+	// Uncomment below lines to see contents of BITree[] 
+	//for (int i=1; i<=n; i++) 
+	//	 cout << BITree[i] << " "; 
+
+	return BITree; 
+} 
+
+
+// Driver program to test above functions 
+int main() 
+{ 
+	int freq[] = {2, 1, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9}; 
+	int n = sizeof(freq)/sizeof(freq[0]); 
+	int *BITree = constructBITree(freq, n); 
+	cout << "Sum of elements in arr[0..5] is "
+		<< getSum(BITree, 5); 
+
+	// Let use test the update operation 
+	freq[3] += 6; 
+	updateBIT(BITree, n, 3, 6); //Update BIT for above change in arr[] 
+
+	cout << "\nSum of elements in arr[0..5] after update is "
+		<< getSum(BITree, 5); 
+
+	return 0; 
+} 

cpp/binary tree/Non_recursive_tree.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// limit for array size 
+const int N = 100000; 
+
+int n; // array size 
+
+// Max size of tree 
+int tree[2 * N]; 
+
+// function to build the tree 
+void build( int arr[]) 
+{ 
+	// insert leaf nodes in tree 
+	for (int i=0; i<n; i++)	 
+		tree[n+i] = arr[i]; 
+
+	// build the tree by calculating parents 
+	for (int i = n - 1; i > 0; --i)	 
+		tree[i] = tree[i<<1] + tree[i<<1 | 1];	 
+} 
+
+// function to update a tree node 
+void updateTreeNode(int p, int value) 
+{ 
+	// set value at position p 
+	tree[p+n] = value; 
+	p = p+n; 
+
+	// move upward and update parents 
+	for (int i=p; i > 1; i >>= 1) 
+		tree[i>>1] = tree[i] + tree[i^1]; 
+} 
+
+// function to get sum on interval [l, r) 
+int query(int l, int r) 
+{ 
+	int res = 0; 
+
+	// loop to find the sum in the range 
+	for (l += n, r += n; l < r; l >>= 1, r >>= 1) 
+	{ 
+		if (l&1) 
+			res += tree[l++]; 
+
+		if (r&1) 
+			res += tree[--r]; 
+	} 
+
+	return res; 
+} 
+
+// driver program to test the above function 
+int main() 
+{ 
+	int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; 
+
+	// n is global 
+	n = sizeof(a)/sizeof(a[0]); 
+
+	// build tree 
+	build(a); 
+
+	// print the sum in range(1,2) index-based 
+	cout << query(1, 3)<<endl; 
+
+	// modify element at 2nd index 
+	updateTreeNode(2, 1); 
+
+	// print the sum in range(1,2) index-based 
+	cout << query(1, 3)<<endl; 
+
+	return 0; 
+} 

cpp/binary tree/lazy_segment.cpp

@@ -0,0 +1,218 @@
+// Program to show segment tree to demonstrate lazy segment tree
+#include <stdio.h> 
+#include <math.h> 
+#define MAX 1000 
+
+
+// constant-sized arrays, we have done it here for simplicity. 
+int tree[MAX] = {0}; // To store segment tree 
+int lazy[MAX] = {0}; // To store pending updates 
+
+/* si -> index of current node in segment tree 
+	ss and se -> Starting and ending indexes of elements for 
+				which current nodes stores sum. 
+	us and ue -> starting and ending indexes of update query 
+	diff -> which we need to add in the range us to ue */
+void updateRangeUtil(int si, int ss, int se, int us, 
+					int ue, int diff) 
+{ 
+
+	if (lazy[si] != 0) 
+	{ 
+		// Make pending updates using value stored in lazy 
+		// nodes 
+		tree[si] += (se-ss+1)*lazy[si]; 
+
+		// checking if it is not leaf node because if 
+		// it is leaf node then we cannot go further 
+		if (ss != se) 
+		{ 
+			// We can postpone updating children we don't 
+			// need their new values now. 
+			// Since we are not yet updating children of si, 
+			// we need to set lazy flags for the children 
+			lazy[si*2 + 1] += lazy[si]; 
+			lazy[si*2 + 2] += lazy[si]; 
+		} 
+
+		// Set the lazy value for current node as 0 as it 
+		// has been updated 
+		lazy[si] = 0; 
+	} 
+
+	// out of range 
+	if (ss>se || ss>ue || se<us) 
+		return ; 
+
+	// Current segment is fully in range 
+	if (ss>=us && se<=ue) 
+	{ 
+		// Add the difference to current node 
+		tree[si] += (se-ss+1)*diff; 
+
+		// same logic for checking leaf node or not 
+		if (ss != se) 
+		{ 
+			// This is where we store values in lazy nodes, 
+			// rather than updating the segment tree itelf 
+			// Since we don't need these updated values now 
+			// we postpone updates by storing values in lazy[] 
+			lazy[si*2 + 1] += diff; 
+			lazy[si*2 + 2] += diff; 
+		} 
+		return; 
+	} 
+
+	// If not completely in rang, but overlaps, recur for 
+	// children, 
+	int mid = (ss+se)/2; 
+	updateRangeUtil(si*2+1, ss, mid, us, ue, diff); 
+	updateRangeUtil(si*2+2, mid+1, se, us, ue, diff); 
+
+	// And use the result of children calls to update this 
+	// node 
+	tree[si] = tree[si*2+1] + tree[si*2+2]; 
+} 
+
+// Function to update a range of values in segment 
+// tree 
+/* us and eu -> starting and ending indexes of update query 
+	ue -> ending index of update query 
+	diff -> which we need to add in the range us to ue */
+void updateRange(int n, int us, int ue, int diff) 
+{ 
+updateRangeUtil(0, 0, n-1, us, ue, diff); 
+} 
+
+
+/* A recursive function to get the sum of values in given 
+	range of the array. The following are parameters for 
+	this function. 
+	si --> Index of current node in the segment tree. 
+		Initially 0 is passed as root is always at' 
+		index 0 
+	ss & se --> Starting and ending indexes of the 
+				segment represented by current node, 
+				i.e., tree[si] 
+	qs & qe --> Starting and ending indexes of query 
+				range */
+int getSumUtil(int ss, int se, int qs, int qe, int si) 
+{ 
+	// If lazy flag is set for current node of segment tree, 
+	// then there are some pending updates. So we need to 
+	// make sure that the pending updates are done before 
+	// processing the sub sum query 
+	if (lazy[si] != 0) 
+	{ 
+		// Make pending updates to this node. Note that this 
+		// node represents sum of elements in arr[ss..se] and 
+		// all these elements must be increased by lazy[si] 
+		tree[si] += (se-ss+1)*lazy[si]; 
+
+		// checking if it is not leaf node because if 
+		// it is leaf node then we cannot go further 
+		if (ss != se) 
+		{ 
+			// Since we are not yet updating children os si, 
+			// we need to set lazy values for the children 
+			lazy[si*2+1] += lazy[si]; 
+			lazy[si*2+2] += lazy[si]; 
+		} 
+
+		// unset the lazy value for current node as it has 
+		// been updated 
+		lazy[si] = 0; 
+	} 
+
+	// Out of range 
+	if (ss>se || ss>qe || se<qs) 
+		return 0; 
+
+	// At this point we are sure that pending lazy updates 
+	// are done for current node. So we can return value 
+	// (same as it was for query in our previous post) 
+
+	// If this segment lies in range 
+	if (ss>=qs && se<=qe) 
+		return tree[si]; 
+
+	// If a part of this segment overlaps with the given 
+	// range 
+	int mid = (ss + se)/2; 
+	return getSumUtil(ss, mid, qs, qe, 2*si+1) + 
+		getSumUtil(mid+1, se, qs, qe, 2*si+2); 
+} 
+
+// Return sum of elements in range from index qs (query 
+// start) to qe (query end). It mainly uses getSumUtil() 
+int getSum(int n, int qs, int qe) 
+{ 
+	// Check for erroneous input values 
+	if (qs < 0 || qe > n-1 || qs > qe) 
+	{ 
+		printf("Invalid Input"); 
+		return -1; 
+	} 
+
+	return getSumUtil(0, n-1, qs, qe, 0); 
+} 
+
+// A recursive function that constructs Segment Tree for 
+// array[ss..se]. si is index of current node in segment 
+// tree st. 
+void constructSTUtil(int arr[], int ss, int se, int si) 
+{ 
+	// out of range as ss can never be greater than se 
+	if (ss > se) 
+		return ; 
+
+	// If there is one element in array, store it in 
+	// current node of segment tree and return 
+	if (ss == se) 
+	{ 
+		tree[si] = arr[ss]; 
+		return; 
+	} 
+
+	// If there are more than one elements, then recur 
+	// for left and right subtrees and store the sum 
+	// of values in this node 
+	int mid = (ss + se)/2; 
+	constructSTUtil(arr, ss, mid, si*2+1); 
+	constructSTUtil(arr, mid+1, se, si*2+2); 
+
+	tree[si] = tree[si*2 + 1] + tree[si*2 + 2]; 
+} 
+
+/* Function to construct segment tree from given array. 
+This function allocates memory for segment tree and 
+calls constructSTUtil() to fill the allocated memory */
+void constructST(int arr[], int n) 
+{ 
+	// Fill the allocated memory st 
+	constructSTUtil(arr, 0, n-1, 0); 
+} 
+
+
+// Driver program to test above functions 
+int main() 
+{ 
+	int arr[] = {1, 3, 5, 7, 9, 11}; 
+	int n = sizeof(arr)/sizeof(arr[0]); 
+
+	// Build segment tree from given array 
+	constructST(arr, n); 
+
+	// Print sum of values in array from index 1 to 3 
+	printf("Sum of values in given range = %d\n", 
+		getSum(n, 1, 3)); 
+
+	// Add 10 to all nodes at indexes from 1 to 5. 
+	updateRange(n, 1, 5, 10); 
+
+	// Find sum after the value is updated 
+	printf("Updated sum of values in given range = %d\n", 
+			getSum( n, 1, 3)); 
+
+	return 0; 
+}