Java 与嵌套循环混淆

我知道嵌套循环背后的原理，但这一点让我对它想要揭示的原因感到困惑：

public static LinkedList LinkedSort(LinkedList list)
{
   for(int k = 1; k < list.size(); k++)
    for(int i = 0; i < list.size() - k; i++)
    {
        if(((Birth)list.get(i)).compareTo(((Birth)list.get(i + 1)))>0)
        {
            Birth birth = (Birth)list.get(i);
            list.set( i,  (Birth)list.get( i + 1));
            list.set(i + 1, birth);
    }
}
return list;
}

公共静态LinkedList LinkedSort（LinkedList列表）
{
对于（int k=1；k0
{
出生=（出生）列表。获取（i）；
set（i，（出生）list.get（i+1））；
列表.集合（i+1，出生）；
}
}
退货清单；
}

---

为什么我比i+1大，然后交换i和i+1？我知道对于这种编码，I+1等于k，但从我的观点来看，I不可能大于k，对吗？运行结果会是什么样子？我很困惑这段代码想告诉我什么，希望你们能帮我澄清我的疑问，谢谢。

示例：您有一个数字列表，您希望按升序排序：

4 2 3 1

第一次迭代执行这些交换操作：

swap（4，2）

，

swap（4，3）

，

swap（4，1）

。第一次迭代后的中间结果是

2 3 1 4

。换句话说，我们能够确定哪个数字是最大的，并且不需要迭代中间结果的最后一项

在第二次迭代中，我们通过以下操作确定第二大数：

swap（3，1）

。中间结果看起来是

2 1 3 4

---

第三次迭代结束时，我们有一个排序列表。

此方法实现了冒泡排序。它按升序重新排列列表中的元素。此代码中没有显示要排序的确切数据，实际比较是在“出生#比较”中进行的

让我们先看看内部循环。它进行实际的排序。内部循环在列表上迭代，并将位置0处的元素与位置1处的元素进行比较，然后将位置1处的元素与位置2处的元素进行比较，以此类推。每次，如果较低的元素大于较高的元素，则将交换它们

在第一次完整运行内部循环之后，列表中的最大值现在位于列表的末尾，因为它总是大于与之比较的值，并且总是被交换。（用纸上的数字试试看会发生什么）

内部循环现在必须再次运行。它可以忽略最后一个元素，因为我们已经知道它包含最大的值。第二次运行后，第二大值位于倒数第二位

必须重复此操作，直到对整个列表进行排序

这就是外部循环所做的。它以精确的次数运行内部循环，以确保列表已排序。它还为内部循环提供了它必须比较的最后一个位置，以忽略已排序的零件。这只是一个优化，内部循环可以忽略k，如下所示：

for(int i = 0; i < list.size() - 1; i++)

for（int i=0；i

---

这将得到相同的结果，但需要更长的时间，因为内部循环每次都会不必要地比较列表末尾已排序的值。

感谢您的详细解释，我明白了。泛型将使您的生活更轻松。