详解一道字节跳动的二面题目，它太经典了！

输入: arr[]={8，5，4，2，1}
输出: 10
解释: 逆序对为(8，5)、(8，4)、(8，2)、(8，1)，(5，4)、(5，2)、(5，1)，还有(4，2)、(4，1)和(2，1)，总共10个。其实也可以直接计算5(5-1)/2=10，前提是知道数组完全逆序

输入: arr[]={5，1，4，2，8}
输出: 4
解释: 逆序对为(5，1)、(5，4)、(5，2)，还有(4，2)，总共4个。
在这里也可以看出数组{5，1，4，2，8}比{8，5，4，2，1}更有序，逆序对的数目可以衡量一个数组的有序程度。

class Solution {
    public int reversePairs(int[] nums) {
        int count = 0;
        int n = nums.length;
        for(int i = 0;i < n - 1; i++){
            for(int j = i+1; j < n; j++){
                if(nums[i] > nums[j]){
                    count++;
                }
            }
        }
        return count;
    }
}

class Solution {
    //合并函数
    private static int mergeAndCount(int[] arr, int l, int m, int r) 
    { 
        int[] left = Arrays.copyOfRange(arr, l, m + 1); 

        int[] right = Arrays.copyOfRange(arr, m + 1, r + 1); 
  
        int i = 0, j = 0, k = l, swaps = 0; 
  
        while (i < left.length && j < right.length) { 
            if (left[i] <= right[j]) 
                arr[k++] = left[i++]; 
            else { 
                arr[k++] = right[j++]; 
                swaps += (m + 1) - (l + i); 
            } 
        } 

        while (i < left.length) 
            arr[k++] = left[i++]; 
 
        while (j < right.length) 
            arr[k++] = right[j++]; 
  
        return swaps; 
    } 
  
    // 归并排序
    private static int mergeSortAndCount(int[] arr, int l, int r) 
    { 
        int count = 0; 
  
        if (l < r) { 
            int m = (l + r) / 2; 
  
            count += mergeSortAndCount(arr, l, m); 

            count += mergeSortAndCount(arr, m + 1, r); 

            count += mergeAndCount(arr, l, m, r); 
        } 
  
        return count; 
    }     
    public int reversePairs(int[] nums) {
        return mergeSortAndCount(nums, 0, nums.length-1);
    }
}

static int getSum(int[] BITree, int index) 
{ 
    int sum = 0; 
    while (index > 0) 
    { 
        //将当前 BITree[] 的值加到 sum 中
        sum += BITree[index]; 
        //找到 index 的父结点
        index -= index & (-index); 
    } 
    return sum; 
} 

static void updateBIT(int[] BITree, int n, int index, int val) 
{ 
    while (index <= n) 
    { 
        BITree[index] += val; 
        index += index & (-index); 
    } 
}

class Solution {
    private static int getSum(int[] BITree, int index) 
    { 
        int sum = 0;
        while(index > 0){
            sum += BITree[index];
            index -= index & (-index);
        }

        return sum;
    } 
 
    private static void updateBITree(int[] BITree, int n, 
                                     int index, int val) 
    { 
        while(index <= n){
            BITree[index] += val;
            index += index & (-index);
        }
    }     
    public int reversePairs(int[] nums) {
        int count = 0;
        int maxElement = 0;
        int n = nums.length;
        int[] arr = new int[n];
        for(int i = 0; i < n; i++){
            if(nums[i] > 0){
                arr[i] = nums[i];
            }else{
                arr[i] = -nums[i];
            }
        }
        for(int i = 0; i < n; i++){
            if(arr[i] > maxElement){
                maxElement = arr[i];
            }
        }

        int[] BITree = new int[maxElement + 1];
        for(int i = 0; i < BITree.length; i++){
            BITree[i] = 0;
        }
        
        for(int i = n - 1; i >= 0; i--){
            count += getSum(BITree, arr[i] - 1);
            updateBITree(BITree, maxElement, arr[i], 1);
        }

        return count;
    }
}

int a[] = {1,2,3,4};
int *temp = (int *)a;
int *p = temp + 2;

std::size_t s2 = p - temp;

class Solution {

