一、冒泡排序
1、两层循环嵌套
2、小则往上浮
记忆特点：双层循环、组内比较
var arr = [1,21,44,3,12,5,54,6,12,5,6,7];
var len = arr.length;
//外层循环控制循环的次数
for(var i = 0; i < len; i++){
//内层循环进行元素的比较，因为轮到最后一个需要排序的元素时已经排序好了，所以可以-1，不需要进行
for(var j = 0; j < len - i - 1; j++){
if(arr[j] > arr[j + 1]){
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//或者使用解构[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
}
}
}
console.log(arr)
二、选择排序
1、两层循环嵌套。
2、假定第一次循环的第一个数 i 是最小的值，保存其下标。
3、然后循环 i 后面的所有数和 i 比较，如果有更小的则保存其下标。
4、在第一趟循环即将结束时将 arr[i] 的值 替换为 arr[minIndex]。
记忆特点：一层循环最小值，二层循环换最小值，最后使用最小值（选择最小值）
var arr = [1,21,44,3,11,5,54,61,12,51,6,7];
var len = arr.length;
for(var i = 0; i < len; i++){
//假定第一趟下标为最小值
var minIndex = i;
//从假定值的后一个开始循环
for(var j = i + 1; j < len; j++){
if(arr[j] < arr[minIndex]){
minIndex = j;
}
}
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
console.log(arr)
三、插入排序
1、两层循环嵌套。
2、外层循环遍历每个元素。
3、内层循环将每次循环到的数和之前排序好的数进行比较。
记忆特点：比较排序好的（插入排序好的）
var arr = [1,21,44,3,11,5,54,61,12,51,6,7];
var len = arr.length;
//假设数组中第一个数已经排序好了，所以从 1 开始循环。
for(var i = 1; i < len; i++){
for(var j = i; j > 0; j --){
//如果当前循环到的比之前排序好的最大值都大，则不用继续此趟比较
if(arr[j] >= arr[j - 1]){
break;
}else{
[arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
}
}
}
console.log(arr)
四、快速排序
1、一层循环，需要递归。
2、以每次递归的第一个数组元素为基准数。
3、比基准数小放入left数组，比基准数大放入right数组。
4、如果小于等于1一个元素则不用进行下一次递归。
5、依次连接 左数组、基准数、右数组。
6、下图是浏览器中打印以下log的结果
console.log(left, ponit, right)
记忆特点：设置标记值，放入左右数组，递归（一层循环）
function quickSort(arr){
//递归出口
if(arr.length <= 1){
return arr;
}
var left = [];
var right = [];
var point = arr[0];
//第一个数组元素被设定为标记点，所以可以从下一个元素开始循环
for(var i = 1; i < arr.length; i++){
if(arr[i] < point){
left.push(arr[i]);
}else{
right.push(arr[i]);
}
}
//进行更深层的比较
return quickSort(left).concat(point, quickSort(right));
}
quickSort([3,44,38,5,47,15,36,26,27,2,46,4,19,50,48])
