web前端 js学习 第七天 （数组--冒泡，选择排序）

 基本数据类型存储在栈内存中  -- 存储的是值

 引用数据类型存储在堆内存中  -- 存储的是地址

    数组的深拷贝和浅拷贝
        浅拷贝实际上拷贝的是地址
        深拷贝实际上拷贝的是值

数值常用方法2：

    splice   删除/替换/插入元素   --- 直接改变原数组   -- 返回被删除的数据，得到的是数组
    concat  合并多个数组   -- 不会改变原数组
    join  数组变成字符串
    reverse   数组反向 
    includes  判断时否包含某个值
    indexOf   判断时否包含某个值，返回角标，找不到就返回-1
    slice(index,index) 截取数组，包含前面的角标不含后面的角标，不写第二个参数（截取后面所有的）
  举例：  
splice(index,howmany,) 
    splice(index,howmany)  删除
    splice(index)  删除后面所有的
    splice(index,howmany,item) 替换
    splice(index,0,item) 插入
   var arr1 = [2, 3, 4, 5];
    arr1.splice(2,2);
    console.log(arr1)
    arr1.splice(1);
    console.log(arr1)
    arr1.splice(2,0,'hello','hi');
    console.log(arr1);


    var res = arr1.splice(2,1);
    console.log(arr1);
    console.log(res)


    var arr1 = [2,3,4];
    var arr2 = ['a','b'];
    var arr3 = ['hello','hey'];
    var re3 = arr1.concat(arr2,arr3);
    console.log(re3)



    var arr = ['a','b','c'];
    var res = arr.join('&&');
    console.log(res);

    var arr = ['a','b','c'];
    console.log(arr.reverse())

    var arr = ['a','b','c'];
    var res = arr.includes('a');
    console.log(res);

冒泡排序

分析：
// [2,3,6,9,11]  排序
    // 9,6,3,2,11  

    // 第一趟
        // 9 6      6 9 3 2 11
        // 9 3      6 3 9 2 11
        // 9 2      6 3 2 9 11
        // 9 11     6 3 2 9 11    

    // 第二趟
        // 6 3     3 6 2 9 11
        // 6 2     3 2 6 9 11 
        // 6 9     3 2 6 9 11  
    
    // 第三趟
        // 3 2     2 3 6 9 11
        // 3 6     2 3 6 9 11 

    // 第四趟
        // 2 3     2 3 6 9 11 

    // 冒泡排序 -- 相邻的数进行比较
var arr = [9,6,3,2,11] ;
   for(var i = 0 ; i < arr.length - 1 ; i++) {
        for(var j = 0 ; j < arr.length - 1 - i; j++) {
            if(arr[j] > arr[j + 1]) {
                var t ; 
                t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t
            }
        }
    }
    console.log(arr)

选择排序

分析
  // 拿第一个位置上的数与后面所有的数进行比较
    // 第一趟
        // 9 8    8 9 7 6 5
        // 8 7    7 9 8 6 5
        // 7 6    6 9 8 7 5
        // 6 5    5 9 8 7 6  最小值

    // 第二趟
        // 9 8   5 8 9 7 6
        // 8 7   5 7 9 8 6
        // 7 6   5 6 9 8 7
    
    // 第三趟
        // 9 8   5 6 8 9 7
        // 8 7   5 6 7 9 8

    // 第四趟
        // 9 8  5 6 7 8 9
var arr = [9,8,7,6,5] ;
for(var j = 0 ; j < arr.length - 1 ; j++){
            for(var i = j + 1 ; i < arr.length ; i++){
                if(arr[j] > arr[i] ) {
                    var t = arr[j];
                    arr[j] = arr[i];
                    arr[i] = t
                }
            }
        }
        console.log(arr)

选择排序（最大最小交换）

分析：
 // var min = 0
        // 9 8   min = 8对应的位置
        // 8 7   min = 7对应的位置
        // ....
        //   min 5对应的位置
        // 5个9进行交换    5 8 7 6 9

    // var min = 1
        // 9 8   min = 8对应的位置
        // 8 7   min = 7对应的位置
        // ....
        //   min 5对应的位置
        // 5个9进行交换
var arr = [9,8,7,6,5] ;
 // 减少交换次数
    for(var i = 0 ; i < arr.length - 1 ; i++){
        // 假设最小值的角标
        var min = i ;
        // 找到最小值的角标
        for(var j = i + 1 ; j < arr.length ; j++) {
            if(arr[min] > arr[j]){
                min = j
            }
        }
        // 交换
        if(min != i) {
            var t = arr[min];
            arr[min] = arr[i];
            arr[i] = t
        }
    }
    console.log(arr)

数组的应用：（数字字母密码随机）

   // 随机取出数组中的一个值
        // 只能通过角标

    var arr = ['a','b','c','d','e'];
    // 随机取出一个数  0 ~ arr.length-1
    var index = parseInt(Math.random() * arr.length) ;
    console.log(arr[index]);