有人能解释一下Java中元素的排序是如何工作的吗？

我对“排序开始”的评论感到困惑。谁能给我解释一下吗

class endsly {
    public static void main(String[] args) {

        int num[] = { 55, 40, 80, 65, 71 };
        int n= num.length;

        System.out.println("Given list:   ");
        for (int i = 0; i < n; i++) {
            System.out.println("  " + num[i]);
        }
        System.out.println("\n");

        //sorting begins

        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (num[i] < num[j]) {
                    int temp = num[i];
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        System.out.println("Sorted list:");
        for (int i = 0; i < n; i++) {
            System.out.println("  " + num[i]);
        }
        System.out.println("  ");
    }
}

class-endsly{
公共静态void main（字符串[]args）{
int num[]={55,40,80,65,71}；
int n=num.length；
System.out.println（“给定列表：”）；
对于（int i=0；i

这两个嵌套循环实现了算法的一种变体，在末尾有一个小的“扭曲”

• 数组的已排序部分位于

  i

  的左侧，即从0（含）到

  i

  的项目（不含）
• 嵌套循环遍历未排序的部分，将逐渐较小的项交换到

  num[i]

• 嵌套循环结束时，最小的未排序项位于

  num[i]

• 在外循环结束时，数组被排序

请注意，这与“经典”选择排序不同，后者从未排序的数组中拾取下一个最小的项，而不交换任何内容，并在嵌套循环的末尾执行单个交换。选择排序的传统实现如下所示：

for (int i = 0; i < n; i++) {
    int minPos = i;
    // Look for a position of the smallest element
    for (int j = i + 1; j < n; j++) {
        if (num[minPos] < num[j]) {
            minPos = j;
        }
    }
    // Perform the swap after the loop has ended
    int temp = num[i];
    num[i] = num[minPos];
    num[minPos] = temp
}

for（int i=0；i

您发布的算法是允许多个交换的，但相反（因此最大的元素放置在数组的头部，而不是最小的元素）。具有多个交换的选择排序（标准选择排序，其中最小元素移动到数组前面）的一般算法为：

for element i at 0 to n:
    for element j at i to n:
        if element at j is less than element at i:
            swap element at i with element at j

从元素

0

开始，该算法找到从索引

0

到索引

n

的最小值，并将其放置在索引

0

处。在下一次迭代中，算法从索引

1

到

n

找到最小值，并将其放置在索引

1

处。在下一次迭代中，算法从索引

2

到

n

找到最小值，并将其放置在索引

2

处。该算法一直持续到最后一次迭代，最后一次迭代从索引

n-1

到

n

找到最小值，并将其放置在索引

n

处

在您的算法的特定情况下，它不是在每次迭代中找到的最小值，而是最大值。因此，一旦数组被排序，数组将从最大值到最小值排序。作为参考，排序算法中的条件是

num[i]

，但更容易理解为

num[j]>num[i]

，这意味着如果

j

处的元素大于

i

处的元素，则应交换元素。通过更改代码以在每个步骤打印数组值，可以看到演示的每个步骤：

public static void main(String[] args) {

    int num[] = { 55, 40, 80, 65, 71 };
    int n= num.length;

    System.out.println("Before sorting");
    printArray(num);
    System.out.println();

    //sorting begins

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (num[i] < num[j]) {
                int temp = num[i];
                num[i] = num[j];
                num[j] = temp;
            }
        }
        System.out.print("Iteration i = " + i + ": ");
        printArray(num);
    }

    System.out.println("\nAfter sorting");
    printArray(num);
    System.out.println();
}

private static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print("  " + array[i]);
    }
    System.out.println();
}

从输出中可以看出，每次迭代都会依次找到最大值并将其向下移动。在第一次迭代中，

80

被移动到索引

0

；在第二个过程中，

71

被移动到索引

1

；以此类推，直到执行了5次迭代（与

num

的大小相匹配）。尽管迭代

i=4

似乎是浪费，但这仅适用于这种特殊情况，因为最后两个元素已经排序（当

65

和

55

在迭代

i=2

中交换时）

一般来说，一步一步地通过排序算法的每次迭代来了解算法在做什么是一个好主意。这也有助于确定算法的复杂性。在这种情况下，使用一组嵌套循环，其中外部循环从

0

运行到

n

，内部循环从

i

（从

0

开始）运行到

n

。这就产生了以下复杂性：n（n-1）（n-2）…或O（n2）。例如，假设数组中有

10个
元素；第一次迭代内部循环将运行
10次
；第二次迭代内部循环将运行
9
；等等有关更多信息，请参阅


问题中的算法与标准选择排序的不同之处在于，标准选择排序查找从
i
到
n
的最小（或最大）元素，并在迭代结束时最多执行一次交换。在这种情况下，不是在最后执行一次交换，而是在找到最小（或最大）值时立即执行交换，这可能会导致每次迭代进行一次以上的交换。这可以通过在每次执行交换时检测算法以打印数组值来证明：

public static void main(String[] args) {

    int num[] = { 55, 40, 80, 65, 71 };
    int n= num.length;

    System.out.println("Before sorting");
    printArray(num);
    System.out.println();

    //sorting begins

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (num[i] < num[j]) {
                int temp = num[i];
                num[i] = num[j];
                num[j] = temp;
                System.out.print("    Swap performed:");
                printArray(num);
            }
        }
        System.out.print("Iteration i = " + i + ": ");
        printArray(num);
    }

    System.out.println("\nAfter sorting");
    printArray(num);
    System.out.println();
}

private static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print("  " + array[i]);
    }
    System.out.println();
}

这类似于，你可以在维基百科上读到相当好的描述。@Turing85差不多。在冒泡排序中，比较相邻项。但这非常接近，也请注意，您的问题不是关于“Java中的元素如何排序”，而是特定代码如何工作<代码>数组。排序
或
集合。排序
（您通常指的是“在Java中对元素进行排序”）的工作方式完全不同。代码中的一些注释：类名应始终为星号
public static void main(String[] args) {

    int num[] = { 55, 40, 80, 65, 71 };
    int n= num.length;

    System.out.println("Before sorting");
    printArray(num);
    System.out.println();

    //sorting begins

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (num[i] < num[j]) {
                int temp = num[i];
                num[i] = num[j];
                num[j] = temp;
                System.out.print("    Swap performed:");
                printArray(num);
            }
        }
        System.out.print("Iteration i = " + i + ": ");
        printArray(num);
    }

    System.out.println("\nAfter sorting");
    printArray(num);
    System.out.println();
}

private static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print("  " + array[i]);
    }
    System.out.println();
}

Before sorting
  55  40  80  65  71

    Swap performed:  80  40  55  65  71
Iteration i = 0:   80  40  55  65  71
    Swap performed:  80  55  40  65  71
    Swap performed:  80  65  40  55  71
    Swap performed:  80  71  40  55  65
Iteration i = 1:   80  71  40  55  65
    Swap performed:  80  71  55  40  65
    Swap performed:  80  71  65  40  55
Iteration i = 2:   80  71  65  40  55
    Swap performed:  80  71  65  55  40
Iteration i = 3:   80  71  65  55  40
Iteration i = 4:   80  71  65  55  40

After sorting
  80  71  65  55  40