    int getSum(int BITree[], int index){
        int sum = 0;
        while(index > 0){
            sum += BITree[index];
            index -= index & (-index);
        }

        return sum;
    }
    void updateBIT(int BITree[], int n, int index, int val){
        while(index <= n){
            BITree[index] += val;
            index += index & (-index);
        }
    }

    void convert(vector<int>& nums) 
    { 
        int n = nums.size();
        int temp[n];
        for(int i = 0; i < n; i++){
            temp[i] = nums[i];
        }
        sort(temp, temp + n);

        for(int i = 0; i < n; i++){
            nums[i] = lower_bound(temp, temp + n, nums[i]) - temp + 1;
        }
    } 

public:
    int reversePairs(vector<int>& nums) {
        int count = 0;
        int n = nums.size();
        if(n <= 0){
            return count;
        }
        convert(nums);
        int BITree[n + 1];
        for(int i = 0; i <= n; i++){
            BITree[i] = 0;
        }

        for(int i = n - 1; i >= 0; i--){
            count += getSum(BITree, nums[i] - 1);
            updateBIT(BITree, n, nums[i], 1);
        }

        return count;
    }
};

class Solution {
    // AVL 树的结点
    struct Node 
    { 
        int key, height; 
        struct Node *left, *right; 
        //以 this.Node 为根的树的大小
        int size;  
    }; 
    
    // 返回树的高度
    int height(struct Node *N) 
    { 
        if (N == NULL) 
            return 0; 
        return N->height; 
    } 
    
    // 返回以结点 N 为根的树的大小
    int size(struct Node *N) 
    { 
        if (N == NULL) 
            return 0; 
        return N->size; 
    } 
    
    /* 创建一个结点 */
    struct Node* newNode(int key) 
    { 
        struct Node* node = new Node; 
        node->key = key; 
        node->left = node->right = NULL; 
        node->height = node->size = 1; 
        return(node); 
    } 
    
    // 右旋操作
    struct Node *rightRotate(struct Node *y) 
    { 
        struct Node *x = y->left; 
        struct Node *T2 = x->right; 
        
        x->right = y; 
        y->left = T2; 
    
        y->height = max(height(y->left), height(y->right))+1; 
        x->height = max(height(x->left), height(x->right))+1; 
    
        y->size = size(y->left) + size(y->right) + 1; 
        x->size = size(x->left) + size(x->right) + 1; 
        //返回新的根结点
        return x; 
    } 
    
    // 左旋操作
    struct Node *leftRotate(struct Node *x) 
    { 
        struct Node *y = x->right; 
        struct Node *T2 = y->left; 
    
        y->left = x; 
        x->right = T2; 
    
        x->height = max(height(x->left), height(x->right))+1; 
        y->height = max(height(y->left), height(y->right))+1; 
    
        x->size = size(x->left) + size(x->right) + 1; 
        y->size = size(y->left) + size(y->right) + 1; 
        // 返回新的根结点
        return y; 
    } 
    
    // 获取平衡因子 
    int getBalance(struct Node *N) 
    { 
        if (N == NULL) 
            return 0; 
        return height(N->left) - height(N->right); 
    } 
    
    // AVL插入操作
    struct Node* insert(struct Node* node, int key, int *result) 
    { 
        if (node == NULL) 
            return(newNode(key)); 
    
        if (key < node->key) 
        { 
            node->left  = insert(node->left, key, result); 
            *result = *result + size(node->right) + 1; 
        } 
        else
            node->right = insert(node->right, key, result); 
    
        node->height = max(height(node->left), 
                        height(node->right)) + 1; 
        node->size = size(node->left) + size(node->right) + 1; 
    
        int balance = getBalance(node); 
    
        if (balance > 1 && key < node->left->key) 
            return rightRotate(node); 

        if (balance < -1 && key > node->right->key) 
            return leftRotate(node); 

        if (balance > 1 && key > node->left->key) 
        { 
            node->left =  leftRotate(node->left); 
            return rightRotate(node); 
        } 

        if (balance < -1 && key < node->right->key) 
        { 
            node->right = rightRotate(node->right); 
            return leftRotate(node); 
        } 
        return node; 
    } 
public:
    int reversePairs(vector<int>& nums) {
        struct Node *root = NULL; 

        int result = 0;   

        for (int i = 0; i< nums.size(); i++) 
        {
            root = insert(root, nums[i], &result); 
        }
        return result; 
    }  
};