剑指offer：数组中的逆序对 && 剑指offer：平衡二叉树

数组中的逆序对：题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述:

题目保证输入的数组中没有的相同的数字

数据范围：

对于%50的数据,size<=10^4

对于%75的数据,size<=10^5

对于%100的数据,size<=2*10^5

示例1
输入
复制

1,2,3,4,5,6,7,0

输出
复制

7

思路

第一种，不通过的方法，时间复杂度为o(n2)

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size() == 0) return 0;
        int len = data.size();
        int  res = 0;
        for(int i = 0; i < data.size(); i++){
            for(int j = 0; j < i; j++)
                if(data[j] > data[i])
                    res++;
            res = res % 1000000007;
        }
        return res;
    }
};

第二种方法

• 利用二分法，比如7,5，6,4
  
  首先一直二分
  然后只剩一个元素的时候，两边开始合并

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size() == 0) return 0;
        vector<int> copy(data);
        return InversePairsHelp(data,copy,0,data.size() - 1);
        
    }
    long InversePairsHelp(vector<int> &data,vector<int> &copy,int start,int end){
        if(start == end)
            return 0;
        
        int mid = (start + end) / 2;
        long left = InversePairsHelp(copy,data,start,mid);
        long right = InversePairsHelp(copy,data,mid + 1,end);
        
        long count = 0;
        int i = mid,j = end;
        int k = end;
        while(i >= start && j > mid){
            if(data[i] > data[j]){
                count += j - mid;
                copy[k--] = data[i--];
            }else
                copy[k--] = data[j--];
        }
        while(i >= start) copy[k--] = data[i--];
        while(j > mid) copy[k--] = data[j--];
        return (left + right + count)%1000000007;
    }
};

平衡二叉树：题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

思路

• 先查看左子树是否为平衡二叉树，如果为平衡二叉树，则计算左子树的深度，否则返回false
• 如果左子树为平衡二叉树，查看右子树是否为平衡二叉树
• 查看左右字数的深度是否小于等于1

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {
        int depth = 0;
        return funcHelp(pRoot,depth);
    }
    bool funcHelp(TreeNode* pRoot,int &depth){
        if(!pRoot)
            return true;
       int left = 0,right = 0;
        if(funcHelp(pRoot->left,left) && funcHelp(pRoot->right,right)){
            if(abs(left - right) <= 1){
                depth = 1 + max(left,right);
                return true;
            }
        }
        return false;
    }
};