一。 冒泡排序
原理：
相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小的数就被排在了第一 位， 第二趟也是如此，如此类推，直到所有的数据排序完成。
规律：
冒泡排序每一轮排序，都可以找出一个较大的值，放在最后面
结论：
比较轮数 = 数组长度 - 1；
每一轮比较的次数 = 数组长度 - 当前的轮数
要点分析：
1、 双层循环
2、外层循环 （控制每次）， 内层循环 （需要遍历 ，到最大长度）。
（因为经过一次内层遍历可以把一个元素放置在正确位置，
因此下次内层循环的最大长度只需要数组长度减1）
3、内层循环控制找出最大的数字并交换到数组最后面。
把一个乱序的数组按照一定的算法结果排序好
1：交换两个数据的位置，利用第三个变量
var tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
口诀
双层 for 循环，一层减一次，里层减外层，变量相交换 (目的：比较数组中的数值大小)
let arr = [5,4,3,2,1]
5,4,3,2,1
第一次比较 5-1
4 5 3 2 1
4 3 5 2 1
4 3 2 5 1
4 3 2 1 5
第二次 5-2
3 4 2 1 5
3 2 4 1 5
3 2 1 4 5
第三次 5-3
2 3 1 4 5
2 1 3 4 5
第四次 5-4
1 2 3 4 5
结论：
比较轮数 = 数组长度 - 1；
每一轮比较的次数 = 数组长度 - 当前的轮数
两个变量交换数值
let a = 10
let b = 20
let c ;
c = a // a = 10
a = b // a = 20
b = c // b = 10
console.log(a,b);
一个数组的排序
let arr = [5, 6, 3, 4, 1, 100, 89]
// 双重For循环，一层减一次，里层减外层，变量相交换
// arr.length为数组长度，冒泡排序比较轮数等于数组长度-1(也就是一层减一次)
for (i = 0; i < arr.length - 1; i++) {
// arr.length-1-i就代表每一轮比较的次数等于数组长度-当前轮数（里层减外层）
for (j = 0; j < arr.length - 1 - i; j++) {
// 每一次对比是前面的一个数和后面的一个数做对比(arr[j]>arr[j+1])
if (arr[j] > arr[j + 1]) {
// 设置一个变量map=arr[j+1],就是map=arr[j+1]的值，arr[j+1]的值保持不变
let map = arr[j + 1]
// 设置arr[j+1]=arr[j],就是把arr[j]的值给arr[j+1],arr[j]不变 l
arr[j + 1] = arr[j]
// map的值给arr[j] arr[j] = map
}
}
}
console.log(arr)
二。选择排序
规则：
选出一个位置，让这个位置上的数和后面所有的数进行比较，如果比较出大小就交换两个数的位置
规律：
每一轮都能选出一个最小数，放在选中的位置上
结论：
比较的轮数 = 数组的长度 - 1；
每一轮比较的次数 = 数组长度 - 当前的轮数；
选择排序
[5,4,3,2,1]
5-1 第一次比较
4 5 3 2 1
3 5 4 2 1
2 5 4 3 1
1 5 4 3 2
5-2 第二次
1 4 5 3 2
1 3 5 4 2
1 2 5 4 3
5-3 第三次
1 2 4 5 3
1 2 3 5 4
5-4 第四次
1 2 3 4 5
一个数组的排序
<script>
let arr = [5,4,3,2,1]
// 外层 比较的是次数
for(let i = 0;i<arr.length-1;i++){
// 内层 j =i 每一层比较的次数
for (let j = i; j < arr.length; j++) {
// 位置上的元素
// j > j + 1
// j > i j 是次数 i 轮数 位置
// arr[j] 内层循环 遍历的数值
// arr[i] 外层循环遍历的位置
if (arr[j] < arr[i]) {
let tmp = arr[i]
arr[i] = arr[j]
arr[j] = tmp
}
}
}
console.log(arr);
</script>
