给定二叉树和树中的节点数，任务是找到违反BST属性的对数。二进制搜索树是基于节点的二进制树数据结构，具有以下属性：
- 节点的左子树仅包含键值小于节点键值的节点。
- 节点的右子树仅包含键大于该节点的键的节点。
- 左和右子树也都必须是二叉搜索树。
例子：
Input:
4
/ \
5 6
Output: 1
For the above binary tree, pair (5, 4)
violate the BST property. Thus, count
of pairs violating BST property is 1.
Input:
50
/ \
30 60
/ \ / \
20 25 10 40
Output: 7
For the above binary tree, pairs (20, 10),
(25, 10), (30, 25), (30, 10), (50, 10),
(50, 40), (60, 40) violate the BST property.
Thus, count of pairs violating BST property
is 7.
方法：
- 将二叉树的有序遍历存储在数组中。
- 现在计算所有对，以使i
a [j]为 数组中的求反数。 - 打印违反BST属性的对数。
下面是上述方法的实现：
Java
// Java program to count number of pairs
// in a binary tree violating the BST property
import java.io.*;
import java.util.*;
// Class that represents a node of the tree
class Node {
int data;
Node left, right;
// Constructor to create a new tree node
Node(int key)
{
data = key;
left = right = null;
}
}
class GFG {
// This method sorts the input array and returns the
// number of inversions in the array
static int mergeSort(int arr[], int array_size)
{
int temp[] = new int[array_size];
return _mergeSort(arr, temp, 0, array_size - 1);
}
// An auxiliary recursive method that sorts
// the input array and returns the number of
// inversions in the array
static int _mergeSort(int arr[], int temp[],
int left, int right)
{
int mid, inv_count = 0;
if (right > left) {
// Divide the array into two parts and
// call _mergeSortAndCountInv() for each
// of the parts
mid = (right + left) / 2;
// Inversion count will be sum of inversions
// in left-part, right-part and number of
// inversions in merging
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
// Merge the two parts
inv_count += merge(arr, temp, left, mid + 1, right);
}
return inv_count;
}
// This method merges two sorted arrays and returns
// inversion count in the arrays
static int merge(int arr[], int temp[], int left,
int mid, int right)
{
int i, j, k;
int inv_count = 0;
// i is index for left subarray
i = left;
// j is index for right subarray
j = mid;
// k is index for resultant merged subarray
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);
}
}
// Copy the remaining elements of left subarray
// (if there are any) to temp
while (i <= mid - 1)
temp[k++] = arr[i++];
// Copy the remaining elements of right subarray
// if there are any) to temp
while (j <= right)
temp[k++] = arr[j++];
// Copy back the merged elements to original array
for (i = left; i <= right; i++)
arr[i] = temp[i];
return inv_count;
}
// Array to store
// inorder traversal of the binary tree
static int[] a;
static int in;
// Inorder traversal of the binary tree
static void Inorder(Node node)
{
if (node == null)
return;
Inorder(node.left);
a[in++] = node.data;
Inorder(node.right);
}
// Function to count the pairs
// in a binary tree violating BST property
static int pairsViolatingBST(Node root, int N)
{
if (root == null)
return 0;
in = 0;
a = new int[N];
Inorder(root);
// Total inversions in the array
int inversionCount = mergeSort(a, N);
return inversionCount;
}
// Driver code
public static void main(String args[])
{
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);
System.out.println(pairsViolatingBST(root, N));
}
}Python3
# Python3 program to count number of pairs
# in a binary tree violating the BST property
# Class that represents a node of the tree
class newNode:
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# Array to store
# inorder traversal of the binary tree
a = []
id = 0
# This method sorts the input array
# and returns the number of inversions
# in the array
def mergeSort(array_size):
temp = [0] * array_size
return _mergeSort(temp, 0, array_size - 1)
# An auxiliary recursive method that sorts
# the input array and returns the number of
# inversions in the array
def _mergeSort(temp, left, right):
inv_count = 0
if (right > left):
# Divide the array into two parts and
# call _mergeSortAndCountInv() for each
# of the parts
mid = (right + left) // 2
# Inversion count will be sum of inversions
# in left-part, right-part and number of
# inversions in merging
inv_count = _mergeSort(temp, left, mid)
inv_count += _mergeSort(temp, mid + 1,
right)
# Merge the two parts
inv_count += merge(temp, left, mid + 1,
right)
return inv_count
# This method merges two sorted arrays
# and returns inversion count in the arrays
def merge(temp, left, mid, right):
global a
inv_count = 0
# i is index for left subarray
i = left
# j is index for right subarray
j = mid
# k is index for resultant merged subarray
k = left
while ((i <= mid - 1) and (j <= right)):
if (a[i] <= a[j]):
temp[k] = a[i]
k += 1
i += 1
else:
temp[k] = a[j]
k += 1
j += 1
inv_count = inv_count + (mid - i)
# Copy the remaining elements of left
# subarray (if there are any) to temp
while (i <= mid - 1):
temp[k] = a[i]
k += 1
i += 1
# Copy the remaining elements of right
# subarray if there are any) to temp
while (j <= right):
temp[k] = a[j]
k += 1
j += 1
# Copy back the merged elements
# to original array
for i in range(left, right + 1, 1):
a[i] = temp[i]
return inv_count
# Inorder traversal of the binary tree
def Inorder(node):
global a
global id
if (node == None):
return
Inorder(node.left)
a.append(node.data)
id += 1
Inorder(node.right)
# Function to count the pairs
# in a binary tree violating
# BST property
def pairsViolatingBST(root, N):
if (root == None):
return 0
Inorder(root)
# Total inversions in the array
inversionCount = mergeSort(N)
return inversionCount
# Driver code
if __name__ == '__main__':
N = 7
root = newNode(50)
root.left = newNode(30)
root.right = newNode(60)
root.left.left = newNode(20)
root.left.right = newNode(25)
root.right.left = newNode(10)
root.right.right = newNode(40)
print(pairsViolatingBST(root, N))
# This code is contributed by bgangwar59C#
// C# program to count number of pairs
// in a binary tree violating the BST property
using System;
// Class that represents a node of the tree
public class Node {
public int data;
public Node left, right;
// Constructor to create a new tree node
public Node(int key)
{
data = key;
left = right = null;
}
}
class GFG {
// This method sorts the input array and returns the
// number of inversions in the array
static int mergeSort(int[] arr, int array_size)
{
int[] temp = new int[array_size];
return _mergeSort(arr, temp, 0, array_size - 1);
}
// An auxiliary recursive method that sorts
// the input array and returns the number of
// inversions in the array
static int _mergeSort(int[] arr, int[] temp,
int left, int right)
{
int mid, inv_count = 0;
if (right > left) {
// Divide the array into two parts and
// call _mergeSortAndCountInv() for each
// of the parts
mid = (right + left) / 2;
// Inversion count will be sum of inversions
// in left-part, right-part and number of
// inversions in merging
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
// Merge the two parts
inv_count += merge(arr, temp, left, mid + 1, right);
}
return inv_count;
}
// This method merges two sorted arrays and returns
// inversion count in the arrays
static int merge(int[] arr, int[] temp, int left,
int mid, int right)
{
int i, j, k;
int inv_count = 0;
// i is index for left subarray
i = left;
// j is index for right subarray
j = mid;
// k is index for resultant merged subarray
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);
}
}
// Copy the remaining elements of left subarray
// (if there are any) to temp
while (i <= mid - 1)
temp[k++] = arr[i++];
// Copy the remaining elements of right subarray
// if there are any) to temp
while (j <= right)
temp[k++] = arr[j++];
// Copy back the merged elements to original array
for (i = left; i <= right; i++)
arr[i] = temp[i];
return inv_count;
}
// Array to store
// inorder traversal of the binary tree
static int[] a;
static int i;
// Inorder traversal of the binary tree
static void Inorder(Node node)
{
if (node == null)
return;
Inorder(node.left);
a[i++] = node.data;
Inorder(node.right);
}
// Function to count the pairs
// in a binary tree violating BST property
static int pairsViolatingBST(Node root, int N)
{
if (root == null)
return 0;
i = 0;
a = new int[N];
Inorder(root);
// Total inversions in the array
int inversionCount = mergeSort(a, N);
return inversionCount;
}
// Driver code
public static void Main(String[] args)
{
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);
Console.WriteLine(pairsViolatingBST(root, N));
}
}
// This code is contributed by Rajput-Ji输出：
7