#include <bits/stdc++.h>
using
namespace
std;
class
Node {
public
:
int
data;
Node* left, * right;
Node(
int
key)
{
data = key;
left = right = nullptr;
}
};
class
GFG {
public
:
static
int
mergeSort(
int
* arr,
int
array_size);
static
int
_mergeSort(
int
* arr,
int
* temp,
int
left,
int
right);
static
int
merge(
int
* arr,
int
* temp,
int
left,
int
mid,
int
right);
static
void
Inorder(Node* node);
static
int
pairsViolatingBST(Node* root,
int
N);
};
int
GFG::mergeSort(
int
* arr,
int
array_size)
{
int
* temp =
new
int
[array_size];
return
_mergeSort(arr, temp, 0, array_size - 1);
}
int
GFG::_mergeSort(
int
* arr,
int
* temp,
int
left,
int
right)
{
int
mid, inv_count = 0;
if
(right > left) {
mid = (right + left) / 2;
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
inv_count += merge(arr, temp, left, mid + 1, right);
}
return
inv_count;
}
int
GFG::merge(
int
* arr,
int
* temp,
int
left,
int
mid,
int
right)
{
int
i, j, k;
int
inv_count = 0;
i = left;
j = mid;
k = left;
while
((i <= mid - 1) && (j <= right)) {
if
(arr[i] <= arr[j]) {
temp[k++] = arr[i++];
}
else
{
temp[k++] = arr[j++];
inv_count = inv_count + (mid - i);
}
}
while
(i <= mid - 1)
temp[k++] = arr[i++];
while
(j <= right)
temp[k++] = arr[j++];
for
(i = left; i <= right; i++)
arr[i] = temp[i];
return
inv_count;
}
int
* a;
int
i;
void
GFG::Inorder(Node* node)
{
if
(node == nullptr)
return
;
Inorder(node->left);
a[i++] = node->data;
Inorder(node->right);
}
int
GFG::pairsViolatingBST(Node* root,
int
N)
{
if
(root == nullptr)
return
0;
i = 0;
a =
new
int
[N];
Inorder(root);
int
inversionCount = mergeSort(a, N);
return
inversionCount;
}
int
main()
{
int
N = 7;
Node* root =
new
Node(50);
root->left =
new
Node(30);
root->right =
new
Node(60);
root->left->left =
new
Node(20);
root->left->right =
new
Node(25);
root->right->left =
new
Node(10);
root->right->right =
new
Node(40);
cout << GFG::pairsViolatingBST(root, N) << endl;
return
0;
}