在 java 7 中实现归并排序

Question

我在 java 中实现合并排序时遇到问题。不幸的是，我几乎一周都在寻找错误，但没有结果。入口处的ArrayList与输出相同。

import java.util.ArrayList;
import java.util.Scanner;

public class MergeSort 
{
    private ArrayList<Integer> basicArrayList = new ArrayList<Integer>();
    ArrayList<Integer> arrayListA = new ArrayList<Integer>();
    ArrayList<Integer> arrayListB = new ArrayList<Integer>();
    Scanner input = new Scanner(System.in);
    private int firstIndexOfArrayList = 0;
    private int lastIndexOfArrayListA;
    private int lastIndexOfArrayListB;

    public void Scal(ArrayList<Integer> basicArrayList, int p, int q, int r) {
        this.firstIndexOfArrayList = p;
        this.lastIndexOfArrayListA = q;
        this.lastIndexOfArrayListB = r;

        int numberOfElementsArrayListA = lastIndexOfArrayListA
                - firstIndexOfArrayList + 1;
        int numberOfElementsArrayListB = lastIndexOfArrayListB
                - lastIndexOfArrayListA;

        for (int i = 0; i < numberOfElementsArrayListA; i++) {
            arrayListA.set(i, basicArrayList.get(firstIndexOfArrayList + i));
        }

        for (int j = 0; j < numberOfElementsArrayListB; j++) {
            arrayListB.set(j, basicArrayList.get(lastIndexOfArrayListA + j));
        }

        arrayListA.add(Integer.MAX_VALUE);
        arrayListB.add(Integer.MAX_VALUE);
        int i = 0;
        int j = 0;

        for (int k = firstIndexOfArrayList; k <= lastIndexOfArrayListB; k++) {
            if (arrayListA.get(i) <= arrayListB.get(j)) {
                basicArrayList.set(k, arrayListA.get(i));
                i = i + 1;
            } else {
                basicArrayList.set(k, arrayListB.get(j));
                j = j + 1;
            }
        }
    }

    public void MergeSort(ArrayList basicArrayList, int p, int r) {
        this.firstIndexOfArrayList = p;
        this.lastIndexOfArrayListB = r;

        if (firstIndexOfArrayList < lastIndexOfArrayListB) {
            int lastIndexOfArrayListA = (firstIndexOfArrayList + lastIndexOfArrayListB) / 2;
            MergeSort(basicArrayList, firstIndexOfArrayList,
                    lastIndexOfArrayListA);
            MergeSort(basicArrayList, lastIndexOfArrayListA + 1,
                    lastIndexOfArrayListB);
            Scal(basicArrayList, firstIndexOfArrayList,
                    lastIndexOfArrayListA,
                    lastIndexOfArrayListB);
        }
    }

    public void setSize() {
        System.out.println("Enter the number of elements to sort: ");
        this.lastIndexOfArrayListB = input.nextInt();
    }

    public int getSize() {
        return lastIndexOfArrayListB;
    }

    public void setData() {
        System.out.println("Enter the numbers: ");
        for (int i = 0; i < lastIndexOfArrayListB; i++) {
            int number;
            number = input.nextInt();
            basicArrayList.add(number);
        }
    }

    public void getTable() {
        System.out.println(basicArrayList.toString());
    }

    public static void main(String[] args) {
        MergeSort output = new MergeSort();
        output.setSize();

        output.setData();

        output.MergeSort(output.basicArrayList,
                output.firstIndexOfArrayList, (output.getSize() - 1));

        output.getTable();
    }

}

Answer 1

在修复您的代码方面，我对此有所了解，据我所知，这似乎可行。为此，您必须更改很多代码，但它现在可以正确排序所有Integers

import java.util.ArrayList;
import java.util.Scanner;

public class MergeSort 
{
    private ArrayList<Integer> basicArrayList = new ArrayList<Integer>();
    Scanner input = new Scanner(System.in);
    private int numbersToSort;

    public void doMergeSort(int firstIndexOfArrayList,int lastIndexOfArrayListB, ArrayList<Integer> arrayList)
    {
        if(firstIndexOfArrayList<lastIndexOfArrayListB && (lastIndexOfArrayListB-firstIndexOfArrayList)>=1)
        {
            int mid = (lastIndexOfArrayListB + firstIndexOfArrayList)/2;
            doMergeSort(firstIndexOfArrayList, mid, arrayList);
            doMergeSort(mid+1, lastIndexOfArrayListB, arrayList);
            Scal(firstIndexOfArrayList,mid,lastIndexOfArrayListB, arrayList);            
        }       
    }   

