Java 对三个命令行整数排序

您好，我正在尝试制作一个代码，从命令行获取三个整数，并将它们排序为最小值、中间值和最大值。我搞不懂中间的程序。它不会总是正确地对它们进行排序。你能帮忙吗

public class SortInteger{

public static int max3(int a, int b, int c) {
       int max = a;
       if (b > max) max = b;
       if (c > max) max = c;
       return max;
    }

public static int min3(int a, int b, int c) {
       int min = a;
       if (b < min) min = b;
       if (c < min) min = c;
       return min;}

public static int sort(int a, int b, int c){
    int sort = a;
        if (sort > b && sort < c) sort = a;
        else sort = b;
        if (sort > a && sort < c) sort = b;
        else sort =c;
        if (sort > c && sort < a) sort = c;
        else sort =b;
        if (sort > c && sort < b) sort = c;
        else sort = b;
        if (sort > a && sort < b) sort = c;
        else sort = c;
        return sort;
        }


public static void main(String[] args){
    int a= Integer.parseInt(args [0]);
    int b=Integer.parseInt(args[1]);
    int c=Integer.parseInt(args[2]);
    StdOut.println("Min is " + min3(a, b, c));
    StdOut.println("Mid is " + sort(a, b, c));
    StdOut.println("Max is " +  max3(a, b, c));


}

公共类排序器{
公共静态int max3（int a、int b、int c）{
int max=a；
如果（b>max）max=b；
如果（c>max）max=c；
返回最大值；
}
公共静态int min3（int a、int b、int c）{
int min=a；
如果（bb&&sorta&&sortc&&sortc&&sorta&&sort

}试试：

public static int mid(int a, int b, int c){
  return a + b + c - max(a,b,c) - min(a,b,c);
}

同样对于

min

和

max

只需使用

Math

：

public static int min(int a, int b, int c){
  return Math.min(Math.min(a,b),c);//Replace with Math.max for max.
}

尝试：

同样对于

min

和

max

只需使用

Math

：

public static int min(int a, int b, int c){
  return Math.min(Math.min(a,b),c);//Replace with Math.max for max.
}

---

在排序函数中，您正在全力以赴。以您的前两个if语句为例：

if (sort > b && sort < c) sort = a;
else sort = b;
if (sort > a && sort < c) sort = b;
else sort =c;

if（sort>b&&sorta&&sort

如果a在b和c之间，那么第一个If语句将为true，sort将作为a的值保留。但是，然后考虑下一个。a中的值不会大于a，因此第二个if语句将为false，并将sort更改为c，即使您已经发现a是中间值。不是你想要的。要解决这个问题，您可以更改if语句为true时执行的代码，以仅返回sort值。比如说：

if (sort > b && sort < c) return sort;
else sort = b;
if (sort > a && sort < c) return sort;
else sort =c;
// etc.

if（sort>b&&sorta&&sort

在排序功能中，您正在全力以赴。以您的前两个if语句为例：

if (sort > b && sort < c) sort = a;
else sort = b;
if (sort > a && sort < c) sort = b;
else sort =c;

if（sort>b&&sorta&&sort

如果a在b和c之间，那么第一个If语句将为true，sort将作为a的值保留。但是，然后考虑下一个。a中的值不会大于a，因此第二个if语句将为false，并将sort更改为c，即使您已经发现a是中间值。不是你想要的。要解决这个问题，您可以更改if语句为true时执行的代码，以仅返回sort值。比如说：

if (sort > b && sort < c) return sort;
else sort = b;
if (sort > a && sort < c) return sort;
else sort =c;
// etc.

if（sort>b&&sorta&&sort

尝试以下操作：

public class SortInteger
{
    //use general sorting algorithm for arbitrary length, this is for 3 length specifically
    public static int[] sort(int[] inputs)
    {
        int k;
        if(inputs[0] >= inputs[1])
        {
            k = inputs[0];
            inputs[0] = inputs[1];
            inputs[1] = k;
        }

        if(inputs[1] >= inputs[2])
        {
           k = inputs[1];
           inputs[1] = inputs[2];
           inputs[2] = k;
        }

        //incase our last element is less than our first we repeat:

        if(inputs[0] >= inputs[1])
        {
            k = inputs[0];
            inputs[0] = inputs[1];
            inputs[1] = k;
        }

        return inputs
    }

    public static void main(String[] args)
    {
        int[] x = new int[3];
        x[0] = Integer.parseInt(args[0]);
        x[1] = Integer.parseInt(args[1]);
        x[2] = Integer.parseInt(args[2]);
        x = sort(x);

       System.out.println("min is: " + x[0]);
       System.out.println("mid is: " + x[1]);
       System.out.println("max is: " + x[2]);
    }


}

请尝试以下操作：

public class SortInteger
{
    //use general sorting algorithm for arbitrary length, this is for 3 length specifically
    public static int[] sort(int[] inputs)
    {
        int k;
        if(inputs[0] >= inputs[1])
        {
            k = inputs[0];
            inputs[0] = inputs[1];
            inputs[1] = k;
        }

        if(inputs[1] >= inputs[2])
        {
           k = inputs[1];
           inputs[1] = inputs[2];
           inputs[2] = k;
        }

        //incase our last element is less than our first we repeat:

        if(inputs[0] >= inputs[1])
        {
            k = inputs[0];
            inputs[0] = inputs[1];
            inputs[1] = k;
        }

        return inputs
    }

    public static void main(String[] args)
    {
        int[] x = new int[3];
        x[0] = Integer.parseInt(args[0]);
        x[1] = Integer.parseInt(args[1]);
        x[2] = Integer.parseInt(args[2]);
        x = sort(x);

       System.out.println("min is: " + x[0]);
       System.out.println("mid is: " + x[1]);
       System.out.println("max is: " + x[2]);
    }


}

---

---

正在使用arg[0]，arg[1]。。。我认为你熟悉阵列。它们会让你的生活变得非常简单我对数组有点粗糙。谢谢大家！正在使用arg[0]，arg[1]。。。我认为你熟悉阵列。它们会让你的生活变得非常简单我对数组有点粗糙。谢谢大家！这是最好的方法，尽管我不会为此创建方法。转换为

int

是不必要的，

java.lang.Math

重载

min

和

max

以获取所有类型的基元类型：这是最好的方法，尽管我不会为此创建方法。转换为

int

是不必要的，

java.lang.Math

重载

min

和

max

以获取所有类型的基本类型：很高兴能够通过OP的代码来说明为什么它是错误的，而不是提供一个完全不同的解决方案（这也很有用）+1很高兴能够通过OP的代码来说明为什么它是错误的，而不是提供一个完全不同的解决方案（这也很有用）+1为什么要把它弄得这么复杂？看起来很直观，也许我被洗脑了，但是在数组上做一个排序方法，吐出来感觉很自然。上面提到的一些技巧很酷，但不是“最简单的思考方式”，而是“最简单的编码方式”，它们比上面提到的更容易思考。这是主观的，我相信缺乏支持票会捍卫你的立场，但在那之前最好离开它。目前，这是唯一一个提示如何使用阵列的解决方案。如果OP对扩展到4,5等感到好奇。。元素列表，这将成为唯一合理的策略，所以是的，在这种情况下它不是最干净的，但它有它的位置。同意，如果上述解决方案应用于3个以上的值，它就不干净了。为什么这么复杂？看起来够直观，也许我被洗脑了，但是在数组上创建一个排序方法，这样吐出来感觉很自然。上面提到的一些技巧很酷，但不是“最简单的思考方式”，而是“最简单的编码方式”，它们比上面提到的更容易思考。这是主观的，我相信缺乏支持票会捍卫你的立场，但在那之前最好离开它。目前，这是唯一一个提示如何使用阵列的解决方案。如果OP对扩展到4,5等感到好奇。。元素列表，这将成为唯一合理的策略，因此是的，在这种情况下它不是最干净的，但它有它的位置。同意，如果上述解决方案应用于3个以上的值，它将不干净。