剑指OfferJZ35：数组中的逆序对-java版

本是古典何须时尚 2022-09-01 14:56 106阅读 0赞

### 剑指OfferJZ35：数组中的逆序对-java版 ###

*   *   *   *  JZ35：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
             *  对于50\\%50%的数据,size\\leq 10^4size≤104
             *  对于100\\%100%的数据,size\\leq 10^5size≤105

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

#### 对于50%50%的数据,size\\leq 10^4size≤104 ####

#### 对于100%100%的数据,size\\leq 10^5size≤105 ####

暴力解法使用两个for循环会超出时间限制  
我们考虑用**归并排序**（归并排序是稳定排序，是一种十分高效的排序）

**归并排序**：是利用归并的思想实现的排序方法，该算法采用经典的**分治策略**（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)

如图：将数组\[8,4,5,7,1,3,6,2\]变成有序数组  
**分**：先按下标将数组从分成左右两部分（如果数组元素个数是奇数个，那就左边比右边多一个元素），接着对于左右两个子数组采取同样的操作，直到将整个数组完全肢解，全部分成**只有一个元素**的数组

**治**：将每一步分开的子数组**排序后**再**原样进行合并**；  
比如图中的最后一次合并，是将\[4,5,7,8\]和\[1,2,3,6\]两个已经有序的子数组再进行排序后合并为最终的有序数组\[1,2,3,4,5,6,7,8\]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70]

本题只是在归并合并的基础上多了一步，**进行合并的同时统计逆序对个数**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 1]

基本思路有了，那么要想解出这道题，**必需要把归并排序的过程掌握清楚**。  
以下图为例：  
**分：划分区间**  
以数组元素的**下标**来划分，首先将数组的首元素下标用l标记，尾元素下标用r标记，mid=(l+r)/2

*  第一次划分：l=0,r=8,mid=(0+8)/2=4 区间\[9，5，2，7，12，4，3，1，11\]分成 左区间：l~mid 即\[9，5，2，7，12\] 右区间：mid+1~r 即\[4，3，1，11\]
 *  第二次划分：同理，区间\[9，5，2，7，12\]分成 左区间：\[9，5，2\] 右区间：\[7，12\]
 *  第三次划分：同理，区间\[4，3，1，11\]分成 左区间：\[4，3\] 右区间：\[1，11\]
 *  第四次划分：同理，区间\[9，5，2\]分成 左区间：\[9，5\] 右区间：\[2\]
 *  第五次划分：同理，区间\[7，12\]分成 左区间：\[7\] 右区间：\[12\]
 *  第六次划分：同理，区间\[4，3\]分成 左区间：\[4\] 右区间：\[3\]
 *  第七次划分：同理，区间\[1，11\]分成 左区间：\[1\] 右区间：\[11\]
 *  第八次划分：同理，区间\[9，5\]分成 左区间：\[9\] 右区间：\[5\]

直到划分的所有区间长度为1时划分结束

//分：划分区间
        private void divide(int l, int r, int[] array) { 
            if(l!=r){ 
                int mid=(l+r)>>1;//(l+r)>>1 代表 l+r的值右移1位，相当于l+r的值除以2取整
                divide(l,mid,array);//左区间
                divide(mid+1,r,array);//右区间
                merge(l,r,mid,array);//治
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 2]

**治：合并两个子区间**

用**i**表示左区间的下标，用**j**表示右区间的下标，其中i=l,j=mid+1分别定为左右区间的起始下标  
接着建立一个长度等于原数组长度的**临时数组**，用于存放临时合并的数组，避免递归过程中频繁开辟空间

*  如果**左右区间都有数字**（即i<=mid 并且 j<=r），这时我们将**左区间的第一个数**和**右区间的第一个数**比较，将**小**的那个数移入到临时数组中  
    比如：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 6]

*  当合并后**只剩有一个区间有数字**（即i<=mid 或者 j<=r）时，直接将这个区间**剩下的所有数字**移入临时区间

如上面例子：最后只剩右区间有一个数12，那就将这个数直接移入到临时数组，为\[2，5，7，9，12\]  
再比如：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 7]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 8]

其它合并过程同理，最后归并排序结果为\[1,2,3,4,5,7,9,11,12\]

