Java 数组计数反转的合并排序实现

Java 数组计数反转的合并排序实现,java,mergesort,Java,Mergesort,下面是我对数组反转的实现。对于某些输入,它会产生所需的结果。例如: 1:0,1,2,3,4,5,6,7,8,9->0反转(正确) 2:1000999997,…..3,2,1->499500反转(正确) 3:1,3,5,2,4,6->3反转(正确) 要不是 4:9,10,8,1,4,7,6,2,5,3->41反转(不正确)。正确答案是33 public class Assignment1 { static int[] result = new int[10]; public static lon

下面是我对数组反转的实现。对于某些输入,它会产生所需的结果。例如:

1:0,1,2,3,4,5,6,7,8,9->0反转(正确)

2:1000999997,…..3,2,1->499500反转(正确)

3:1,3,5,2,4,6->3反转(正确)

要不是

4:9,10,8,1,4,7,6,2,5,3->41反转(不正确)。正确答案是33

public class Assignment1 {
static int[] result = new int[10];

public static long divideW (int Arr[]) {
    long countLeft ;
    long countRight ;
    long countMerge ;

    int mid = (Arr.length)/2;

    if (Arr.length <= 1)
        return 0;
    else
    {
        int leftArr[] = new int [mid];
        int rightArr[] = new int [Arr.length - mid];

        for (int i = 0; i < mid; i++){
            leftArr[i] = Arr[i];
        }
        for (int j = 0; j < rightArr.length ; j++){
            rightArr[j] = Arr[mid + j];
        }   
        countLeft = divideW (leftArr);
        countRight = divideW (rightArr);

        //int[] result = new int[Arr.length];
        countMerge = conquer(leftArr, rightArr, result);
        return (countLeft + countRight + countMerge);
    }
}
public static long conquer (int []l, int[]r, int[] result) {
    int i = 0;
    int j = 0;
    int k = 0;
    long count = 0;
    while ((i < l.length) && (j < r.length)) {
    if (l[i] <= r [j]) {
        result[k] = l[i++];
    }
    else if (l[i] > r[j]) {
        result[k] = r[j++];
        count += l.length - i;
    }
    ++k;
    }
    while ( i < l.length) {
        result[k++] = l[i++];
    }
    while ( j < r.length) {
        result[k++] = r[j++];
    }
    return count;
}


public static void main(String[] args) {
    Assignment1 rs = new Assignment1();
    int anArr[] = {9,10,8,1,4,7,6,2,5,3};

    System.out.println (rs.divideW(anArr));

    for (int i = 0 ; i < result.length; ++i) {
        System.out.println (result[i]);
    }  
    }
}
公共类分配1{
静态int[]结果=新int[10];
公共静态长分隔符W(int Arr[]){
长倒左;
长倒计时权;
长计数合并;
int mid=(Arr.length)/2;

如果(Arr.length您答案中的问题(我认为它是正确的)如下:

countMerge = conquer(leftArr, rightArr, result);
您只需在未排序的数组(leftArr,rightArr)上完成部分操作,这就是反转数不同的原因。我对该代码进行了如下更改,它可以正常工作:

Arrays.sort(leftArr);
Arrays.sort(rightArr);
countMerge = conquer(leftArr, rightArr, result);

您的解决方案不正确,因为它没有将排序后的数组传递到征服 作用

下面是我使用C#实现的代码

使用系统;
名称空间排序算法
{
使用合并排序的公共类反转计数
{
公共静态长反转计数{get;set;}
公共静态void Main(字符串[]args)
{
//加载数组
int[]数组={9,10,8,1,4,7,6,2,5,3};//{10,4,7,8,6,2,3,5};//{1,3,5,2,4,6}->3;//{9,10,8,1,4,7,6,2,5,3}-->41;//{0,1,2,3,3,4,5,6,7,8,9}->0;//{10,4,7,8,6,2,5;//;
Console.WriteLine(“================未排序的数组项==============”);
//打印未排序的数组
印刷品(阵列);
Console.WriteLine(“===================反转计数===========”);
//对数组进行排序
arrayInts=合并排序(arrayInts);
//打印排序数组
印刷品(阵列);
控制台写入线(反转计数);
Console.ReadKey();
}
私有静态int[]合并排序(int[]数组)
{

if(arrayInts.Length Arrays.sort)将对其进行排序,但它不是合并排序实现。根据合并排序实现,我应该通过divideW(leftArr)和divideW(rightArr)来划分发生的问题调用并通过调用征服函数来解决问题。您的目标是计算分区数或合并对数组或两者进行排序?如果第一个,我的解决方案有效,第二个是否有效,如果第三个只是将合并排序数组传递给征服方法。我向您指出计数而不是提供的错误ding完整的工作实现。只是一个提示,重写
divideW
,以便在iti发现问题所在并获得正确答案后对传递的数组进行排序。但我仍然无法理解它是如何解决的。在返回语句之前的divideW方法末尾,我必须放入一个类似for的for循环(int k=0;k@PLB我们的目标不是简单地删除家庭作业标签。您需要进行大量编辑。如果问题太具体或太糟糕,请将其标记出来,以便可以关闭或删除(如)。如果问题很好,只有这样您才可以简单地删除家庭作业标签,但这是罕见的。upsi,对不起:)好的,我从现在开始注意
using System;

namespace SortingAlgos
{
    public class InversionCountUsingMergeSort
    {
        public static long InversionCount { get; set; }
        public static void Main(string[] args)
        {
            //Load an array
            int[] arrayInts = { 9, 10, 8, 1, 4, 7, 6, 2, 5, 3 };// { 10, 4, 7, 8, 6, 2, 3, 5 };//{1,3,5,2,4,6}--->3;//{ 9, 10, 8, 1, 4, 7, 6, 2, 5, 3 }-->41;//{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }--->0;//{ 10, 4, 7, 8, 6, 2, 3, 5 }; //LoadInts();

            Console.WriteLine("========= UnSorted Array Items ==========");

            //Print an unsorted array
            PrintInts(arrayInts);

            Console.WriteLine("========== Inversion Count =========");
            //Sort the array
            arrayInts = MergeSort(arrayInts);

            //Print Sorted array
            PrintInts(arrayInts);
            Console.WriteLine(InversionCount);
            Console.ReadKey();
        }

        private static int[] MergeSort(int[] arrayInts)
        {
            if (arrayInts.Length <= 1)
            {
                return arrayInts;
            }
            else
            {
                int[] result = new int[arrayInts.Length];

                int midPoint = arrayInts.Length / 2;
                int[] leftArray = new int[midPoint];
                int[] rightArray;
                if (arrayInts.Length % 2 == 0)
                {
                    rightArray = new int[midPoint];
                }
                else
                {
                    rightArray = new int[midPoint + 1];
                }

                for (int indexLeft = 0; indexLeft < midPoint; indexLeft++)
                {
                    leftArray[indexLeft] = arrayInts[indexLeft];
                }
                int indexRight = 0;
                for (int indexOnArryInts = midPoint; indexOnArryInts < arrayInts.Length; indexOnArryInts++)
                {
                    if (indexRight < rightArray.Length)
                    {
                        rightArray[indexRight] = arrayInts[indexOnArryInts];
                        indexRight++;
                    }
                }

                leftArray = MergeSort(leftArray);
                rightArray = MergeSort(rightArray);
                return MergeArrays(leftArray, rightArray);

            }
        }

        private static int[] MergeArrays(int[] leftArray, int[] rightArray)
        {
            int arraySize = leftArray.Length + rightArray.Length;
            int[] arrayFinal = new int[arraySize];
            int leftIndex = 0, rightIndex = 0;
            for (int index = 0; index < arraySize; index++)
            {
                if (leftIndex < leftArray.Length && rightIndex < rightArray.Length)
                {
                    if (leftArray[leftIndex] <= rightArray[rightIndex])
                    {
                        arrayFinal[index] = leftArray[leftIndex];
                        leftIndex++;                    
                    }
                    else if (leftArray[leftIndex] > rightArray[rightIndex])
                    {
                        arrayFinal[index] = rightArray[rightIndex];
                        rightIndex++;
                        InversionCount += leftArray.Length - leftIndex;
                    }
                }
                else if (leftIndex < leftArray.Length)
                {
                    arrayFinal[index] = leftArray[leftIndex];
                    leftIndex++;
                }
                else if (rightIndex < rightArray.Length)
                {
                    arrayFinal[index] = rightArray[rightIndex];
                    rightIndex++;
                }
            }
            return arrayFinal;
        }

        private static void PrintInts(int[] arrayInts)
        {
            for (int index = 0; index < arrayInts.Length; index++)
            {
                Console.WriteLine(string.Format("{0}", arrayInts[index]));
            }
        }
    }
}