笔试算法题（32）：归并算法求逆序对 & 将数组元素转换为数组中剩下的其他元素的乘积

出题：多人按照从低到高排成一个前后队列，如果前面的人比后面的高就认为是一个错误对；
　　例如：[176,178,180,170,171]中的错误对 为

　　　　<176,170>, <176,171>, <178,170>, <178,171>, <180,170>, <180,171>。
　　现在要求从一个整数序列中找出所有这样的错误对；

分析：

• 逆序对（Inversion Pair）：在N个可判断大小的数中，逆序对的数量为[0,n(n-1)/2]，使用归并排序求一个序列的逆序对数量，时间复杂度为O(NlogN)，空 间复杂度为O(N)；
• 使用m=(i+j)/2递归处理数字序列，首先计算小子文件的逆序对，并进行排序；排序之后的小子文件参与大文件的逆序对求取，由于 已经小子文件已经排序，所以可以避免许多比较操作；

解题：

int Partition(int *array, int i, int j) {
        /**
         * 使用额外O(N)的空间保存最终排序的序列
         * */
        int m=(i+j)/2;
        int tarray[j-i+1]; int index=0;
        int ti=i,tj=m+1;
        int count=0;

        printf("
%d,%d, %d,%d",i,j,array[i],array[j]);
        while(ti<=m && tj<=j) {
                if(array[ti]>array[tj]) {
                        /**
                         * 注意仅当右边序列的元素小于左边序列
                         * 的元素时，count的值才会增加，并且根据
                         * 以排序的特性可得出总计的逆序对
                         * */
                        count+=m-ti+1;
                        tarray[index]=array[tj];
                        tj++;
                } else {
                        tarray[index]=array[ti];
                        ti++;
                }
                index++;
        }
        /**
         * 注意处理当左右子序列的剩余元素，由于已经排序，所以
         * 可以直接复制到tarray中
         * */
        if(ti>m) {
                while(tj<=j) {
                        tarray[index]=array[tj];
                        tj++;index++;
                }

        } else if(tj>j) {
                while(ti<=m) {
                        tarray[index]=array[ti];
                        ti++;index++;
                }
        }

        for(int k=i;k<=j;k++)
                array[k]=tarray[k];

        return count;
}

int Merge(int *array, int i, int j) {
        /**
         * 当只有一个元素的时候，返回0
         * 当i和j相邻的时候，使用直接比较替代递归调用
         * */
        printf("
**%d, %d",i,j);
        if(i==j) return 0;
        if(i+1==j) {
                if(array[i]>array[j]) {
                        int t=array[i];
                        array[i]=array[j];
                        array[j]=t;
                        return 1;
                } else
                        return 0;
        }

        /**
         * 使用二分递归，count的值由三部分决定：
         * 左右子序列各自内部的逆序对，和左子序列和
         * 右子序列之间的逆序对。
         * 由于经过Merge之后左右子序列已经排序，所以
         * partition可以在O(N)时间复杂度内完成，但是
         * 需要额外的O(N)的空间复杂度
         * */
        int m=(i+j)/2;
        int count=0;
        count+=Merge(array,i,m);
        count+=Merge(array,m+1,j);
        count+=Partition(array,i,j);

        return count;
}

int main() {
        int array[]={7,2,1,4,3,5,6};
        printf("
%d",Merge(array, 0, 6));

        return 0;
}

出题：一个长度为n的数组a[0],a[1],...,a[n-1]。现在更新数组的名个元素，即a[0]变为a[1]到a[n-1]的积，a[1]变为 a[0]和a[2]到a[n-1]的积，...，a[n-1]为a[0]到a[n-2]的积（就是除掉当前元素，其他所有元素的积）；
　　1). 要求具有线性复杂度；
　　2). 要求不能使用除法运算；

分析：创建两个数组left[N]和right[N]，对于a[i]而言，left[i]存储i之前的元素乘积，right[i]存储i之后的元素乘积，所以left和right的初始化仅需要两次扫描数组，为线性时间复杂度，并且没有使用除法；

解题：

void Transfer(int *array, int length) {
        int leftarray[length];
        int rightarray[length];

        leftarray[0]=1;
        for(int i=1;i<length;i++)
                leftarray[i]=leftarray[i-1]*array[i-1];

        rightarray[length-1]=1;
        for(int i=length-2;i>-1;i--)
                rightarray[i]=rightarray[i+1]*array[i+1];

        for(int i=0;i<length;i++)
                array[i]=leftarray[i]*rightarray[i];
}

int main() {
        int array[]={5,2,3,4};
        int length=4;
        Transfer(array,length);
        for(int i=0;i<length;i++)
                printf("%d, ",array[i]);
        return 0;
}