    public void Scal(int firstIndexOfArrayList,int lastIndexOfArrayListA,int lastIndexOfArrayListB, ArrayList<Integer> arrayList)
    {
        ArrayList<Integer> mergedSortedArray = new ArrayList<Integer>();

        int leftIndex = firstIndexOfArrayList;
        int rightIndex = lastIndexOfArrayListA+1;

        while(leftIndex<=lastIndexOfArrayListA && rightIndex<=lastIndexOfArrayListB)
        {
            if(arrayList.get(leftIndex)<=arrayList.get(rightIndex))
            {
                mergedSortedArray.add(arrayList.get(leftIndex));
                leftIndex++;
            }
            else
            {
                mergedSortedArray.add(arrayList.get(rightIndex));
                rightIndex++;
            }
        }

        while(leftIndex<=lastIndexOfArrayListA)
        {
            mergedSortedArray.add(arrayList.get(leftIndex));
            leftIndex++;
        }

        while(rightIndex<=lastIndexOfArrayListB)
        {
            mergedSortedArray.add(arrayList.get(rightIndex));
            rightIndex++;
        }

        int i = 0;
        int j = firstIndexOfArrayList;

        while(i<mergedSortedArray.size())
        {
            arrayList.set(j, mergedSortedArray.get(i++));
            j++;
        }
    }

    public void setSize() 
    {
        System.out.println("Enter the number of elements to sort: ");
        this.numbersToSort = input.nextInt();
    }

    public int getSize() 
    {
        return numbersToSort;
    }

    public void setData() 
    {
        System.out.println("Enter the numbers: ");
        for (int i = 0; i < numbersToSort; i++) 
        {
            int number;
            number = input.nextInt();
            basicArrayList.add(number);
        }
    }

    public void getTable() 
    {
        System.out.println(basicArrayList.toString());
    }

    public void runSort(ArrayList<Integer> arrayList)
    {
        doMergeSort(0, this.numbersToSort-1, arrayList);
    }

    public static void main(String[] args) 
    {
        MergeSort output = new MergeSort();
        output.setSize();
        output.setData();
        output.runSort(output.basicArrayList);
        output.getTable();
    }
}

Answer 2

试试这个代码。以下代码采用ArrayList 输入并输出ArrayList，因此它仍然可以在您的代码的相同基础上工作。实际排序在不同的类MergeSort 中处理，并传递给ForMergeSort。希望这会有所帮助

MergeSort.java

public class MergeSort 
{
    private int[] array;
    private int[] tempMergArr;
    private int length;

    public void sort(int[] inputArr)
    {

    }

    public int[] getSortedArray(int[] inputArr)
    {
        this.array = inputArr;
        this.length = inputArr.length;
        this.tempMergArr = new int[length];
        doMergeSort(0, length - 1);

        for(int i=0;i<length;i++)
        {
            int correctNumber = i+1;
            System.out.println("Value "+correctNumber+" of the sorted array which was sorted via the Merge Sort is: "+inputArr[i]);
        }

        return inputArr;
    }

    private void doMergeSort(int lowerIndex, int higherIndex) 
    {
        if (lowerIndex < higherIndex) 
        {
            int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
            doMergeSort(lowerIndex, middle);
            doMergeSort(middle + 1, higherIndex);
            mergeParts(lowerIndex, middle, higherIndex);
        }
    }

    private void mergeParts(int lowerIndex, int middle, int higherIndex) 
    {
        for (int i = lowerIndex; i <= higherIndex; i++) 
        {
            tempMergArr[i] = array[i];
        }
        int i = lowerIndex;
        int j = middle + 1;
        int k = lowerIndex;

        while (i <= middle && j <= higherIndex) 
        {
            if (tempMergArr[i] <= tempMergArr[j]) 
            {
                array[k] = tempMergArr[i];
                i++;
            } 

            else 
            {
                array[k] = tempMergArr[j];
                j++;
            }

            k++;
        }

        while (i <= middle) 
        {
            array[k] = tempMergArr[i];
            k++;
            i++;
        }
    }
}

ForMergeSort.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class ForMergeSort
{
    ArrayList<Integer> arrayList = new ArrayList<Integer>();
    ArrayList<Integer> sortedArrayList = new ArrayList<Integer>();
    MergeSort mS = new MergeSort();

    public void buildArrayList()
    {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the number of elements to sort: ");
        int toSort = input.nextInt();
        System.out.println("Enter the numbers: ");
        for(int i =0; i<toSort; i++)
        {
            int number = input.nextInt();
            arrayList.add(number);
        }
    }

    public void runMergeSort(ArrayList<Integer> arrayList)
    {
        int[] arrayOfValues = new int[arrayList.size()];

        int i = 0;
        for(int a:arrayList)
        {
            arrayOfValues[i] = a;
            i++;
        }

        MergeSort mS = new MergeSort();

        for(int intOfArray:mS.getSortedArray(arrayOfValues))
        {
            sortedArrayList.add(intOfArray);
        }

        System.out.println(sortedArrayList.toString());
    }

    public static void main(String[] args)
    {
        ForMergeSort fMS = new ForMergeSort();
        fMS.buildArrayList();
        fMS.runMergeSort(fMS.arrayList);
    }
}