Java中ArrayList中的合并排序

我正在学习如何用Java实现基本算法，所以我是这个环境中的新手。我正在尝试使用ArrayList实现合并排序算法，程序将从文件中读取数据（每行中的整数），并使用合并排序生成排序结果。然而，我的代码显示了相同的结果，因为它没有整理出任何东西！如果有人能找出我的错误，我会非常高兴。因为我是一个初学者，代码非常简单，没有经过优化，性能可能也不是很快

这是我的密码：

public class MergeSortExp1 {

    public static void main(String[] args) {

        ArrayList<Integer>number = new ArrayList<Integer>();

        Scanner myScanner = null;
        try {
        myScanner = new Scanner(new File("/Users/Sabbir/Desktop/workload.txt"));
        } catch (FileNotFoundException e) {

        e.printStackTrace();
        }

        while(myScanner.hasNextInt()){
            number.add(myScanner.nextInt());
        }

        System.out.println("Before sorting" +number);
        number=mergeSort(number);
        System.out.println("Sorted Array =" +number);
    }

        public static ArrayList<Integer> mergeSort( ArrayList<Integer> Input)
        {
            if (Input.size() ==1){
                return Input;
            }
            else {
                int mid= Input.size()/2;
                ArrayList<Integer> left= new ArrayList<Integer>(mid);
                ArrayList<Integer> right=new ArrayList<Integer>(Input.size()-mid);

               for (int i = 0; i < mid; i++) {
                   left.add(Input.get(i));
                   } 

               for (int i = 0; i < Input.size()-mid; i++) {
                   right.add(Input.get(i));
               } 

               left=mergeSort(left); 
               right=mergeSort(right);
               merge(left,right,Input);
            }
               return Input;
        }


        public static void merge (ArrayList<Integer>left,ArrayList<Integer>right,ArrayList<Integer>Input)
        {
            int i1=0;// left Index
            int i2=0;// right Index
            int InputIndex=0;

            for (int i = 0; i < Input.size(); i++) {
                if (i2>=right.size() || (i1<left.size() && left.get(i)<=right.get(i))) 
                {
                    Input.set(InputIndex,left.get(i1));
                    InputIndex++;
                }
                else {
                    Input.set(InputIndex, right.get(i2));
                    InputIndex++;
                }
            }

        }
}

公共类MergeSortExp1{
公共静态void main（字符串[]args）{
ArrayListnumber=新的ArrayList（）；
扫描器myScanner=null；
试一试{
myScanner=newscanner（新文件（“/Users/Sabbir/Desktop/workload.txt”）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}
while（myScanner.hasNextInt（））{
add（myScanner.nextInt（））；
}
系统输出打印项次（“排序前”+编号）；
编号=合并排序（编号）；
System.out.println（“排序数组=“+number”）；
}
公共静态ArrayList合并排序（ArrayList输入）
{
if（Input.size（）==1）{
返回输入；
}
否则{
int mid=Input.size（）/2；
ArrayList left=新的ArrayList（中间）；
ArrayList right=新的ArrayList（Input.size（）-mid）；
对于（int i=0；i如果（i2>=right.size（）| |（i1如果您的合并方法正常（我不测试它），您忘记将左右合并以进行输入，请按如下所示编辑代码，然后重试：

 // This is called recursion. Calling a method again within the  
 //method until the value of left and right becomes 1.
 left=mergeSort(left); 
 right=mergeSort(right);

 merge(left,right,Input);

希望对您有所帮助！
导入java.util.ArrayList；
import java.util.ArrayList;
import java.io.*;
import java.util.*;

public class Mergesort1 {

    public static void main(String[] args) {
        ArrayList<Integer> values = new ArrayList<Integer>();
        int zeilen = 0;

        try{
            FileInputStream in = new FileInputStream(args[0]);
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String line;
            while((line = reader.readLine()) != null){
                values.add(Integer.parseInt(line));
                zeilen++;
            }
            try{  
                FileOutputStream out = new FileOutputStream(args[1]);
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));

                sort(values); //sortien array list
                for (int i=0; i<values.size(); i++){
                    writer.write("" + values.get(i));
                    writer.newLine();
                }
                writer.close();
            }
            catch(Exception e){
                System.out.println(e);
            }
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
      public static ArrayList<Integer> sort( ArrayList<Integer> values)
        {
            if (values.size() ==1){
                return values;
            }
            else {
                int mid= values.size()/2;
                ArrayList<Integer> left= new ArrayList<Integer>(mid);
                ArrayList<Integer> right=new ArrayList<Integer>(values.size()-mid);

               for (int i = 0; i < mid; i++) {
                   left.add(values.get(i));
                   } 

               for (int i = mid; i < values.size(); i++) {
                   right.add(values.get(i));
               } 

               left=sort(left); 
               right=sort(right);
               merge(left,right,values);
            }
               return values;
        }


        public static void merge (ArrayList<Integer>left,ArrayList<Integer>right,ArrayList<Integer>values)
        {
            int i1=0;// left Index
            int i2=0;// right Index
            int InputIndex=0;



            for (int i = 0; i < values.size(); i++) {

                if(i1==left.size()){
                    values.set(i, right.get(i2));
                    i2++;
                }
                else{
                    if (i2==right.size()){
                        values.set(i,left.get(i1));
                        i1++;
                    }
                    else{
                        if (left.get(i1)<=right.get(i2)) {
                            values.set(i,left.get(i1));
                            i1++;
                        }
                        else {
                            if (left.get(i1)>=right.get(i2)) {
                            values.set(i, right.get(i2));
                            i2++;
                            }
                        }
                    }
                }

            }
        }
}

导入java.io.*；
导入java.util.*；
公共类合并器1{
公共静态void main（字符串[]args）{
ArrayList值=新的ArrayList（）；
int-zeilen=0；
试一试{
FileInputStream in=新的FileInputStream（args[0]）；
BufferedReader reader=新的BufferedReader（新的InputStreamReader（in））；
弦线；
而（（line=reader.readLine（））！=null）{
add（Integer.parseInt（line））；
zeilen++；
}
试试{
FileOutputStream out=新的FileOutputStream（args[1]）；
BufferedWriter writer=new BufferedWriter（new OutputStreamWriter（out））；
排序（值）；//排序数组列表
对于（int i=0；如果从您正在调用
merge
method的地方调用，我有多傻啊？我应该在调用递归方法之后调用merge（左，右，输入）！left=mergeSort（左）；right=mergeSort（右）；merge（左，右，输入）；right？我现在得到一些错误。比如：线程中的异常“main”java.lang.IndexOutOfBoundsException:索引：1，大小：1在java.util.ArrayList.rangeCheck（ArrayList.java:635）在java.util.ArrayList.get（ArrayList.java:411）在Sort.MergeSortExp1.merge（MergeSortExp1.java:66）在Sort.MergeSortExp1.MergeSortExp1.MergeSortExp1在Sort.MergeSortExp1.MergeSortExp1.java:51）在Sort.MergeSortExp1.main（MergeSortExp1.java:28）你能解释一下，我是在哪里犯的错误吗？好了，问题解决了，一切正常。感谢所有试图帮助我的人。