冒泡排序和ES5常用的方法

数组的排序

冒泡排序

• 先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置
  
• 数组遍历一遍以后，那么最后一个数字就是最大的那个了
  
• 然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
  
• 以此类推，最后就会按照顺序把数组排好了
• 规则：前后两个数两两进行比较，如果符合交换条件，就交换两数的位置。

•         特殊：每一轮比较完成以后，都会找到一个较大的数，放在正确的位置。
  
  
   
       第一轮：五次
           9, 8, 7, 6, 5, 4
           8, 9, 7, 6, 5, 4
           8, 7, 9, 6, 5, 4
           8, 7, 6, 9, 5, 4
           8, 7, 6, 5, 9, 4
           8, 7, 6, 5, 4, 9
  
       第二轮：四次
           8, 7, 6, 5, 4
           7, 8, 6, 5, 4
           7, 6, 8, 5, 4
           7, 6, 5, 8, 4
           7, 6, 5, 4, 8
  
       第三轮：三次
           7, 6, 5, 4
           6, 7, 5, 4
           6, 5, 7, 4
           6, 5, 4, 7
  
       第四轮：两次
           6, 5, 4
           5, 6, 4
           5, 4, 6
  
       第五轮：一次
           5, 4
           4, 5
  
       每一轮比较的次数 = 数组长度 - (当前轮数 + 1)
   
  
   var arr = [9, 8, 7, 6, 5, 4];
  
   for(var i = 0; i < arr.length - 1; i++){
       for(var j = 0; j < arr.length - (i + 1); j++){
           //前后两两进行比较
           if(arr[j] > arr[j + 1]){
               var tmp = arr[j];
               arr[j] = arr[j + 1];
               arr[j + 1] = tmp;
           }
       }
   }
  
   console.log(arr);
  

选择排序

选择排序：打擂台法

规律：选出一个位置，和后面所有的数，进行比较，如果，符合条件就直接交换位置。

特点：每一次都找出一个较小的数，放在正确的位置。

            第一轮：
                9, 8, 7, 6, 5, 4
                8, 9, 7, 6, 5, 4
                7, 9, 8, 6, 5, 4
                6, 9, 8, 7, 5, 4
                5, 9, 8, 7, 6, 4
                4, 9, 8, 7, 6, 5

            第二轮：
                   9, 8, 7, 6, 5
                   8, 9, 7, 6, 5
                   7, 9, 8, 6, 5
                   6, 9, 8, 7, 5
                   5, 9, 8, 7, 6

            第三轮：
                      9, 8, 7, 6
                      8, 9, 7, 6
                      7, 9, 8, 6
                      6, 9, 8, 7

            第四轮：
                         9, 8, 7
                         8, 9, 7
                         7, 9, 8

            第五轮：
                             9, 8
                             8, 9


        
        var arr = [9, 8, 7, 6, 5, 4];

        for(var i = 0; i < arr.length - 1; i++){
            for(var j = i + 1; j < arr.length; j++){
                if(arr[i] > arr[j]){
                    var tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }

        console.log(arr);

快速排序

快速排序/分治法

先找一个基准数

function num(arr){
                // 如果只有一个数就直接输出此数字
                if(arr.length <= 1){
                    return arr;
                }
                // 找到基数
                var index = parseInt(arr / 2);
                // 把基数拿出来
                var aba = arr.splice(index,1);
                // 设置左右两个空值
                var left = [];
                var right = [];
                
                for(var a = 0 ; a < arr.length;a++){
                // 如果小于则给左边盒子插入
                    if(arr[a] < aba){
                        left.push(arr[a])
                    }
                // 如果大于则给右边盒子插入

                    else{
                        right.push(arr[a])
                    }
                }
                // 返回值：给左边加基数和右边的数组
                return num(left).concat(aba,num(right))
            }
            var ttt = num(arr);
            console.log(ttt);

ES5

indexOf

Array.indexOf()
                格式：数组.indexOf(item, start);
                【注】start不传入，默认从0开始查找。
                功能：在数组中查找item，从start开始第一次出现的下标。
                返回值：如果能查找的到，返回查找到的下标，否则，返回-1

forEach

arr.forEach(function(item, index, array){
                item 是当前遍历到的元素
                index是当前遍历到的元素的下标
                array数组本身

                console.log(item, index, array);
            })

map

Array.map()
                功能：映射
                映射关系：写在函数的return部分。
                返回值：生成一个映射关系生成的新数组
            
            让上述数组中每一个元素，增加30%
            
            var newArr = arr.map(function(item, index, array){
                return item * 1.3;
            })

            console.log(newArr);
            console.log(arr);

filter

Array.filter()
                功能：过滤
                过滤条件：return后面的表达式
            
            var newArr = arr.filter(function(item, index, array){
                return item > 30;
            })

            console.log(newArr);
            console.log(arr);

every

Array.every()
                功能：判断数组中的每一个元素，是否都符合条件
                返回值：如果是，返回true， 否则false
                判断条件：return后面的表达式
                【注】短路操作
            
            var res = arr.every(function(item, index, array){
                console.log(item, index, array);
                return item < 300;
            })

            console.log(res);
            console.log(arr);

some

 Array.some()
                功能：判断数组中的有一个元素，是否符合条件
                返回值：如果是，返回true， 否则false
                判断条件：return后面的表达式
                【注】短路操作
           
            var res = arr.some(function(item, index, array){
                console.log(item, index, array);
                return item > 300;
            })

            console.log(res);
            console.log(arr);