无法在 Java 中对 3 个浮点数进行排序

Question

I am wring program that sorts three integers. But I am not getting result for the input {1,3,2}. Probably some logic mistake in the 4th if statement.

The numbers are taken as input.

// program to sorting 3 double.

import java.util.*;

public class Sorting {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        System.out.println("Input the numbers for sorting");

        double num1 = in.nextDouble();
        double num2 = in.nextDouble();
        double num3 = in.nextDouble();

        double a = 0;
        double b = 0;
        double c = 0;

        if ((num1 > num2) && (num2 > num3)) {
            a = num1;
            b = num2;
            c = num3;
        }
        if ((num1 > num2) && (num3 > num2)) {
            a = num1;
            b = num3;
            c = num2;
        }

        if ((num2 > num1) && (num1 > num3)) {
            a = num2;
            b = num1;
            c = num3;
        }

        if ((num2 > num1) && (num3 > num1)) {
            a = num2;
            b = num3;
            c = num1;
        }

        if ((num3 > num1) && (num1 > num2)) {
            a = num3;
            b = num1;
            c = num2;
        }

        if ((num3 > num1) && (num2 > num1)) {
            a = num3;
            b = num2;
            c = num1;
        }
        System.out.println(" The numbers are in" + c + "< " + b + "< " + a);

    }
}

Answer 1

If you are happy with an array, you may use the Arrays.sort() method:

    double[] numbers = new double[] { num1, num2, num3 };
    Arrays.sort(numbers);
    System.out.println("The numbers are " + Arrays.toString(numbers));

Given input 1 3 2 this prints The numbers are [1.0, 2.0, 3.0] .

Answer 2

I would do it with arrays. Example :

class DoubleSorter {
    public double[] sorted;
    public boolean[] deleted;
    public int array_position=0;
    public int element_to_delete=0;
    public DoubleSorter() {
    }
    public void self_calling_sorter(double[] numbers) {
        double bestnum=0;
        boolean finished=true;
        for (int i=0; i < numbers.length; i++) {
             if (deleted[i] == false) {
                 if (finished==true) { //First set to bestnum
                     bestnum=numbers[i];
                     element_to_delete=i;
                     finished=false;
                 }
                 else {
                     if (numbers[i] >= bestnum) {
                         bestnum=numbers[i];
                         element_to_delete=i;
                     }
                 }
             }
         }
         deleted[element_to_delete]=true;
         if (finished==false) {
             sorted[array_position]=bestnum;
             array_position++;
             self_calling_sorter(numbers);
         }
    }

    public double[] sort(double[] numbers) {
        sorted=new double[numbers.length];
        deleted=new boolean[numbers.length];
        for (int i=0; i < numbers.length; i++) {
             deleted[i]=false;
        }
        self_calling_sorter(numbers);
        return sorted;
    }
}

This function takes an array, looks for the biggest element, writes it down, sets it to null, calls itself, looks for the biggest element, excludes the taken, because they were set to null, writes the biggest number again...

Example of how it works :

numbers={1,3,2};
result={null,null,null};

First sorting :

result={3,null,null};
numbers={1,null,2};

Second sorting :

result={3,2,null};
numbers={1,null,null};

Third sorting :

result={3,2,1};
numbers={null,null,null};

A fourt sorting isnt executed because it notices that bestnum is null because it couldnt be set.

This function is more flexible and can sort a almost infinite amount of numbers much easier.

And here is how I would integrate it in your code :

import java.util.*;

public class Sorting {

    public static void main(String[] args) {
        DoubleSorter sorter=new DoubleSorter();
        Scanner in = new Scanner(System.in);
        System.out.println("How many numbers would you like to sort ?");
        int count = in.nextInt();
        double[] numbers=new double[count];
        for (int i=0; i < count; i++) {
             System.out.println("Number "+Integer.toString(i));
             numbers[i]=in.nextDouble();
        }
        System.out.println("The sorted list is : "+Arrays.toString(sorter.sort(numbers)));
    }
}

EDIT :

I saw this and realized that you'd probably like to sort them the other way round.

 System.out.println(" The numbers are in" + c + "< " + b + "< " + a);

Then you'll only have to change this :

if (numbers[i] >= bestnum) {
    bestnum=numbers[i];
    element_to_delete=i;
}

to this :

if (numbers[i] <= bestnum) {
    bestnum=numbers[i];
    element_to_delete=i;
}