|
1 | 1 | ## 1. 冒泡排序算法思想 |
2 | 2 |
|
3 | | -> 冒泡排序(Bubble Sort)基本思想: |
| 3 | +> **冒泡排序(Bubble Sort)基本思想**: |
4 | 4 | > |
5 | | -> 第 `i (i = 1,2,... )` 趟排序时从序列中前 `n - i + 1` 个元素的第 `1` 个元素开始,相邻两个元素进行比较,若前者大于后者,两者交换位置,否则不交换。 |
| 5 | +> 第 `i (i = 1, 2, ...)` 趟排序时从序列中前 `n - i + 1` 个元素的第 `1` 个元素开始,相邻两个元素进行比较,若前者大于后者,两者交换位置,否则不交换。 |
6 | 6 | |
7 | | -冒泡排序法是通过相邻元素之间的比较与交换,使值较小的元素逐步从后面移到前面,值较大的元素从前面移到后面,就像水底的气泡一样向上冒,故称这种排序方法为冒泡排序法。 |
| 7 | +简单来说,「冒泡排序法」通过相邻元素之间的比较与交换,使值较小的元素逐步从后面移到前面,值较大的元素从前面移到后面。 |
| 8 | + |
| 9 | +这个过程就像水底的气泡一样向上冒,这也是冒泡排序法名字的由来。 |
8 | 10 |
|
9 | 11 | ## 2. 冒泡排序算法步骤 |
10 | 12 |
|
11 | | -- 先将序列中第 `1` 个元素与第 `2` 个元素进行比较,若前者大于后者,则两者交换位置,否则不交换; |
12 | | -- 然后将第 `2` 个元素与第 `3` 个元素比较,若前者大于后者,则两者交换位置,否则不交换; |
13 | | -- 依次类推,直到第 `n - 1` 个元素与第 `n` 个元素比较(或交换)为止。经过如此一趟排序,使得 `n` 个元素中值最大元素被安置在序列的第 `n` 个位置上。 |
14 | | -- 此后,再对前 `n - 1` 个元素进行同样过程,使得该 `n - 1` 个元素中值最大元素被安置在第 `n - 1` 个位置上。 |
15 | | -- 然后再对前 `n - 2` 个元素重复上述过程,直到某一趟排序过程中不出现元素交换位置的动作,排序结束。 |
| 13 | +1. 第 `1` 趟排序,从序列中前 `n` 个元素的第 `1` 个元素开始,相邻两个元素依次进行比较和交换: |
| 14 | + 1. 先将序列中第 `1` 个元素与第 `2` 个元素进行比较,如果前者大于后者,则两者交换位置,否则不交换; |
| 15 | + 2. 然后将第 `2` 个元素与第 `3` 个元素比较,如果前者大于后者,则两者交换位置,否则不交换; |
| 16 | + 3. 依次类推,直到第 `n - 1` 个元素与第 `n` 个元素比较(或交换)为止。 |
| 17 | + 4. 经过第 `1` 趟排序,使得 `n` 个元素中第 `i` 个值最大元素被安置在第 `n` 个位置上。 |
| 18 | +2. 第 `2` 趟排序,从序列中前 `n - 1` 个元素的第 `1` 个元素开始,相邻两个元素依次进行比较和交换: |
| 19 | + 1. 先将序列中第 `1` 个元素与第 `2` 个元素进行比较,若前者大于后者,则两者交换位置,否则不交换; |
| 20 | + 2. 然后将第 `2` 个元素与第 `3` 个元素比较,若前者大于后者,则两者交换位置,否则不交换; |
| 21 | + 3. 依次类推,直到对 `n - 2` 个元素与第 `n - 1` 个元素比较(或交换)为止。 |
| 22 | + 4. 经过第 `2` 趟排序,使得数组中第 `2` 个值最大元素被安置在第 `n - 1` 个位置上。 |
| 23 | +3. 依次类推,对前 `n - 2` 个元素重复上述排序过程,直到某一趟排序过程中不出现元素交换位置的动作,则排序结束。 |
16 | 24 |
|
17 | 25 | ## 3. 冒泡排序动画演示 |
18 | 26 |
|
19 | | - |
| 27 | + |
| 28 | + |
| 29 | +1. 初始序列为:`[6, 2, 3, 5, 1, 4]`。 |
| 30 | +2. 第 `1` 趟排序,从序列中前 `6` 个元素的第 `1` 个元素开始,相邻两个元素进行比较和交换:: |
| 31 | + 1. 先将序列中第 `1` 个元素与第 `2` 个元素进行比较,也就是将 `6` 和 `2` 进行比较。因为 `6 > 2`,所以两者交换位置,交换位置后,`2` 在第 `1` 位,`6` 在第 `2` 位。 |
| 32 | + 2. 然后将第 `2` 个元素与第 `3` 个元素比较,也就是将 `2` 和 `3` 进行比较。因为 `2 < 3`,所以不用交换; |
| 33 | + 3. 依次类推,直到第 `5` 个元素与第 `6` 个元素比较(或交换)为止。 |
| 34 | + 4. 经过第 `1` 趟排序,使得 `6` 个元素中第 `6` 个值最大元素被安置在第 `6` 个位置上。此时序列变为: `[2, 3, 5, 1, 4, 6]`。 |
| 35 | +3. 第 `2` 趟排序,从序列中前 `5` 个元素的第 `1` 个元素开始,相邻两个元素进行比较和交换:: |
| 36 | + 1. 先将序列中第 `1` 个元素与第 `2` 个元素进行比较,也就是将 `2` 和 `3` 进行比较。因为 `2 < 3`,所以不用交换; |
| 37 | + 2. 然后将第 `2` 个元素与第 `3` 个元素比较,也就是将 `3` 和 `4` 进行比较。因为 `3 < 5`,所以不用交换; |
| 38 | + 3. 然后将第 `3` 个元素与第 `4` 个元素比较,也就是将 `5` 和 `1` 进行比较。因为 `5 > 1`,所以两者交换位置,交换位置后,`1` 在第 `3` 位,`5` 在第 `4` 位。 |
| 39 | + 4. 依次类推,直到第 `4` 个元素与第 `5` 个元素比较(或交换)为止。 |
| 40 | + 5. 经过第 `2` 趟排序,使得 `5` 个元素中第 `5` 个值最大元素被安置在第 `5` 个位置上。此时序列变为: `[2, 3, 1, 4, 5, 6]`。 |
| 41 | +4. 依次类推,对前 `4` 个元素重复上述排序过程,直到某一趟排序过程中不出现元素交换位置的动作,则排序结束。此时序列变为:`[1, 2, 3, 4, 5, 6]`。 |
20 | 42 |
|
21 | 43 | ## 4. 冒泡排序算法分析 |
22 | 44 |
|
23 | | -- 最好的情况下,初始时序列已经是从小到大有序(升序),则只需经过一趟 `n - 1` 次元素之间的比较,并且不移动元素,算法就可结束排序。此时,算法的时间复杂度为 $O(n)$。 |
24 | | -- 最差的情况是当参加排序的初始序列为逆序,或者最小值元素处在序列的最后时,则需要进行 `n - 1` 趟排序,总共进行 $∑^n_{i=2}(i−1) = \frac{n(n−1)}{2}$ 次元素之间的比较,因此,冒泡排序算法的平均时间复杂度为 $O(n^2)$。 |
25 | | -- 冒泡排序方法在排序过程中需要移动较多次数的元素。因此,冒泡排序方法比较适合于参加排序序列的数据量较小的情况,尤其是当序列的初始状态为基本有序的情况;而对于一般情况,这种方法是排序时间效率最低的一种方法。 |
26 | | -- 由于元素交换是在相邻元素之间进行的,不会改变值相同元素的相对位置,因此,冒泡排序法是一种 **稳定排序法**。 |
| 45 | +- **最佳时间复杂度**:$O(n)$。最好的情况下(初始时序列已经是升序排列),则只需经过 `1` 趟排序,总共经过 `n - 1` 次元素之间的比较,并且不移动元素,算法就可结束排序。因此,冒泡排序算法的最佳时间复杂度为 $O(n)$。 |
| 46 | +- **最坏时间复杂度**:$O(n^2)$。最差的情况下(初始时序列已经是降序排列,或者最小值元素处在序列的最后),则需要进行 `n - 1` 趟排序,总共进行 $∑^n_{i=2}(i−1) = \frac{n(n−1)}{2}$ 次元素之间的比较,因此,冒泡排序算法的最坏时间复杂度为 $O(n^2)$。 |
| 47 | +- **冒泡排序适用情况**:冒泡排序方法在排序过程中需要移动较多次数的元素,并且排序时间效率比较低。因此,冒泡排序方法比较适合于参加排序序列的数据量较小的情况,尤其是当序列的初始状态为基本有序的情况。 |
| 48 | +- **排序稳定性**:由于元素交换是在相邻元素之间进行的,不会改变值相同元素的相对位置,因此,冒泡排序法是一种 **稳定排序算法**。 |
27 | 49 |
|
28 | 50 | ## 5. 冒泡排序代码实现 |
29 | 51 |
|
30 | 52 | ```Python |
31 | 53 | class Solution: |
32 | 54 | def bubbleSort(self, arr): |
| 55 | + # 第 i 趟排序 |
33 | 56 | for i in range(len(arr)): |
| 57 | + # 从序列中前 n - i + 1 个元素的第 1 个元素开始,相邻两个元素进行比较 |
34 | 58 | for j in range(len(arr) - i - 1): |
| 59 | + # 相邻两个元素进行比较,如果前者大于后者,则交换位置 |
35 | 60 | if arr[j] > arr[j + 1]: |
36 | 61 | arr[j], arr[j + 1] = arr[j + 1], arr[j] |
37 | 62 |
|
|
0 commit comments