笔试算法题（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)/;
         int tarray[j-i+]; int index=;
         int ti=i,tj=m+;
         int count=;

         printf("\n%d,%d, %d,%d",i,j,array[i],array[j]);
         while(ti<=m && tj<=j) {
                 if(array[ti]>array[tj]) {
                         /**
                          * 注意仅当右边序列的元素小于左边序列
                          * 的元素时，count的值才会增加，并且根据
                          * 以排序的特性可得出总计的逆序对
                          * */
                         count+=m-ti+;
                         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("\n**%d, %d",i,j);
         if(i==j) return ;
         if(i+==j) {
                 if(array[i]>array[j]) {
                         int t=array[i];
                         array[i]=array[j];
                         array[j]=t;
                         return ;
                 } else
                         return ;
         }

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

         return count;
 }

 int main() {
         int array[]={,,,,,,};
         printf("\n%d",Merge(array, , ));

         return ;
 }

出题：一个长度为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[]=;
         for(int i=;i<length;i++)
                 leftarray[i]=leftarray[i-]*array[i-];

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

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

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