Java中的选择排序产生不正确的结果

我是Java新手，我正在尝试编写一个选择排序程序。 下面是我的代码：

public class SelectionSort {
    public static int a[] = {6, 4, 9, 3, 1, 7};

    public static void main(String[] args) {
        int min, i, j;
        for(i = 0; i < a.length - 1; i++) {
            min = i ;
            for(j = i + 1; j < a.length; j++) {
                if (a[j] < a[min]) {
                    min = j; 
                }
                if (min != i) {
                    int temp = a[i];
                    a[i] = a[min];
                    a[min] = temp;
                }
            }
        }
        for (i = 0; i < a.length; i++) {
            System.out.println("a : " + a[i]);
        }
    }
}

我犯了一个小错误，我想不出来。谁能帮我修一下吗？

你就快到了

交换元素的部分应位于内环外部。

换句话说，您需要首先在数组的其余部分中找到最小的元素，然后将其交换到当前位置。现在，当你找到一个较小的数字时，你正在交换，并且在这个过程中，你无法跟踪这个较小数字的新位置

另一种修复代码的方法是将交换保持在原来的位置，但在每次交换后更新

min

：

if (min !=i) {
    int temp = a[i];
    a[i] = a[min];
    a[min]= temp;
    min = i;       /* Update `min' to reflect the number's new position */
}

这也会起作用，但效率相当低

---

另外，

if（min！=i）

检查是不必要的，因为将一个元素与其自身交换是无害的禁止操作。

您正在为每个内部循环的迭代交换元素，将下面的块置于内部循环之外。您应该只为外部循环的每个迭代交换

---

你为什么不能选择comparator系列。由于您是java新手，您也可以学习java提供的特性。检查下面的例子

import java.util.Comparator;

public class MyIntComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return (o1>o2 ? -1 : (o1==o2 ? 0 : 1));
    }
}
--------------------------------------------------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Simple2 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(7);
        list.add(2);
        list.add(1);
        Collections.sort(list, new MyIntComparable());
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

import java.util.Comparator；
公共类MyIntComparator实现Comparator{
@凌驾
公共整数比较（整数o1，整数o2）{
返回值（o1>o2-1:（o1==o2？0:1））；
}
}
--------------------------------------------------------
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公共类Simple2{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
增加（5）；
增加（4）；
增加（3）；
增加（7）；
增加（2）；
增加第（1）款；
Collections.sort（list，new MyIntComparable（））；
用于（整数：列表）{
System.out.println（整数）；
}
}
}

处理任何算法的简单逻辑是分成多个步骤：
###第一步− 将最小值设置为位置0或任何高值
###步骤2− 搜索列表中的最小元素
###步骤3− 以最小指数交换价值
###步骤4− 重复，直到迭代结束
e、 g.

14、33、27、10、35、19、42、44

**10**、33、27、**14**、35、19、42、44

10、**14**、27、**33**、35、19、42、44

10、14、**19**、33、35、**27**、42、44

10、14、19、**27**、35、**33**、42、44

10、14、19、27、**33**、**35**、42、44

10、14、19、27、33、35、**42**、44未找到最小值时跳过
final int[]intArr=new int[]{14,33,27,10,35,19,42,44}；
int指数=-1；
布尔isMin；
对于（int i=0；i=intArr[j]）{
最小值=intArr[j]；
指数=j；
isMin=真；
}
}
if（isMin）{
intArr[index]=intArr[i]；
intar[i]=min；
}
}
Arrays.stream（intArr）.forEach（System.out:：println）；

哦，是的，我现在拿到了。但是，如果交换代码在内部循环中，会发生什么情况？@Newbie-每次

（min！=i）

条件为真时，您都在交换。您最终将交换一个已交换的值，即，您的数组在迭代中实际上会出现顺序错误（相对于每个迭代的预期输出）。但这并不能真正回答问题，不是吗？这是改变方法的答案。：）您的类是一个比较器，而不是一个可比较的类，因此请正确命名它。+1。您提供了短代码、输入、预期输出和实际输出。

         if (min !=i) {
                int temp = a[i];
                a[i] = a[min];
                a[min]= temp;
            }

import java.util.Comparator;

public class MyIntComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return (o1>o2 ? -1 : (o1==o2 ? 0 : 1));
    }
}
--------------------------------------------------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Simple2 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(7);
        list.add(2);
        list.add(1);
        Collections.sort(list, new MyIntComparable());
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

Simple logic to approach any algo is to break into multiple step :
    
### Step 1 − Set MIN to location 0 or any high Value
    ### Step 2 − Search the minimum element in the list
    ### Step 3 − Swap with value at index of minimum
    ### Step 4 − Repeat until iteration gets over
e.g. <br>
14, 33, 27, 10, 35, 19, 42, 44 <br>
**10**, 33, 27, **14**, 35, 19, 42, 44 <br>
10, **14**, 27, **33**, 35, 19, 42, 44 <br>
10, 14, **19**, 33, 35, **27**, 42, 44 <br> 
10, 14, 19, **27**, 35, **33**, 42, 44 <br>
10, 14, 19, 27, **33**, **35**, 42, 44 <br>
10, 14, 19, 27, 33, 35, **42**, 44 skip as no min found

    
    
        final int[] intArr = new int[]{14, 33, 27, 10, 35, 19, 42, 44};
        int index = -1;
        boolean isMin;
        for (int i = 0; i < intArr.length; i++) {
          int min = 999999999;
          isMin = false;
          for (int j = i + 1; j < intArr.length; j++) {
            if (intArr[j] < min && intArr[i] >= intArr[j]) {
              min = intArr[j];
              index = j;
              isMin = true;
            }
          }
          if (isMin) {
            intArr[index] = intArr[i];
            intArr[i] = min;
          }
        }
        Arrays.stream(intArr).forEach(System.out::println);