Question

我正在尝试编写一个程序，生成一个由随机数填充的数组，然后对它们进行排序并将排序的数组作为单独的数组返回，以便比较这两个数组。

然而，一旦我创建了我的随机数组，然后尝试创建另一个已排序的数组，排序的数组“覆盖”随机数，当我尝试将其打印出来时，随机数会显示为已排序的数组。

我的问题是：我如何修改我的代码，以便我可以创建随机双精度数组，然后生成另一个独立的数组，该数组是该随机数的排序版本？

主：

import java.io.IOException;
import java.util.InputMismatchException;
import java.util.Scanner;


public class BubbleMain {

public static void main(String args[])throws IOException{

    int n;
    Scanner keyboard = new Scanner(System.in);

    while(true){
        try{
            System.out.println("Enter the size of the array");
            n = keyboard.nextInt();

            if(n >= 2){
                break;
            }
            System.out.println("Size must be 2 or greater");
        }catch(InputMismatchException e){
            System.out.println("Value must be an integer");
            keyboard.nextLine();
        }
    }


    double[] template = new double[n];
    double[] mess = Bubble.randPop(template);

    double[] tidy = Bubble.bubbleSort(mess);


    Bubble.printOut(mess);
    Bubble.printOut(tidy);


}
}

冒泡等级：

public class Bubble {

private double[] list;

public Bubble(double[] list){

    this.list = list;
}

public double[] getArray(){
    return list;
}

public static double[] randPop(double[] template){

    for(int i = 0; i < template.length; i++){
        template[i] = Math.random();
    }

    return template;
}



public static double[] bubbleSort(double[] mess){

    double[] tidy = new double[mess.length];

    for(int i=0; i<mess.length; i++)
    {
        for(int j=i + 1; j<mess.length; j++)
        {
            if(mess[i] > mess[j])
            {
                double temp = mess[i];
                mess[i] = mess[j];
                mess[j] = temp;
            }
        }
        tidy[i] = mess[i];
    }
    return tidy;
}




public static void printOut(double[] list){

    for(int i = 0; i < list.length; i++){
        System.out.println(list[i]);
    }
}

}

Answer 1

首先创建一个数组副本：

public static double[] bubbleSort(double[] mess){
    // Copy the array    
    double[] tidy = Arrays.copyOf(mess, mess.length);

    // sort
    for(int i=0; i<tidy.length; i++)
    {
        for(int j=i + 1; j<tidy.length; j++)
        {
            if(tidy[i] > tidy[j])
            {
                double temp = tidy[i];
                tidy[i] = tidy[j];
                tidy[j] = temp;
            }
        }
    }
    return tidy;
}

Answer 2

在bubbleSort中，您要对mess数组进行排序，然后将其分配给tidy。所以混乱将被排序，整洁也将引用排序的数组。

您需要copy数组到tidy

double[] tidy = Arrays.copyOf(mess, mess.length);

然后排序。

将冒泡排序作为单独的数组返回

2 个答案: