Queries to calculate sum with alternating signs of array elements in a given range

// C++ program to evaluate the queries to calculate sum with alternating signs of array elements in a given range
#include <bits/stdc++.h>
using namespace std;


// Recursive function to construct Segment Tree for the subarray [start..end]
int recurBuildSegmentTree(int* segmentTree, int arr[], int start, int end, int si)
{

	// If there is one element in the subarray
	if (start == end) 
	{
		if(start % 2 == 0) {
		segmentTree[si] = arr[start];
	}
	else {
    	segmentTree[si] = -arr[start];
	}
		return arr[start];
	}


	// Else get the middle element then recursively call the function to create the left and right subtree
	int middle = start + (end - start)/2;


	// For left subtree
	int left = recurBuildSegmentTree(segmentTree, arr, start, middle, si * 2 + 1);

	// For right subtree
	int right = recurBuildSegmentTree(segmentTree, arr, middle + 1, end, si * 2 + 2);

	segmentTree[si] = segmentTree[si * 2 + 1] + segmentTree[si * 2 + 2];


	return segmentTree[si];
}


// Function for constructing a Segment Tree from a given array of integers
int* buildSegmentTree(int arr[], int n)
{

	// Calculate the height of the segment tree
	int x = (int)(ceil(log2(n)));


	// Calculate the maximum size of Segment Tree
	int max_size = 2 * (int)pow(2, x) - 1;


	// Allocating memory
	int* segmentTree = new int[max_size];


	// Call a recursive function to fill the allocated memory recursively
	recurBuildSegmentTree(segmentTree, arr, 0, n - 1, 0);


	// Return the constructed Segment Tree
	return segmentTree;
}


// Function to update element of a Segment Tree
void update(int* segmentTree, int index, int start, int end, int pos, int val)
{

	// If current node is a leaf node
	if (start == end) {

		// If current index is even
		if (start % 2 == 0) {
		
		// Update segmentTree[index]
		segmentTree[index] = val;
	    }
		else {
		
		// Update segmentTree[index]
		segmentTree[index] = -val;
		}
		return;
	}


	// Divide the segment tree elements into left and right subtree
	int mid = start + (end - start) / 2;


	// If element lies in left subtree
	if (mid >= pos) {
		update(segmentTree, 2 * index + 1, start, mid, pos, val);
	}

	// Else If element lies in right subtree
	else {
		update(segmentTree, 2 * index + 2, mid + 1, end, pos, val);
	}


	// Update segmentTree[index]
	segmentTree[index] = segmentTree[2 * index + 1] + segmentTree[2 * index + 2];
}


// Function to find the sum of array elements in the range [L, R]
int sumQuery(int* segmentTree, int start, int end, int L, int R, int index)
{

	// If start and end doesn't lie in the range [L, R]
	if (L > end || R < start) {
	return 0;
	}


	// If start and end lies in the range [L, R]
	if (L <= start && R >= end) 
	{
        	// Return the elements at index 'index'
	return segmentTree[index];
	}

	int mid = start + (end - start) / 2;


	// Find the sum from the left subtree
	int left = sumQuery(segmentTree, start, mid, L, R, 2 * index + 1);


	// Find the sum from right subtree
	int right = sumQuery(segmentTree, mid + 1, end, L, R, 2 * index + 2);


	// Return sum of left subtree sum and right subtree sum
	return left + right;
}


// Main Function
int main()
{

	// Number of integers in the given array
	int N =5;

	// Given array
	int arr[] = { 6, 1, 4, 0, 3 };

	// Given number of Queries
	int q = 3;

	// Given Queries
	vector<vector<int> > queries =  { { 2, 0, 3 }, { 1, 1,  2 }, {2, 1, 4} };
    	
	// Construct a Segment Tree from the given array
	int* segmentTree = buildSegmentTree(arr, N);

	for (int i = 0; i < q; i++) 
	{

		// Type of Query
		int queryType = queries[i][0];

		// If query is of type 1
		if (queryType == 1) {
			update(segmentTree, 0, 0, N - 1, queries[i][1], queries[i][2]);
			cout<<"Query "<<i+1<<" : Updated element at index "<<queries[i][1]<<" with a value "<<queries[i][2]<<endl;
		}

		// Else if query is of type 2
		else {
			if (queries[i][1] % 2 == 0) {                
				cout <<"Query "<<i+1<<" : "<<sumQuery(segmentTree, 0, N - 1, queries[i][1], queries[i][2], 0)<<endl;
		    }
			else {
				cout <<"Query "<<i+1<<" : "<<-sumQuery(segmentTree, 0, N - 1, queries[i][1], queries[i][2], 0)<<endl;
			}
		}
	}
}

Output:
Query 1 : 9
Query 2 : Updated element at index 1 with a value 2
Query 3 : -5