补充前俩次的具体例子（方便理解）

冒泡排序实例数组{5，3，4，1，2}

第一轮外层循环（i=0）

内层循环

要进行 n - i - 1 = 5 - 0 - 1 = 4 次比较

第 1 次比较：比较 arr[0]（值为 5）和 arr[1]（值为 3），因为 5 > 3，所以交换它们的位置，数组变为 {3, 5, 4, 1, 2}

第 2 次比较：比较 arr[1]（值为 5）和 arr[2]（值为 4），因为 5 > 4，所以交换它们的位置，数组变为 {3, 4, 5, 1, 2}

第 3 次比较：比较 arr[2]（值为 5）和 arr[3]（值为 1），因为 5 > 1，所以交换它们的位置，数组变为 {3, 4, 1, 5, 2}

第 4 次比较：比较 arr[3]（值为 5）和 arr[4]（值为 2），因为 5 > 2，所以交换它们的位置，数组变为 {3, 4, 1, 2, 5}

第一轮外层循环结束后，数组中最大的元素 5 被 “冒泡” 到了数组的末尾。此时末尾的 1 个元素 {5} 已经是有序的

第二轮外层循环（i=1）

内层循环

要进行 n - i - 1 = 5 - 1 - 1 = 3 次比较，因为第一轮已经确定了末尾的 1 个元素是最大且有序的，所以这次不需要再比较这个元素

第 1 次比较：比较 arr[0]（值为 3）和 arr[1]（值为 4），因为 3 < 4，所以不交换位置，数组仍为 {3, 4, 1, 2, 5}

第 2 次比较：比较 arr[1]（值为 4）和 arr[2]（值为 1），因为 4 > 1，所以交换它们的位置，数组变为 {3, 1, 4, 2, 5}

第 3 次比较：比较 arr[2]（值为 4）和 arr[3]（值为 2），因为 4 > 2，所以交换它们的位置，数组变为 {3, 1, 2, 4, 5}

第二轮外层循环结束后，此时未排序部分中最大的元素 4 被 “冒泡” 到了倒数第二个位置。此时末尾的 2 个元素 {4, 5} 已经是有序的

第三轮外层循环（i=2）

内层循环

要进行 n - i - 1 = 5 - 2 - 1 = 2 次比较

第 1 次比较：比较 arr[0]（值为 3）和 arr[1]（值为 1），因为 3 > 1，所以交换它们的位置，数组变为 {1, 3, 2, 4, 5}

第 2 次比较：比较 arr[1]（值为 3）和 arr[2]（值为 2），因为 3 > 2，所以交换它们的位置，数组变为 {1, 2, 3, 4, 5}

第三轮外层循环结束后，此时未排序部分中最大的元素 3 被 “冒泡” 到了倒数第三个位置。此时末尾的 3 个元素 {3, 4, 5} 已经是有序的

第四轮外层循环（i=3）

内层循环

要进行 n - i - 1 = 5 - 3 - 1 = 1 次比较

第 1 次比较：比较 arr[0]（值为 1）和 arr[1]（值为 2），因为 1 < 2，所以不交换位置，数组仍为 {1, 2, 3, 4, 5}

直接选择排序具体实例{9，3，2，1，3}

第一轮外层循环（i=0）

初始时，假定 min = i = 0，也就是假设数组的第一个元素 9 是最小值

内层循环

从 j = i + 1 = 1 开始，将 arr[j] 与 arr[min] 作比较：

当 j = 1 时，arr[1] = 3，由于 3 < 9，所以更新 min = 1

当 j = 2 时，arr[2] = 2，由于 2 < 3，所以更新 min = 2

当 j = 3 时，arr[3] = 1，由于 1 < 2，所以更新 min = 3

当 j = 4 时，arr[4] = 3，由于 3 > 1，所以 min 保持为 3

内层循环结束后，把 arr[i]（即 arr[0]）和 arr[min]（即 arr[3]）交换，数组变为 {1, 3, 2, 9, 3}。此时，数组的第一个位置已经放置了最小值。

第二轮外层循环（i=1）

假定 min = i = 1，也就是假设数组的第二个元素 3 是最小值

内层循环

从 j = i + 1 = 2 开始，将 arr[j] 与 arr[min] 作比较：

当 j = 2 时，arr[2] = 2，由于 2 < 3，所以更新 min = 2

当 j = 3 时，arr[3] = 9，由于 9 > 2，所以 min 保持为 2

当 j = 4 时，arr[4] = 3，由于 3 > 2，所以 min 保持为 2

内层循环结束后，把 arr[i]（即 arr[1]）和 arr[min]（即 arr[2]）交换，数组变为 {1, 2, 3, 9, 3}。此时，数组的前两个位置已经按从小到大的顺序排列好了

第三轮外层循环（i=2）

假定 min = i = 2，也就是假设数组的第三个元素 3 是最小值

内层循环从 j = i + 1 = 3 开始，将 arr[j] 与 arr[min] 作比较

当 j = 3 时，arr[3] = 9，由于 9 > 3，所以 min 保持为 2

当 j = 4 时，arr[4] = 3，由于 3 = 3，所以 min 保持为 2

因为 min 等于 i，所以不进行交换，数组依旧是 {1, 2, 3, 9, 3}。此时，数组的前三个位置已经按从小到大的顺序排列好了

第四轮外层循环（i=3）

假定 min = i = 3，也就是假设数组的第四个元素 9 是最小值

内层循环从 j = i + 1 = 4 开始，将 arr[j] 与 arr[min] 作比较

当 j = 4 时，arr[4] = 3，由于 3 < 9，所以更新 min = 4

内层循环结束后，把 arr[i]（即 arr[3]）和 arr[min]（即 arr[4]）交换，数组变为 {1, 2, 3, 3, 9}