数组中的逆序对

题目描述

        在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。例如：在数组{7，5，6，4}中，一共存在5对逆序对，分别是｛7，5｝，｛7，4｝，｛7，6｝，｛5，4｝，｛6，4｝。

---

        这道题的第一思路就是顺序扫描整个数组，然后每扫到一个数字，就拿后面的数字与它比较，如果后面的数字比它小，则这两个数字就组成了一个逆序对。假设数组中含有n个数，由于每个数字都要和O（n）个数字进行比较，因此这种算法的时间复杂度是O（n^2）。

        为了更好的时间效率，可以考虑优先比较两个相邻的数字。以数组｛7，5，6，4｝为例在分析统计逆序对的过程。

        如下图所示，先把数组分解成两个长度为2的子数组，再把这两个子数组分别拆分成两个长度为1的子数组。接下来一边合并相邻的子数组，以便统计逆序对的数目。在第一对长度为1的子数组｛7｝、｛5｝中，7大于5，因此（7，5）也是一个逆序对。同样的，在第二对长度为1的子数组｛6｝、｛4｝中，也有逆序对（6，4）。由于已经统计了这两对子数组内部的逆序对了，因此需要把这两对子数组排序，以免在以后的统计过程中再避免重复。

        统计逆序对的过程如下：夏娜吧数组分割成子数组，统计出子数组内部的逆序对的数目，然后再统计出两个相邻子数组之间的逆序对的数目。在统计逆序对的过程中，还需要对数组进行排序。如果对排序算法很熟悉，不难发现，以上过程就是一个归并排序，综上有下列代码:

using System;

namespace 数组中的逆序对
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[4] { 7, 5, 6, 4 };
            Solution s = new Solution();
            Console.WriteLine(s.InversePairs(arr));
        }
    }

    class Solution
    {
        /// <summary>
        /// 输入一个数组，统计该数组中出现的逆序对
        /// </summary>
        /// <param name="data">传入的数组</param>
        /// <returns>返回数组中逆序对的数量</returns>
        public int InversePairs(int[] data)
        {
            //如果传入的数组不合法，那么返回0
            if (data == null || data.Length <= 1)
                return 0;

            //创建一个辅助数组用于储存排好序的数字
            int[] copy = new int[data.Length];

            //初始化辅助数组
            for (int i = 0; i < data.Length; i++)
                copy[i] = data[i];

            int count = InversePairs(ref data,ref copy, 0, data.Length - 1);

            return count;
        }

        /// <summary>
        /// 指定一个范围，通过递归，对数组进行排序和逆序对的统计
        /// </summary>
        /// <param name="data"></param>
        /// <param name="copy"></param>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <returns>返回当前范围内逆序对的数量</returns>
        private int InversePairs(ref int[] data, ref int[] copy, int start, int end)
        {
            //如果当前范围内的数字只剩一个，那么重新设置辅助数组的值，并返回逆序对的数量
            if (start == end)
            {
                copy[start] = data[start];
                return 0;
            }

            //定义一个变量用于储存平均值，把范围内的数字分为两部分进行排序与统计
            int mid = (start + end) >> 1;

            //统计左右两部分的逆序对
            int left = InversePairs(ref data, ref copy, start, mid)%1000000007;
            int right = InversePairs(ref data, ref copy, mid+ 1, end) % 1000000007;

            //初始化为前半段最后一个数字的下标
            int i = mid;
            //初始化为后半段最后一个数字的下标
            int j = end;

            //辅助数组的下标
            int copyIndex = end;
            //逆序对的计数器
            int count = 0;

            //比较数组中左右范的数，找出所有的逆序对
            while (i >= start && j >= mid + 1 )
            {
                //如果当前左边数组中的值大于当前右边数组中的值，那么当前左边的值肯定大于右边的所有值（因为数组从小到大排列），统计当前右边小于左边的值，并把左边的值放入辅助数组中
                //如果左边的值小于右边的值，那么把右边的大值放入辅助数组中
                if (data[i] > data[j])
                {
                    copy[copyIndex--] = data[i--];
                    //count += j - length - start;
                    count += j - mid;
                    if (count > 1000000007)
                        count %= 1000000007;
                }
                else
                {
                    copy[copyIndex--] = data[j--];
                }
            }

            //把剩下的没有遍历的数全部放入辅助数组
            for (; i > start; i--)
                copy[copyIndex--] = data[i];
            for (; j > mid; j--)
                copy[copyIndex--] = data[j];

            //拷贝数组,把排好序的数组放入data中，在后面的判断中不会导致顺序出错
            for (i = start; i <= end; i++)
                data[i] = copy[i];

            //返回该范围内逆序对的数量
            return (count + left + right) % 1000000007;
        }
    }
}

        归并排序的时间复杂度是O（nlohn），比直观的O（n^2）要快，但同时归并排序需要一个长度为n的辅助数组，相当于用O（n）的空间消耗换来了时间效率的提升，因此这是一种空间换时间的算法。