//治：合并两个子区间
        private void merge(int l, int r, int mid, int[] array) { 
            int i=l;//左区间的起点
            int j=mid+1;//右区间的起点
            int[] temp=new int[r-l+1];//在排序前，先建好一个长度等于原数组长度的临时数组，用于存放临时合并的数组，避免递归中频繁开辟空间
            int index=0;//临时数组下标
            while(i<=mid && j<=r){ //左区间右区间都有数字
                if(array[i]>array[j]){ //左区间现存数字中的第一个数字大于右区间现存数字中的第一个数字（逆序对）
                    temp[index++]=array[j++];//将小的数字放入到临时数组中//将每一步分开的子数组排序后再原样进行合并
                    //sum+=mid-i+1;//在合并的过程中统计逆序对个数（多了这一步）
                }else { //左区间现存数字中的第一个数字更小
                    temp[index++]=array[i++];
                }
            }
            //以下针对有一个区间数字都合并完了，另一个区间还没合并完的情况
            while (i<=mid){ //说明左区间还有剩余的数字
                temp[index++]=array[i++];//将剩余的所有数字直接放入到临时数组中(因为这里剩下的数字肯定是有序的)
            }
            while (j<=r){ //说明右区间还有剩余的数字
                temp[index++]=array[j++];//将剩余的所有数字直接放入临时数组中
            }
            //把临时数组中合并后的元素复制回原来的数组
            index=0;
            for(int k=l;k<=r;k++){ 
                array[k]=temp[index++];
            }
        }

本题只需要在递归排序的合并过程中加上统计逆序对的代码就行了  
sum=mid-i+1;

完整解题代码：

public class jz35{ 
    
        private long sum;//用来统计逆序对的个数
        public int InversePairs(int[] array) { 
            sum=0;
            int l=0;
            int r=array.length-1;
            divide(l,r,array);
            return (int)(sum%1000000007);
        }
    
        //分：划分区间
        private void divide(int l, int r, int[] array) { 
            if(l!=r){ 
                int mid=(l+r)>>1;//(l+r)>>1 代表 l+r的值右移1位，相当于l+r的值除以2取整
                divide(l,mid,array);//左区间
                divide(mid+1,r,array);//右区间
                merge(l,r,mid,array);//治
            }
        }
    
        //治：合并两个子区间
        private void merge(int l, int r, int mid, int[] array) { 
            int i=l;//左区间的起点
            int j=mid+1;//右区间的起点
            int[] temp=new int[r-l+1];//在排序前，先建好一个长度等于原数组长度的临时数组，用于存放临时合并的数组，避免递归中频繁开辟空间
            int index=0;//临时数组下标
            while(i<=mid && j<=r){ //左区间右区间都有数字
                if(array[i]>array[j]){ //左区间现存数字中的第一个数字大于右区间现存数字中的第一个数字（逆序对）
                    temp[index++]=array[j++];//将小的数字放入到临时数组中//将每一步分开的子数组排序后再原样进行合并
                    sum+=mid-i+1;//在合并的过程中统计逆序对个数（多了这一步）
                }else { //左区间现存数字中的第一个数字更小
                    temp[index++]=array[i++];
                }
            }
            //以下针对有一个区间数字都合并完了，另一个区间还没合并完的情况
            while (i<=mid){ //说明左区间还有剩余的数字
                temp[index++]=array[i++];//将剩余的所有数字直接放入到临时数组中(因为这里剩下的数字肯定是有序的)
            }
            while (j<=r){ //说明右区间还有剩余的数字
                temp[index++]=array[j++];//将剩余的所有数字直接放入临时数组中
            }
            //把临时数组中合并后的元素复制回原来的数组
            index=0;
            for(int k=l;k<=r;k++){ 
                array[k]=temp[index++];
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 9]

![在这里插入图片描述][dee0998fa65f411aa403e04ca5d18006.gif_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70]: /images/20220829/32c4f303d35f494ea6aa03e260ac804d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 1]: /images/20220829/b8b0918173c144bfacb2460922ce4d9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 2]: /images/20220829/d5a6cc0739744037879237c8701d17eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 3]: /images/20220829/120cc44e5dca438891357eac60be4a00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 4]: /images/20220829/a2acd472bb694c6b84ce566e9859da03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 5]: /images/20220829/36612ae604424d7c8a7868415dfdd253.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 6]: /images/20220829/a7b57f70a49344b8af5da1196b48f387.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 7]: /images/20220829/475285f1686a420d8cc20fe9dde6a3e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 8]: /images/20220829/95d2ff1c411541d9b705080fca95b829.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk5MjAyMQ_size_16_color_FFFFFF_t_70 9]: /images/20220829/390de1fefab34fbe8b57d7078f4b7002.png
[dee0998fa65f411aa403e04ca5d18006.gif_pic_center]: /images/20220829/64acfde4a8d74be495199e712e27c748.png