【零基础学Python】算法-冒泡排序

def bubble_sort(arr):
    n = len(arr)  # 获取数组的长度
    for i in range(n):  # 外层循环
        for j in range(0, n-i-1):  # 内层循环
            if arr[j] > arr[j+1]:  # 比较相邻元素
                arr[j], arr[j+1] = arr[j+1], arr[j]  # 交换
    return arr

该代码实现了冒泡排序（Bubble Sort）算法。下面将详细解释代码中的循环部分及其运行过程，并标明是外层循环还是内层循环。

### 代码结构分析

```python
def bubble_sort(arr):
    n = len(arr)  # 获取数组的长度
    for i in range(n):  # 外层循环
        for j in range(0, n-i-1):  # 内层循环
            if arr[j] > arr[j+1]:  # 比较相邻元素
                arr[j], arr[j+1] = arr[j+1], arr[j]  # 交换
    return arr
```

### 外层循环

- **外层循环**: `for i in range(n):`
  - 这个循环的目的是控制需要进行多少次遍历。因为在每一轮遍历后，最大的元素会“冒泡”到数组的末尾，所以随着遍历次数的增加，待排序的元素数量逐渐减少。因此，外层循环的范围是从 `0` 到 `n-1`。

### 内层循环

- **内层循环**: `for j in range(0, n-i-1):`
  - 这个循环用于比较相邻的元素并进行交换。具体来说，它会遍历从 `0` 到 `n-i-1` 的索引，这样在每一轮中，它会比较 `arr[j]` 和 `arr[j+1]`，并在必要时进行交换。
  - 内层循环的范围随着外层循环的进行而减小，因为每完成一轮外层循环，最后的 `i` 个元素已经是排好序的，因此不再需要比较它们。

### 运行过程示例

以示例数组 `[64, 34, 25, 12]` 为例，分析每次循环的过程：

1. **第一次外层循环 (`i=0`)**:
   - 内层循环 (`j=0`): 比较 `64` 和 `34`，`64 > 34`，交换 → `[34, 64, 25, 12]`
   - 内层循环 (`j=1`): 比较 `64` 和 `25`，`64 > 25`，交换 → `[34, 25, 64, 12]`
   - 内层循环 (`j=2`): 比较 `64` 和 `12`，`64 > 12`，交换 → `[34, 25, 12, 64]`
   - 此时，`64` 已经是最大的元素，位于最后。

2. **第二次外层循环 (`i=1`)**:
   - 内层循环 (`j=0`): 比较 `34` 和 `25`，`34 > 25`，交换 → `[25, 34, 12, 64]`
   - 内层循环 (`j=1`): 比较 `34` 和 `12`，`34 > 12`，交换 → `[25, 12, 34, 64]`
   - 此时，`34` 已经在正确的位置。

3. **第三次外层循环 (`i=2`)**:
   - 内层循环 (`j=0`): 比较 `25` 和 `12`，`25 > 12`，交换 → `[12, 25, 34, 64]`
   - 此时，`25` 已经在正确的位置。

4. **第四次外层循环 (`i=3`)**:
   - 内层循环不执行，因为范围是 `0` 到 `n-i-1`，即 `0` 到 `0`，所以结束。

### 结果

最终，经过所有的循环，数组 `[64, 34, 25, 12]` 被排序为 `[12, 25, 34, 64]`，并返回。

### 总结

- **外层循环**负责控制遍历的次数，逐步减少待排序的元素。
- **内层循环**负责比较和交换相邻元素，确保每次遍历后最大的元素被移动到正确的位置。