Java 数组计数反转的合并排序实现
下面是我对数组反转的实现。对于某些输入,它会产生所需的结果。例如: 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反转(不正确)。正确答案是33Java 数组计数反转的合并排序实现,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
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]));
}
}
}
}