冒泡排序算法

目录

举例说明

外层循环for(i=1;i;i++)

内循环for (int j = 0; j < n - i; j++)

思想：一次冒出一个数，相邻的两个元素，两两比较

//升序  for(i=1;i<n;i++) {     for(j=0;j<n-i;j++)     {         if(a[j]>a[j+1])         {             int temp = a[j];             a[j] = a[j+1];             a[j+1] = temp;         }     } }

冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复比较和交换相邻元素的方式来排序一个列表。

冒泡排序的详细步骤：

1. 初始化变量：

   • 定义一个数组 a 和它的长度 n。

2. 外循环：

   • 外循环从 i = 1 开始，直到 i < n。
   • 这个循环控制需要进行多少轮冒泡，每一轮都将一个未排序的最大元素移动到数组的末尾。

3. 内循环：

   • 内循环从 j = 0 开始，直到 j < n - i。
   • 这个循环比较并交换相邻的元素。随着外循环的进行，每一轮内循环的范围会减少，因为最大的元素逐渐被移到数组的末尾。

4. 比较和交换：

   • 在内循环中，如果 a[j] > a[j + 1]，则交换 a[j] 和 a[j + 1]。
   • 使用临时变量 temp 来辅助交换。

5. 重复步骤2到4：

   • 继续重复上述步骤，直到外循环完成。

举例说明

假设数组 a = [5, 3, 8, 4, 2]，长度 n = 5。

第1轮外循环 (i = 1)：

• 内循环 (j = 0 到 3):
  • 比较 a[0] 和 a[1]，5 > 3，交换，得到 [3, 5, 8, 4, 2]
  • 比较 a[1] 和 a[2]，5 < 8，不交换
  • 比较 a[2] 和 a[3]，8 > 4，交换，得到 [3, 5, 4, 8, 2]
  • 比较 a[3] 和 a[4]，8 > 2，交换，得到 [3, 5, 4, 2, 8]

第2轮外循环 (i = 2)：

• 内循环 (j = 0 到 2):
  • 比较 a[0] 和 a[1]，3 < 5，不交换
  • 比较 a[1] 和 a[2]，5 > 4，交换，得到 [3, 4, 5, 2, 8]
  • 比较 a[2] 和 a[3]，5 > 2，交换，得到 [3, 4, 2, 5, 8]

第3轮外循环 (i = 3)：

• 内循环 (j = 0 到 1):
  • 比较 a[0] 和 a[1]，3 < 4，不交换
  • 比较 a[1] 和 a[2]，4 > 2，交换，得到 [3, 2, 4, 5, 8]

第4轮外循环 (i = 4)：

• 内循环 (j = 0):
  • 比较 a[0] 和 a[1]，3 > 2，交换，得到 [2, 3, 4, 5, 8]

经过以上四轮冒泡，数组已经排序为 [2, 3, 4, 5, 8]。

这种方法确保每轮冒泡都会将当前未排序部分中的最大元素移动到正确的位置，最终完成排序。

外层循环for(i=1;i<n;i++)

在冒泡排序算法中，外循环的作用是控制经过多少次冒泡过程。每次冒泡过程都会将一个未排序的最大元素移动到数组的末尾。在经过 n-1 次冒泡后，整个数组就已经是有序的了。

• 外循环初始化 (int i = 1)： 外循环从 i 初始化为1开始。这里的 i 表示已经完成排序的轮数。

• 外循环条件 (i < n)： 外循环的条件是 i 必须小于数组的长度 n。这是因为在最坏情况下，我们需要进行 n-1 轮冒泡才能完全排序好数组。

• 每次迭代 (i++)： 在每次迭代结束时，i 自增1。随着 i 的增加，表示已经有 i 个最大的元素被移动到数组的末尾，因此下一轮内循环只需要考虑前 n-i 个元素。

外循环的作用是控制排序过程的进行次数，以确保数组最终有序。

内循环for(j = 0; j < n - i; j++)

内循环 是冒泡排序算法的核心部分之一。它的主要作用是遍历数组中还未排序的部分，通过比较和交换相邻元素，将较大的元素逐步“冒泡”到数组的末尾。下面是对内循环的详细解释：

内循环在每次外循环迭代时遍历数组的一部分，并通过相邻元素的比较和交换，将当前未排序部分的最大元素移动到该部分的末尾。随着外循环次数的增加，内循环的范围逐渐减小，因为每次外循环结束后，最大的元素已经被放到了正确的位置，不再需要参与后续的比较和交换。

1. 初始化变量 j：

   • 内循环变量 j 从0开始，这意味着每次从数组的第一个元素开始比较。

2. 内循环条件 (j < n - i)：

   • 内循环的条件是 j 必须小于 n - i，其中 n 是数组的长度，i 是当前的外循环次数。
   • 这种设置保证了每次外循环结束后，内循环的范围会减小 i，即不需要再比较已经排序好的元素。

3. 比较和交换相邻元素：

   • 在内循环中，每次比较 a[j] 和 a[j + 1]。如果前一个元素大于后一个元素，就交换这两个元素。
   • 使用一个临时变量 temp 来帮助交换。