今天我们来探讨一下选择排序和冒泡排序
冒泡排序的核心 就是如果当前项的值与后一项的值进行对比，如果前一项的值大于后一项，那么就将他的值调换位置
首先准备一个乱序数组
//遍历数组
var arr1 = [9, 3, 6, 4, 2, 1, 8, 5, 7]
// 0 1 2 3 4 5 6 7 8
console.log('原始数组',arr1);
for (var k = 0; k < arr1.length - 1; k++) {//决定执行几次所谓的 冒泡排序
console.log('这是第', k + 1 ,'次循环', '此时k === ' ,k);
//通过打印，我们发现有很多不必要的对比
//规律是每一轮判断的执行次数,减少k次
//k = 0 第一次循环 确定了下表为8的值
//k = 1 第二次循环 确定了下表为7 8的值
//k = 2 第三次循环 确定了下表为6 7 8的值
//k = 3 第四次循环 确定了下表为5 6 7 8的值
//k = 4 第五次循环 确定了下表为4 5 6 7 8的值
//k = 5 第六次循环 确定了下表为3 4 5 6 7 8的值
//k = 6 第七次循环 确定了下表为2 3 4 5 6 7 8的值
//k = 7 第八次循环 确定了下表为1 2 3 4 5 6 7 8的值
//k = 8 第九次循环 确定了下表为0 1 2 3 4 5 6 7 8的值
//通过分析我们得出最后一次循环没有必要，所以我们可以将外层循环 - 1
//优化2 优化3
//在打印之后，我们发现每一轮循环都有一些没有必要的判断
//每一次判断的执行次数，减少k次
for (var i = 0; i < arr1.length - 1 - k; i++) {//拿到所有的下标对应的值，执行第一次循环
//i的值是0到8，最后一次循环的时候i的值为8
// console.log(i);
console.log(arr1[i],arr1[i + 1]);
// console.log(arr1[i]);
//判断执行的时候是arr1[7]>arr1[8]进行对比
//不减一在判断执行的时候是arr1[8]>arr1[9]进行对比，因为没有arr1[9]所以要减一
if (arr1[i] > arr1[i + 1]) {
var temp = arr1[i];
arr1[i] = arr1[i + 1];
arr1[i + 1] = temp;
}
}
}
console.log('处理完的数据', arr1);
选择排序
//创建一个数组
var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
console.log('原始数组', arr);
// var minIndex = 0 //假设当前最小值的下标为 0
// for (var i = 1; i < arr.length; i++) {//i从1开始，如果不是从1开始那么就会产生arr[minIndex]的值域arr[i]的值相比较，两个都是0，就没有要比较的意义
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[0] //定义一个变量存储数组下标为0的值
// arr[0] = arr[minIndex]//将下标为0的值重新赋值 当前数组中最小的值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[0]原本的值 此时就完成了交换
// console.log('第一次选择排序之后的数组', arr);
// minIndex = 1 //假设当前最小值的下标为 1
// for (var i = 2; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[1] //定义一个变量存储数组下标为0的值
// arr[1] = arr[minIndex]//将下标为0的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[0]原本的值
// console.log('第二次选择排序之后的数组', arr);
// var minIndex = 2 //假设当前最小值的下标为 2
// for (var i = 3; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[2] //定义一个变量存储数组下标为0的值
// arr[2] = arr[minIndex]//将下标为0的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[0]原本的值
// console.log('第三次选择排序之后的数组', arr);
// var minIndex = 3 //假设当前最小值的下标为 3
// for (var i = 4; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[3] //定义一个变量存储数组下标为3的值
// arr[3] = arr[minIndex]//将下标为0的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[3]原本的值
// console.log('第四次选择排序之后的数组', arr);
// var minIndex = 4 //假设当前最小值的下标为 4
// for (var i = 5; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[4] //定义一个变量存储数组下标为4的值
// arr[4] = arr[minIndex]//将下标为4的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[4]原本的值
// console.log('第五次选择排序之后的数组', arr);
// var minIndex = 5 //假设当前最小值的下标为 5
// for (var i = 6; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[5] //定义一个变量存储数组下标为5的值
// arr[5] = arr[minIndex]//将下标为5的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[5]原本的值
// console.log('第六次选择排序之后的数组', arr);
// var minIndex = 6 //假设当前最小值的下标为 6
// for (var i = 7; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[6] //定义一个变量存储数组下标为6的值
// arr[6] = arr[minIndex]//将下标为4的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[6]原本的值
// console.log('第七次选择排序之后的数组', arr);
// var minIndex = 7 //假设当前最小值的下标为 7
// for (var i = 8; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
// minIndex = i
// }
// //for循环结束之后minIndex记录的就是真实的最小的值的下标
// //此时交换真实最小值与我们假设的最小值
// }
// var temp = arr[7] //定义一个变量存储数组下标为7的值
// arr[7] = arr[minIndex]//将下标为7的值重新赋值
// arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[7]原本的值
// console.log('第八次选择排序之后的数组', arr);
//将上述流程转化为循环
/*
第几次循环 假设谁是最小值 和谁交换 内层循环丛几开始
k == 0 1 0 0 1
k == 1 2 1 1 2
k == 2 3 2 2 3
k == 3 4 3 3 4
k == 4 5 4 4 5
*/
for (var k = 0;k < arr.length; k++) {
var minIndex = k
for (var i = k + 1; i < arr.length; i++) {//i从1开始，如果不是从1开始那么就会产生arr[minIndex]的值域arr[i]的值相比较，两个都是0，就没有要比较的意义
if (arr[minIndex] > arr[i]) {//如果当前if分支执行,说明在数组中找到了一个比假设最小的值更小的数
minIndex = i
}
//for循环结束之后minIndex记录的就是真实的最小的值的下标
//此时交换真实最小值与我们假设的最小值
}
var temp = arr[k] //定义一个变量存储数组下标为0的值
arr[k] = arr[minIndex]//将下标为0的值重新赋值 当前数组中最小的值
arr[minIndex] = temp//将下标minIndex的值重新赋值给arr[0]原本的值 此时就完成了交换
}
console.log('选择排序之后的数组', arr);
数据存储的区别
变量存储的的地方分两个 堆内存 栈内存
基本类型存储的在栈内存中，复杂数据类型本体存储到堆内存中，将数据地址存储到栈内存中，
赋值基本数据类型 就相当于把值复制了一份，复制以后两个变量没有关系，就相当于我有一张试卷，
我复制一张给你，让你书写答案，不会影响到我的这张试卷
复杂数据类型，变量存储的是地址，所以在进行变量赋值的时候就是将地址赋值给了另一个地址，相
当与两个变量存储的是同一个地址 就相当与我房间有一把钥匙，我把钥匙复制一份给你，你拥有了
我房间里的钥匙，我可以看到你对房间的布局和改变，所以在修改变量的值的时候会改变初始的值
注意 基本数据类型比较的是存储值的比较，复杂数据类型比较的是地址
基本数据类型 将值复制一份传递给形参，在函数内部修改，不会影响外界
基本数据类型 将数据存储的地址复制一份传递给形参，在函数内部修改，会影响外界
