如何在java中实现降序选择排序？

我想实现一个选择排序方法，它接受整数数组并按降序排序。但是，诀窍是保持原始选择排序方法不变，而是使用简单的算术运算，并且在数组完成排序后不添加额外的循环来交换元素。这是我的代码，其思想是在局部变量中存储最大值和最小值的位置，并在内部循环完成迭代后将它们与相应的位置交换。我甚至尝试只使用一个变量来找到最小值并将其放在数组的末尾，但我失败了，我得到了错误的结果，我需要帮助发现错误。这是我的密码

public static void newSortMethod(int[]a){
    for(int i = 0; i < a.length-1; i++){
        int maxPosition=i;
        int minPosition=i;
        for(int j = i+1; j < a.length; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
            if(a[j] > a[maxPosition]){
                maxPosition = j;
            }
        }
        swap(a,maxPosition,i);
        swap(a,minPosition,a.length-i-1);
    }
    System.out.println();
}

public static void swap(int[]a, int i, int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

public static void main(String[] args) {
    int[] a = {2,6,3,9,5,4,8,7,0,13,-3,1};
    newSortMethod(a);
}

publicstaticvoidnewsortmethod（int[]a）{
for（int i=0；ia[maxPosition]）{
maxPosition=j；
}
}
交换（a、maxPosition、i）；
交换（a、最小位置、a、长度-i-1）；
}
System.out.println（）；
}
公共静态无效交换（int[]a，int i，int j）{
int temp=a[i]；
a[i]=a[j]；
a[j]=温度；
}
公共静态void main（字符串[]args）{
int[]a={2,6,3,9,5,4,8,7,0,13，-3,1}；
方法（a）；
}

这是到目前为止程序的输出

---

-3 8 2 9 13 5 4 6 3 1 7 0

您原来的算法是错误的。首先，

if

块应与

minPosition

和

maxPosition

进行比较，而不是与

i

进行比较。其次，如果同时选择最小值和最大值，则内部for循环应停止在

a.length-i

，而不是

a.length

（因为顶部的

i

元素也已排序）。这两种方法都可以作为升序算法

public static void newSortMethod(int[]a){
    for(int i = 0; i < a.length; i++){
        int maxPosition=i;
        int minPosition=i;
        for(int j = i+1; j < a.length - i; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
            if(a[j] > a[maxPosition]){
                maxPosition = j;
            }
        }
        swap(a,maxPosition,i);
        swap(a,minPosition,a.length-i-1);
    }
}

publicstaticvoidnewsortmethod（int[]a）{
for（int i=0；ia[maxPosition]）{
maxPosition=j；
}
}
交换（a、maxPosition、i）；
交换（a、最小位置、a、长度-i-1）；
}
}

要切换到降序，只需添加一行即可

public static void newSortMethod(int[]a){
    for(int i = 0; i < a.length; i++){
        int maxPosition=i;
        int minPosition=i;
        for(int j = i+1; j < a.length - i; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
            if(a[j] > a[maxPosition]){
                maxPosition = j;
            }
        }
        swap(a,minPosition,maxPosition); // <-- this line
        swap(a,maxPosition,i);
        swap(a,minPosition,a.length-i-1);
    }
}

publicstaticvoidnewsortmethod（int[]a）{
for（int i=0；ia[maxPosition]）{
maxPosition=j；
}
}
交换（a、最小位置、最大位置）你原来的算法是错误的。首先，
if
块应该与
minPosition
和
maxPosition
进行比较，而不是
i
。其次，如果你同时选择了最小值和最大值，那么你的内部for循环应该在
a.length-i
处停止，而不是
a.length
（因为顶部的
i
元素也会被排序）。这两种方法都可以作为升序算法

public static void newSortMethod(int[]a){
    for(int i = 0; i < a.length; i++){
        int maxPosition=i;
        int minPosition=i;
        for(int j = i+1; j < a.length - i; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
            if(a[j] > a[maxPosition]){
                maxPosition = j;
            }
        }
        swap(a,maxPosition,i);
        swap(a,minPosition,a.length-i-1);
    }
}

publicstaticvoidnewsortmethod（int[]a）{
for（int i=0；ia[maxPosition]）{
maxPosition=j；
}
}
交换（a、maxPosition、i）；
交换（a、最小位置、a、长度-i-1）；
}
}

要切换到降序，只需添加一行即可

public static void newSortMethod(int[]a){
    for(int i = 0; i < a.length; i++){
        int maxPosition=i;
        int minPosition=i;
        for(int j = i+1; j < a.length - i; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
            if(a[j] > a[maxPosition]){
                maxPosition = j;
            }
        }
        swap(a,minPosition,maxPosition); // <-- this line
        swap(a,maxPosition,i);
        swap(a,minPosition,a.length-i-1);
    }
}

publicstaticvoidnewsortmethod（int[]a）{
for（int i=0；ia[maxPosition]）{
maxPosition=j；
}
}
交换（a、minPosition、maxPosition）；//错误
首先，让我们看看代码中的问题。有一些问题，在编程中经常发生


您的代码仍在尝试使用
swap（a，minPosition，i）
进行升序排序，然后尝试将最大值放在末尾，这不是您想要的：您希望将最大值放在开头
您的
n
从未被修改，因此您将继续打印
0

样品溶液
现在让我们来看一些有效的方法。我不完全确定升序选择排序是什么样的，但我想应该是这样的：

public static void ascendingSortMethod(int[]a){
    int n = 0; // this is only to count how many times the swap method was called
    for(int i = 0; i < a.length-1; i++){
        int minPosition = i;
        for(int j = i+1; j < a.length; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
        }
        if(minPosition != i){ // check whether swap is necessary
            swap(a,minPosition,i);
            n ++;
        }
    }
    System.out.println(n);
}

错误
首先，让我们看看代码中的问题。有一些问题，在编程中经常发生


您的代码仍在尝试使用
swap（a，minPosition，i）
进行升序排序，然后尝试将最大值放在末尾，这不是您想要的：您希望将最大值放在开头
您的
n
从未被修改，因此您将继续打印
0

样品溶液
现在让我们来看一些有效的方法。我不完全确定升序选择排序是什么样的，但我想应该是这样的：

public static void ascendingSortMethod(int[]a){
    int n = 0; // this is only to count how many times the swap method was called
    for(int i = 0; i < a.length-1; i++){
        int minPosition = i;
        for(int j = i+1; j < a.length; j++){
            if(a[j] < a[minPosition]){
                minPosition = j;
            }
        }
        if(minPosition != i){ // check whether swap is necessary
            swap(a,minPosition,i);
            n ++;
        }
    }
    System.out.println(n);
}

你为什么要比较a[j]

a[i]？你不应该做

a[j]

？是的，这是许多错误中的一个。谢谢你的发现。你能把你得到的输出放进去吗？你为什么要比较

a[j]

a[i]

？你不应该做

a[j]

？是的，是众多错误中的一个。感谢您的发现。您能把您得到的输出放进去吗？我用输入尝试了这段代码{