函数运行机制
数组排序基础
let ary = [10,20,30,40];
// splice(n,m) 从数组索引N开始，删除M个元素，把删除的部分以新数组包裹起来返回，原来数组发生改变
// let res = ary.splice(1,1);
// =>res [20]
// =>ary [10,30,40]
// splice(n,0,x) 从索引n开始，不删除，把x添加到索引n的前面
let res = ary.splice(1,0,'js')
console.log(res); //=>[]
console.log(ary);//=>[10,'js',30,40]
let ary1=[10,20];
let ary2=[30,40];
let res=ary1.concat('js',ary2);
console.log(res);//=>[10,20,'js',30,40]
let ary = [1,3,2,4,3,5,2];
ary.sort();
console.log(ary);//=>[1,2,2,3,4,5]
let ary = [12,45,28,35,4];
//局限性：不传递参数的情况下只能处理10以内的数字排序
ary.sort();
console.log(ary);//=>[12,28,35,4,45] 按照第一个字符排 若相同再按第二个字符排
ary.sort(function(a,b){
return a-b; //a是当前项，b是下一项 如果大于0 交换位置
});
console.log(ary);//=>[4,12,28,35,45]
冒泡排序
//思想：让数组中的当前项和后一项进行比较，如果当前项比后一项大，则两项交换位置（让大的靠后）即可
/*
*bubble: 实现冒泡排序
* @params
* ary [ARRAY] 需要排序的数组
* @return
* [ARRAY]排序后的新数组
*/
function bubble(){
let temp=null;
// 外层循环I控制比较的轮数
for(let i=0;i<ary.length-1;i++){
// 里层循环控制每一轮比较的次数J
for(let j=0;j<ary.length-1-i;j++){
if(ary[j]>ary[j+1]){
//
temp=ary[j];
ary[j]=ary[j+1];
ary[j+1]=temp;
}
}
}
return ary;
}
let ary = [12,8,24,16,1];
ary=bubble(ary);
console.log(ary);
基本思想就是逐个的比较
分步运行
//js
function bubleSort(arr){
var len = arr.length;
for(let outer = len; outer >=2; outer--){
for(len inner = 0; inner <=outer - 1;inner++){
if(arr[inner] > arr[inner + 1]){
let temp = arr[inner];
arr[inner] = arr[inner + 1];
let[inner + 1] = temp;
}
}
}
return arr;
}
外层循环，从最大值开始递减，因为内层是两两比较，因此最外层当>=2时即可停止；
内层是两两比较，从0开始，比较inner与inner+1，因此，临界条件是inner<outer -1
- es6方法
arr2 = [1,2,3,4];
[arr2[0],arr2[1]] = [arr2[1],arr2[0]] //ES6解构赋值
console.log(arr2) // [2, 1, 3, 4]
//es6优化
function bubleSort(arr) {
var len = arr.length;
for (let outer = len ; outer >= 2; outer--) {
for(let inner = 0; inner <=outer - 1; inner++) {
if(arr[inner] > arr[inner + 1]) {
[arr[inner],arr[inner+1]] = [arr[inner+1],arr[inner]]
}
}
}
return arr;
}
