当我们需要对一个数组进行排序时,可以使用冒泡排序算法。下面是一个详细的分解过程,以帮助你更好地理解冒泡排序的实现过程。
假设我们要对以下数组进行排序:
```c
int arr[] = {64, 34, 25, 12, 22, 11, 90};
```
第一趟排序:比较相邻的两个元素,如果前者大于后者,则交换它们的位置。
首先比较 `64` 和 `34`,发现 `64` 大于 `34`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {34, 64, 25, 12, 22, 11, 90};
```
接着比较 `64` 和 `25`,同样需要交换它们的位置。交换后的数组为:
```c
int arr[] = {34, 25, 64, 12, 22, 11, 90};
```
接着比较 `64` 和 `12`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {34, 25, 12, 64, 22, 11, 90};
```
接着比较 `64` 和 `22`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {34, 25, 12, 22, 64, 11, 90};
```
接着比较 `64` 和 `11`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {34, 25, 12, 22, 11, 64, 90};
```
最后比较 `64` 和 `90`,不需要交换它们的位置。第一趟排序完成后,数组变为:
```c
int arr[] = {34, 25, 12, 22, 11, 64, 90};
```
第二趟排序:再次比较相邻的两个元素,遍历到倒数第二个数,因为最后一个数已经是最大的了。
首先比较 `34` 和 `25`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {25, 34, 12, 22, 11, 64, 90};
```
接着比较 `34` 和 `12`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {25, 12, 34, 22, 11, 64, 90};
```
接着比较 `34` 和 `22`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {25, 12, 22, 34, 11, 64, 90};
```
接着比较 `34` 和 `11`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {25, 12, 22, 11, 34, 64, 90};
```
最后比较 `34` 和 `64`,不需要交换它们的位置。第二趟排序完成后,数组变为:
```c
int arr[] = {25, 12, 22, 11, 34, 64, 90};
```
第三趟排序:再次比较相邻的两个元素,遍历到倒数第三个数。
首先比较 `25` 和 `12`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {12, 25, 22, 11, 34, 64, 90};
```
接着比较 `25` 和 `22`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {12, 22, 25, 11, 34, 64, 90};
```
接着比较 `25` 和 `11`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {12, 22, 11, 25, 34, 64, 90};
```
最后比较 `25` 和 `34`,不需要交换它们的位置。第三趟排序完成后,数组变为:
```c
int arr[] = {12, 22, 11, 25, 34, 64, 90};
```
第四趟排序:再次比较相邻的两个元素,遍历到倒数第四个数。
首先比较 `12` 和 `22`,不需要交换它们的位置。接着比较 `22` 和 `11`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {12, 11, 22, 25, 34, 64, 90};
```
最后比较 `22` 和 `25`,不需要交换它们的位置。第四趟排序完成后,数组变为:
```c
int arr[] = {12, 11, 22, 25, 34, 64, 90};
```
第五趟排序:再次比较相邻的两个元素,遍历到倒数第五个数。
首先比较 `12` 和 `11`,需要交换它们的位置。交换后的数组为:
```c
int arr[] = {11, 12, 22, 25, 34, 64, 90};
```
最后比较 `12` 和 `22`,不需要交换它们的位置。第五趟排序完成后,数组变为:
```c
int arr[] = {11, 12, 22, 25, 34, 64, 90};
```
第六趟排序:再次比较相邻的两个元素,遍历到倒数第六个数。
首先比较 `11` 和 `12`,不需要交换它们的位置。接着比较 `12` 和 `22`,不需要交换它们的位置。最后比较 `22` 和 `25`,不需要交换它们的位置。第六趟排序完成后,数组变为:
```c
int arr[] = {11, 12, 22, 25, 34, 64, 90};
```
第七趟排序:再次比较相邻的两个元素,遍历到倒数第七个数。
首先比较 `11` 和 `12`,不需要交换它们的位置。接着比较 `12` 和 `22`,不需要交换它们的位置。接着比较 `22` 和 `25`,不需要交换它们的位置。最后比较 `25` 和 `34`,不需要交换它们的位置。第七趟排序完成后,数组变为:
```c
int arr[] = {11, 12, 22, 25, 34, 64, 90};
```
现在,数组已经按升序排列好了。冒泡排序的时间复杂度为 $O(n^2)$,并不是最优的排序算法,但是容易理解和实现。