基本排序算法-冒泡排序

---

函数运行机制
数组排序基础

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;
}