compareTo对int数组进行排序

Question

我有一个整数数组，需要按升序排序。 我需要使用compareTo 。

我有一个问题的数组排序。 最大的数字出现在数组的最前面； 其余按升序排序。

驱动程序：import java.util.Scanner;

public class Driver2 {

    public static void main(String[] args) {

        int prior,compareResult;
        String task;
        Task[] taskList = new Task[4];
        int [] taskListPrior = new int[4];
        Scanner scan = new Scanner(System.in);


        System.out.print("Enter priority (between 1 & 10) for breakfast: ");
        prior = scan.nextInt();
        task = "eatBreakfast";

        Task eatBreakfast = new Task(prior,task);
        System.out.println("Breakfast priority is: " + eatBreakfast.getPriority());
        taskList[0] = eatBreakfast;
        taskListPrior[0] = eatBreakfast.getPriority();

        System.out.print("Enter priority (between 1 & 10) for lunch: ");
        prior = scan.nextInt();
        task = "eatLunch";

        Task eatLunch = new Task(prior,task);
        System.out.println("Lunch priority is: " + eatLunch.getPriority());
        taskList[1] = eatLunch;
        taskListPrior[1] = eatLunch.getPriority();

        System.out.print("Enter priority (between 1 & 10) for dinner: ");
        prior = scan.nextInt();
        task = "eatDinner";

        Task eatDinner = new Task(prior,task);
        System.out.println("Dinner priority is: " + eatDinner.getPriority());
        taskList[2] = eatDinner;
        taskListPrior[2] = eatDinner.getPriority();

        System.out.print("Enter priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        task = "haveNap";

        Task haveNap = new Task(prior,task);
        System.out.println("Nap priority is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        taskListPrior[3] = haveNap.getPriority();

        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        System.out.print("Enter new priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        haveNap.setPriority(prior);
        System.out.println("New priority for nap is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        taskListPrior[3] = haveNap.getPriority();
        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        Task tempTask;
        int tempTaskPrior;
        for(int current = 0 ; current < taskList.length ; current++) 
        {
                for(int i = 1 ; i < (taskList.length) ; i++)
                {
                    compareResult = (taskList[current]).compareTo(taskList[i]);
                    if(compareResult == 1){
                        tempTask = (taskList[i]);
                        tempTaskPrior = (taskListPrior[i]);
                        taskList[i] = (taskList[current]);
                        taskListPrior[i] = (taskListPrior[current]);
                        taskList[current]  = tempTask;
                        taskListPrior[current] = tempTaskPrior;
                    }
                  }
        }

        System.out.println("Printing sorted list of task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        }

}

任务类：公共类任务实现Priority，Comparable {public int Prior，priorityQuery，priorityNum; public String task，taskItem，fullTask​​; 任务taskName;

    public Task(int priorityQuery, String taskQuery){
        task = taskQuery;
        if (priorityQuery >= minPriority && priorityQuery <= maxPriority)
            prior = priorityQuery;
        else
            System.out.println("Out of valid range, task will have no priority");
    }

    public void setPriority(int priority)
    {
        if (priority >= minPriority && priority <= maxPriority)
            prior = priority;
            else
            System.out.println("Out of valid range, task will have no priority");
    }

    public int getPriority()
    {
        return prior;
    }

    public String toString(){
        taskItem = task;

        return taskItem;
    }

    public Task getTaskName(){
        return taskName;
    }

    public int compareTo(Task compTask){
        if (this.getPriority() < compTask.getPriority())
            return 1;
        else if (this.getPriority() > compTask.getPriority())
            return -1;
        else 
            return 0;

    }

}

实际上有两个并行数组，一个用于compareTo方法的数组仅由整数组成。

Answer 1

该排序例程有问题。 每次从1开始启动内部循环，因此current可能大于i 。 因此，它将（在某些情况下）将原位替换为原位。

正确的答案是使用java.util.Arrays.sort() 。

如果您对排序算法感兴趣，请编写一个独立的类并实现一个单元测试脚本，以确保在嵌入代码之前它可以工作。

Answer 2

如前所述，您应该尝试使用Arrays.sort(Object[] array)解决方案：

public class Driver {

    public static void main(String[] args) {

        int prior, compareResult;
        String task;
        Task[] taskList = new Task[4];
        Scanner scan = new Scanner(System.in);

        System.out.print("Enter priority (between 1 & 10) for breakfast: ");
        prior = scan.nextInt();
        task = "eatBreakfast";

        Task eatBreakfast = new Task(prior, task);
        System.out.println("Breakfast priority is: " + eatBreakfast.getPriority());
        taskList[0] = eatBreakfast;

        System.out.print("Enter priority (between 1 & 10) for lunch: ");
        prior = scan.nextInt();
        task = "eatLunch";

        Task eatLunch = new Task(prior, task);
        System.out.println("Lunch priority is: " + eatLunch.getPriority());
        taskList[1] = eatLunch;

        System.out.print("Enter priority (between 1 & 10) for dinner: ");
        prior = scan.nextInt();
        task = "eatDinner";

        Task eatDinner = new Task(prior, task);
        System.out.println("Dinner priority is: " + eatDinner.getPriority());
        taskList[2] = eatDinner;

        System.out.print("Enter priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        task = "haveNap";

        Task haveNap = new Task(prior, task);
        System.out.println("Nap priority is: " + haveNap.getPriority());
        taskList[3] = haveNap;

        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

        System.out.print("Enter new priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        haveNap.setPriority(prior);
        System.out.println("New priority for nap is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

        //  Sort this      
        Arrays.sort(taskList);

        System.out.println("Printing sorted list of task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

    }

}

我删除了所有对int [] taskListPrior = new int[4];引用int [] taskListPrior = new int[4]; 这是没有意义的，并用简单的Arrays.sort(taskList)代替了排序算法。

您的Task类可能保持不变，但是您应该扩展其compareTo方法，以解决两个比较任务的优先级相同的情况。 我在任务字段上添加了一个比较：

public int compareTo(Task compTask) {
    if (compTask==null) return 1;

    if (this.getPriority() < compTask.getPriority())
        return 1;
    else if (this.getPriority() > compTask.getPriority())
        return -1;
    else
        return this.task.compareTo(compTask.task);

}