关于算法:算法冒泡排序法的原理

冒泡排序的根本思维就是：从无序序列头部开始，进行两两比拟，依据大小替换地位，直到最初将最大（小）的数据元素替换到了无序队列的队尾，从而成为有序序列的一部分；下一次持续这个过程，直到所有数据元素都排好序。
算法的外围在于每次通过两两比拟替换地位，选出残余无序序列里最大（小）的数据元素放到队尾

上面用流程来形容冒泡排序的运作过程：
假如有一个数组 arr

package main
import "fmt"
func main() {var arr [5]int = [5]int{-1, 2, 7, 3, 0}
}

为了不便示意数据，咱们将
-1设为 A；
2 设为 B；
7 设为 C；
3 设为 D
0 设为 E

第一次大循环

大循环	A	B	C	D	E	小循环两两比拟
	-1	2	7	3	0
第 1 次循环	-1	2				A 和 B
………		2	7			B 和 C
………			3	7		C 和 D
………				0	7	D 和 E
后果	-1	2	3	0	7	小循环比拟 4 次

当进行第 1 循环时，对数组共排了 4 次
此时后果为 [-1, 2, 3, 0, 7]

第二次大循环

大循环	A	B	C	D	E	小循环两两比拟
	-1	2	3	0	7
第 2 次循环	-1	2				A 和 B
………		2	7			B 和 C
………			0	3		C 和 D
后果	-1	2	0	3	7	小循环比拟 3 次

当进行第 2 循环时，对数组共排了 3 次
此时后果为 [-1, 2, 0, 3, 7]

第三次大循环

大循环	A	B	C	D	E	小循环两两比拟
	-1	2	0	3	7
第 3 次循环	-1	2				A 和 B
………		0	2			B 和 C
后果	-1	0	2	3	7	小循环比拟 3 次

当进行第 3 循环时，对数组共排了 2 次
此时后果为 [-1, 0, 2, 3, 7]

第四次大循环

大循环	A	B	C	D	E	小循环两两比拟
	-1	2	0	3	7
第 4 次循环	-1	2				A 和 B
后果	-1	0	2	3	7	小循环比拟 1 次

当进行第 4 循环时，对数组共排了 1 次
此时后果为 [-1, 0, 2, 3, 7]

总结：
设数组长度为 len，大循环次数为 i，小循环次数为 j
当 i = 1 时，j = len – 1 = 4;
当 i = 2 时，j = len – 2 = 3;
当 i = 3 时，j = len – 3 = 2;
当 i = 4 时，j = len – 4 = 1;

能够看出，i 和 j 的关系为 j = len – i
那么用代码示意就是

package main

import "fmt"

func main() {var arr [5]int = [5]int{-1, 2, 7, 3, 0}
   
   for i := 1; i < len(arr); i++ {  // 大循环
      for j := 0; j < len(arr) - i; j++ {  // 小循环，j = len - i
         if arr[j] > arr[j+1] {arr[j], arr[j+1] = arr[j+1], arr[j]
         }
      }
   }
   fmt.Println("新的 arr =", arr)
}

输入后果就是：

新的 a =  [-1 0 2 3 7]

第一次大循环

第二次大循环

第三次大循环

第四次大循环